Serverseitige Skriptanwendungsfälle

  • Freigeben Version: Zurich
  • Aktualisiert 31. Juli 2025
  • 15 Minuten Lesedauer

    • Anwendungsfälle für serverseitige Skripts umfassen Protokollierungsausgabe, das Abrufen von Anwenderobjekten und das Ändern von Datums-/Uhrzeitwerten.

    Über Business Rules auf das Workflow-Scratchpad zugreifen

    Ein Katalogelement wurde angefordert, und der angehängte Workflow enthält eine Skriptausführungsaktivität, die einen Wert im Scratchpad ausfüllt. Aus einer Business-Regel, die für das angeforderte Element ausgeführt wird, möchten Sie Scratchpad-Werte abrufen oder festlegen.

    Voraussetzungen

    Erforderliche Rolle: admin.

    Name: Greifen Sie über Business-Regeln auf Workflow-Scratchpad zu.

    Typ: Business-Regel.

    Tabelle: sc_req_item (angefordertes Element).

    Beschreibung: Ein Katalogelement wurde angefordert. Der angefügte Workflow enthält eine Aktivität zur Skriptausführung, die einen Wert in das Scratchpad eingibt. Aus einer Business-Regel, die für das angeforderte Element ausgeführt wird, möchten Sie Scratchpad-Werte abrufen oder festlegen.

    Parameter: n/a.

    Skript: 
    //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(); 
}

    Einer Gruppe basierend auf einer Bereitstellungsplanaufgabe ein Katalogelement zuweisen

    Weisen Sie der Datenbankgruppe ein Servicekatalogelement zu, wenn sie einen Bereitstellungsplan mit einer Katalogaufgabe verwendet, die der Desktopgruppe zugewiesen ist.

    Voraussetzungen

    Erforderliche Rolle: Administrator

    Warnung:
    Die hier beschriebene Anpassung wurde für die Verwendung in bestimmten Fällen entwickelt und wird von Now Support nicht unterstützt. Diese Methode wird wie sie ist zur Verfügung gestellt und sollte vor der Implementierung gründlich getestet werden. Veröffentlichen Sie alle Fragen und Kommentare zu dieser Anpassung in unserem Community-Forum.

    Name: Katalogelement basierend auf der Bereitstellungsplanaufgabe der Gruppe zuweisen.

    Typ: Zuweisungsregel.

    Beschreibung: Diese Zuweisungsregel weist der Datenbankgruppe ein Servicekatalogelement zu, wenn ein Bereitstellungsplan verwendet wird, in dem der Desktopgruppe eine Katalogaufgabe zugewiesen ist.

    Skript:

    //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; } } }

    Dauer berechnen

    Eventuell müssen Sie Benutzern häufig eine Möglichkeit geben, anzugeben, wann eine Aufgabe oder ein Prozess fällig ist. Mit der Skripteinbindung DurationCalculator können Sie das Fälligkeitsdatum entweder mit einer einfachen Dauer oder einer relativen Dauer berechnen.

    Normalerweise erfordert das Festlegen eines Fälligkeitsdatums, dass Sie die Arbeitszeit und nicht die Gesamtzeit berechnen. Bei der Bestimmung des Fälligkeitsdatums wird nur der Teil des Tages berücksichtigt, an dem Arbeit ausgeführt wird. Beispielsweise ist eine Aufgabe in 10 Stunden fällig, ist jedoch auf einen Geschäftstag-Zeitplan beschränkt. Wenn die Arbeit am Montag um 10:00 Uhr beginnt, ist sie am Dienstag um 12:00 Uhr fällig, wie unten berechnet.
    10am-5pm on Monday (6 hours) + 8am-12pm on Tuesday (4 hours)

    Informationen zu Zeitplänen, die Sie als Eingaben für DurationCalculator-Methoden verwenden können, finden Sie unter Zeitpläne werden erstellt und verwendet .

    Dieses Skript veranschaulicht die Verwendung von DurationCalculator zur Berechnung eines Fälligkeitsdatums.

    /**
 * 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");}

    Einfache Dauer und relative Dauer

    Wie viel Arbeit zum Abschließen einer Aufgabe erforderlich ist, kann als „relative Dauer“ ausgedrückt werden.

    Die relative Dauer bestimmt den erwarteten Fälligkeitszeitpunkt relativ zur Startzeit. Beispiele für relative Dauer sind „Nächster Geschäftstag bis 16 Uhr“ oder „2 Geschäftstage bis 30 Uhr“.

    Um eine relative Dauer zu berechnen, müssen Kalender und Zeitzone berücksichtigt werden, um zu bestimmen, was „nächster Geschäftstag“ bedeutet, da der Kalender definiert, welche Tage gültige Arbeitstage sind, und auch die Zeitzone das Ergebnis beeinflusst. Als Beispiel betrachten Sie „Nächster Geschäftstag bis 16 Uhr“:
    • Wenn es Montag, 12 Uhr ist: Nächster Geschäftstag bis 16 Uhr => Dienstag, 16 Uhr
    • Wenn es Freitag, 14 Uhr ist: Nächster Geschäftstag bis 16 Uhr => folgender Montag, 16 Uhr
    Hinweis:
    Der nächste Geschäftstag wird häufig durch einen Starttag und eine Startzeit definiert. Zum Beispiel bedeutet „Nächster Geschäftstag bis 16 Uhr, wenn vor 14 Uhr“, dass, wenn die aktuelle Uhrzeit an einem Geschäftstag später als 14 Uhr ist, „nächster Arbeitstag“ tatsächlich 2 Geschäftstage sind, da der heutige Tag nicht zählt.

    Weitere Informationen zu relativen dauern finden Sie unter Define a relative duration.

    Einfache Dauer berechnen

    Dieses Beispiel mit Business Rule und Skript veranschaulicht, wie eine einfache Dauer berechnet wird.

    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();

    Dieses Skript veranschaulicht die Verwendung von DurationCalculator zur Berechnung einer einfachen Dauer.

    /**
 * 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());}

    Relative Dauer berechnen

    Ein Beispiel für ein Skript zur Berechnung der relativen Dauer.

    Dieses Skript berechnet die relative Dauer für „Nächster Geschäftstag bis 16 Uhr, wenn nach 10 Uhr“:
    // 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");

    Dieses Skript veranschaulicht die Verwendung von DurationCalculator zur Berechnung einer relativen Dauer.

    /**
 * 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");}

    So implementieren Sie eine relative Dauer

    Sie können eine relative Dauer implementieren, indem Sie die Tabelle „cmn_relative_duration“ und die DurationCalculator-Skripteinbindung erstellen.

    Vorbereitungen

    Erforderliche Rolle: Administrator

    Prozedur

    1. Erstellen Sie die Tabelle „cmn_relative_duration“.
    2. Erstellen Sie die DurationCalculator-Skripteinbindung.
    3. Erstellen Sie einen Beispieleintrag für eine relative Dauer (z. B. „Nächster Geschäftstag bis 16 Uhr“).
    4. Fügen Sie die erforderlichen Felder zu SLA-Tabellen hinzu, um die relative Dauer zu unterstützen.
    5. Ändern Sie die Dauerberechnung für SLAs.
    6. Ändern Sie die Berechnung „SLA-Prozent-Timer“ für SLAs (muss „work_seconds“ verwenden).
    7. Fügen Sie dem Workflow Zeitplanfelder hinzu: Zeitplan und Zeitzone (ausgewählt basierend auf dem Feld aus der Workflow-Tabelle).
    8. Fügen Sie der Workflow-Aufgabenaktivität Felder zur Unterstützung der Dauer hinzu.
    9. Implementieren Sie das Skript zur Dauerberechnung für die Aufgabenaktivität.

    Tabelle für relative Dauer und DurationCalculator-Methoden

    Die Tabelle „cmn_relative_duration“ unterstützt die Definition eines Fälligkeitsdatums entweder als Zeitdauer oder als relative Dauer.

    Diese Tabelle besteht aus zwei Feldern: „Name“ und „Skript“. Das Feld „Skript“ enthält das Skript zur Berechnung der relativen Dauer. Dieses Skript enthält die Variable „calculator“, mit der das Fälligkeitsdatum berechnet wird.

    Die DurationCalculator-Skripteinbindung kann zur Durchführung der Dauerberechnungen verwendet werden. In dieser Skripteinbindung stehen die folgenden Methoden zur Verfügung.

    Tabelle : 1. Tabelle für DurationCalculator-Skripteinbindung
    Methode Beschreibung
    setSchedule(String schedID, [String timezone]) Legt den Zeitplan und die Zeitzone fest, die zur Berechnung des Fälligkeitsdatums verwendet werden sollen.
    setStartDateTime(GlideDateTime start) Legt die Startzeit für die Dauerberechnungen fest. Wenn „start“ leer ist, wird das aktuelle Datum/die aktuelle Uhrzeit verwendet.
    calcDuration(int seconds) Berechnet das Enddatum und die Endzeit. Nach Abschluss werden die Eigenschaften „this.endDateTime“ und „this.seconds“ festgelegt, um die Ergebnisse der Berechnung anzuzeigen.
    calcRelativeDuration(String relativeDurationID) Berechnet die Dauer mithilfe des angegebenen Skripts für die relative Dauer. Nach Abschluss werden die Eigenschaften „this.endDateTime“ und „this.seconds“ festgelegt, um die Ergebnisse der Berechnung anzuzeigen.
    getEndDateTime() Ruft die durch calcDuration/calcRelativeDuration festgelegte Eigenschaft „this.endDateTime“ ab, die das Enddatum und die Endzeit für die Dauer angibt.
    getSeconds() Ruft die von calcDuration/calcRelativeDuration festgelegte Eigenschaft „this.seconds“ ab, die die Gesamtzahl durchzuführender Arbeitssekunden für die Dauer angibt.
    Hinweis:
    Dies ist die Gesamtarbeitszeit, nicht die Gesamtzeit zwischen Start- und Endzeit, und kann zur Bestimmung von Prozentsätzen der Arbeitszeit verwendet werden.
    getTotalSeconds() Ruft die von calcDuration/calcRelativeDuration festgelegte Eigenschaft „this.totalSeconds“ ab, die die Gesamtzahl von Sekunden zwischen der Start- und Endzeit der Dauer angibt.

    Die folgenden Funktionen werden in Skripts zur Berechnung der relativen Dauer verwendet:

    Tabelle : 2. Funktionen in Skripts für die relative Dauer
    Funktion Beschreibung
    boolean isAfter(GlideDateTime dt, String time) Liegt die „time“ des Tages nach der von „dt“ angegebenen Uhrzeit? Wenn „dt“ leer ist, wird das aktuelle Datum/die aktuelle Uhrzeit verwendet. „time“ wird als „hh:mm:ss“ im 24-Stunden-Format angegeben.
    calcRelativeDueDate(GlideDateTime start, int days, String endTime) Berechnet das Fälligkeitsdatum, indem bei „start“ begonnen und „days“ anhand von Zeitplan und Zeitzone addiert wird. Wenn wir den Tag finden, an dem die Arbeit fällig ist, legen Sie „time“ auf die „endTime“ dieses Tages fest. Nach Abschluss werden die Eigenschaften „this.endDateTime“ und „this.seconds“ festgelegt, um die Ergebnisse der Berechnung anzuzeigen. Wenn „endTime“ leer ist, verwenden Sie das Ende des Arbeitstags.

    Benutzerobjekt abrufen

    In einer Business Rule oder einem anderen Serverskript gibt die Methode gs.getUser() ein Benutzerobjekt zurück. Das Benutzerobjekt ist eine interne Darstellung des aktuell angemeldeten Benutzers und liefert Informationen über den Benutzer und verschiedene Dienstprogrammfunktionen.

    Warum und wann dieser Vorgang ausgeführt wird

    Eine Liste und Beschreibung der verfügbaren bereichsbezogenen Methoden für das Anwenderobjekt finden Sie unter GlideUser .

    Prozedur

    1. Rufen Sie den aktuellen Benutzer ab. 
      var myUserObject = gs.getUser()
    2. Verwenden Sie die Methode getUserByID, um einen anderen Benutzer mit dem Feld user_name oder der sys_id im Zieldatensatz abzurufen.
      Beispiel: 
      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'));

    Protokollausgabe

    GSProtokoll Ist eine Skripteinbindung, die die Skriptprotokollierung und das Debugging vereinfacht, indem Ebenen der Protokollausgabe implementiert werden, die durch die vom Aufrufer identifizierten sys_properties-Werte ausgewählt werden können.

    Protokollebene

    Protokolle können sich auf der Ebene „Debuggen“, „Info“, „Hinweis“, „Warnung“, „Fehler“ befinden. oder kritisch (nach BSD syslog.h und Follower). Die standardmäßige Protokollierungsebene ist „Hinweis“, daher sollten Ebenen entsprechend ausgewählt werden.

    Verwendungszweck

    Verwenden Sie das Skript für jedes serverseitige Skript, in dem Sie die Event-Protokollierung implementieren möchten.

    Informationen zur API-Referenz finden Sie unter GSLog() .

    Weitere Informationen finden Sie unter Debugging-Skripts

    GlideDateTime-Feldwert ändern

    Dieses Beispiel zeigt, wie Sie einen ändern GlideDateTime Feldwert mit einem serverseitigen Skript.

    Angegeben GlideDateTime Feld- oder Skriptobjekt, zeigen Sie eine Vielzahl von Möglichkeiten an, den Wert einfach zu ändern. Dasselbe Konzept gilt auch für das GlideDate-Objekt.
    Hinweis:
    Das folgende Skript ist nur für globale Anwendungen vorgesehen.
    //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());
    Siehe auch:

    Verwenden anwenderdefinierter Warteschlangen zum Verarbeiten von Ereignissen

    Sie können anwenderdefinierte Warteschlangen für Anwendungen verwenden, die ein großes Volumen von Ereignissen oder Ereignisse erstellen, deren Verarbeitung lange dauert. Diese Aufgabe zeigt, wie eine anwenderdefinierte Warteschlange und ihr Überwachungsprozess erstellt und ein Skript zum Senden von Ereignissen an die Warteschlange verwendet werden.

    Vorbereitungen

    Erforderliche Rolle: Administrator

    Hinweis:
    Diese Informationen sind für fortgeschrittene Anwender gedacht, die die Ereignisverarbeitung verstehen.

    Prozedur

    1. Navigieren zu Systemrichtlinie > Events > Registryan.
    2. Wählen Sie das Ereignis aus, für das Sie eine anwenderdefinierte Warteschlange erstellen möchten.
      Die Ereignisregistrierung Formularanzeigen.
    3. Füllen Sie aus Warteschlange Feld für das Ereignis in der Ereignisregistrierung.
      Verwenden Sie nur Kleinbuchstaben, keine Leerzeichen und keine Sonderzeichen außer Unterstrich (_).

      Formular „Ereignisregistrierung“, das das Feld „Warteschlange“ mit dem Namen der Warteschlange in Kleinbuchstaben hervorhebt.

    4. Klicken Sie auf Absenden.
      Ein neues Ereignis wird in der Tabelle Ereignisse [sysevent] aufgeführt.

      Im folgenden Beispiel wird das Ereignis „EmployeeOccasion“ zu „my_Queue“ hinzugefügt, wenn das Ereignis generiert wird. Die Ereignisse hängen in der Warteschlange fest. Um dieses Problem zu beheben, erstellen Sie einen Prozess, um die Warteschlange auf Ereignisse zu überwachen.Ereignistabelle, die das Ereignis mit der hinzugefügten Warteschlange auflistet, die im Warteschlangenfeld aufgeführt ist.

    5. Navigieren zu Systemzeitplaner > Geplante Jobs > Geplante Aufgaben Und öffnen Sie die geplante Aufgabe mit dem Namen Prozess für Textindexereignisse .
      Zeitplan Tabelle mit *Text In Name Suchfeld und der Name des Prozess für Textindexereignisse Zeitplan hervorgehoben.
    6. Klicken Sie auf das Menüsymbol „zusätzliche Aktionen“ Symbolmenü „zusätzliche Aktionen“)--> und auswählen Einfügen und beibehalten Um eine Kopie von zu erstellen Prozess für Textindexereignisse .
      Wichtig:
      Stellen Sie sicher, dass Sie den Auftrag kopieren und nicht überschreiben Prozess für Textindexereignisse Geplante Aufgabe.
    7. Ändern Sie im kopierten Zeitplanelement den Wert in Name Feld.
    8. In Auftragskontext Feld ersetzen Sie den Wert für GlideEventManager() Parameter mit dem Namen der neuen Warteschlange.
      Zeitplanelement Formular mit dem umbenannten kopierten Element und dem aktualisierten Warteschlangennamen für GlideEventManager in Auftragskontext Feld.
      Der Warteschlangenüberwachungsprozess sucht im Beispiel nach Ereignissen und verarbeitet sie My_Queue Ereigniswarteschlange.

      Ereignistabelle, die den Inhalt der Felder „verarbeitet“ und „Warteschlange“ hervorhebt.

    9. Verwenden Sie gs.eventWarteschlange() Fünfter Parameter der Methode zum Senden von Ereignissen an die anwenderdefinierte Warteschlange.

      Der folgende Code zeigt, wie ein Ereignis an die anwenderdefinierte Warteschlange „my_Queue“ gesendet wird.

      gs.eventQueue('x_60157_employee_spe.employeeOccasion', todaysOccasions, todaysOccasions.number, todaysOccasions.u_employee.name, 'my_queue');
      Hinweis:
      Wenn sich ein Ereignis in befindet Ereignisregistrierung Und es wird kein Warteschlangenname für angegeben gs.eventWarteschlange , Die Warteschlange aus dem Ereignisregistrierung Ist dem Ereignis weiterhin zugewiesen. Beispiel: gs.eventQueue('x_60157_Employee_spe.EmployeeOccasion') Ordnet das Ereignis weiterhin zu My_Queue . Wenn der Warteschlangenname in angegeben ist gs.eventWarteschlange() Anruf, die Warteschlange hat Priorität.
      Sie können überprüfen, ob das aufgerufene Ereignis verarbeitet wurde, indem Sie überprüfen Ereignisse [Sysevent] Tabelle.

      Ereignistabelle, die verarbeitete Ereignisse nach Ereignisname gefiltert auflistet.