# Pergunta aberta

Para realizar uma pergunta ao usuário, você pode utilizar o **input pergunta aberta** com algumas máscaras, filtros ou apenas um campo para digitar o que deseja.

Para configurar, basta acessar a aba input e em seguida selecionar a opção pergunta aberta no ícone `?`. Nesse caso, não há uma pergunta setada, logo o texto da pergunta precisa estar em output.

![](/files/EC5EfIBKG0q2IomUlk8V)

## Estrutura

```json
{
    "default": {
        "type": "text_input",
        "payload": {
            "mode": "textarea",
            "cognitive": true|false,
            "mask": "cellphone|cep|cpf|cpf_cnpj|numeric|email|money|vehicle_plate|password|custom"       
        }
    }
}
```

### Atributos:

* **type:** text\_input
* **payload:**
  * **mode: textarea (opcional):** ao utilizar essa informação, o campo de input no widget passa a ter uma quebra de linha automática.
  * **cognitive (default: true):** determina se a mensagem será enviada para curadoria ou não
  * **mandatory (opcional):** determina a obrigatoriedade de um nó. A configuração padrão do mandatory é `false`. [Veja aqui como configurar.](https://docs.altu.d1.cx/build/assistentes/builder/componentes/input/text_input#configurar-mandatory)
  * **tries:** indica quantas tentativas o usuário terá em caso de erro (é preciso utilizar o `mandatory: true` para que haja a validação das tentativas). Cada mensagem será exibida após uma tentativa, ou seja **não haverá** abertura de input após a última mensagem.
  * **error\_message:** mensagens exibidas de acordo com a sequência de erros. A quantidade de tentativas (tries) deve ser equivalente a quantia de frases cadastradas, caso contrário as fraseologias serão repetidas
  * **mask (opcional):** máscara a ser aplicada no campo de entrada
    * **cellphone:** máscara para número de celular brasileiro
    * **cep:** máscara para CEP brasileiro
    * **cpf:** máscara para CPF
    * **cpf\_cnpj:** máscara dinâmica para CPF ou CNPJ
    * **numeric:** máscara para aceitar somente dígitos numéricos
    * **email:** máscara para validação de email
    * **money:** máscara monetária, aceita somente números
    * **vehicle\_plate:** máscara para placa de veículos antigas(a partir de 1990) e novas(a partir de 2018) segundo Mercosul
    * **password:** máscara para receber a senha do usuário
    * **telefone\_fixo:** máscara para número de telefone fixo brasileiro
    * **fixo\_or\_cellphone:** máscara dinâmica para número de celular ou telefone fixo brasileiros
    * **custom:** permite customização de diversos tipo de máscaras, baseada na biblioteca [jQuery Mask Plugin](https://igorescobar.github.io/jQuery-Mask-Plugin/docs.html):
  * **maskFormat:** string com formato desejado para a máscara. É obrigatório se a máscara for do tipo `custom`
  * **maskOptions(opcional):** json com opções adicionais para aplicação avançada no formato. Por exemplo, funções de callback, pattern e placeholder
  * **max (opcional):** número que limita o máximo de caracteres do input (atributo maxlength)
  * **min (opcional):** número que limita o mínimo de caracteres do input (atributo minlength)
  * **filter (opcional):**
    * **regex:** aplica uma expressão regular na mensagem digitada
      * **pattern:** expressão regular a ser aplicada
      * **replace:** o que será substituído nos matches
  * **placeholder (opcional):** campo aberto que será exibido para que o usuário digite algo
  * **optional (default: false):** permite que o input aceite uma entrada vazia. Por exemplo, ao teclar apenas "Enter".

Payload com `mask` usando o atributo opcional `mandatory`:

{% tabs %}
{% tab title="Exemplo 1" %}
&#x20;Payload com `mask`:

```json
{
    "default": {
        "type": "text_input",
        "payload": {
            "cognitive": false,
            "mask": "email"
        }
    }
}js
```

{% endtab %}

{% tab title="Exemplo 2" %}
Payload com `mask`, `filter` e `placeholder`:

```json
{
    "default": {
        "type": "text_input",
        "payload": {
            "mask": "cellphone",
            "filter": {
                "regex": {
                    "pattern": "\\D",
                    "replace": ""
                }
            },
            "placeholder": "(##) 9####-####"
        }
    }
}
```

No exemplo acima, o campo para input do celular será apresentado com uma máscara. Ao enviarmos a resposta para o Watson, será aplicada expressão regular e tudo que o que não for dígito será removido. \
Ex: \
ao digitar `(35) 99988-7766,` \
o que chegará ao assistente é `35999887766`.
{% endtab %}

{% tab title="Exemplo 3" %}
Payload com máscara `password`, usando os atributos opcionais `min` e `max`:

```json
{
    "default": {
        "type": "text_input",
        "payload": {
            "max": 10,
            "min": 5,
            "mask": "password",
            "cognitive": "false"
        }
    }
}
```

No exemplo acima, será apresentado um input de texto com a máscara do tipo `password`, a entrada do usuário nesse exemplo deve ser uma senha com o tamanho entre o `min` e o `max`.
{% endtab %}

{% tab title="Exemplo 4" %}
Payload com máscara `custom`, usando o atributo opcional `maskOptions`:

```javascript
{
    "default": {
        "type": "text_input",
        "payload": {
            "cognitive": "false",
            "mask": "custom",
            "maskFormat": "00/00/0000",
            "maskOptions": {
                "translation": {
                    "0": {
                        "pattern": "[0-9]",
                        "optional": false
                    }
                },
                "placeholder": "Digite somente números"
            }
        }
    }
}
```

No exemplo acima, será apresentado um input de texto com a máscara do tipo `custom` e uma formatação que aceita somente números, passada para o `maskFormat`. Isso é definido pelo atributo `maskOptions`, que tem um `translation`, cujo `pattern` limita dígitos de 0 a 9. Além disso, será apresentado um `placeholder` no campo input: "Digite somente números".
{% endtab %}

{% tab title="Exemplo 5" %}

```json
{
    "default": {
        "type": "text_input",
        "payload": {
            "optional": true
        }
    }
}
```

{% endtab %}

{% tab title="Exemplo 6" %}

```json
{
    "default": {
        "type": "text_input",
        "payload": {
            "mask": "cpf",
            "tries": 5,
            "mandatory": true,
            "error_message": [
                "string 1",
                "string 2"
            ]
        }
    }
}
```

{% endtab %}
{% endtabs %}

### **Configurar mandatory**

O resultado da validação do `mandatory` virá dentro da variável `input.valid` , sendo   `true` para quando o valor inserido pelo usuário atenda os requisitos da máscara usada, ou `false` para quando o usuário passar por todas as tentativas. Veja o exemplo abaixo:

```json
{
    "default": {
        "type": "text_input",
        "payload": {
            "mask": "cpf",
            "tries": 3,
            "mandatory": true,
            "error_message": [
                "Você errou, tente novamente",
                "Por favor tente uma última vez",
                "Não consegui validar o seu cpf, tente novamente mais tarde"
            ]
        }
    }
}
```

A configuração dos destinos será:

1 - No caso de o input atingir a condição da máscara, ou seja, usuário digitar um cpf, usamos:

```
input.valid  == true
```

2 - No caso de o input não atingir a condição da máscara depois de todas as tentativas `tries` usamos:

```
input.valid  == false
```

{% hint style="info" %}
Ao utilizar o `tries` com **`mandatory: true`**` ``os somente serão executados os`` `**`outputs`**` ``e o`` `**`input`**` ``até que ultrapasse o limite de tries ou o usuário envie a informação válida.`
{% endhint %}


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.altu.d1.cx/build/assistentes/builder/componentes/input/text_input.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
