Skip to main content

Know Your Customer

KYC o traducido al español 'Conoce a tu cliente' es un tipo de verificación de identidad que permite a cualquier usuario poder autenticarse de manera confiable.

Caso de uso​

En este caso de uso, nos pondremos en el papel de una aplicación que tiene el requerimiento de verificar la identidad de un usuario previo a darse de alta dentro de la plataforma.

La implementación lucirá de la siguiente manera:

Screens​

Diseño de base de datos​

La aplicación tendrá en su base de datos las siguientes entidades:

  • User: El usuario registrado en la plataforma
const mongoose = require('mongoose')

const schema = new mongoose.Schema({
  firstname: String,
  lastname: String,
  identification: String,
  password: String,
  username: String,
  email: String,
  verified: Boolean,
})

module.exports = mongoose.model('user', schema)

Registro de usuario​

Vamos a registrar nuestro punto de entrada para la aplicación. Para ello, vamos a agregar una ruta de tipo GET y retornaremos nuestra vista HTML en donde el usuario podrá completar el formulario de registro.

const express = require('express')
const path = require('path')
const app = express()

app.use(express.urlencoded({ extended: true }))
app.use(express.static(path.join(__dirname, 'public')))

app.get('/', (req, res) => {
  res.sendFile(path.join(__dirname, 'public', 'index.html'))
})

Creación de inspección​

Lo siguiente es agregar el endpoint que recibirá dicho formulario. Para ello, vamos agregar una ruta de tipo POST. Con la información del formulario, registraremos en la base de datos un usuario con un estado inicial de no verificado.

Para comprobar la identidad de dicho usuario y cambiar su estado de no verificado a verificado, vamos a crear una inspección de tipo people. Observa que pasamos una propiedad llamada callbackURL. Esta propiedad nos permite indicar a Autoinspector que cuando la inspección haya sido finalizada por el cliente, dicho usuario sea redireccionado a otro dominio/ubicación.

De esta manera, una vez que el usuario haya terminado con la inspección y este devuelta en nuestra aplicación, podremos saber si la inspección que realizo esta approved o disapproved, y en base a dicho veredicto tomar la decision de verificar la cuenta o no.

Cuando la inspección haya sido creada correctamente, tendremos acceso a la propiedad magicLink que permitirá redireccionar al cliente a la plataforma de inspección: Inspection App

app.post('/auth/register', async (req, res) => {
  // We create the user
  const user = await userEntity.create({
    email: req.body.email,
    firstname: req.body.firstname,
    lastname: req.body.lastname,
    identification: req.body.identification,
    username: req.body.username,
    password: req.body.password,
    // See that here we start the user as non verified one
    verified: false,
  })

  const inspection = await autoinspector.inspections.people.create({
    locale: 'es_AR',
    // See here that we pass the callbackURL. Because our server takes care of backend and frontend, we need the user back to our same domain
    callbackURL: `${req.get('origin')}/identity/verification`,
    initialStatus: 'started',
    delivery: {
      // We disable the delivery of all notifications. By this way, we avoid to send emails from Autoinspector to our client
      disabled: true,
    },
    metadata: {
      // We save as metadata our policy id. Later this value will be consume by the webhook at the moment of update our policy status
      userId: user._id,
    },
    producer: {
      internalId: user._id,
    },
    // Here we pass all the information related to our user registered
    consumer: {
      email: user.email,
      firstName: user.firstname,
      lastName: user.lastname,
      identification: user.identification,
    },
    //Here we send a built-in template alias. If you want to customize your inspection template, you can do it using inspection studio
    templateId: 'easy',
  })

  //Here we redirect our user from our domain to Autoinspector Inspection App usin the magicLink property
  res.status(301).redirect(inspection.magicLink)
})

Veredicto de inspección​

Una vez que la inspección haya sido finalizada por el usuario dentro de la plataforma de Autoinspector, es momento de agregar la ruta que recibirá la petición del usuario cuando se encuentre de nuevo en nuestra plataforma.

El path de la ruta tiene que coincidir con el callbackURL que definimos al momento de crear la inspección.

Al callbackURL que hayamos definido, se le agregara un query parameter llamado: inspectionId. Esto nos permitirá poder encontrar la inspección asociada a un user en particular.

En este ejemplo, la url a la cual sera redireccionado el cliente lucirá algo como:

https://${YOUR_DOMAIN}/identity/verification?inspectionId=
app.get('/identity/verification', async (req, res) => {
  // Here we extract the inspectionId from the request query
  const { inspectionId } = req.query

  // Find the inspection id to check the veredict and know to who belongs to
  const inspection = await autoinspector.inspections.retrieve(inspectionId)

  const isInspectionApproved = inspection.veredict === 'approved'

  if (isInspectionApproved) {
    //If the inspection is approved, we verify the user account
    await userEntity.updateOne(
      {
        _id: inspection.metadata.userId,
      },
      {
        $set: {
          verified: true,
        },
      }
    )

    // We send the view to tell to the user that their account is verified
    return res.sendFile(path.join(__dirname, 'public', 'identity-success.html'))
  }

  // Otherwise, we send the view to tell to the user that their could not verify their identity
  return res.sendFile(path.join(__dirname, 'public', 'identity-declined.html'))
})

Código fuente​

Si deseas probar esta implementación, puedes ver el código fuente de los diferentes lenguajes y probarlo en local.