Cas d’utilisation de scripts côté serveur

Les cas d’utilisation des scripts côté serveur incluent la journalisation de la sortie, l’obtention d’objets utilisateur et la modification des valeurs de date/heure.

Accéder au bloc-notes du workflow à partir des règles métier

Un élément de catalogue a été demandé et le workflow joint contient une activité de script d’exécution qui renseigne une valeur dans le bloc-notes. Depuis une règle métier en cours d’exécution sur l’élément demandé, vous souhaitez récupérer ou définir des valeurs de bloc-notes.

Prérequis

Rôle requis : admin.

Nom : Bloc-notes d’accès au workflow à partir des règles métier.

Type : règle métier.

Table : sc_req_item (élément demandé).

Description : Un élément de catalogue a été demandé. Le workflow joint contient une activité de script d’exécution qui renseigne une valeur dans le bloc-notes. Depuis une règle métier en cours d’exécution sur l’élément demandé, vous souhaitez récupérer ou définir des valeurs de bloc-notes.

Paramètres : n/a.

Script :

//the run script activity sets a value in the scratchpad
workflow.scratchpad.important_msg = "scratch me";
 
//get the workflow script include helper 
var workflow = new Workflow();
 
//get the requested items workflow context 
//this will get all contexts so you will need to get the proper one if you have multiple workflows for a record 
var context = workflow.getContexts(current); 
//make sure we have a valid context 
if (context.next()) { 
  //get a value from the scratchpad 
  var msg = context.scratchpad.important_msg; 
  //msg now equals "scratch me", that was set in the run script activity
 
  //add or modify a scratchpad value
  context.scratchpad.status = "completed"; 
  //we need to save the context record to save the scratchpad
  context.update(); 
}

Affecter un élément de catalogue à un groupe en fonction d’une tâche de plan d’exécution

Affectez un élément de catalogue de services au groupe de base de données s’il utilise un plan d’exécution dont une tâche de catalogue est affectée au groupe de bureau.

Prérequis

Rôle requis : admin

Avertissement :

La personnalisation décrite ici a été développée pour une utilisation dans des instances spécifiques, et n'est pas prise en charge par Now Support. Cette méthode est fournie telle quelle et doit être testée rigoureusement avant d'être implémentée. Publiez toutes les questions et commentaires concernant cette personnalisation dans notre forum communautaire.

Nom : Affecter un élément de catalogue au groupe en fonction de la tâche du plan d’exécution.

Type : règle d’affectation.

Description : cette règle d’affectation affecte un élément de catalogue de services au groupe de base de données s’il utilise un plan d’exécution dont une tâche de catalogue est affectée au groupe de bureau.

Script:

//Return catalog items that have no group but do have a delivery plan assigned var ri  = new GlideRecord ( "sc_cat_item" ) ;
ri.addQuery("group", "=", null);
ri.addQuery("delivery_plan", "!=", null);
ri.query(); 
while(ri.next()) {
    gs.log("Found an item"); 
    //Return tasks that point to the same delivery plan as the above item 
    var dptask = new GlideRecord("sc_cat_item_delivery_task");
    dptask.addQuery("delivery_plan", "=", ri. delivery_plan);
    dptask.query(); 
    while(dptask.next()) {
        gs.log("Found a task");
        var gp = dptask.group.getDisplayValue();
        gs.log(gp); 
        //If the task is assigned to desktop, assign the item's group to desktop
        if (dptask.group.getDisplayValue() == "Desktop") {
            ri.group.setDisplayValue("Desktop");
            gs.log("updating " + ri.getDisplayValue());
            ri.update(); 
            break; } } }

Calcul des durées

Souvent, vous devrez fournir aux utilisateurs un moyen de spécifier la date d’échéance d’une tâche ou d’un processus. À l’aide de l’include de script DurationCalculator, vous pouvez calculer la date d’échéance en utilisant une durée simple ou une durée relative.

En règle générale, la définition d’une date d’échéance nécessite que vous calculiez le temps de travail plutôt que le temps total. Seule la partie de la journée où le travail est effectué est prise en compte pour déterminer la date d’échéance. Par exemple, une tâche arrive à échéance dans 10 heures, mais est limitée à un calendrier de jour ouvrable. Si les travaux commencent à 10h le lundi, ils sont dus le mardi à 12h comme calculé ci-dessous.

10am-5pm on Monday (6 hours) + 8am-12pm on Tuesday (4 hours)

Pour plus d’informations sur les calendriers, que vous pouvez utiliser comme entrées dans les méthodes DurationCalculator, voir Création et utilisation de calendriers.

Ce script montre comment utiliser DurationCalculator pour calculer une date d’échéance.

/**
 * Demonstrate the use of DurationCalculator to compute a due date.
 * 
 * You must have a start date and a duration. Then you can compute a
 * due date using the constraints of a schedule.
 */
 
gs.include('DurationCalculator');
executeSample();
 
/**
 * Function to house the sample script.
 */function executeSample(){
 
    // First we need a DurationCalculator object.var dc =new DurationCalculator();
 
    // --------------- No schedule examples ------------------
 
    // Simple computation of a due date without using a schedule. Seconds// are added to the start date continuously to get to a due date.
    dc.setStartDateTime("5/1/2012");if(!dc.calcDuration(2*24*3600)){// 2 days
    	gs.log("*** Error calculating duration");return;}
    gs.log("calcDuration no schedule: "+ dc.getEndDateTime());// "2012-05-03 00:00:00" two days later
 
    // Start in the middle of the night (2:00 am) and compute a due date 1 hour in the future// Without a schedule this yields 3:00 am.
    dc.setStartDateTime("5/3/2012 02:00:00");if(!dc.calcDuration(3600)){
        gs.log("*** Error calculating duration");return;}
    gs.log("Middle of night + 1 hour (no schedule): "+ dc.getEndDateTime());// No scheduled start date, just add 1 hour
 
 
    // -------------- Add a schedule to the date calculator ---------------------
    addSchedule(dc);
 
    // Start in the middle of the night and compute a due date 1 hour in the future.// Since we start at 2:00 am the computation adds the 1 hour from the start// of the day, 8:00am to get to 9:00am
    dc.setStartDateTime("5/3/2012 02:00:00");if(!dc.calcDuration(3600)){// 
        gs.log("*** Error calculating duration");return;}
    gs.log("Middle of night + 1 hour (with 8-5 schedule): "+ dc.getEndDateTime());// 9:00 am
 
    // Start in the afternoon and add hours beyond quiting time. Our schedule says the work day// ends at 5:00pm, if the duration extends beyond that, we roll over to the next work day.// In this example we are adding 4 hours to 3:00pm which gives us 10:00 am the next day.
    dc.setStartDateTime("5/3/2012 15:00:00");if(!dc.calcDuration(4*3600)){// 
        gs.log("*** Error calculating duration");return;}
    gs.log("Afternoon + 4 hour (with 8-5 schedule): "+ dc.getEndDateTime());// 10:00 am.
 
    // This is a demo of adding 2 hours repeatedly and examine the result. This// is a good way to visualize the result of a due date calculation.
    dc.setStartDateTime("5/3/2012 15:00:00");// for(var i=2; i<24; i+=1){if(!dc.calcDuration(i*3600)){// 
            gs.log("*** Error calculating duration");return;}
        gs.log("add "+ i +" hours gives due date: "+ dc.getEndDateTime());}
 
    // Setting the timezone causes the schedule to be interpreted in the specified timezone.// Run the same code as above with different timezone. Note that the 8 to 5 workday is// offset by the two hours as specified in our timezone.
    dc.setTimeZone("GMT-2");
    dc.setStartDateTime("5/3/2012 15:00:00");for(var i=2; i<24; i+=1){if(!dc.calcDuration(i*3600)){// 
            gs.log("*** Error calculating duration");return;}
        gs.log("add "+ i +" hours gives due date (GMT-2): "+ dc.getEndDateTime());}}
 
/** 
 * Add a specific schedule to the DurationCalculator object.
 *  
 * @param durationCalculator An instance of DurationCalculator
 */function addSchedule(durationCalculator){//  Load the "8-5 weekdays excluding holidays" schedule into our duration calculator.var scheduleName ="8-5 weekdays excluding holidays";var grSched =new GlideRecord('cmn_schedule');
    grSched.addQuery('name', scheduleName);
    grSched.query();if(!grSched.next()){
        gs.log('*** Could not find schedule "'+ scheduleName +'"');return;}
    durationCalculator.setSchedule(grSched.getUniqueValue(),"GMT");}

Durée simple par rapport à la durée relative

La quantité de travail nécessaire pour accomplir une tâche peut être exprimée en « durée relative ».

La durée relative détermine la date et l’heure d’échéance prévues par rapport à l’heure de début. Des exemples de durées relatives incluent « Jour ouvrable suivant à 16h » ou « 2 jours ouvrables à 10h30 ».

Pour calculer une durée relative, le calendrier et le fuseau horaire doivent être pris en compte pour déterminer ce que signifie « jour ouvrable suivant », car c’est le calendrier qui définit quels jours sont des jours ouvrables valides et le fuseau horaire affectera également le résultat. À titre d’exemple, considérez « Jour ouvrable suivant à 16 heures » :

• Si c’est le lundi à 12h : Jour ouvrable suivant à 16h => mardi à 16h
• Si c’est le vendredi à 14h : Jour ouvrable suivant à 16h => le lundi suivant à 16h

Remarque :

Le jour ouvrable suivant est souvent défini par un jour et une heure de début. Par exemple, « le jour ouvrable suivant à 16h si avant 14h » indique que si l’heure actuelle est après 14h un jour ouvrable, alors « Jour ouvrable suivant » signifie en réalité 2 jours ouvrables puisque le jour ne compte pas.

Pour plus d’informations sur les durées relatives, reportez-vous à la section Define a relative duration.

Calcul d’une durée simple

Cette règle métier et cet exemple de script montrent comment calculer une durée simple.

var dur =new DurationCalculator();
dur.setSchedule(current.schedule);
dur.setStartDateTime("");
 
if(current.duration_type==""){
         dur.calcDuration(current.duration.getGlideObject().getNumericValue()/1000);}else{
         dur.calcRelativeDuration(current.duration_type);}
 
    current.end_date_time= dur.getEndDateTime();
    current.work_seconds= dur.getSeconds();

Ce script montre comment utiliser DurationCalculator pour calculer une durée simple.

/**
 * Sample script demonstrating use of DurationCalculator to compute simple durations
 * 
 */
 
gs.include('DurationCalculator');
executeSample();
 
/**
 * Function to house the sample script.
 */
function executeSample(){
 
    // First we need a DurationCalculator object.
    var dc =new DurationCalculator();
 
    // Compute a simple duration without any schedule. The arguments
    // can also be of type GlideDateTime, such as fields from a GlideRecord.
    var dur = dc.calcScheduleDuration("5/1/2012","5/2/2012");
    gs.log("calcScheduleDuration no schedule: "+ dur);
    // 86400 seconds (24 hours)
 
    // The above sample is useful in limited cases. We almost always want to 
    // use some schedule in a duration computation, let's load a schedule.
    addSchedule(dc);
 
    // Compute a duration using the schedule. The schedule
    // specifies a nine hour work day. The output of this is 32400 seconds, or
    // a nine hour span.
    dur = dc.calcScheduleDuration("5/23/2012 12:00","5/24/2012 12:00");
    gs.log("calcScheduleDuration with schedule: "+ dur);
    // 32400 seconds (9 hours)
 
    // Compute a duration that spans a weekend and holiday. Even though this
    // spans three days, it only spans 9 work hours based on the schedule.
    dur = dc.calcScheduleDuration("5/25/2012 12:00","5/29/2012 12:00");
    gs.log("calcScheduleDuration with schedule spaning holiday: "+ dur);
    // 32400 seconds (9 hours)
 
    // Use the current date time in a calculation. The output of this is
    // dependent on when you run it.
    var now =new Date();
    dur = dc.calcScheduleDuration("5/15/2012",new GlideDateTime());
    gs.log("calcScheduleDuration with schedule to now: "+ dur);
    // Different on every run.}
 
/** 
 * Add a specific schedule to the DurationCalculator object.
 *  
 * @param durationCalculator An instance of DurationCalculator
 */
function addSchedule(durationCalculator){
   //  Load the "8-5 weekdays excluding holidays" schedule into our duration calculator.
   var scheduleName ="8-5 weekdays excluding holidays";
   var grSched =new GlideRecord('cmn_schedule');
   grSched.addQuery('name', scheduleName);
   grSched.query();if(!grSched.next()){
        gs.log('*** Could not find schedule "'+ scheduleName +'"');
        return;}
    durationCalculator.setSchedule(grSched.getUniqueValue());}

Calcul d’une durée relative

Exemple de script de calcul de durée relative.

Ce script calcule la durée relative pour « Jour suivant à 16h si après 10h » :

// Next day at 4pm if before 10am
var days =1;
if(calculator.isAfter(calculator.startDateTime,"10:00:00")) 
      days++;
 
calculator.calcRelativeDueDate(calculator.startDateTime, days,"16:00:00");

Ce script montre comment utiliser DurationCalculator pour calculer une durée relative.

/**
 * Sample use of relative duration calculation.
 * 
 */
 
gs.include('DurationCalculator');
executeSample();
 
/**
 * Function to house the sample script.
 */
function executeSample(){
 
    // First we need a DurationCalculator object. We will also use
    // the out-of-box relative duration "2 bus days by 4pm"
    var dc =new DurationCalculator();
    var relDur ="3bf802c20a0a0b52008e2859cd8abcf2";
    // 2 bus days by 4pm if before 10am
    addSchedule(dc);
 
    // Since our start date is before 10:00am our result is two days from
    // now at 4:00pm.
    dc.setStartDateTime("5/1/2012 09:00:00");
    if(!dc.calcRelativeDuration(relDur)){
        gs.log("*** calcRelativeDuration failed");
        return;}
    gs.log("Two days later 4:00pm: "+ dc.getEndDateTime());
 
    // Since our start date is after 10:00am our result is three days from
    // now at 4:00pm.
    dc.setStartDateTime("5/1/2012 11:00:00");
    if(!dc.calcRelativeDuration(relDur)){
        gs.log("*** calcRelativeDuration failed");
        return;}
    gs.log("Three days later 4:00pm: "+ dc.getEndDateTime());}
 
/** 
 * Add a specific schedule to the DurationCalculator object.
 *  
 * @param durationCalculator An instance of DurationCalculator
 */
function addSchedule(durationCalculator){
  //  Load the "8-5 weekdays excluding holidays" schedule into our duration calculator.
  var scheduleName ="8-5 weekdays excluding holidays";
  var grSched =new GlideRecord('cmn_schedule');
  grSched.addQuery('name', scheduleName);
  grSched.query();
  if(!grSched.next()){
        gs.log('*** Could not find schedule "'+ scheduleName +'"');
        return;}
  durationCalculator.setSchedule(grSched.getUniqueValue(),"GMT");}

Comment implémenter une durée relative

Vous pouvez implémenter une durée relative en créant la table cmn_relative_duration et l’include de script DurationCalculator .

Avant de commencer

Rôle requis : admin

Procédure

1. Créez la table cmn_relative_duration.
2. Créez l’include de script DurationCalculator.
3. Créez un exemple d’entrée de durée relative (par exemple, « Jour ouvrable suivant à 16h »).
4. Ajoutez les champs nécessaires aux tables SLA pour prendre en charge les durées relatives.
5. Modifiez le calcul de la durée pour les SLA.
6. Modifier le calcul de la minuterie du pourcentage de SLA pour les SLA (utiliser work_seconds).
7. Ajoutez des champs de calendrier au workflow : calendrier et fuseau horaire (sélectionnés en fonction du champ dans la table de workflow).
8. Ajoutez des champs de support de durée à l’activité Tâche du workflow.
9. Implémentez le script de calcul de durée pour l’activité de la tâche.

La table de durée relative et les méthodes DurationCalculator

La table cmn_relative_duration prend en charge la définition d’une date d’échéance comme une durée ou une durée relative.

Cette table se compose de deux champs : « nom » et « script ». Le champ « script » contient le script de calcul de durée relative. Ce script inclut la variable « calculatrice », qui est utilisée pour calculer la date d’échéance.

L’include de script DurationCalculator peut être utilisé pour effectuer les calculs de durée. Les méthodes suivantes sont disponibles dans cet include de script.

Tableau 1. Table d’include de script DurationCalculator

Fonction de message REST	Description
setSchedule(String schedID, [String timezone])	Définit le calendrier et le fuseau horaire à utiliser pour calculer la date d’échéance.
setStartDateTime (début de GlideDateTime)	Définit l’heure de début des calculs de durée. Si « démarrage » est vide, utilise la date/heure actuelle.
calcDuration(nombre entier de secondes)	Calcule la date et l’heure de fin. Une fois l’opération terminée, les propriétés this.endDateTime et this.seconds sont définies pour indiquer les résultats du calcul.
calcRelativeDuration(Chaîne relativeDurationID)	Calcule la durée à l’aide du script de durée relative spécifié. Une fois l’opération terminée, les propriétés this.endDateTime et this.seconds sont définies pour indiquer les résultats du calcul.
getEndDateTime()	Obtient la propriété this.endDateTime définie par calcDuration/calcRelativeDuration, indiquant la date et l’heure de fin de la durée.
getSeconds()	Obtient la propriété this.seconds définie par calcDuration/calcRelativeDuration, qui indique le nombre total de secondes de travail à effectuer pendant la durée. Remarque : Il s’agit du temps de travail total, et non du temps total entre les heures de début et de fin, qui peut être utilisé pour déterminer les pourcentages du temps de travail
getTotalSeconds()	Obtient la propriété this.totalSeconds définie par calcDuration/calcRelativeDuration, qui indique le nombre total de secondes entre les heures de début et de fin de la durée.

Les fonctions suivantes sont utilisées dans les scripts de durée relative :

Tableau 2. Fonctions de script de durée relative

Fonction	Description
booléen isAfter(GlideDateTime dt, String time)	L’heure de la journée est-elle postérieure à l’heure de la journée spécifiée par 'dt' ? DT, si ce champ est vide, utilise la date/heure actuelle. L’heure est en « HH :MM :SS » au format 24 heures.
calcRelativeDueDate(GlideDateTime début, int jours, chaîne endTime)	Calcule la date d’échéance en commençant par « début » et en ajoutant « jours » à l’aide de la planification et du fuseau horaire. Lorsque nous trouvons le jour où le travail est dû, définissez l’heure de fin de ce jour. Une fois l’opération terminée, les propriétés this.endDateTime et this.seconds seront définies pour indiquer les résultats du calcul. Si endTime est vide, utilisez la fin de la journée de travail de fin.

Obtenir un objet utilisateur

Dans une règle métier ou un autre script serveur, la méthode gs.getUser() renvoie un objet utilisateur. L’objet user est une représentation interne de l’utilisateur actuellement connecté et fournit des informations sur l’utilisateur et diverses fonctions utilitaires.

Pourquoi et quand exécuter cette tâche

Pour obtenir la liste et une description des méthodes incluses dans le champ d’application disponibles pour l’objet utilisateur, consultez GlideUser.

Procédure

1. Récupérer l’utilisateur actuel.

   var myUserObject = gs.getUser()

2. Utilisez la méthode getUserByID pour extraire un autre utilisateur à l’aide du champ user_name ou de la sys_id sur l’enregistrement cible.
   Par exemple :

   var ourUser = gs.getUser(); 
   gs.print(ourUser.getFirstName()); //print the first name of the user you are currently logged in as 
   newUser = ourUser.getUserByID(<user_sys_id>); //fetch a different user, using the sys_id of the target user record. 
   gs.print(newUser.getFirstName()); //first name of the user you fetched above 
   gs.print(newUser.isMemberOf('Capacity Mgmt'));

Sortie de journal

GSLog est un include de script qui simplifie la journalisation et le débogage des scripts en implémentant des niveaux de sortie de journal, sélectionnables par valeur de sys_properties identifiées par appelant.

Niveau de journal

Les journaux peuvent être au niveau du débogage, de l’information, de l’avis, de l’avertissement, de l’erreur ou de la critique (après BSD syslog.h et les suiveurs). Le niveau de journalisation par défaut est notice, les niveaux doivent donc être choisis en conséquence.

Où l’utiliser

À utiliser pour tout script côté serveur dans lequel vous souhaitez implémenter la journalisation des événements.

Pour obtenir la référence de l’API, consultez GSLog().

Pour plus d’informations, voir Débogage de scripts

Modifier une valeur de champ GlideDateTime

Cet exemple montre comment modifier une valeur de champ GlideDateTime à l’aide d’un script côté serveur.

Au vu d’un champ GlideDateTime ou d’un objet de script, affichez différentes manières de modifier facilement la valeur. Le même concept s’applique également à l’objet GlideDate .

Remarque :

Le script suivant est uniquement destiné aux applications globales.

//You first need a GlideDateTime object
//this can be from instantiating a new object "var gdt = new GlideDateTime()"
//or getting the object from a GlideDateTime field
//getting the field value (for example: var gdt = current.start_date) only returns the string value, not the object
//to get the object use var gdt = current.start_date.getGlideObject();
//now gdt is a GlideDateTime object
var gdt = current.start_date.getGlideObject();
 
//All methods can use negative values to subtract intervals
 
//add 1 hour (60 mins * 60 secs)
gdt.addSeconds(3600);
 
//add 1 day
gdt.addDaysLocalTime(1);
 
//subtract 1 day
gdt.addDaysLocalTime(-1);
 
//add 3 weeks
gdt.addWeeksLocalTime(3);
 
//subtract 6 months
gdt.addMonthsLocalTime(-6);
 
//add 1 year, representing the date and time using the UTC timezone instead of the local user's timezone.
gdt.addYearsUTC(1);
 
//set the value of the GlideDateTime object to the current session timezone/format
GlideSession.get().setTimeZoneName('US/Eastern');
gdt.setDisplayValue('2018-2-28 00:00:00');
gs.info('In ' + GlideSession.get().getTimeZoneName() + ": " + gdt.getDisplayValue());

Voir aussi :

• GlideDateTime
• GlideDate : global
• GlideDate : dans le champ d’application
• GlideDateTime : global
• GlideDateTime : dans le champ d’application
• GlideTime : dans le champ d’application

Utilisation de files d’attente personnalisées pour traiter des événements

Vous pouvez utiliser des files d’attente personnalisées pour les applications qui créent un grand volume d’événements ou des événements dont le traitement prend beaucoup de temps. Cette tâche montre comment créer une file d’attente personnalisée, son processus de surveillance et utiliser un script pour envoyer des événements à la file d’attente.

Avant de commencer

Rôle requis : admin

Remarque :

Ces informations sont destinées aux utilisateurs avancés qui comprennent le traitement des événements.

Procédure

1. Accédez à la Politique système > Événements > Registre.
2. Sélectionnez l’événement pour lequel vous souhaitez créer une file d’attente personnalisée.
   Le formulaire d’inscription à l’événement s’affiche.
3. Renseignez le champ File d’attente de l’événement dans le registre des événements.
   Utilisez uniquement des lettres minuscules, pas d’espace et aucun caractère spécial à l’exception du trait de soulignement (_).

   

4. Cliquez sur Envoyer.
   Un nouvel événement est répertorié dans la table Événements [sysevent].

   Dans l’exemple suivant, lorsque l’événement employeeOccasion est généré, il est ajouté à my_queue. Les événements sont bloqués dans la file d’attente. Pour résoudre ce problème, créez un processus pour surveiller la file d’attente lors de la recherche d’événements.

5. Accédez à la Planificateur système > Travaux planifiés > Travaux planifiés et ouvrez le processus d’événements d’index de texte nommé tâche planifiée.
   
6. Cliquez sur l’icône du menu des actions ) > et sélectionnez Insérer et rester pour créer une copie du processus d’événements d’index de texte.
   Important :

   Assurez-vous de copier la tâche et de ne pas écraser les événements d’index de texte traiter la tâche planifiée.
7. Dans l’élément de calendrier copié, modifiez la valeur du champ Nom .
8. Dans le champ Contexte de la tâche , remplacez la valeur du paramètre GlideEventManager() par le nom de la nouvelle file d’attente.
   
   Le processus de surveillance de file d’attente recherche et traite les événements dans l’exemple my_queue file d’attente des événements.

   

9. Utilisez le cinquième paramètre de la méthode gs.eventQueue() pour envoyer des événements à la file d’attente personnalisée.

   Le code suivant montre comment envoyer un événement à la file d’attente personnalisée my_queue.

   gs.eventQueue('x_60157_employee_spe.employeeOccasion', todaysOccasions, todaysOccasions.number, todaysOccasions.u_employee.name, 'my_queue');

   Remarque :

   Si un événement se trouve dans le registre des événements et qu’aucun nom de file d’attente n’est fourni à gs.eventQueue, la file d’attente du registre des événements est toujours affectée à l’événement. Par exemple, gs.eventQueue('x_60157_employee_spe.employeeOccasion') associe toujours l’événement à my_queue. Si le nom de la file d’attente est fourni dans l’appel gs.eventQueue(), la file d’attente est prioritaire.
   Vous pouvez vérifier que l’événement appelé a été traité en consultant la table Événements [sysevent].