JSONArray.addAll(JSONArray)

Cette méthode ajoute un tableau à un autre.

Pour le contexte d'exécution de dialogue suivant :

{
  "context": {
    "toppings_array": ["onion", "olives"],
    "more_toppings": ["mushroom","pepperoni"]
  }
}

Effectuez la mise à jour suivante :

{
  "context": {
    "toppings_array": "<? $toppings_array.addAll($more_toppings) ?>"
  }
}

Résultat : La méthode elle-même renvoie null. Cependant, le premier tableau est mis à jour pour inclure les valeurs du second tableau.

{
  "context": {
    "toppings_array": ["onion", "olives", "mushroom", "pepperoni"]
  }
}

JSONArray.append(object)

Cette méthode ajoute une nouvelle valeur à l'élément JSONArray et renvoie l'élément JSONArray modifié.

Pour le contexte d'exécution de dialogue suivant :

{
  "context": {
    "toppings_array": ["onion", "olives"]
  }
}

Effectuez la mise à jour suivante :

{
  "context": {
    "toppings_array": "<? $toppings_array.append('ketchup', 'tomatoes') ?>"
  }
}

Résultat :

{
  "context": {
    "toppings_array": ["onion", "olives", "ketchup", "tomatoes"]
  }
}

JSONArray.clear()

Cette méthode efface toutes les valeurs du tableau et renvoie la valeur null.

Utilisez l'expression suivante dans la sortie pour définir une zone qui efface un tableau que vous avez enregistré dans une variable contextuelle ($toppings_array) de ses valeurs.

{
  "output": {
    "array_eraser": "<? $toppings_array.clear() ?>"
  }
}

Ensuite, si vous faites référence à la variable contextuelle $toppings_array, elle renvoie uniquement ' [] '.

JSONArray.contains(Object value)

Cette méthode renvoie la valeur true si l'élément JSONArray d'entrée contient la valeur d'entrée.

Pour ce dialogue, le contexte d'exécution est défini par un nœud précédent ou une application externe :

{
  "context": {
    "toppings_array": ["onion", "olives", "ham"]
  }
}

Condition de noeud ou de réponse de dialogue :

$toppings_array.contains('ham')

Résultat : true car le tableau contient l'élément ham.

JSONArray.containsIgnoreCase (valeur d'objet)

Cette méthode renvoie true si l'entrée JSONArray contient la valeur d'entrée, que la valeur soit spécifiée en majuscules ou en minuscules.

Pour ce dialogue, le contexte d'exécution est défini par un nœud précédent ou une application externe :

{
  "context": {
    "toppings_array": ["onion", "olives", "ham"]
  }
}

Condition de noeud ou de réponse de dialogue :

$toppings_array.containsIgnoreCase('HAM')

Résultat : true car le tableau contient l'élément ham et le cas est ignoré.

JSONArray.containsIntent (String intent_name, Double min_score, [Entier top_n])

Cette méthode renvoie true si le tableau JSONArray, intents, contient spécifiquement l'intention indiquée et que celle-ci possède une cote de confiance égale ou supérieure à la cote minimale définie. Vous pouvez éventuellement définir un nombre d'éléments principaux pour indiquer que l'intention doit être incluse dans ce nombre pour figurer dans le tableau. Le paramètre top_n est ignoré si vous indiquez un nombre négatif.

Cette méthode renvoie false si l'intention spécifiée ne figure pas dans le tableau, si sa cote de confiance n'est pas supérieure ou égale à la cote de confiance minimale, ou si l'index de l'intention dans le tableau est inférieur à l'emplacement d'index spécifié.

Le service génère automatiquement un tableau d'intents qui répertorie les intentions que le service détecte dans l'entrée chaque fois que l'entrée utilisateur est soumise. Le tableau répertorie en premier lieu toutes les intentions détectées par le service dans l'ordre de confiance la plus élevée.

Vous pouvez utiliser cette méthode dans une condition de noeud non seulement pour vérifier la présence d'une intention, mais également pour définir un seuil de cote de confiance à respecter afin que le noeud puisse être traité et que sa réponse soit renvoyée.

Par exemple, utilisez l'expression suivante dans une condition de noeud lorsque vous souhaitez déclencher le noeud de dialogue uniquement lorsque les conditions suivantes sont remplies :

• L'intention #General_Ending est présente.
• Le score de confiance de l'objectif #General_Ending est supérieur à 80%.
• L'intention #General_Ending est l'une des 2 meilleures intentions du tableau d'intentions.

intents.containsIntent("General_Ending", 0.8, 2)

JSONArray.filter(temp, "temp.property operator comparison_value")

Filtre un tableau en comparant chaque valeur d'élément de tableau à une valeur que vous spécifiez. Cette méthode est similaire à une projection de collection. Une projection de collection renvoie un tableau filtré basé sur un nom dans une paire nom-valeur d'élément de tableau. La méthode de filtrage renvoie un tableau filtré basé sur une valeur d'une paire nom-valeur d'élément de tableau.

L'expression de filtre comprend les valeurs suivantes :

• temp : nom d'une variable utilisée temporairement lorsque chaque élément du tableau est évalué. Par exemple, city.

• property : propriété d'élément que vous souhaitez comparer à comparison_value. Spécifiez la propriété en tant que propriété de la variable temporaire nommée dans le premier paramètre. Utilisez la syntaxe : temp.property. Par exemple, si latitude est un nom d'élément valide pour une paire nom-valeur du tableau, spécifiez la propriété sous la forme city.latitude.

• operator : opérateur à utiliser pour comparer la valeur de la propriété à comparison_value.

  Les opérateurs pris en charge sont :

  Opérateurs de filtre pris en charge

  Opérateur	Description
  ==	Est égal à
  >	Est supérieure à
  <	Est inférieur à
  >=	Est supérieur ou égal à
  <=	Est inférieur ou égal à
  !=	N'est pas égal à

• comparison_value : valeur à laquelle vous souhaitez comparer chaque valeur de propriété d'élément de tableau. Pour spécifier une valeur pouvant changer en fonction de l'entrée utilisateur, utilisez une variable contextuelle ou une entité comme valeur. Si vous spécifiez une valeur qui peut varier, ajoutez une logique pour garantir que la valeur comparison_value est valide au moment de l'évaluation, sinon une erreur se produit.

[
   {
      "name":"Tokyo",
      "population":9273000
   },
   {
      "name":"Rome",
      "population":2868104
   },
   {
      "name":"Beijing",
      "population":20693000
   },
   {
      "name":"Paris",
      "population":2241346
   }
]

$cities.filter("city", "city.population > 5000000")

[
   {
      "name":"Tokyo",
      "population":9273000
   },
   {
      "name":"Beijing",
      "population":20693000
   }
]

The cities with more than 5 million people include <?  T(String).join(", ",($cities.filter("city", "city.population > 5000000")).![name]) ?>.

$cities.filter("city", "city.population > $population_min")

[
   {
      "name":"Tokyo",
      "population":9273000
   },
   {
      "name":"Beijing",
      "population":20693000
   }
]

The cities with more than $population_min people include <?  T(String).join(", ",($cities.filter("city", "city.population > $population_min")).![name]) ?>.

$cities.filter("y", "y.name == @city")

[
   {
      "name":"Tokyo",
      "population":9273000
   }
]

The population of @city is: <? ($cities.filter("y", "y.name == @city").![population]).get(0) ?>.

JSONArray.get(Integer)

Cette méthode renvoie un index d'entrée à partir de l'élément JSONArray.

Pour ce dialogue, le contexte d'exécution est défini par un nœud précédent ou une application externe :

{
  "context": {
    "name": "John",
    "nested": {
      "array": [ "one", "two" ]
    }
  }
}

Condition de noeud ou de réponse de dialogue :

$nested.array.get(0).getAsString().contains('one')

Résultat : True car le tableau imbriqué contient one comme valeur.

Réponse :

"output": {
  "generic" : [
    {
      "values": [
        {
        "text" : "The first item in the array is <?$nested.array.get(0)?>"
        }
      ],
      "response_type": "text",
      "selection_policy": "sequential"
    }
  ]
  }

JSONArray.getRandomItem()

Cette méthode renvoie un élément aléatoire à partir de l'élément JSONArray d'entrée.

Pour le contexte d'exécution de dialogue suivant :

{
  "context": {
    "toppings_array": ["onion", "olives", "ham"]
  }
}

Sortie du noeud de dialogue :

{
  "output": {
  "generic" : [
    {
      "values": [
        {
    "text": "<? $toppings_array.getRandomItem() ?> is a great choice!"
        }
      ],
      "response_type": "text",
      "selection_policy": "sequential"
    }
  ]
  }
}

Résultat : "ham is a great choice!" ou "onion is a great choice!" ou "olives is a great choice!"

Le texte de sortie résultant est choisi de manière aléatoire.

JSONArray.indexOf(value)

Cette méthode renvoie le numéro d'index de l'élément dans le tableau qui correspond à la valeur que vous spécifiez en tant que paramètre ou à -1 si la valeur est introuvable dans le tableau. La valeur peut être une chaîne ( "School" ), un nombre entier ( 8 ) ou un double ( 9.1 ). La valeur doit être une correspondance exacte et est sensible à la casse.

Par exemple, les variables contextuelles suivantes contiennent des tableaux :

{
  "context": {
    "array1": ["Mary","Lamb","School"],
    "array2": [8,9,10],
    "array3": [8.1,9.1,10.1]
  }
}

Les expressions suivantes peuvent être utilisées pour déterminer l'index de tableau auquel la valeur est spécifiée :

<? $array1.indexOf("Mary") ?> returns `0`
<? $array2.indexOf(9) ?> returns `1`
<? $array3.indexOf(10.1) ?> returns `2`

Cette méthode peut être utile pour obtenir l'index d'un élément dans un tableau d'intentions, par exemple. Vous pouvez appliquer la méthode indexOf au tableau d'intentions généré chaque fois que l'entrée utilisateur est évaluée afin de déterminer le numéro d'index du tableau d'une intention spécifique.

intents.indexOf("General_Greetings")

Si vous souhaitez connaître la cote de confiance d'une intention spécifique, vous pouvez transmettre l'expression précédente en tant que valeur d'index à une expression avec la syntaxe intents[index].confidence. Exemple :

intents[intents.indexOf("General_Greetings")].confidence

JSONArray.join(String delimiter)

Cette méthode joint toutes les valeurs de ce tableau à une chaîne. Les valeurs sont converties en chaînes de caractères et délimitées par le délimiteur d'entrée.

Pour le contexte d'exécution de dialogue suivant :

{
  "context": {
    "toppings_array": ["onion", "olives", "ham"]
  }
}

Sortie du noeud de dialogue :

{
  "output": {
  "generic" : [
    {
      "values": [
        {
    "text": "This is the array: <? $toppings_array.join(';') ?>"
        }
      ],
      "response_type": "text",
      "selection_policy": "sequential"
    }
  ]
  }
}

Résultat :

This is the array: onion;olives;ham;

Si un utilisateur mentionne plusieurs garnitures et que vous avez défini une entité nommée @toppings capable de reconnaître les mentions de garnitures, vous pouvez utiliser l'expression suivante dans la réponse pour dresser la liste des garnitures mentionnées :

So, you'd like <? @toppings.values.join(',') ?>.

Si vous définissez une variable qui stocke plusieurs valeurs dans un tableau JSON, vous pouvez renvoyer un sous-ensemble de valeurs du tableau. Utilisez la méthode join() pour les formater correctement.

"flights_found": [
  {
    "time": "10:00",
    "flight_code": "OK123"
  },
  {
    "time": "12:30",
    "flight_code": "LH421"
  },
  {
    "time": "16:15",
    "flight_code": "TS4156"
  }
]

<? $flights_found.![flight_code] ?>

The flights that fit your criteria are:
  <? T(String).join(",", $flights_found.![flight_code]) ?>.

JSONArray.joinToArray(template, retainDataType)

Cette méthode extrait les informations de chaque élément du tableau et génère un nouveau tableau qui est formaté en fonction du modèle que vous spécifiez. Le modèle peut être une chaîne, un objet JSON ou un tableau. La méthode renvoie un tableau de chaînes, un tableau d'objets ou un tableau de tableaux, selon le type de modèle.

Cette méthode est utile pour formater les informations sous la forme d'une chaîne que vous pouvez renvoyer dans le cadre de la sortie d'un noeud de dialogue ou pour transformer les données dans une structure différente afin de pouvoir les utiliser avec une API externe.

Dans le modèle, vous pouvez référencer des valeurs du tableau source à l'aide de la syntaxe suivante, où {property} représente le nom de la propriété dans le tableau source.

%e.{property}%

Par exemple, supposons que votre assistant stocke un tableau contenant les détails du vol dans une variable contextuelle. Les données stockées peuvent se présenter comme suit:

"flights": [
      {
        "flight": "AZ1040",
        "origin": "JFK",
        "carrier": "Alitalia",
        "duration": 485,
        "destination": "FCO",
        "arrival_date": "2019-02-03",
        "arrival_time": "07:00",
        "departure_date": "2019-02-02",
        "departure_time": "16:45"
      },
      {
        "flight": "DL1710",
        "origin": "JFK",
        "carrier": "Delta",
        "duration": 379,
        "destination": "LAX",
        "arrival_date": "2019-02-02",
        "arrival_time": "10:19",
        "departure_date": "2019-02-02",
        "departure_time": "07:00"
      },
      {
        "flight": "VS4379",
        "origin": "BOS",
        "carrier": "Virgin Atlantic",
        "duration": 385,
        "destination": "LHR",
        "arrival_date": "2019-02-03",
        "arrival_time": "09:05",
        "departure_date": "2019-02-02",
        "departure_time": "21:40"
      }
    ]

Pour générer un tableau de chaînes décrivant ces vols sous une forme lisible par l'utilisateur, vous pouvez utiliser l'expression suivante:

${Flight_data}.joinToArray("Flight %e.flight% to %e.destination%", true)

Cette expression renvoie le tableau de chaînes suivant: ["Flight AZ1040 to FCO","Flight DL1710 to LAX","Flight VS4379 to LHR"].

Le paramètre retainDataType facultatif indique si la méthode doit conserver le type de données de toutes les valeurs d'entrée dans le tableau renvoyé. Si retainDataType est défini sur false ou omis, dans certains cas, les chaînes du tableau d'entrée peuvent être converties en nombres dans le tableau renvoyé. Par exemple, si les valeurs sélectionnées dans le tableau d'entrée sont "1", "2" et "3", le tableau renvoyé peut être [ 1, 2, 3 ]. Pour éviter des conversions de type inattendues, spécifiez true pour ce paramètre.

<br/>Flight number: %e.flight% <br/> Airline: %e.carrier% <br/> Departure date: %e.departure_date% <br/> Departure time: %e.departure_time% <br/> Arrival time: %e.arrival_time% <br/>

${Flight_data}.joinToArray(${Template})

Flight number: AZ1040
Airline: Alitalia
Departure date: 2019-02-02
Departure time: 16:45
Arrival time: 07:00

Flight number: DL1710
Airline: Delta
Departure date: 2019-02-02
Departure time: 07:00
Arrival time: 10:19

Flight number: VS4379
Airline: Virgin Atlantic
Departure date: 2019-02-02
Departure time: 21:40
Arrival time: 09:05

{
  "departure": "Flight %e.flight% departs on %e.departure_date% at %e.departure_time%.",
  "arrival": "Flight %e.flight% arrives on %e.arrival_date% at %e.arrival_time%."
}

JSONArray.remove(Integer)

Cette méthode retire l'élément de la position d'index dans l'élément JSONArray et renvoie l'élément JSONArray ainsi mis à jour.

Pour le contexte d'exécution de dialogue suivant :

{
  "context": {
    "toppings_array": ["onion", "olives"]
  }
}

Effectuez la mise à jour suivante :

{
  "context": {
    "toppings_array": "<? $toppings_array.remove(0) ?>"
  }
}

Résultat :

{
  "context": {
    "toppings_array": ["olives"]
  }
}

JSONArray.removeValue(object)

Cette méthode retire la première occurrence de la valeur dans l'élément JSONArray et renvoie l'élément JSONArray ainsi mis à jour.

Pour le contexte d'exécution de dialogue suivant :

{
  "context": {
    "toppings_array": ["onion", "olives"]
  }
}

Effectuez la mise à jour suivante :

{
  "context": {
    "toppings_array": "<? $toppings_array.removeValue('onion') ?>"
  }
}

Résultat :

{
  "context": {
    "toppings_array": ["olives"]
  }
}

JSONArray.set(Integer index, Object value)

Cette méthode affecte la valeur d'entrée à l'index d'entrée de l'élément JSONArray et renvoie l'élément JSONArray ainsi modifié.

Pour le contexte d'exécution de dialogue suivant :

{
  "context": {
    "toppings_array": ["onion", "olives", "ham"]
  }
}

Sortie du noeud de dialogue :

{
  "context": {
    "toppings_array": "<? $toppings_array.set(1,'ketchup')?>"
  }
}

Résultat :

{
  "context": {
    "toppings_array": ["onion", "ketchup", "ham"]
  }
}

JSONArray.size()

Cette méthode renvoie la taille de l'élément JSONArray sous la forme d'un entier.

Pour le contexte d'exécution de dialogue suivant :

{
  "context": {
    "toppings_array": ["onion", "olives"]
  }
}

Effectuez la mise à jour suivante :

{
  "context": {
    "toppings_array_size": "<? $toppings_array.size() ?>"
  }
}

Résultat :

{
  "context": {
    "toppings_array_size": 2
  }
}

JSONArray split(expression régulière de type Chaîne)

Cette méthode fractionne la chaîne d'entrée à l'aide de l'expression régulière d'entrée. Le résultat obtenu est un élément JSONArray composé de chaînes.

Pour l'entrée suivante :

"bananas;apples;pears"

La syntaxe suivante :

{
  "context": {
    "array": "<?input.text.split(";")?>
  }
}

Génère la sortie suivante :

{
  "context": {
    "array": [ "bananas", "apples", "pears" ]
  }
}

Prise en charge de com.google.gson.JsonArray

En plus des méthodes intégrées, vous pouvez utiliser des méthodes standard de la classe com.google.gson.JsonArray.

{
  "context":{
    "answer": "<? output.answer?:new JsonArray().append('temp_value') ?>"
  }

.after(date-heure de type Chaîne)

Détermine si la valeur date-heure figure après l'argument date-heure.

.before(date-heure de type Chaîne)

Détermine si la valeur date-heure figure avant l'argument date-heure.

Exemple :

• @sys-time.before('12:00:00')

• @sys-date.before('2016-11-21')

• Si vous comparez des éléments différents, tels que time vs. date, date vs. time, et time vs. date and time, la méthode renvoie un message faux et une exception est imprimée dans le journal JSON de la réponse output.log_messages.

  Par exemple, @sys-date.before(@sys-time).

• Si vous comparez date and time vs. time, la méthode ignore la date et ne compare que les heures.

now(fuseau horaire de type Chaîne)

Renvoie une chaîne avec la date et l'heure en cours au format yyyy-MM-dd HH:mm:ss. Vous pouvez également indiquer une valeur timezone pour obtenir la date et l'heure actuelles d'un fuseau horaire spécifique, avec une chaîne renvoyée au format yyyy-MM-dd HH:mm:ss 'GMT'XXX.

• Fonction statique.
• Les autres méthodes dates-heure peuvent être appelées sur les valeurs date-heure qui sont renvoyées par cette fonction et peuvent être transmises en tant qu'arguments.
• L'interface utilisateur crée automatiquement une variable contextuelle $timezone pour que l'heure correcte soit renvoyée lorsque vous effectuez un test à partir du volet "Try it out". Si vous ne transmettez pas de fuseau horaire, celui qui est défini automatiquement par l'interface utilisateur est utilisé. En dehors de l'interface utilisateur, le fuseau horaire GMT est utilisé. Pour en savoir plus sur la syntaxe à utiliser pour spécifier le fuseau horaire, voir Fuseaux horaires pris en charge par les entités du système.

Exemple d'utilisation de now() pour vérifier d'abord si c'est le matin avant que l'assistant ne réponde avec un message d'accueil spécifique au matin.

{
  "conditions": "now().before('12:00:00')",
  "output": {
      "generic": [
        {
        "values": [
          {
          "text": "Good morning!"
          }
        ],
        "response_type": "text",
        "selection_policy": "sequential"
        }
      ]
  }
}

Exemple d'utilisation de now() avec un fuseau horaire pour obtenir l'heure actuelle (en Angleterre):

{
  "output": {
      "generic": [
        {
        "values": [
          {
          "text": "The current date and time is: <? now('Europe/London') ?>"
          }
        ],
        "response_type": "text",
        "selection_policy": "sequential"
        }
      ]
  }
}

Vous pouvez remplacer la valeur du fuseau horaire codée en dur par une variable contextuelle afin de modifier dynamiquement l'heure en fonction d'un fuseau horaire transmis à l'expression. Par exemple : <? now('$myzone') ?>. La variable contextuelle $myzone peut avoir pour valeur 'Australia/Sydney' dans une conversation et pour valeur 'Mexico/BajaNorte' dans une autre conversation.

.reformatDateTime(String format)

Formate les chaînes de date et d'heure au format souhaité pour la sortie utilisateur.

Renvoie une chaîne mise en forme selon le format spécifié :

• MM/dd/yyyy pour 12/31/2016
• h a pour 10pm

Pour renvoyer le jour de la semaine :

• EEEE pour mardi
• E pour Tue
• u pour l'index de jour (1 = Lundi, ..., 7 = Dimanche)

Par exemple, cette définition de variable contextuelle crée une variable $time qui sauvegarde la valeur 17:30:00 sous 5:30 PM.

{
  "context": {
    "time": "<? @sys-time.reformatDateTime('h:mm a') ?>"
  }
}

Le format suit les règles Java SimpleDateFormat.

Remarque: Lorsque vous essayez de formater uniquement l'heure, la date est traitée comme 1970-01-01.

.sameMoment(String date/time)

• Détermine si la valeur date-heure est identique à l'argument date-heure.

.sameOrAfter(String date/time)

• Détermine si la valeur date-heure figure après ou est identique à l'argument date-heure.
• Semblable à .after().

.sameOrBefore(String date/time)

• Détermine si la valeur date-heure figure avant ou est identique à l'argument date-heure.

today()

Renvoie une chaîne avec la date en cours au format yyyy-MM-dd.

• Fonction statique.
• Les autres méthodes de date peuvent être appelées sur les valeurs date qui sont renvoyées par cette fonction et peuvent être transmises en tant qu'arguments.
• Si la variable contextuelle $timezone est définie, cette fonction renvoie des dates exprimées dans le fuseau horaire du client. Sinon, le fuseau horaire GMT est utilisé.

Exemple de noeud de dialogue today() utilisé dans la zone de sortie :

{
  "conditions": "#what_day_is_it",
  "output": {
    "generic": [
      {
        "values": [
          {
          "text": "Today's date is <? today() ?>."
          }
        ],
        "response_type": "text",
        "selection_policy": "sequential"
      }
    ]
  }
}

Résultat : Today's date is 2018-03-09.

Utilisation des intervalles de temps

Pour afficher une réponse selon que la date du jour se situe ou non dans une période donnée, vous pouvez utiliser une combinaison de méthodes liées au temps. Par exemple, si vous proposez annuellement une offre spéciale pendant les fêtes de fin d'année, vous pouvez vérifier si la date du jour se situe entre le 25 novembre et le 24 décembre de cette année. Commencez par définir les dates d’intérêt en tant que variables contextuelles.

Dans les expressions suivantes de variables contextuelles de date de début et de fin, la date est construite en concaténant la valeur dérivée de l'année en cours avec les valeurs du mois et du jour codées en dur.

"context": {
   "end_date": "<? now().reformatDateTime('Y') + '-12-24' ?>",
   "start_date": "<? now().reformatDateTime('Y') + '-11-25' ?>"
 }

Dans la condition de réponse, vous pouvez indiquer que vous souhaitez afficher la réponse uniquement si la date du jour se situe entre les dates de début et de fin que vous avez définies en tant que variables contextuelles.

now().after($start_date) && now().before($end_date)

Prise en charge de java.util.Date

En plus des méthodes intégrées, vous pouvez utiliser des méthodes standard de la classe java.util.Date.

Pour obtenir la date du jour dans une semaine à partir d'aujourd'hui, vous pouvez utiliser la syntaxe suivante :

{
  "context": {
    "week_from_today": "<? new Date(new Date().getTime() +
      (7 * (24*60*60*1000L))) ?>"
  }
}

Cette expression permet d'abord d'obtenir la date actuelle en millisecondes depuis le 1er janvier 1970, 00:00:00 Temps Universel Coordonné. Elle calcule également le nombre de millisecondes dans 7 jours. (La formule (24*60*60*1000L) représente un jour en millisecondes.) Elle ajoute ensuite 7 jours à la date du jour. Le résultat obtenu correspond à la date complète du jour dans une semaine à partir d'aujourd'hui. Par exemple, Fri Jan 26 16:30:37 UTC 2018. L'heure est dans le fuseau horaire du temps universel coordonné. Vous pouvez toujours remplacer le 7 par une variable (par exemple, $number_of_days) que vous pouvez transmettre. Assurez-vous que sa valeur est définie avant que cette expression ne soit évaluée.

Si vous voulez pouvoir comparer la date avec une autre date générée par le service, vous devez reformater la date. Les entités système (@sys-date) et d'autres méthodes intégrées (now()) convertissent les dates au format yyyy-MM-dd

{
  "context": {
    "week_from_today": "<? new Date(new Date().getTime() +
      (7 * (24*60*60*1000L))).format('yyyy-MM-dd') ?>"
  }
}

Après reformatage de la date, le résultat est 2018-01-26. Vous pouvez désormais utiliser une expression telle que @sys-date.after($week_from_today) dans une condition de réponse pour comparer une date spécifiée par l'utilisateur à la date enregistrée dans la variable contextuelle.

L'expression suivante calcule l'heure qu'il sera dans 3 heures :

{
  "context": {
    "future_time": "<? new Date(new Date().getTime() + (3 * (60*60*1000L)) -
      (5 * (60*60*1000L))).format('h:mm a') ?>"
  }
}

La valeur (60*60*1000L) représente une heure en millisecondes. Cette expression ajoute 3 heures à l'heure en cours. Il recalcule ensuite l'heure du fuseau horaire du temps universel coordonné au fuseau horaire de l'EST en lui soustrayant 5 heures. Elle reformate également les valeurs de date afin d'inclure les heures et les minutes.

toDouble()

Convertit l'objet ou la zone en type Nombre double. Vous pouvez appeler cette méthode sur n'importe quel objet ou sur n'importe quelle zone. Si la conversion échoue, null est renvoyé.

toInt()

Convertit l'objet ou la zone en type Nombre entier. Vous pouvez appeler cette méthode sur n'importe quel objet ou sur n'importe quelle zone. Si la conversion échoue, null est renvoyé.

toLong()

Convertit l'objet ou la zone en type Nombre long. Vous pouvez appeler cette méthode sur n'importe quel objet ou sur n'importe quelle zone. Si la conversion échoue, null est renvoyé.

Si vous spécifiez un type numérique Long dans une expression SpEL, vous devez ajouter un L au numéro pour l'identifier comme tel. Par exemple, 5000000000L. Cette syntaxe est requise pour les nombres qui ne font pas partie du type Entier 32 bits. Par exemple, les nombres supérieurs à 2^31 (2 147 483 648) ou inférieurs à -2 (-2 147 483 648) sont considérés comme des nombres longs. Les types numériques Long ont une valeur minimale de -2^63 et une valeur maximale de 2^63-1 (ou 9,223,372,036,854,775,807).

Si vous devez déterminer si un nombre est trop long pour être reconnu, vérifiez s'il y a plus de 18 entiers dans le nombre en utilisant une expression comme celle-ci :

<? @sys-number.toString().length() > 18 ?>

Si vous devez travailler avec des nombres plus longs que 18 entiers, envisagez d'utiliser une entité motif (avec une expression régulière telle que \d{20} ) pour travailler avec eux au lieu d'utiliser @sys-number.

Mathématiques standard

Utilisez des expressions SpEL pour définir des équations mathématiques standard, dans lesquelles les opérateurs sont représentés à l'aide de ces symboles :

Par exemple, dans une réponse à un nœud de dialogue, vous pouvez ajouter une variable contextuelle qui capture un nombre spécifié dans la saisie de l'utilisateur ( @sys-number ) et l'enregistre en tant que $your_number. Vous pourriez ensuite ajouter le texte suivant à la réponse :

I'm doing math. Given the value you specified ($your_number), when I add 5, I get: <? $your_number + 5 ?>.
When I subtract 5, I get: <? $your_number - 5 ?>.
When I multiply it by 5, I get: <? $your_number * 5 ?>.
When I divide it by 5, I get: <? $your_number/5 ?>.

Si l'utilisateur indique 10, le texte de la réponse devient :

I'm doing math. Given the value you specified (10), when I add 5, I get: 15.
When I subtract 5, I get: 5.
When I multiply it by 5, I get: 50.
When I divide it by 5, I get: 2.

Prise en charge des nombres Java

java.lang.Math()

Effectue des opérations numériques de base.

Vous pouvez utiliser les méthodes Class:

max ()

{
  "context": {
    "bigger_number": "<? T(Math).max($number1,$number2) ?>"
  },
  "output": {
    "generic": [
      {
        "values": [
          {
          "text": "The bigger number is $bigger_number."
          }
        ],
        "response_type": "text",
        "selection_policy": "sequential"
      }
    ]
  }
}

min ()

{
  "context": {
    "smaller_number": "<? T(Math).min($number1,$number2) ?>"
  },
  "output": {
    "generic": [
      {
        "values": [
          {
          "text": "The smaller number is $smaller_number."
          }
        ],
        "response_type": "text",
        "selection_policy": "sequential"
      }
    ]
  }
}

pow()

{
  "context": {
    "power_of_two": "<? T(Math).pow($base.toDouble(),2.toDouble()) ?>"
  },
  "output": {
    "generic": [
      {
        "values": [
          {
          "text": "Your number $base to the second power is $power_of_two."
          }
        ],
        "response_type": "text",
        "selection_policy": "sequential"
      }
    ]
  }
}

Pour plus d'informations, voir la documentation de référencejava.lang.Math.

java.util.Random()

Renvoie un nombre aléatoire. Vous pouvez utiliser l'une des options de syntaxe suivantes :

• Pour renvoyer une valeur booléenne aléatoire (true ou false), utilisez <?new Random().nextBoolean()?>.
• Pour renvoyer un nombre double aléatoire compris entre 0 (inclus) et 1 (exclu), utilisez <?new Random().nextDouble()?>.
• Pour renvoyer un entier aléatoire entre 0 (inclus) et un nombre que vous spécifiez, utilisez <?new Random().nextInt(n)?> où n est le haut de la plage de nombres que vous voulez + 1. Par exemple, si vous souhaitez renvoyer un nombre aléatoire entre 0 et 10, indiquez <?new Random().nextInt(11)?>.
• Pour renvoyer un entier aléatoire de la plage de valeurs entière entière (-2147483648 à 2147483648), utilisez <?new Random().nextInt()?>.

Par exemple, vous pouvez créer un noeud de dialogue qui est déclenché par l'intention #random_number. La première condition de réponse peut se présenter comme suit :

Condition = @sys-number
{
  "context": {
    "answer": "<? new Random().nextInt(@sys-number.numeric_value + 1) ?>"
  },
  "output": {
    "generic": [
      {
        "values": [
          {
          "text": "Here's a random number between 0 and @sys-number.literal: $answer."
          }
        ],
        "response_type": "text",
        "selection_policy": "sequential"
      }
    ]
  }
}

Voir la documentation de référence java.util.Random pour plus d'informations sur les autres méthodes.

Vous pouvez également utiliser des méthodes standard des classes suivantes :

• java.lang.Byte
• java.lang.Integer
• java.lang.Long
• java.lang.Double
• java.lang.Short
• java.lang.Float

JSONObject.clear()

Cette méthode efface toutes les valeurs de l'objet JSON et renvoie la valeur null.

Par exemple, vous souhaitez effacer les valeurs actuelles de la variable contextuelle $user.

{
  "context": {
    "user": {
      "first_name":"John",
      "last_name":"Snow"
    }
  }
}

Utilisez l'expression suivante dans la sortie pour définir une zone qui efface l'objet de ses valeurs.

{
  "output": {
    "object_eraser": "<? $user.clear() ?>"
  }
}

Si vous faites référence à la variable contextuelle $user, elle renvoie uniquement {}.

Vous pouvez utiliser la méthode clear() sur les objets JSON context ou output dans le corps de l'appel d'API /message.

{
  "output": {
    "generic": [
      {
        "values": [
          {
          "text": "Response for this node."
          }
        ],
        "response_type": "text",
        "selection_policy": "sequential"
      }
    ],
    "context_eraser": "<? context.clear() ?>"
  }
}

{
  "output": {
    "generic": [
      {
        "values": [
          {
          "text": "Have a great day!"
          }
        ],
        "response_type": "text",
        "selection_policy": "sequential"
      }
    ],
    "output_eraser": "<? output.clear() ?>"
  }
}

JSONObject.has(String)

Cette méthode renvoie la valeur true si l'élément JSONObject complexe contient une propriété du nom d'entrée.

Pour le contexte d'exécution de dialogue suivant :

{
  "context": {
    "user": {
      "first_name": "John",
      "last_name": "Snow"
    }
  }
}

Sortie du noeud de dialogue :

{
  "conditions": "$user.has('first_name')"
}

Résultat : la condition est true car l'objet utilisateur contient la propriété first_name.

JSONObject.remove(String)

Cette méthode retire une propriété du nom de l'élément JSONObject d'entrée. L'élément JSONElement qui est renvoyé par cette méthode est l'élément JSONElement en cours de retrait.

Pour le contexte d'exécution de dialogue suivant :

{
  "context": {
    "user": {
      "first_name": "John",
      "last_name": "Snow"
    }
  }
}

Sortie du noeud de dialogue :

{
  "context": {
    "attribute_removed": "<? $user.remove('first_name') ?>"
  }
}

Résultat :

{
  "context": {
    "user": {
      "last_name": "Snow"
    },
    "attribute_removed": {
      "first_name": "John"
    }
  }
}

Prise en charge de com.google.gson.JsonObject

En plus des méthodes intégrées, certaines des méthodes standard de la classe com.google.gson.JsonObject sont également prises en charge.

String.append(Object)

Cette méthode ajoute un objet d'entrée à la chaîne sous forme de chaîne et renvoie une chaîne modifiée.

Pour le contexte d'exécution de dialogue suivant :

{
  "context": {
    "my_text": "This is a text."
  }
}

La syntaxe suivante :

{
  "context": {
    "my_text": "<? $my_text.append(' More text.') ?>"
  }
}

Génère la sortie suivante :

{
  "context": {
    "my_text": "This is a text. More text."
  }
}

String.contains(String)

Cette méthode renvoie la valeur true si la chaîne contient la sous-chaîne d'entrée.

Entrée : Yes, I'd like to go.

La syntaxe suivante :

{
  "conditions": "input.text.contains('Yes')"
}

Résultat : la condition est true.

String.endsWith(String)

Cette méthode renvoie la valeur true si la chaîne se termine par la sous-chaîne d'entrée.

Pour l'entrée suivante :

"What is your name?".

La syntaxe suivante :

{
  "conditions": "input.text.endsWith('?')"
}

Résultat : la condition est true.

String.equals (Chaîne)

Cette méthode renvoie true si la chaîne spécifiée est identique à la chaîne d'entrée.

Entrée: "Oui"

La syntaxe suivante :

{
  "conditions": "input.text.equals('Yes')"
}

Résultat : la condition est true.

Si l'entrée est Yes., le résultat est false car l'utilisateur a inclus une période et l'expression attend uniquement le texte exact, Yes sans aucune ponctuation.

String.equalsIgnoreCase(String)

Cette méthode renvoie true si la chaîne spécifiée est égale à la chaîne d'entrée, que la casse des lettres corresponde ou non.

Entrée: "oui"

La syntaxe suivante :

{
  "conditions": "input.text.equalsIgnoreCase('Yes')"
}

Résultat : la condition est true.

Si l'entrée est Yes., le résultat est false car l'utilisateur a inclus un point et l'expression n'attend que le texte Yes, en majuscules ou en minuscules, sans aucune ponctuation.

String.extract(String regexp, Integer groupIndex)

Cette méthode renvoie une chaîne de l'entrée qui correspond au canevas de groupe d'expressions régulières que vous spécifiez. Elle renvoie une chaîne vide si aucune correspondance n'est trouvée.

Cette méthode est conçue pour extraire des correspondances pour différents groupes de canevas d'expression régulière, et non pour des correspondances différentes pour un canevas d'expression régulière. Pour rechercher des correspondances différentes, reportez-vous à la méthode getMatch.

Dans cet exemple, la variable contextuelle permet de sauvegarder une chaîne qui correspond au groupe de canevas d'expression régulière que vous spécifiez. Dans l'expression, deux groupes de canevas d'expression régulière sont définis, chacun entre parenthèses. Un troisième groupe inhérent est composé des deux groupes. Il s'agit du premier groupe de regex groupIndex 0) ; il correspond à une chaîne qui contient le groupe de numéros et le groupe de texte complets. Le deuxième groupe d'expressions régulières (groupIndex 1) correspond à la première occurrence d'un groupe de nombres. Le troisième groupe (groupIndex 2) correspond à la première occurrence d'un groupe de textes après un groupe de nombres.

{
  "context": {
    "number_extract": "<? input.text.extract('([\\d]+)(\\b [A-Za-z]+)',n) ?>"
  }
}

Lorsque vous spécifiez la regex dans JSON, vous devez fournir deux barres obliques inverses (\). Si vous spécifiez cette expression dans une réponse de nœud, vous devez fournir une seule barre oblique inversée. Exemple :

<? input.text.extract('([\d]+)(\b [A-Za-z]+)',n) ?>

Entrée :

"Hello 123 this is 456".

Résultat :

• Lorsque n=0, la valeur est 123 this.
• Lorsque n=1, la valeur est 123.
• Lorsque n=2, la valeur est this.

String.find(String regexp)

Cette méthode renvoie la valeur true si l'un des segments de la chaîne correspond à l'expression régulière d'entrée. Vous pouvez appeler cette méthode sur un élément JSONArray ou JSONObject, et elle convertit le tableau ou l'objet en chaîne de caractères avant d'effectuer la comparaison.

Pour l'entrée suivante :

"Hello 123456".

La syntaxe suivante :

{
  "conditions": "input.text.find('^[^\d]*[\d]{6}[^\d]*$')"
}

Résultat : la condition est true car la partie numérique du texte d'entrée correspond à l'expression régulière ^[^\d]*[\d]{6}[^\d]*$.

String.getMatch(String regexp, Integer matchIndex)

Cette méthode renvoie une chaîne de l'entrée qui correspond à l'occurrence du canevas de groupe d'expressions régulières que vous spécifiez. Cette méthode renvoie une chaîne vide si aucune correspondance n'est trouvée.

Lorsque des correspondances sont trouvées, elles sont ajoutées à ce que vous pouvez considérer comme un tableau de correspondances. Si vous souhaitez renvoyer la troisième correspondance, car le nombre d'éléments du tableau commence à 0, spécifiez 2 comme valeur matchIndex. Par exemple, si vous entrez une chaîne de texte avec trois mots correspondant au modèle spécifié, vous pouvez renvoyer la première, la deuxième ou la troisième correspondance uniquement en spécifiant sa valeur d'index.

Dans l'expression suivante, vous recherchez un groupe de nombres dans l'entrée. Cette expression enregistre la deuxième chaîne de correspondance de canevas dans la variable contextuelle $second_number, car la valeur d'index 1 est spécifiée.

{
  "context": {
    "second_number": "<? input.text.getMatch('([\\d]+)',1) ?>"
  }
}

Si vous spécifiez l'expression dans la syntaxe JSON, vous devez fournir deux barres obliques inversées (\). Si vous spécifiez l'expression dans une réponse de nœud, vous devez fournir une seule barre oblique inversée.

Exemple :

<? input.text.getMatch('([\d]+)',1) ?>

• Entrée utilisateur :

  "hello 123 i said 456 and 8910".
  

• Résultat : 456

Dans cet exemple, l'expression recherche le troisième bloc de texte dans l'entrée.

<? input.text.getMatch('(\b [A-Za-z]+)',2) ?>

Pour la même entrée utilisateur, cette expression renvoie and.

String.isEmpty()

Cette méthode renvoie la valeur true si la chaîne est une chaîne vide, mais pas null.

Pour le contexte d'exécution de dialogue suivant :

{
  "context": {
    "my_text_variable": ""
  }
}

La syntaxe suivante :

{
  "conditions": "$my_text_variable.isEmpty()"
}

Résultat : la condition est true.

String.length()

Cette méthode renvoie le nombre de caractères de la chaîne.

Pour l'entrée suivante :

"Hello"

La syntaxe suivante :

{
  "context": {
    "input_length": "<? input.text.length() ?>"
  }
}

Génère la sortie suivante :

{
  "context": {
    "input_length": 5
  }
}

String.matches(String regexp)

Cette méthode renvoie la valeur true si la chaîne correspond à l'expression régulière d'entrée.

Pour l'entrée suivante :

"Hello".

La syntaxe suivante :

{
  "conditions": "input.text.matches('^Hello$')"
}

Résultat : la condition est true car le texte d'entrée correspond à l'expression régulière \^Hello\$.

String.startsWith(String)

Cette méthode renvoie la valeur true si la chaîne débute par la sous-chaîne d'entrée.

Pour l'entrée suivante :

"What is your name?".

La syntaxe suivante :

{
  "conditions": "input.text.startsWith('What')"
}

Résultat : la condition est true.

String.substring(Integer beginIndex, Integer endIndex)

Cette méthode permet d'obtenir une sous-chaîne contenant le caractère situé à l'adresse beginIndex et le dernier ensemble de caractères à indexer avant endIndex. Le caractère endIndex n'est pas inclus.

Pour le contexte d'exécution de dialogue suivant :

{
  "context": {
    "my_text": "This is a text."
  }
}

La syntaxe suivante :

{
  "context": {
    "my_text": "<? $my_text.substring(5, $my_text.length()) ?>"
  }
}

Génère la sortie suivante :

{
  "context": {
    "my_text": "is a text."
  }
}

String.toJson()

Cette méthode analyse une chaîne qui contient des données JSON et renvoie un objet ou un tableau JSON, comme dans cet exemple:

${json_var}.toJson()

Si la variable contextuelle ${json_var} contient la chaîne suivante:

"{ \"firstname\": \"John\", \"lastname\": \"Doe\" }"

La méthode toJson() renvoie l'objet suivant:

{
  "firstname": "John",
  "lastname": "Doe"
}

String.toLowerCase()

Cette méthode renvoie la chaîne originale convertie en lettres minuscules.

Pour l'entrée suivante :

"This is A DOG!"

La syntaxe suivante :

{
  "context": {
    "input_lower_case": "<? input.text.toLowerCase() ?>"
  }
}

Génère la sortie suivante :

{
  "context": {
    "input_lower_case": "this is a dog!"
  }
}

String.toUpperCase()

Cette méthode renvoie la chaîne de caractères originale convertie en majuscules.

Pour l'entrée suivante :

"hi there".

La syntaxe suivante :

{
  "context": {
    "input_upper_case": "<? input.text.toUpperCase() ?>"
  }
}

Génère la sortie suivante :

{
  "context": {
    "input_upper_case": "HI THERE"
  }
}

String.trim()

Cette méthode enlève les espaces au début et à la fin de la chaîne et renvoie la chaîne ainsi modifiée.

Pour le contexte d'exécution de dialogue suivant :

{
  "context": {
    "my_text": "   something is here    "
  }
}

La syntaxe suivante :

{
  "context": {
    "my_text": "<? $my_text.trim() ?>"
  }
}

Génère la sortie suivante :

{
  "context": {
    "my_text": "something is here"
  }
}

Prise en charge de java.lang.String

En plus des méthodes intégrées, vous pouvez utiliser des méthodes standard de la classe java.lang.String.

{
  "formatted String": "<? T(java.lang.String).format('%d + %d equals %d', 1, 1, 2) ?>"
}

{
  <? T(String).format('%.2f',<number to format>) ?>
}