Activar la vinculación con OTP

La contraseña de un solo uso (OTP) se utiliza como el ID&V método para activar un enlace de dispositivo pendiente.

Esta página continúa el flujo después de Crear enlace de dispositivo (flujo amarillo).

Prerrequisitos:

Ya has iniciado createBinding o resumeBinding.
El emisor seleccionó un método ID&V basado en OTP (por ejemplo, OTP_SMS).
Tu aplicación de comerciante puede recopilar un OTP del usuario final.

Flujo

Paso

Descripción

El usuario final selecciona una opción OTP (SMS, correo electrónico o banca en línea).

La aplicación del comerciante reenvía la selección al backend de Thales.

3–5

El backend de Thales solicita VTS y el emisor que entregue el OTP por el canal seleccionado.

El usuario final introduce el OTP en la aplicación del comerciante. La aplicación del comerciante posee la interfaz de usuario.

7–8

El backend de Thales valida el OTP con VTS y el emisor.

El SDK de Thales recibe el resultado y activa el enlace localmente.

El backend de Thales notifica al backend del comerciante/PSP que el enlace está activo.

Integración del SDK

1. Seleccionar un método ID&V OTP

Durante createBinding o resumeBinding, selecciona uno de los métodos ID&V OTP:

OTP_SMS
OTP_EMAIL
OTP_ONLINE_BANKING

Una vez que la aplicación envíe el ID&V método seleccionado con éxito, el onIssuerAuthenticationReady callback será devuelto a la aplicación. De lo contrario, un onError callback será devuelto.

@Override
public void onIssuerAuthenticationRequired(PendingBindingSession pendingBindingSession) { 
    // Enviar método ID&V OTP_SMS
    for (IDVMethod idvMethod : pendingBindingSession.getIdvMethods()) {
        if (idvMethod.getType().equals(IDVType.OTP_SMS)) {
            pendingBindingSession.submitIdvMethod(idvMethod);
        }
    }
}

@Override
public void onIssuerAuthenticationReady(PendingBindingSession pendingBindingSession, 
                                        @Nullable OtpActivationStatus status) {
    
}

@Override
public void onError(TMGClientException exception) { 
    // Comprobar si hay algún error
    int errorCode = exception.getErrorCode();
    int errorMessage = exception.getMessage();
}

guard let idvSession = VisaService.shared.idvSession else {
    // no hay sesión idv
    return
}
// 1. Mostrar la lista de métodos idv
do {
    let idvMethods = try idvSession.idvMethods
    let selectedIdvMethod = idvMethods[0] // el usuario selecciona un método idv OTP (OTP_SMS)
    
    // 2. enviar el método idv
    idvSession.selectIDVMethod(selectedIdvMethod) { (result) in
        if let otpActivationStatus = result {
            let maxOtpVerificationAllowed = otpActivationStatus.maxOTPVerificationAllowed
            let maxOtpRequestsAllowed = otpActivationStatus.maxOTPRequestsAllowed
            let otpExpiration = otpActivationStatus.otpExpiration
            
            // 3. Mostrar página para introducir el OTP
        }
    }
} catch let error {
    // manejar error
}

// 4. El fallo en el paso 2, selectIDVMethod, se manejará en completionHandler.
VisaService.shared.completionHandler = { (session, error) in
    // 5. Comprobar si es un error de selectIDVMethod.
    if let session = session,
        let error = error,
        error.description == TMGError.invalidIdvMethod.description {
        VisaService.shared.idvSession = session
        // 6. Reintentar el flujo IDV.
    }
}

2. Activar el enlace

Recopila el OTP en tu aplicación de comerciante, luego llama a activateBinding en el IDVSession.

@Override
public void onIssuerAuthenticationReady(IDVSession idvSession, 
                                        @Nullable OtpActivationStatus status) { 
    // Activar enlace
    String otp;
    idvSession.activateBinding(otp);
}

@Override
public void onIssuerAuthenticationError(@Nullable IDVSession idvSession, 
                                        TMGClientException tmgClientException) {
    // Comprobar el error o reintentar
}

El resultado se devuelve a través de onSuccess o onIssuerAuthenticationError.

Si la activación falla, utiliza el IDVSession devuelto en onIssuerAuthenticationError para reintentar.

// 1. Valor OTP de la entrada del usuario
let otp = ""

guard let idvSession = VisaService.shared.idvSession else {
    // no hay sesión idv
    return
}
// 2. Llamar a activar
idvSession.activateBinding(withValue: otp)

VisaService.shared.completionHandler = { (session, error) in
    // 2. Enlace exitoso
    if error == nil {
        
    } else if let error = error,
                let session = session,
                error.description == TMGError.serverErrorWrongOTP.description {
        VisaService.shared.idvSession = session
        // 3. Reintentar la entrada OTP y mostrar mensaje de error
    }
}

El resultado se devuelve en completionHandler.

Si la activación falla, completionHandler devuelve un IDVSession y un error para reintentar.

AnteriorActivar la vinculación con app-to-app SiguienteActivar la vinculación con atención al cliente

Última actualización hace 5 meses

¿Te fue útil?