Autres exemples de calcul

Cette section fournit d'autres exemples de calcul. Dans ces exemples, dataObject représente l'objet sur lequel porte le calcul. N'oubliez pas de conserver inchangées les deux premières lignes du calcul, telles qu'elles sont lorsque vous ouvrez la boîte de dialogue Modifier la formule :

1
2
import System
static def GetAttributeValue(dataObject):

Plusieurs de ces exemples utilisent des attributs qui ne figurent pas dans votre base de données. Pour utiliser ces exemples, vous devez soit créer les attributs requis, soit modifier les exemples afin d'utiliser des attributs présents dans votre base de données.

Compaison de l'utilisateur actuel et de l'utilisateur Déclenché par

1
2
3
4
5
6
7
import System
static def GetAttributeValue(Incident):
    if Incident.RaiseUser == null:
        return 'Déclenché par est NULL'
    if Incident.GetCurrentUserName().ToLower() == Incident.RaiseUser.Name.ToLower():
        return 'déclenché par l'utilisateur actuel'
    return 'CurrentUser=' + Incident.GetCurrentUserName() + ' Déclenché par=' + Incident.RaiseUser.Name

La première instruction teste l'attribut Déclenché par de l'incident pour voir s'il est NULL, puis renvoie Déclenché par est NULL si la condition est vraie.

Si l'instruction n'est pas vraie, la deuxième instruction « if » s'exécute et vérifie si l'utilisateur actuel est identique à l'utilisateur Déclenché par. Si tel est le cas, le système renvoie déclenché par l'utilisateur actuel.

Vous utilisez .ToLower() dans cette ligne pour éviter les problèmes de sensibilité à la casse : les deux chaînes sont mises en minuscules.

Si aucune des instructions n'est vraie, la ligne finale est exécutée, et renvoie des valeurs CurrentUser et Déclenché par distinctes.

Calcul de l'âge d'un utilisateur

1
2
3
âge = DateTime.Now.Year - dataObject.DateOfBirth.Year
âge-- if DateTime.Now.Month < dataObject.DateOfBirth.Month or (DateTime.Now.Month == dataObject.DateOfBirth.Month and DateTime.Now.Day < dataObject.DateOfBirth.Day)
return âge

Ce calcul inclut une variable nommée âge (âge), déterminée par soustraction de l'année DateOfBirth (date de naissance) de l'utilisateur à partir de l'année en cours. Une année supplémentaire est soustraite si l'utilisateur n'a pas encore fêté son anniversaire cette année-là (mois en cours inférieur au mois de naissance, ou égal au mois de naissance mais avec un jour actuel inférieur au jour de naissance).
âge-- signifie « soustraire 1 de âge ».
Un signe égal (=) unique signifie « rendre cela égal à », deux signes égal (==) signifient « cela est égal à ».

Calcul de la durée de service d'un utilisateur

1
2
3
4
5
end = DateTime.Now
end = dataObject.EndDate if dataObject.EndDate != null
los = end.Year - dataObject.StartDate.Year
    los-- if end.Month < dataObject.StartDate.Month or (end.Month == dataObject.StartDate.Month and end.Day < dataObject.StartDate.Day)
return los

La variable end (fin) est définie sur la date du jour, sauf si l'enregistrement d'utilisateur contient une date de fin (EndDate n'est pas NULL), auquel cas la variable prend la valeur EndDate. La variable los est ensuite obtenue en soustrayant StartDate (date de début) de la variable end ; une année supplémentaire est soustraite si EndDate se produit plus tôt dans l'année que StartDate.
!= signifie « est différent de ».

Calcul de la date la plus récente d'une collection

Dans ce calcul, nous avons une collection de commandes (Order) associée à dataObject et nous cherchons à connaître la date de commande (OrderDate) la plus récente pour tous les éléments de la collection. (Vous pourriez utiliser simplement la fonction de collection Framework Max(" ") mais notre exemple présente des concepts très utiles.)

1
2
3
4
5
lastOrderDate = null
for order in dataObject.Orders:
    if lastOrderDate == null or lastOrderDate < order.OrderDate:
        lastOrderDate = order.OrderDate
        return lastOrderDate

Sur la première ligne, la variable lastOrderDate (dernière date de commande) est configurée sur NULL. (Souvenez-vous qu'un seul signe = signifie « rendre cette valeur égale à » et que deux signes égal (==) signalent une égalité existante.)
La deuxième ligne crée une boucle dans la collection dataObject.Orders avec la variable order (commande). La partie indentée du calcul est exécutée sur chacun des objets de la collection, tour à tour.
Notez que la troisième ligne est indentée d'un seul espace pour indiquer qu'elle appartient à la deuxième ligne. La troisième ligne indique que, si la variable lastOrderDate (dernière date de commande) est NULL (ce qui est le cas la première fois puisqu'elle est définie sur NULL à la ligne 1) ou si elle est inférieure à la valeur OrderDate (date de commande) de l'objet concerné, alors...
La quatrième ligne définit la variable lastOrderDate (dernière date de commande) comme étant égale à la valeur OrderDate de l'objet actuel dans la collection.
Le calcul revient ensuite à la troisième ligne pour l'objet suivant de la collection, et teste de nouveau la valeur lastOrderDate pour savoir si elle est NULL (ce qui n'est plus le cas) ou inférieure à la valeur OrderDate de l'objet suivant de la collection. Si elle est inférieure à la valeur OrderDate de l'objet, alors lastOrderDate est configurée sur cette nouvelle valeur.
Lorsque le calcul a traité tous les objets de la collection, la ligne finale du calcul renvoie la valeur détectée pour lastOrderDate.

Addition des valeurs des résultats d'un calcul appliqué à tous les objets d'une collection

Dans les exemples précédents, nous avons vu comment exécuter des calculs arithmétiques et comment créer un calcul en boucle sur tous les objets d'une collection. Dans cet exemple, nous allons combiner ces deux techniques pour calculer la somme des résultats de calculs réalisés sur tous les objets d'une collection.

Ce calcul détermine le coût total d'une collection d'objets, d'après le coût unitaire de chaque objet de la collection et de la valeur de quantité de chaque élément. Le coût de chaque objet de la collection est donc obtenu en multipliant la quantité d'un élément par le prix unitaire correspondant. Le coût total est ensuite calculé en additionnant tous les coûts des objets. Pour ce faire, le calcul détermine le coût du premier objet, puis l'ajoute au coût du deuxième objet, et ainsi de suite pour tout le calcul.

1
2
3
4
coût = 0
for item in dataObject.Items:
    coût = coût + (item.Quantity * item.UnitCost)
        return coût

Sur la première ligne, la variable coût (coût) est configurée sur 0.
La deuxième ligne crée une boucle dans la collection dataObject.Items avec la variable item (élément).
La troisième ligne (indentée) définit la variable coût (coût) sur la somme de la valeur en cours et du résultat de la multiplication de l'attribut Quantity (quantité) par l'attribut UnitCost (coût unitaire). La troisième ligne est alors répétée pour tous les objets de la collection. Chaque fois que le calcul fait une boucle pour traiter un nouvel objet de la collection, il ajoute le coût de ce nouvel objet au total.
Une fois que le calcul a traité tous les objets de la collection, la ligne finale du calcul renvoie la valeur définie pour coût.

Calculs sur des collections de collections

Ce calcul est une extension de l'exemple précédent. Il détermine la valeur totale d'une collection de commandes où chaque commande inclut plusieurs éléments. Dans cet exemple, le coût total est la somme d'une collection de collections.

1
2
3
4
5
coût = 0
    for order in dataObject.Orders:
        for item in order.Items:
            coût = coût + (item.UnitCost * item.Quantity)
        return coût

Sur la première ligne, la variable coût (coût) est configurée sur 0.
La deuxième ligne (indentée) crée une boucle dans la collection dataObject.Orders avec la variable order (commande).
La troisième ligne (à double indentation) crée une boucle dans la collection dataObject.Items, enfant de la collection dataObject.Orders, à l'aide de la variable item (élément).
La quatrième ligne (à triple indentation) définit la variable coût sur la somme de la valeur en cours et du résultat de la multiplication de l'attribut Quantity (quantité) par l'attribut UnitCost (coût unitaire). La quatrième ligne est alors répétée pour tous les objets de la collection dataObject.Items. Chaque fois que le calcul fait une boucle pour traiter un nouvel objet de la collection, il ajoute le coût de ce nouvel objet au total.
Une fois que le calcul a traité tous les objets de la première sous-collection Order, il passe à la deuxième et répète la ligne 4 sur tous les éléments de cette sous-collection.
Lorsque tous les objets de la collection dataObject.Items de niveau supérieur ont été traités, la ligne finale du calcul renvoie la valeur définie pour coût.

Génération d'un texte incluant des données issues de votre base de données

Cet exemple explique comment créer une chaîne de texte incluant des données issues de votre base de données.

1
return String.Format("Bonjour {0}, ces informations ont été mises à jour pour la dernière fois par {1}", dataObject.RaiseUser.Title, dataObject.LastUpdateUser.Title)

La fonction String.Format(" ", {0}, {1}. ...) renvoie une chaîne où les paramètres {0}, {1}, etc. définissent l'endroit où obtenir les données à insérer dans la chaîne. Notez que les paramètres démarrent à {0}. Dans notre exemple de calcul, {0} est remplacé par le nom d'utilisateur Déclenché par (dataObject.RaiseUser.Title) et {1} est remplacé par le nom du dernier utilisateur qui a mis à jour l'enregistrement (dataObject.LastUpdateUser.Title).
Par exemple, si l'incident a été journalisé pour Gill Bond et mis à jour pour la dernière fois par Jane Green, la chaîne finale est la suivante : Bonjour Gill Bond, ces informations ont été mises à jour pour la dernière fois par Jane Green.