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
/entities/user.entity.js
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.

/main.js
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

/main.js
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=
/main.js
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.