Base de conhecimento

Voltar à visão geral do suporte

Manipulador de avaliação de valor

Esse manipulador avalia se um valor é válido com base em um padrão ou em uma lista de padrões.

Tipo: value_evaluation_handler

Atributos

Aqui está uma explicação dos atributos disponíveis:

  • to_evaluate: A entrada precisa corresponder ao padrão /sdefinido. Se corresponder, a entrada é válida.
  • code_word_evaluation: A entrada de fala só será verificada se esse atributo estiver definido. Pode ser uma cadeia de caracteres vazia. Se um comando de entrada de fala começar com a palavra-chave fornecida, o restante do comando será usado para avaliação.
    • Necessário: Falso
    • Valor padrão: Nenhum

Eventos

O manipulador emite os seguintes eventos:

  • VALID: Se a entrada fornecida corresponder ao padrão.
  • ALREADY_VALID: Se a entrada fornecida corresponder a um padrão que já foi validado com êxito.
  • ALL_VALID: Se todos os elementos da to_evaluate coleção tiverem sido validados com êxito.
  • INVALID: Se a entrada fornecida não corresponder a nenhum padrão.

A estrutura de carga útil é a seguinte:

   {
          "command": "VALID",    
          "device":
          {
             "modality": "value-evaluation",
             "name": "value-evaluation",
             "source": "value-evaluation",
             "descriptor": "value-evaluation"
          },
          "payload":
          {
             "code": "i am legend"
          }
    }
   {
          "command": "INVALID",    
          "dispositivo":
          {
             "modalidade": "valor-avaliação",
             "nome": "valor-avaliação",
             "fonte": "valor-avaliação",
             "descritor": "valor-avaliação"
          },
          "carga útil":
          {
          }
    }

Exemplo

<context><
    param name="validations" type="string"></param>
</context>

<handlers>
    <value_evaluation_handler>
        <code_word_extraction>validate</code_word_extraction>
        <list name="to_evaluate" listType="UNNAMED">
            <elem>machine .+</elem>
            <elem>station .+</elem>
        </list>
    </value_ evaluation_handler>
</handlers>

<states>
    <onevent>
        <rule id="is_valid">
            <expression>
                <![ CDATA[ #{event(value-evaluation):command} == 'VALID' ]]>
            </expression>
            <actions>
                <setvar id="add_validation">
                    <context_of>step</context_of>
                    <context_update><
                        param name="validations" type="string">#{validations} #{event:payload.code}</param>
                    </context_update>
                </setvar>
            </actions>
        </rule>

        <rule id="all_valid">
            <expressão>
                <![ CDATA[ #{event(value-evaluation):command} == 'ALL_VALID' ]]>
            </expression>
            <actions>
                <finish_workflow id="exit"/>
            </actions>
        </rule><

        rule id="invalid_input">
            <expression>
                <![ CDATA[ #{event(value-evaluation):command} == 'INVALID' ]]>
            </expression>
            <actions>
                <ui_notification id="invalid_value" type="ERROR" duration="SHORT" show_immediately="true">
                    <message>"Não é um valor válido!</message>
                </ui_notification>
            </actions>
        </rule>
    </onevent>
</states>

Manipulador do extrator de valor

Esse manipulador é usado para implementar a varredura de código de barras por meio de hardware de digitalização dedicado. Ele extrai o scanner ou a entrada de fala com base em uma lista de padrões e verifica se pelo menos um desses padrões é válido.

Tipo: value_extractor_handler

Atributos

Aqui está uma explicação do atributo disponível:

  • padrão: A entrada precisa corresponder ao padrão definido. Se corresponder, os grupos definidos podem ser extraídos.
    • Necessário: Sim

Elementos

Os diferentes elementos são os seguintes:

  • GRP: Armazena as informações sobre como cada item no grupo deve ser extraído como uma lista de parâmetros.
    • Necessário: Não
    • Valor padrão: Lista vazia
  • allowed_values: Permite definir uma lista de valores a serem verificados após o padrão ter sido avaliado como correto. Isso não pode ser usado com expressões regulares contendo or, porque cada grupo precisa conter um valor permitido ou varredura.
    • Necessário: Não
    • Valor padrão: Nenhum
  • code_word_extraction: A entrada de fala só será verificada se esse atributo estiver definido. Pode ser uma cadeia de caracteres vazia. Se um comando de entrada de fala começar com a palavra-chave fornecida, o restante do comando será usado para extrair as informações necessárias. Observe que o reconhecimento de fala por meio de expressões regulares não é possível. Todos os valores potenciais precisam ser adicionados à sintaxe por meio da ação correspondente.
    • Necessário: Não
    • Valor padrão: Nenhum
  • extract_to_workflow: Por padrão, os grupos resultantes serão armazenados no escopo da etapa. Definir esse atributo como true salvará as variáveis no escopo do fluxo de trabalho.
    • Necessário: Não
    • Valor padrão: Nenhum
  • entrada: Permite que você passe uma entrada inicial para ser verificada no resume.
    • Necessário: Não
    • Valor padrão: Nenhum

Eventos

O manipulador emite os seguintes eventos:

  • VALID_EXTRACTIONou INVALID_EXTRACTION: O manipulador verificará qualquer evento de entrada com as BARCODE modalidades e SPEECH (se o code_word_extraction parâmetro for fornecido) e emitirá um evento com os VALID_EXTRACTION comandos ouINVALID_EXTRACTION.
  • INVALID_PATTERN: Se o padrão fornecido contiver um erro de sintaxe, o manipulador emitirá um evento com o INVALID_PATTERN comando .

A estrutura de carga útil é a seguinte:

   {
          "command": "VALID_EXTRACTION",    
          "device":
          {
             "modality": "value_extractor",
             "name": "value_extractor",
             "source": "value_extractor",
             "descriptor": "value_extractor"
          },
          "payload":
          {
             "technology": "SCAN", // [SCAN, VOICE]
             "code": "123456789",
             "speech_command": "null"
          }
    }
   {
          "command": "INVALID_PATTERN",    
          "device":
          {
             "modality": "value_extractor",
             "name": "value_extractor",
             "source": "value_extractor",
             "descriptor": "value_extractor"
          },
          "payload":
          {
             "technology": "pattern",
             "código": "(.() *",
             "speech_command": "null"
          }
    }

Exemplo

<value_extractor_handler pattern="(.+)_(.+)" code_word_extraction="USER">
    <grp>
        <param name="grp_1" type="string">prefix</param><
        param name="grp_2" type="string">suffix</param>
    </grp>
</value_extractor_handler>

Um código como "test_user" será extraído com êxito. Depois, #{prefix} conterá "teste" e #{suffix} conterá "usuário".

Exemplo estendido com o processamento de eventos emitidos

<context>
    <list name="user_name_list" listType="UNNAMED"><
        elem>barry</elem>
        <elem>white</elem>
    </list>
</context>

<handlers>
    <value_extractor_handler pattern="(.+)_(.+)">
        <code_word_extraction></code_word_extraction>
        <input>admin_barry</input>
        <extract_to_workflow>true</extract_to_ workflow>
        <grp>
            <param name="grp_1" type="string">user_role</param>
            <param name="grp_2" type="string">user_name</param>
        </grp>
        <allowed_values>
            <list name="grp_1" listType="UNNAMED"><
                elem>admin</elem>
                <elem>supervisor</elem>
            </list>
            <param name="grp_2" type="object">#{user_name_list}</param>
        </allowed_values>
    </value_extractor_handler>
</handlers>

<states>
    <onevent>
        <rule id="set_user"><
            expression><![ CDATA[ #{event(value_extractor):command} == 'VALID_EXTRACTION' && exists(#{user_role}) && exists(#{user_name}) ]]></expression>
            <actions>
                <setvar id="set_user">
                    <context_of>workflow</context_of>
                    <context_update><
                        param name="userrole" type="string">#{user_role}</param>
                        <param name="username" type="string">#{ user_name}</param>
                    </context_update>
                </setvar>
            </actions>
        </rule>

        <rule id="invalid_input">
            <expression><![ CDATA[ #{event(value_extractor):command} == 'INVALID_EXTRACTION' && #{event:payload.technology} == 'SCAN' ]]></expression>    
            <actions>
                <ui_notification id="invalid_user" type="ERROR" duration="SHORT" show_immediately="true">
                   <message>"#{event:payload.code}" não é um usuário válido!</message>
                </ui_notification>
            </actions>
        </rule>
    </onevent>
</estados>