JSONArray.addAll(JSONArray)

Este método anexa uma matriz a outra.

Para esse contexto de tempo de execução de diálogo:

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

Faça essa atualização:

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

Resultado: o próprio método retorna null. No entanto, a primeira matriz é atualizada para incluir os valores por meio da segunda matriz.

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

JSONArray.append(object)

Esse método anexa um novo valor no JSONArray e retorna o JSONArray modificado.

Para esse contexto de tempo de execução de diálogo:

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

Faça essa atualização:

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

Resultado:

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

JSONArray.clear()

Esse método limpa todos os valores da matriz e retorna nulo.

Use a expressão a seguir na saída para definir um campo que limpa uma matriz que você salvou em uma variável de contexto ($toppings_array) de seus valores.

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

Então, se você fizer referência à variável de contexto $toppings_array, ela retornará apenas ' [] '.

JSONArray.contains (Object value)

Esse método retorna true se o JSONArray de entrada contém o valor de entrada.

Para essa caixa de diálogo, o contexto de tempo de execução é definido por um nó anterior ou aplicativo externo:

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

Nó de diálogo ou condição de resposta:

$toppings_array.contains('ham')

Resultado: true porque a matriz contém o elemento ham.

JSONArray.containsIgnoreCase (Valor do objeto)

Esse método retornará true se o JSONArray de entrada contiver o valor de entrada, independentemente de o valor ser especificado em letras maiúsculas ou minúsculas.

Para essa caixa de diálogo, o contexto de tempo de execução é definido por um nó anterior ou aplicativo externo:

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

Nó de diálogo ou condição de resposta:

$toppings_array.containsIgnoreCase('HAM')

Resultado: true porque a matriz contém o elemento ham e as letras maiúsculas e minúsculas são ignoradas.

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

Esse método retornará true se o JSONArray intents contiver particularmente a intenção especificada e essa intenção tiver uma pontuação de confiança que seja igual ou maior que a pontuação mínima especificada. Opcionalmente, é possível especificar um número para indicar que a intenção deve ser incluída dentro desse número de elementos principais na matriz. O parâmetro top_n será ignorado se você especificar um número negativo.

Retornará false se a intenção especificada não estiver na matriz, não tiver uma pontuação de confiança que seja igual ou maior que a pontuação de confiança mínima ou o índice da matriz da intenção for menor que o local de índice especificado.

O serviço gera automaticamente uma matriz intents que lista as intenções que o serviço detecta na entrada sempre que a entrada do usuário é enviada. A matriz lista todas as intenções que são detectadas pelo serviço em ordem de maior confiança primeiro.

É possível usar esse método em uma condição do nó para não somente verificar a presença de uma intenção, mas para configurar um limite de pontuação de confiança que deve ser atendido antes que o nó possa ser processado e sua resposta retornada.

Por exemplo, use a expressão a seguir em uma condição do nó quando você desejar acionar o nó de diálogo somente quando as condições a seguir forem atendidas:

• A intenção #General_Ending está presente.
• A pontuação de confiança da intenção #General_Ending é superior a 80%.
• A intenção #General_Ending é uma das 2 principais intenções na matriz de intenções.

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

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

Filtra uma matriz comparando cada valor do elemento de matriz com um valor especificado. Esse método é semelhante a uma projeção de coleção. Uma projeção de coleção retorna uma matriz filtrada com base em um nome em um par nome-valor de elemento de matriz. O método de filtro retorna uma matriz filtrada com base em um valor em um par nome-valor de elemento da matriz.

A expressão de filtro consiste nos valores a seguir:

• temp: nome de uma variável que é usada temporariamente conforme cada elemento de matriz é avaliado. Por exemplo, city.

• property: propriedade do elemento que você deseja comparar com o comparison_value. Especifique a propriedade como uma propriedade da variável provisória que você nomeia no primeiro parâmetro. Use a sintaxe: temp.property. Por exemplo, se latitude for um nome de elemento válido para um par nome-valor na matriz, especifique a propriedade como city.latitude.

• operator: operador a ser usado para comparar o valor da propriedade com o comparison_value.

  Os operadores suportados são:

  Operadores de filtro suportados

  Operador	Descrição
  ==	É igual a
  >	é maior do que
  <	é menor do que
  >=	É maior ou igual a
  <=	É menor do que ou igual a
  !=	Não é igual a

• comparison_value: valor que você deseja comparar com cada valor da propriedade do elemento de matriz. Para especificar um valor que possa mudar dependendo da entrada do usuário, use uma variável de contexto ou entidade como o valor. Se você especificar um valor que possa variar, adicione lógica para garantir que o valor comparison_value seja válido no momento da avaliação ou ocorrerá um erro.

[
   {
      "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)

Esse método retorna o índice de entrada do JSONArray.

Para essa caixa de diálogo, o contexto de tempo de execução é definido por um nó anterior ou aplicativo externo:

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

Nó de diálogo ou condição de resposta:

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

Resultado: True porque a matriz aninhada contém one como um valor.

Resposta:

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

JSONArray.getRandomItem()

Esse método retorna um item aleatório do JSONArray de entrada.

Para esse contexto de tempo de execução de diálogo:

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

Saída do nó de diálogo:

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

Resultado: "ham is a great choice!" ou "onion is a great choice!" ou "olives is a great choice!"

O texto de saída resultante é escolhido aleatoriamente.

JSONArray.indexOf(value)

Esse método retorna o número de índice do elemento na matriz que corresponde ao valor especificado como um parâmetro ou -1 se o valor não é localizado na matriz. O valor pode ser um String ( "School" ), Integer ( 8 ) ou Double ( 9.1 ). O valor deve ser uma correspondência exata e diferencia maiúsculas de minúsculas.

Por exemplo, as variáveis de contexto a seguir contêm matrizes:

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

As expressões a seguir podem ser usadas para determinar o índice de matriz em que o valor é especificado:

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

Esse método pode ser útil para obter o índice de um elemento em uma matriz de intenções, por exemplo. É possível aplicar o método indexOf à matriz de intenções gerados cada vez que a entrada do usuário é avaliada para determinar o número de índice da matriz de uma intenção específica.

intents.indexOf("General_Greetings")

Se você desejar saber a pontuação de confiança de uma intenção específica, será possível passar a expressão anterior como o valor index para uma expressão com a sintaxe intents[index].confidence. Por exemplo:

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

JSONArray.join (delimitador de sequência)

Esse método reúne todos os valores nessa matriz para uma sequência. Os valores são convertidos em cadeias de caracteres e delimitados pelo delimitador de entrada.

Para esse contexto de tempo de execução de diálogo:

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

Saída do nó de diálogo:

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

Resultado:

This is the array: onion;olives;ham;

Se uma entrada de usuário mencionar várias coberturas e você definir uma entidade chamada @toppings que possa reconhecer menções de coberturas, você poderá usar a seguinte expressão na resposta para listar as coberturas que foram mencionadas:

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

Se você definir uma variável que armazena diversos valores em uma matriz JSON, será possível retornar um subconjunto da matriz. Use o método join() para formatá-los corretamente

"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)

Esse método extrai informações de cada item na matriz e constrói uma nova matriz que é formatada de acordo com o modelo especificado. O modelo pode ser uma sequência, um objeto JSON ou uma matriz.. O método retorna uma matriz de sequências, uma matriz de objetos ou uma matriz de matrizes, dependendo do tipo de modelo..

Este método é útil para formatar informações como uma sequência que você pode retornar como parte da saída de um nó de diálogo ou para transformar dados em uma estrutura diferente para que você possa usá-la com uma API externa

No modelo, é possível referenciar valores da matriz de origem usando a sintaxe a seguir, em que {property} representa o nome da propriedade na matriz de origem.

%e.{property}%

Por exemplo, suponha que seu assistente armazene uma matriz que contenha detalhes de voo em uma variável de contexto. Os dados armazenados podem ser semelhantes a este:

"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"
      }
    ]

Para construir uma matriz de sequências que descrevem esses voos em um formato legível pelo usuário, é possível usar a expressão a seguir:

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

Essa expressão retornaria a seguinte matriz de cadeias: ["Flight AZ1040 to FCO","Flight DL1710 to LAX","Flight VS4379 to LHR"].

O parâmetro opcional retainDataType especifica se o método deve preservar o tipo de dados de todos os valores de entrada na matriz retornada Se retainDataType for configurado como false, ou omitido, em algumas situações, as sequências na matriz de entrada poderão ser convertidas em números na matriz retornada Por exemplo, se os valores selecionados da matriz de entrada forem "1", "2" e "3", a matriz retornada poderá ser [ 1, 2, 3 ]. Para evitar conversões de tipo inesperadas, especifique true para esse parâmetro

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

Esse método remove o elemento na posição de índice do JSONArray e retorna o JSONArray atualizado.

Para esse contexto de tempo de execução de diálogo:

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

Faça essa atualização:

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

Resultado:

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

JSONArray.removeValue(object)

Esse método remove a primeira ocorrência do valor do JSONArray e retorna o JSONArray atualizado.

Para esse contexto de tempo de execução de diálogo:

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

Faça essa atualização:

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

Resultado:

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

JSONArray.set(Integer index, Object value)

Esse método configura o índice de entrada do JSONArray para o valor de entrada e retorna o JSONArray modificado.

Para esse contexto de tempo de execução de diálogo:

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

Saída do nó de diálogo:

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

Resultado:

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

JSONArray.size()

Esse método retorna o tamanho do JSONArray como um número inteiro.

Para esse contexto de tempo de execução de diálogo:

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

Faça essa atualização:

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

Resultado:

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

JSONArray split(String regexp)

Esse método divide a sequência de entrada usando a expressão regular de entrada. O resultado é um JSONArray de sequências.

Para essa entrada:

"bananas;apples;pears"

Essa sintaxe:

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

Resultados nessa saída:

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

Suporte ao com.google.gson.JsonArray

Além dos métodos integrados, é possível usar os métodos padrão da classe com.google.gson.JsonArray.

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

.after (Data ou hora da sequência)

Determina se o valor de data/hora é após o argumento de data/hora.

.before(String date or time)

Determina se o valor de data/hora é anterior ao argumento de data/hora.

Por exemplo:

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

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

• Se você comparar itens diferentes, como time vs. date, date vs. time e time vs. date and time, o método retornará false e uma exceção será impressa no registro JSON da resposta output.log_messages.

  Por exemplo, @sys-date.before(@sys-time).

• Se você comparar date and time vs. time, o método ignorará a data e comparará apenas as horas.

now(String time zone)

Retorna uma sequência com a data e hora atuais no formato yyyy-MM-dd HH:mm:ss. Opcionalmente, especifique um valor timezone para obter a data e hora atuais para um fuso horário específico, com uma sequência retornada no formato yyyy-MM-dd HH:mm:ss 'GMT'XXX.

• Função estática.
• Os outros métodos de data/hora podem ser chamados em valores de data/hora que são retornados por essa função e ela pode ser transmitida como seus argumentos.
• A interface do usuário cria automaticamente uma variável de contexto $timezone para que a hora correta seja retornada quando você fizer o teste no painel "Try it out". Se você não passar um fuso horário, o fuso horário configurado automaticamente pela UI será usado. Fora da UI, o GMT é usado como o fuso horário. Para saber mais sobre a sintaxe a ser usada para especificar o fuso horário, consulte Fusos horários suportados por entidades do sistema.

Exemplo de uso do now() para primeiro verificar se é de manhã antes que o assistente responda com uma saudação específica da manhã

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

Exemplo de uso de now() com um fuso horário para retornar a hora atual (na Inglaterra):

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

Você pode substituir o valor do fuso horário codificado por uma variável de contexto para alterar dinamicamente a hora com base em um fuso horário que é passado para a expressão. Por exemplo: <? now('$myzone') ?>. A variável de contexto $myzone pode ser configurada como 'Australia/Sydney' em uma conversa e como 'Mexico/BajaNorte' em outra.

.reformatDateTime(String format)

Formata as cadeias de data e hora no formato desejado para a saída do usuário.

Retorna uma sequência formatada de acordo com o formato especificado:

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

Para retornar o dia da semana:

• EEEE para terça-feira
• E para o Tue
• u para índice do dia (1 = segunda-feira, ..., 7 = domingo)

Por exemplo, essa definição de variável de contexto cria uma variável $time que salva o valor 17:30:00 como 17:30 PM.

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

O formato segue as regras Java SimpleDateFormat.

Observação: Quando você tenta formatar somente a hora, a data é tratada como 1970-01-01.

.sameMoment(String date/time)

• Determina se o valor de data/hora é o mesmo que o argumento de data/hora.

.sameOrAfter(String date/time)

• Determina se o valor de data/hora é posterior ou igual ao argumento de data/hora.
• Análogo a .after().

.sameOrBefore(String date/time)

• Determina se o valor de data/hora é anterior ou igual ao argumento de data/hora.

hoje ()

Retorna uma sequência com a data atual no formato yyyy-MM-dd.

• Função estática.
• Os outros métodos de data podem ser chamados em valores de data que são retornados por essa função e podem ser passados como seus argumentos.
• Se a variável de contexto $timezone estiver configurada, essa função retornará datas no fuso horário do cliente. Caso contrário, o fuso horário GMT será usado.

Exemplo de um nó de diálogo com today() usado no campo de saída:

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

Resultado: Today's date is 2018-03-09.

Trabalhando com períodos de tempo

Para mostrar uma resposta com base em se a data de hoje cai dentro de um determinado prazo, é possível usar uma combinação de métodos relacionados a horário. Por exemplo, se você executar uma oferta especial durante a temporada de férias todos os anos, será possível verificar se a data de hoje cai entre 25 de novembro e 24 de dezembro do presente ano. Primeiro, defina as datas de interesse como variáveis de contexto.

Nas expressões de variáveis de contexto de data inicial e final a seguir, a data está sendo construída pela concatenação do valor derivado do ano atual com valores de dia e mês codificados.

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

Na condição de resposta, será possível indicar que você deseja mostrar a resposta somente se a data atual cair entre as datas de início e encerramento definidas como variáveis de contexto.

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

Suporte ao java.util.Date

Além dos métodos integrados, é possível usar os métodos padrão da classe java.util.Date.

Para obter a data do dia que cai uma semana a partir de hoje, é possível usar a sintaxe a seguir.

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

Essa expressão obtém primeiro a data atual em milissegundos desde 1º de janeiro de 1970, 00:00:00 Coordinated Universal Time. Ela também calcula o número de milissegundos em 7 dias. (O (24*60*60*1000L) representa um dia em milissegundos.) Em seguida, ele inclui 7 dias na data atual. O resultado é a data integral do dia que cai uma semana a partir de hoje. Por exemplo, Fri Jan 26 16:30:37 UTC 2018. O horário está no fuso horário da Hora Universal Coordenada É possível sempre mudar o 7 para uma variável ($number_of_days, por exemplo) que você pode passar. Certifique-se de que seu valor seja definido antes que essa expressão seja avaliada.

Se você quiser comparar a data com outra data gerada pelo serviço, deverá reformatar a data. As entidades do sistema (@sys-date) e outros métodos integrados (now()) convertem as datas para o formato yyyy-MM-dd.

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

Depois de reformatar a data, o resultado é 2018-01-26. Agora, você pode usar uma expressão como @sys-date.after($week_from_today) em uma condição de resposta para comparar uma data especificada na entrada do usuário com a data salva na variável de contexto.

A expressão a seguir calcula o horário daqui a 3 horas.

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

O valor (60*60*1000L) representa uma hora em milissegundos. Essa expressão inclui 3 horas no horário atual. Em seguida, ele recalcula a hora do fuso horário do Tempo Universal Coordenado para o fuso horário EST, subtraindo 5 horas dele. Também reformata os valores de data para incluir horas e minutos AM ou PM.

toDouble()

Converte o objeto ou campo no tipo de número Duplo. Será possível chamar esse método em qualquer objeto ou campo. Se a conversão falhar, null será retornado.

toInt()

Converte o objeto ou campo no tipo de número Inteiro. Será possível chamar esse método em qualquer objeto ou campo. Se a conversão falhar, null será retornado.

toLong()

Converte o objeto ou campo no tipo de número Longo. Será possível chamar esse método em qualquer objeto ou campo. Se a conversão falhar, null será retornado.

Se você especifica um tipo de número Longo em uma expressão SpEL, deve-se anexar um L ao número para identificá-lo como tal. Por exemplo, 5000000000L. Essa sintaxe é necessária para quaisquer números que não se ajustam ao tipo de Número inteiro de 32 bits. Por exemplo, números maiores que 2^31 (2.147.483.648) ou menores que -2 (-2.147.483.648) são considerados tipos de números longos. Os tipos de número longo têm um valor mínimo de -2^63 e um valor máximo de 2^63-1 (ou 9.223.372.036.854.775.807).

Se você precisar determinar se um número é muito longo para ser reconhecido, verifique se há mais de 18 números inteiros no número usando uma expressão como esta:

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

Se você precisar trabalhar com números maiores que 18 inteiros, considere uma entidade padrão (com uma expressão regular, como \d{20} ) para trabalhar com eles em vez de usar @sys-number.

Matemática padrão

Use expressões SpEL para definir equações de matemática padrão, em que os operadores são representados usando estes símbolos:

Por exemplo, em uma resposta de nó de diálogo, você pode adicionar uma variável de contexto que captura um número especificado na entrada do usuário ( @sys-number ) e o salva como $your_number. Em seguida, é possível incluir o texto a seguir como uma resposta de texto:

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 ?>.

Se o usuário especificar 10, a resposta de texto resultante será semelhante a isto:

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.

Suporte a números do Java

java.lang.Math()

Executa operações numéricas básicas.

É possível usar os métodos de Classe:

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"
      }
    ]
  }
}

Para obter mais informações, consulte a documentação de referência dojava.lang.Math

java.util.Random()

Retorna um número aleatório. É possível usar uma das opções de sintaxe a seguir:

• Para retornar um valor booleano aleatório (verdadeiro ou falso), use <?new Random().nextBoolean()?>.
• Para retornar um número duplo aleatório entre 0 (incluído) e 1 (excluído), use <?new Random().nextDouble()?>.
• Para retornar um número inteiro aleatório entre 0 (incluído) e um número que você especificar, use <?new Random().nextInt(n)?> em que n é o maior número no intervalo de números desejado + 1. Por exemplo, se quiser retornar um número aleatório entre 0 e 10, especifique <?new Random().nextInt(11)?>.
• Para retornar um número inteiro aleatório da faixa de valores de número inteiro completa (-2147483648 a 2147483648), use <?new Random().nextInt()?>.

Por exemplo, você pode criar um nó de diálogo que é acionado pela intenção #random_number. A primeira condição de resposta pode ser semelhante a esta:

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"
      }
    ]
  }
}

Consulte a documentação de referência java.util.Random para obter informações sobre outros métodos.

Também é possível usar métodos padrão das classes a seguir:

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

JSONObject.clear()

Esse método limpa todos os valores do objeto JSON e retorna nulo.

Por exemplo, você deseja limpar os valores atuais da variável de contexto $user.

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

Use a expressão a seguir na saída para definir um campo que limpa o objeto de seus valores.

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

Se você fizer referência à variável de contexto $user, ela retornará apenas {}.

É possível usar o método clear() nos objetos JSON context ou output no corpo da chamada /message da API .

{
  "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.tem (Sequência)

Esse método retorna true se o JSONObject complexo possui uma propriedade do nome de entrada.

Para esse contexto de tempo de execução de diálogo:

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

Saída do nó de diálogo:

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

Resultado: a condição é true porque o objeto de usuário contém a propriedade first_name.

JSONObject.remove (Sequência)

Esse método remove uma propriedade do nome da entrada JSONObject. O JSONElement que é retornado por esse método é o JSONElement que está sendo removido.

Para esse contexto de tempo de execução de diálogo:

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

Saída do nó de diálogo:

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

Resultado:

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

Suporte ao com.google.gson.JsonObject

Além dos métodos integrados, alguns dos métodos padrão da classe com.google.gson.JsonObject também são suportados.

String.append (Object)

Esse método anexa um objeto de entrada à sequência como uma sequência e retorna uma sequência modificada.

Para esse contexto de tempo de execução de diálogo:

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

Essa sintaxe:

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

Resultados nessa saída:

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

String.contains (String)

Esse método retorna true se a sequência contém a subsequência de entrada.

Entrada: Yes, I'd like to go.

Essa sintaxe:

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

Resultados: a condição é true.

String.endsWith(String)

Esse método retorna true se a sequência termina com a subsequência de entrada.

Para essa entrada:

"What is your name?".

Essa sintaxe:

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

Resultados: a condição é true.

String.equals(Sequência)

Este método retornará true se a sequência especificada for exatamente igual à sequência de entrada.

Entrada: "Yes"

Essa sintaxe:

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

Resultados: a condição é true.

Se a entrada for Yes., o resultado será false, pois o usuário incluiu um ponto final e a expressão espera apenas o texto exato, Yes sem nenhuma pontuação.

String.equalsIgnoreCase(String)

Esse método retorna true se a cadeia de caracteres especificada for igual à cadeia de caracteres de entrada, independentemente do fato de a caixa das letras corresponder ou não.

Entrada: "yes"

Essa sintaxe:

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

Resultados: a condição é true.

Se a entrada for Yes., o resultado será false porque o usuário incluiu um ponto final e a expressão espera apenas o texto Yes, em letras maiúsculas ou minúsculas, sem nenhuma pontuação.

String.extract(String regexp, Integer groupIndex)

Esse método retorna uma sequência da entrada que corresponde ao padrão do grupo de expressão regular especificado. Ele retorna uma sequência vazia caso nenhuma correspondência seja localizada.

Esse método foi projetado para extrair correspondências para diferentes grupos de padrões de expressão regular, não diferentes correspondências para um único padrão de expressão regular. Para localizar correspondências diferentes, consulte o método getMatch.

Neste exemplo, a variável de contexto está salvando uma sequência que corresponde ao grupo de padrões de expressão regular especificado. Na expressão, dois grupos de padrões de expressão regular são definidos, ambos entre parênteses. Um terceiro grupo inerente é composto pelos dois grupos. Esse é o primeiro grupo regex groupIndex 0); ele corresponde a uma string que contém o grupo de números completos e o grupo de texto. O segundo grupo de expressão regular (groupIndex 1) corresponde à primeira ocorrência de um grupo de números. O terceiro grupo (groupIndex 2) corresponde à primeira ocorrência de um grupo de texto após um grupo de números.

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

Ao especificar o regex em JSON, deve-se fornecer duas barras invertidas (\). Para especificar essa expressão em uma resposta de nó, você precisa de apenas uma barra invertida. Por exemplo:

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

Entrada:

"Hello 123 this is 456".

Resultado:

• Quando n=0, o valor é 123 this.
• Quando n=1, o valor é 123.
• Quando n=2, o valor é this.

String.localizar (String regexp)

Esse método retorna true se qualquer segmento da sequência corresponde à expressão regular de entrada. Você pode chamar esse método em um elemento JSONArray ou JSONObject, e ele converte o array ou objeto em uma string antes de fazer a comparação.

Para essa entrada:

"Hello 123456".

Essa sintaxe:

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

Resultado: a condição é true porque a parte numérica do texto de entrada corresponde à expressão regular ^[^\d]*[\d]{6}[^\d]*$.

String.getMatch(String regexp, Integer matchIndex)

Esse método retorna uma sequência da entrada que corresponde à ocorrência do padrão de expressão regular especificado. Ele retorna uma sequência vazia caso nenhuma correspondência seja localizada.

Conforme correspondências são localizadas, elas são incluídas em algo semelhante a uma matriz de correspondências. Como a contagem de elementos da matriz começa em 0, especifique 2 como o valor de matchIndex para retornar a terceira correspondência. Por exemplo, ao inserir uma sequência de texto com três palavras que correspondem ao padrão especificado, é possível retornar a primeira, a segunda ou a terceira correspondência apenas especificando seu valor de índice.

Na expressão a seguir, você está procurando um grupo de números na entrada. Esta expressão salva a segunda sequência de correspondência de padrão na variável de contexto $second_number porque o valor de índice 1 está especificado.

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

Ao especificar a expressão em sintaxe JSON, deve-se fornecer duas barras invertidas (\). Para especificar a expressão em uma resposta de nó, você precisa de apenas uma barra invertida.

Por exemplo:

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

• Entrada do usuário:

  "hello 123 i said 456 and 8910".
  

• Resultado: 456

Neste exemplo, a expressão procura o terceiro bloco de texto na entrada.

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

Para a mesma entrada do usuário, essa expressão retorna and.

String.isEmpty()

Esse método retorna true se a sequência é uma sequência vazia, mas não nula.

Para esse contexto de tempo de execução de diálogo:

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

Essa sintaxe:

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

Resultados: a condição é true.

String.length()

Esse método retorna o comprimento de caracteres da sequência.

Para essa entrada:

"Hello"

Essa sintaxe:

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

Resultados nessa saída:

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

String.matches (String regexp)

Esse método retorna true se a sequência corresponde à expressão regular de entrada.

Para essa entrada:

"Hello".

Essa sintaxe:

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

Resultado: a condição é true porque o texto de entrada corresponde à expressão regular \^Hello\$.

String.startsWith(String)

Esse método retorna true se a sequência inicia com a subsequência de entrada.

Para essa entrada:

"What is your name?".

Essa sintaxe:

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

Resultados: a condição é true.

String.substring( Integer beginIndex, Integer endIndex)

Esse método obtém uma substring com o caractere em beginIndex e o último conjunto de caracteres a ser indexado antes de endIndex. O caractere endIndex não está incluído.

Para esse contexto de tempo de execução de diálogo:

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

Essa sintaxe:

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

Resultados nessa saída:

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

String.toJson()

Este método analisa uma sequência que contém dados JSON e retorna um objeto ou matriz JSON, como neste exemplo:

${json_var}.toJson()

Se a variável de contexto ${json_var} contiver a seguinte sequência:

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

O método toJson() retorna o objeto a seguir:

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

String.toLowerCase()

Esse método retorna a cadeia de caracteres original que é convertida em letras minúsculas.

Para essa entrada:

"This is A DOG!"

Essa sintaxe:

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

Resultados nessa saída:

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

String.toUpperCase()

Esse método retorna a cadeia de caracteres original que é convertida em letras maiúsculas.

Para essa entrada:

"hi there".

Essa sintaxe:

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

Resultados nessa saída:

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

String.trim()

Esse método reduz quaisquer espaços no início e no final da sequência e retorna a sequência modificada.

Para esse contexto de tempo de execução de diálogo:

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

Essa sintaxe:

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

Resultados nessa saída:

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

Suporte ao java.lang.String

Além dos métodos integrados, é possível usar os métodos padrão da 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>) ?>
}