Get Process

Este artigo explica como obter o resultado de um processo na plataforma usando o método GetProcess através da REST API.

Importante

Atenção!

Atualização no retorno dos fluxos IDUnico e IDCheck(IDUnico + Check).

O retorno do resultado para todos os processos com fluxo IDUnico e IDCheck foi atualizado, generalizando o resultado com os outros fluxos.

Quando o processo IDUnico finaliza com o resultado inconclusivo ou falha de liveness, retornamos o resultado PROCESS_RESULT_INVALID_IDENTITY.

Exemplo do antigo retorno do resultado de processo quando o usuário era autenticado:

{
    "process": {
        ...
        // Estado atual do processo.
        "state": "PROCESS_STATE_FINISHED",
        // Resultado atual do processo.
        "result": "PROCESS_RESULT_OK",
        ...
    }
}

Exemplo do antigo retorno do resultado do processo quando a autenticação era inconclusiva ou falha de liveness:

{
    "process": {
        ...
        // Estado do processo
        "state": "PROCESS_STATE_FINISHED",
        // Resultado do processo.
        "result": "PROCESS_RESULT_INVALID_IDENTITY",
        ...
    }
}

Novo retorno no resultado

Quando o processo finaliza com sucesso no liveness e inconclusivo do IDUnico, devolveremos o resultado PROCESS_RESULT_OK e incluiremos AUTHENTICATION_RESULT_INCONCLUSIVE no campo authenticationResult de authenticationInfo.

Exemplo do novo retorno do resultado do processo quando o usuário for AUTENTICADO:

{
    "process": {
        ...
        // Estado atual do processo
        "state": "PROCESS_STATE_FINISHED",
        // Resultado atual do processo.
        "result": "PROCESS_RESULT_OK",
        // Resultados da etapa de autenticação.
        "authenticationInfo": {
            // Id da autenticação do processo.
            "authenticationId": "cf9e618e-e7a4-4340-b745-b228383c927f",
            // Resultado da autenticação com o ID.
            "authenticationResult": "AUTHENTICATION_RESULT_POSITIVE",
            // Resultado do Liveness.
            "livenessResult": "LIVENESS_RESULT_LIVE"
        },
        ...
    }
}

Exemplo do novo retorno do resultado do processo quando a autenticação do usuário for INCONCLUSIVO:

{
    "process": {
        ...
        // Estado atual do processo
        "state": "PROCESS_STATE_FINISHED",
        // Resultado atual do processo.
        "result": "PROCESS_RESULT_OK",
        // Resultados da etapa de autenticação.
        "authenticationInfo": {
            // id da autenticação do processo.
            "authenticationId": "cf9e618e-e7a4-4340-b745-b228383c927f",
            // Resultado da autenticação com o IDUnico.
            "authenticationResult": "AUTHENTICATION_RESULT_INCONCLUSIVE",
            // Resultado do Liveness.
            "livenessResult": "LIVENESS_RESULT_LIVE"
        },
        ...
    }
}

Atenção

Não há alteração no retorno quando o processo finalizar com falha de liveness.

Exemplo de retorno do resultado do processo quando o usuário NÃO passar no liveness:

{
    "process": {
        ...
        // Estado atual do processo
        "state": "PROCESS_STATE_FINISHED",
        // Resultado atual do processo.
        "result": "PROCESS_RESULT_INVALID_IDENTITY",
        // Resultados da etapa de autenticação.
        "authenticationInfo": {
            // id da autenticação do processo.
            "authenticationId": "cf9e618e-e7a4-4340-b745-b228383c927f",
            // Resultado da autenticação com o IDUnico.
            "authenticationResult": "AUTHENTICATION_RESULT_UNSPECIFIED",
            // Resultado do Liveness.
            "livenessResult": "LIVENESS_RESULT_NOT_LIVE"
        },
        ...
    }
}

Formas de fazer uma requisição GET

Através do ID do processo é possível recuperar todas informações do processo.

cURL

curl -X 'GET' \
  'https://api.cadastro.uat.unico.app/client/v1/process/{processId}' \
  -H 'accept: application/json' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer {{TOKEN}}'

ATENÇÃO

Lembre-se de trocar o processId pelo id do processo desejado.

Postman

Para utilizar o Postman, siga os passos:

1. Selecione o método GET.
2. Insira a URL https://api.cadastro.uat.unico.app/client/v1/process/ e adicione o id do seu processo.
3. Selecione a aba Authorization.
4. Na lista de Type, selecione Bearer Token.
5. Insira o token obtido no campo Token com o prefixo Bearer .

NodeJS

const axios = require('axios');

const TOKEN = 'SEU_TOKEN'; // Substitua com o seu token
const processId = 'SEU_PROCESS_ID'; // Substitua com o ID do processo que você deseja acessar

const headers = {
  'accept': 'application/json',
  'Content-Type': 'application/json',
  'Authorization': `Bearer ${TOKEN}`
};

const apiUrl = `https://api.cadastro.uat.unico.app/client/v1/process/${processId}`;

axios.get(apiUrl, { headers })
  .then(response => {
    console.log('Resposta da API:', response.data);
  })
  .catch(error => {
    console.error('Erro ao fazer a requisição:', error);
  });

Java

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;

public class ExemploRequisicaoGET {

    public static void main(String[] args) {
        String token = "SEU_TOKEN"; // Substitua com o seu token
        String processId = "SEU_PROCESS_ID"; // Substitua com o ID do processo que você deseja acessar

        try {
            URL url = new URL("https://api.cadastro.uat.unico.app/client/v1/process/" + processId);
            HttpURLConnection connection = (HttpURLConnection) url.openConnection();
            connection.setRequestMethod("GET");

            // Defina os cabeçalhos da requisição
            connection.setRequestProperty("accept", "application/json");
            connection.setRequestProperty("Content-Type", "application/json");
            connection.setRequestProperty("Authorization", "Bearer " + token);

            int responseCode = connection.getResponseCode();
            if (responseCode == HttpURLConnection.HTTP_OK) {
                BufferedReader in = new BufferedReader(new InputStreamReader(connection.getInputStream()));
                String inputLine;
                StringBuilder response = new StringBuilder();

                while ((inputLine = in.readLine()) != null) {
                    response.append(inputLine);
                }
                in.close();

                // Imprima a resposta da API
                System.out.println("Resposta da API: " + response.toString());
            } else {
                System.err.println("Erro ao fazer a requisição. Código de resposta: " + responseCode);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

C#

using System;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Threading.Tasks;

class Program
{
    static async Task Main(string[] args)
    {
        string token = "SEU_TOKEN"; // Substitua com o seu token
        string processId = "SEU_PROCESS_ID"; // Substitua com o ID do processo que você deseja acessar

        using (HttpClient client = new HttpClient())
        {
            client.BaseAddress = new Uri("https://api.cadastro.uat.unico.app/");
            client.DefaultRequestHeaders.Accept.Clear();
            client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
            client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", token);

            HttpResponseMessage response = await client.GetAsync($"client/v1/process/{processId}");

            if (response.IsSuccessStatusCode)
            {
                string responseBody = await response.Content.ReadAsStringAsync();
                Console.WriteLine("Resposta da API: " + responseBody);
            }
            else
            {
                Console.WriteLine("Erro ao fazer a requisição. Código de resposta: " + response.StatusCode);
            }
        }
    }
}

Go

package main

import (
    "fmt"
    "net/http"
    "io/ioutil"
)

func main() {
    token := "SEU_TOKEN" // Substitua com o seu token
    processId := "SEU_PROCESS_ID" // Substitua com o ID do processo que você deseja acessar

    url := fmt.Sprintf("https://api.cadastro.uat.unico.app/client/v1/process/%s", processId)

    client := &http.Client{}
    req, err := http.NewRequest("GET", url, nil)
    if err != nil {
        fmt.Println("Erro ao criar a requisição:", err)
        return
    }

    req.Header.Add("accept", "application/json")
    req.Header.Add("Content-Type", "application/json")
    req.Header.Add("Authorization", "Bearer " + token)

    resp, err := client.Do(req)
    if err != nil {
        fmt.Println("Erro ao fazer a requisição:", err)
        return
    }
    defer resp.Body.Close()

    if resp.StatusCode == http.StatusOK {
        body, err := ioutil.ReadAll(resp.Body)
        if err != nil {
            fmt.Println("Erro ao ler a resposta da API:", err)
            return
        }
        fmt.Println("Resposta da API:", string(body))
    } else {
        fmt.Println("Erro ao fazer a requisição. Código de resposta:", resp.StatusCode)
    }
}

Fluxos

O resultado é exibido de acordo com o fluxo.

1 - ID flow

2 - IDCheck flow (IDUnico + Check)

3 - IDDocs flow (IDUnico + Check + Docs)

4 - IDSign flow (IDUnico + Check + Sign)

5 - IDdocsign flow (IDUnico + Check + Docs + Sign)

6 - IDToken flow (IDToken)