Verificación de número de móvil usando Laravel

Muchos gigantes de TI como Facebook, Google y especialmente el sector de BFSI (Banca, Servicios Financieros y Seguros) tienen un gran gusto por la técnica de autenticación basada en OTP (Contraseña de un solo uso) para obtener usuarios genuinos, ya que se les pide que proporcionen algo que saben. y algo que tienen.

Según mi experiencia, me encantaría hacer una declaración de que el ecosistema de Laravel facilita la implementación de dicha aplicación. En este artículo, vamos a construir una aplicación basada en OTP para la verificación de números móviles en PHP usando Laravel.

DEMO EN VIVO DESCARGAR

Entonces, la idea básica es verificar los números móviles de los usuarios enviando OTP en sus teléfonos y pedirles que lo ingresen.

Cómo funciona

Antes de comenzar el desarrollo, tengamos una descripción general de cómo funciona el sistema de verificación de número de teléfono móvil.

Flujo de aplicación

  • Se almacena la información del usuario junto con su número de teléfono móvil.
  • Siempre que se le pide a un usuario que verifique su número de teléfono móvil, se envía una solicitud a la puerta de enlace de SMS para enviar un SMS con una OTP generada aleatoriamente.
  • Se envía una OTP al número de teléfono móvil del usuario a través de una puerta de enlace SMS.
  • Se le pide al usuario que ingrese a la OTP.
  • El número de móvil se activa después de una verificación exitosa.

Dime más….!!!

Registrarse con SMS Gateway

Las puertas de enlace SMS tienen un contrato con casi todos los proveedores de servicios de redes móviles. Para enviar SMS a un número de teléfono móvil, tenemos que comprar una suscripción de un SMS Gateway.

Hice mi investigación para encontrar la puerta de enlace SMS adecuada para entregar mensajes y descubrí que Msg91 , Solutions Infini , SMS Gupshup y Twilio son bastante populares. Pero, desafortunadamente, ninguno de ellos es gratuito para probar.

Sin embargo, para la demostración en este artículo, estoy usando Msg91 ya que tienen un rango de precios flexible.

Obtención de la CLAVE API MSG91

  1. Regístrese en Msg91
  2. Visite este enlace y haga clic en Comprar créditos y complete el formulario como se muestra a continuación.
  3. Ahora haga clic en siguiente, se le pedirá que complete un formulario en el que debe proporcionar sus datos personales. Una vez que complete con éxito este formulario, será redirigido a la página de pago.
  4. Proceda con el pago. Una vez realizado el pago, debería ver los créditos por SMS acreditados en su cuenta.
  5. Para obtener la clave API, vaya al documento API y haga clic en KEY en la esquina superior derecha. Se le mostrará su clave API en una ventana emergente.

Me muero de hambre … ¡¡Hablemos de negocios !!

Preparando nuestra base de datos

En esta aplicación, tendremos un sistema de autenticación donde el usuario deberá iniciar sesión en la aplicación para realizar la verificación del número de móvil.

Necesitamos configurar nuestra base de datos usando el archivo .env .

Migraciones

Podemos manipular nuestra base de datos usando Migraciones sin usar herramientas como PHPMyAdmin. Para obtener más información, visite los documentos oficiales .

Aquí, usaremos la interfaz de línea de comandos artesanal para crear migraciones. Vaya a la raíz principal y escriba el siguiente comando.

php artisan make : migración create_users_table

Esto creará automáticamente un archivo de migraciones dentro de la carpeta de base de datos / migraciones y el archivo recién creado debe contener el siguiente código.

/database/migrations/%timestamp%_create_users_table.php

use Illuminate Database Schema Blueprint ;
use Illuminate Database Migrations Migration ;

class CreateUsersTable amplía la migración {

    / **

     * Ejecuta las migraciones.


     *


     * @return void


     * /

    public function up ( )
    {
        //
    }

    / **

     * Invertir las migraciones.


     *


     * @return void


     * /
función
    pública abajo ( ) { // } }
   
       
   

En el código anterior, tenemos dos funciones como se explica a continuación.

  • La función up () se usa para crear una tabla.
  • La función down () se usa para eliminar una tabla.

Utilice el Generador de esquemas para crear una tabla con el nombre de usuarios. Reemplace el código anterior con el código siguiente.

/database/migrations/%timestamp%_create_users_table.php

use Illuminate Database Schema Blueprint ;
use Illuminate Database Migrations Migration ;

class CreateUsersTable amplía la migración {

    / **

     * Ejecuta las migraciones.


     *


     * @return void


     * /

    public function up ( )
    {

        Schema
:: create ( ‘users’ , function ( Blueprint $ table ) {
            $ table -> increments ( ‘id’ ) ;
            $ table-> cadena ( ‘nombre’ , 255 ) ;
            $ tabla -> cadena ( ‘correo electrónico’ , 255 ) ;
            $ tabla -> cadena ( ‘contraseña’ , 255 ) ;
            $ tabla -> entero ( ‘móvil’ ) ;
            $ tabla -> integer ( ‘isVerified’ ) ;
            $ tabla -> cadena ( ‘recordar_token’ , 100 ) -> ;
        } ) ;
    }

    / **

     * Revertir las migraciones.


     *


     * @return void


     * /

    public function down ( )
    {

        Schema
:: drop ( ‘usuarios’ ) ;
    }

}

Ahora su archivo de migración está listo. Para ejecutar la migración y crear la tabla de ‘usuarios’ , use la línea de comando que se muestra a continuación y ejecute:

php migrar artesanal

Si desea revertir la migración, use el siguiente comando.

php artisan migrate: retroceder O php artisan migrate: restablecer

Siembra

¿Por qué sembrar? Porque la siembra nos permite llenar la tabla con datos de muestra para probar nuestra aplicación. Cree un archivo PHP llamado UserTableSeeder.php dentro de la carpeta database / seeds y escriba el código a continuación.

base de datos / semillas / DatabaseSeeder.php

use Illuminate Database Seeder ;
use Illuminate Database Eloquent Model ;

class DatabaseSeeder extiende Seeder {

    / **

     * Ejecuta las semillas de la base de datos.


     *


     * @return void


     * /

    public function run ( )
    {


        DB
:: table ( ‘users’ ) -> insert ( [
            ‘id’     => ,
            ‘name’     => ‘Shashank’ ,
            ’email’    => ‘ shashank @ codificación.,
            ‘contraseña’ => Hash :: make ( ‘shashank’ ) ,
            ‘móvil’ => ‘098765432’ ,
            ‘isVerified’ => 0
        ] ) ;
    }

}

Nuestro archivo de sembradoras está listo. Ahora inserte los datos en la tabla usando el siguiente comando.

php artisan db: semilla

Creando nueva aplicación

Entonces, estamos listos con nuestra base de datos y tabla, con la ayuda de la migración de Laravel.

Creemos Rutas, Controlador y Vistas para nuestra aplicación.

Rutas

En esta aplicación, crearemos seis rutas que son muy importantes como se enumeran a continuación.

  • /: Creo que esta ruta no necesita presentación.
  • / login: como sugiere el propio nombre, el usuario puede iniciar sesión utilizando esta ruta.
  • / home: se utiliza para mostrar la página de inicio.
  • / sendOtp: esta ruta se utilizará para enviar SMS al número de móvil del usuario.
  • / verifyOtp: Usando esta ruta verificaremos la OTP ingresada por el usuario.
  • / logout: Finalmente cerrar sesión.

Ahora abra su archivo routes.php y agregue las siguientes rutas.

aplicación / Http / routes.php
Route :: get ( ‘/’ , [
    ‘uses’ => ‘userController @ index’
    ] ) ;


Route
:: post ( ‘/ login’ , [
    ‘uses’ => ‘userController @ userLogin’
    ] ) ;


Route
:: get ( ‘/ home’ , [
    ‘uses’ => ‘userController @ home’
    ] ) ;


Route
:: post ( ‘/ sendOtp’ , [
    ‘middleware’ ,
    ‘usa’ => ‘userController @ sendOtp’
] ) ;


Route
:: post ( ‘/ verifyOtp’ , [
    ‘middleware’ => ‘checkSession’ ,
    ‘uses’ => ‘userController @ verifyOtp’
] ) ;


Route
:: get ( ‘/ logout’ , [
    ‘uses’ => ‘userController @ logout’
    ] ) ;

En el método GET / POST anterior , el primer parámetro es el nombre de la ruta y el segundo parámetro es una matriz donde proporcionamos el nombre del controlador. Se requiere que este controlador se ejecute cuando se ejecuta la URL.

Debe haber notado el método POST donde tenemos un par clave => valor más como ‘middleware’ => ‘checkSession’ en el segundo parámetro. Podemos pasar el middleware a las rutas antes de que se ejecute el método del controlador para realizar cualquier operación.

Magia del middleware

El método apropiado para filtrar solicitudes HTTP en Laravel es el uso de Middlewares HTTP. El mejor ejemplo es comprobar si un usuario está verificado y autenticado en nuestra aplicación, que es lo que vamos a ver en esta aplicación. Leer más sobre middleware .

Crearemos middleware, una vez más usando el comando artesanal de PHP llamado checkSession. El siguiente comando creará el archivo checkSession.php dentro de la carpeta app Http Middleware .

php artisan make: middleware checkSession

Ahora abra el archivo checkSession.php y escriba el código a continuación. El siguiente código nos permitirá verificar si un usuario ha iniciado sesión o no.

aplicación / Http / Middleware / checkSession.php
espacio de nombres App Http Middleware ;

use Closure ;

use Illuminate Support Facades Auth ;

class checkSession {

    / **

     * Maneja una solicitud entrante.


     *


     * @param Illuminate Http Request $ request


     * @param Closure $ next


     * @return mixed


     * /

    public function handle ( $ request , Closure $ next )
    {
        if ( Auth :: user ( ) === null ) {
            exit (
                json_encode (
                    array (
                    ‘error’ => 1 ,
                    ‘message’ => ‘Has cerrado sesión, vuelve a iniciar sesión.’ ,
                    ‘logIn’ => 0
                    )
                )
            ) ;
        } else {
            return $ next ( $ request ) ;
        }
    }
}

Hasta ahora, nuestro middleware no es más que un extraño a nuestro marco de Laravel. Para Laravel, este es solo un archivo normal dentro de una carpeta en particular.

Para que este middleware funcione, tenemos que decirle a Laravel:

“Laravel, este es mi middleware y tienes que ejecutarlo en la ruta XYZ”.

Técnicamente, tenemos que registrar nuestro middleware en el archivo kernel.php , que se encuentra dentro de la carpeta app Http Middleware . Abra el archivo kernel.php y busque la matriz $ routeMiddleware y agregue el siguiente par clave / valor.

‘checkSession’ => App Http Middleware checkSession :: clase

Ahora ha registrado su middleware y debería funcionar correctamente.

Controlador

Hemos cubierto migraciones, rutas y middlewares. Entonces, creemos un controlador llamado asuserController.php usando el comando artisan. Escriba el siguiente comando en la terminal.

php artisan make: controller userController

Ahora abra userController.php que se encuentra en el directorio app / HTTP / Controllers . Para ser honesto, todas las funciones definidas en este controlador se explican por sí mismas, excepto una. Lo alcanzaremos a medida que avancemos.

userController.php
espacio de nombres App Http Controllers ;

use App Http Requests ;
use App Http Controllers Controller ;

use Illuminate Http Request ;
use Illuminate Support Facades Session ;

use Auth ;
use App User ;
use App MSG91 ;

class userController extiende Controller {

    / **

    * Mostrar página de inicio.


    *


    * @return Response


    * /
índice de función
    pública ( ) { si
        ( Auth :: usuario ( ) == nulo ) { vista de
            retorno ( “inicio de sesión” ) ;
        } else {
            return redirect ( ‘/ home’ ) ;
        }
    }

    / **

    * Función para iniciar sesión.


    *


    * @return Response


    * /
función
    pública userLogin ( Solicitar $ solicitud ) { $ contraseña = $ solicitud -> input ( ‘contraseña’ ) ;

       
        $ correo electrónico = $ solicitud -> entrada ( ‘correo electrónico’ ) ;

        if ( Auth :: intento ( [ ’email’ => $ email , ‘contraseña’  => $ contraseña ] ) ) {

            echo json_encode ( array (
                ‘logIn’ => true
            ) ) ;
        } else {
            echo json_encode ( array (
                ‘logIn’ => false ,
                ‘error’ => “Combinatoin de contraseña de correo electrónico incorrecta”.
            ) ) ;
        }
    }

    / **

    * Muestra la página de inicio.


    *


    * @return Response


    * /

    public function home ( Request $ request ) {

        if ( Auth :: user ( ) ! = null ) {

            // Obteniendo información del usuario.
            $ usuarios = Usuario :: donde ( ‘id’ , Auth :: usuario ( ) -> id) -> primero ( ) ;
            $ usuarios [ ‘móvil’ ] = substr ( $ usuarios [ ‘móvil’ ] , 4 ) ;

            return view ( “myHome” , compact ( ‘usuarios’ ) ) ;
        } else {
            return redirect ( ‘/’ ) ;
        }
    }

    / **

    * Función para cerrar sesión Usuario


    * @return Response


    * /
función
    pública logout ( ) {

        Auth
:: logout ( ) ;
        return redireccionar ( ‘/’ ) ;
    }
}

Hemos cubierto todas las funciones básicas como iniciar sesión, obtener información del usuario y mostrar la página de inicio sin la operación de cierre de sesión.

Envío y verificación de OTP

¡¡Ah !! Finalmente, el MSG91 entra en escena. Realizaremos una solicitud CURL a la API MSG91 para enviar OTP en el dispositivo móvil del usuario. Creemos una clase dentro de la carpeta de la aplicación llamada MSG91.php .

El siguiente código envía llamadas SMS a la API MSG91. Esta función espera dos parámetros: OTP y Número de móvil.

app / MSG91.php

aplicación de espacio de nombres ;

/ **

* clase MSG91 para enviar SMS en números móviles.


* @author Shashank Tiwari


* /

class MSG91 {

    function __construct ( ) {

    }

    private $ API_KEY = ‘API_KEY’ ;
    privado $ SENDER_ID = VERIFY ;
    privado $ ROUTE_NO = 4 ;
    privado $ RESPONSE_TYPE = ‘json’ ; función

    pública sendSMS ( $ OTP , $ mobileNumber ) {
        $ isError = 0 ;
        $ mensaje de error = verdadero ;

        // Su mensaje para enviar, agregando codificación URL.
        $ message = urlencode ( “Bienvenido a www.codershood.info, su OPT es: $ OTP) ;
     

        // Preparando los parámetros
        de la publicación $ postData = array (
            ‘authkey’ => $ this -> API_KEY ,
            ‘mobiles’ => $ mobileNumber ,
            ‘message’ => $ message ,
            ‘sender’ => $ this -> SENDER_ID ,
            ‘ruta’ => $ esto -> ROUTE_NO ,
            ‘respuesta’ => $ esto -> RESPONSE_TYPE
        ) ;
     
        $ url = “https://control.msg91.com/sendhttp.php” ;
     
        $ ch = curl_init ( ) ;
        curl_setopt_array ( $ ch , array (

            CURLOPT_URL
=> $ url ,

            CURLOPT_RETURNTRANSFER
=> verdadero ,

            CURLOPT_POST
=> verdadero ,

            CURLOPT_POSTFIELDS
=> $ postData
        ) ) ;
     
     
        // Ignorar la verificación del certificado SSL
        curl_setopt ( $ ch , CURLOPT_SSL_VERIFYHOST , 0 ) ;
        curl_setopt ( $ ch , CURLOPT_SSL_VERIFYPEER , 0 ) ;
     
     
        // obtener respuesta
        $ salida = curl_exec ( $ ch ) ;
     
        // Error de impresión si lo hay
        if ( curl_errno ( $ ch ) ) {
            $ isError = true ;
            $ errorMessage = curl_error ( $ ch ) ;
        }
        curl_close ( $ ch ) ;
        if ( $ isError ) {
            return array ( ‘error’ => 1 , ‘message’ => $ errorMessage ) ;
        } else {
            return array ( ‘error’ => 0 ) ;
        }
    }
}
?>

Envío de OTP

La imagen de arriba es la representación pictórica de cómo funciona este proceso. Básicamente, implica los tres pasos que se enumeran a continuación,

  1. El usuario envía una solicitud de verificación de número de teléfono móvil al servidor.
  2. El servidor inicia una solicitud de SMS a SMS Gateway.
  3. Luego, la puerta de enlace SMS envía un SMS junto con OTP al teléfono móvil.

Cree una función dentro de userController y asígnele el nombre sendOtp () . Esta función llamará a MSG91 creando su objeto. Si CURL se ejecuta correctamente, OTP se almacenará en la sesión.

userController.php
/ **

* Envío de la OTP.


*


* @return Response


* /
función
pública sendOtp ( Solicitar $ solicitud ) { $ respuesta = matriz ( ) ; $ userId = Auth :: usuario ( ) -> id ; $ usuarios = Usuario :: donde ( ‘id’ , $ userId ) -> first ( ) ; if ( isset ( $ usuarios [

   
   

   

    ‘móvil’ ] ) && $ usuarios [ ‘móvil’ ] == “” ) {
        $ respuesta [ ‘error’ ] = 1 ;
        $ respuesta [ ‘mensaje’ ] = ‘Número de móvil no válido’ ;
        $ respuesta [ ‘logIn’ ] = 1 ;
    } más {

        $ otp = rand ( 100000 , 999999 ) ;
        $ MSG91 = nuevo MSG91 ( ) ;

        $ msg91Response = $ MSG91 -> sendSMS ( $ otp , $ usuarios [ ‘móvil’ ] ) ;

        if ( $ msg91Response [ ‘error’ ] ) {
            $ respuesta [ ‘error’ ] = 1 ;
            $ respuesta [ ‘mensaje’ ] = $ msg91Response [ ‘mensaje’ ] ;
            $ respuesta [ ‘logIn’ ] = 1 ;
        } else {


            Sesión
:: put ( ‘OTP’ , $ otp ) ;

            $ respuesta [ ‘error’ ] = 0 ;
            $ response [ ‘message’ ] = ‘Se crea su OTP.’ ;
            $ respuesta [ ‘OTP’ ] = $ otp ;
            $ respuesta [ ‘logIn’ ] = 1 ;
        }
    }
    echo json_encode ( $ respuesta ) ;
}

Verificación de OTP

  1. El usuario envía una solicitud de verificación de número de teléfono móvil a un servidor junto con OTP.
  2. El servidor verifica la OTP del usuario con la OTP enviada al número móvil.
  3. Si la OTP ingresada por los usuarios es igual a la OTP enviada al número de teléfono móvil, entonces el servidor actualiza el estado del usuario como se verifica, como se muestra en la imagen a continuación.

Después de enviar un SMS al número de móvil registrado del usuario, nuestra aplicación le pedirá al usuario que ingrese la OTP. Cuando el usuario ingresa OTP en el cuadro de entrada y hace clic en el botón de verificación, se realiza una llamada a la función verifyOtp () .

En esta función, la OTP almacenada en la sesión y la OTP ingresada por el usuario serán verificadas de forma cruzada. Si ambas OTP coinciden, actualizaremos el estado isVefired del usuario como 1.

userController.php
/ **

* Función para verificar OTP.


*


* @return Response


* /
función
pública verifyOtp ( Solicitar $ solicitud ) { $ respuesta = matriz ( ) ; $ ingresadoOtp = $ solicitud -> entrada ( ‘otp’ ) ; $ userId = Auth :: usuario ( ) -> id ; // Obteniendo UserID. if ( $ userId == “” || $ userId == null )

   

   
     

    {
        $ respuesta [ ‘error’ ] = 1 ;
        $ response [ ‘message’ ] = ‘Se desconectó, vuelva a iniciar sesión.’ ;
        $ respuesta [ ‘logIn’ ] = 0 ;
    } else {
        $ OTP = $ solicitud -> sesión ( ) -> get ( ‘OTP’ ) ;
        if ( $ OTP === $ EnterOtp ) {

            // Actualizando el estado del usuario “isVerified” como 1.


            Usuario
::donde ( ‘id’ , $ userId ) -> actualizar ( [ ‘isVerified’ => 1 ] ) ;

            // Eliminando la variable de

            sesión Session
:: olvide ( ‘OTP’ ) ;

            $ respuesta [ ‘error’ ] = 0 ;
            $ respuesta [ ‘isVerified’ ] = 1 ;
            $ respuesta [ ‘logIn’ ] = 1 ;
            $ respuesta [ ‘mensaje’ ] = “Tu número está verificado”. ;
        } else {
            $ respuesta [ ‘error’ ] = 1 ;
            $ respuesta [ ‘isVerified’ ] = 0 ;
            $ respuesta [ ‘logIn’ ] = 1 ;
            $ response [ ‘message’ ] = “OTP no coincide”. ;
        }
    }
    echo json_encode ( $ respuesta ) ;
}

Vista

Al final del túnel, usaremos la plantilla Blade de Laravel. Para que Laravel sepa que se está utilizando el motor de plantillas Blade de Laravel, tenemos que agregar una extensión .blade.php después del nombre del archivo.

Cree dos vistas de la siguiente manera:

  1. login.blade.php
  2. myHome.blade.php

El siguiente código es para login.blade.php.

login.blade.php
< html >
< head >
    < title > Verificación del número de móvil en Laravel < / title >
    < link rel = “stylesheet” href = “css / bootstrap.min.css” >
    < link rel = “stylesheet” href = “css / font -awesome.min.css “ >    
    < link rel = ” hoja de estilo ” href = ” css / style.css “ >    
< / head >
< body ng-app= “Iniciar sesión” ng-controller = “LoginController” class = “loginContainer” >

    < div class = “container” >

        < div class = “row” >
            < h2 > Iniciar sesión < / h2 >
            < label > Nombre de usuario: < / label >
            < tipo de entrada = “texto” clase = “control de formulario”ng-model = “email” nombre = “email” marcador de posición = “Introduzca su correo electrónico” >
            < br / >
            < etiqueta > Contraseña: < / etiqueta >
            < entrada tipo = “contraseña” clase = “-control de formulario” NG-modelo = “contraseña” nombre = “contraseña” marcador de posición = “Introduzca su contraseña” >
            < br / >
            < botón de clase = “Bot”ng-click = “iniciar sesión ()” >Iniciar sesión < / button >

        < / div >    
    < / div >

    < script type = “text / javascript” >

        ‘usar estricto’;


        const BASE_URL = ‘{!!
url (). ‘/’ !!} ‘;

    < / script >
    < script src = “{{asset (‘/ js / angular.min.js’)}}” > < / script >
    < script src = “{{asset (‘/ js / script.js’) }} “ > <

< / html >

Esa era la página de inicio de sesión. Escribamos ahora el código para la página de inicio. Cuando el usuario inicia sesión en la aplicación, será redirigido a / home URL que utilizará el archivo myHome.blade.php para mostrar la página de inicio.

El siguiente código es para myHome.blade.php.

myHome.blade.php
< html >

<
head >

    <
title > Verificación del número de móvil en Laravel < / title >

    <
link rel = “stylesheet” href = “{{asset (‘/ css / bootstrap.min.css’)}}” >

    <
link rel = “hoja de estilo” href = “{{activo (‘/ css / font-awesome.min.css’)}}” >    

    <
link rel = “hoja de estilo” href = “{{activo (‘/ css / style.css’ )}} “>    

<
/ cabeza >

<
cuerpo ng-app = “home” ng-controller = “index” class = “container” >


    <
div class = “row” >

        <
div class = “header” >

            <
div class = “col-md-4” >

                Hola,
{ { $ users [ ‘name’ ] } }

            <
/ div >

            <
div class =“col-md-8” >

                <
ul clase = “navegador” >

                    <
li >

                        <
un href = “{{url ( ‘/ home’)}}” título = “Inicio” >

                            <
i clase = “fa fa- inicio “ aria-hidden = ” true “ > < / i >

                        <
/ a >

                    <
/ li >

                    <
li >

                        <
Un href = “{{url ( ‘/ cierre de sesión’)}}” título = “Salir” >

                            <
i clase = “fa fa-cierre de sesión” aria-oculta = “true” > < / i >

                        <
/ una >

                    <
/ li >

                <
/ ul >

            <
/ div >

        <
/ div >

    <
/ div >


    <
div class = “userInfo row” >
   

        <
div class = “information” >

            <
h3 > Su número de teléfono móvil ****** { { $ users [ ‘mobile’ ] } } es

                <
span id = “isVerified” >

                    @ si
( $ users [ ‘isVerified’ ] === 0 ) no verificado. @else Verificado. @endif

                <


            <
/ h3 >

        <
/ div >


        <
div id = “otpSection” class = “otpSection” >


            <
input type = “hidden” name = “_token” id = “_token” ng-model = “_token” value = “{{ csrf_token ()}} “ >


            <
div id = ” sendOtpSection ” class = ” sendOtpSection “
                estilo =“display: @if ($ users [‘isVerified’] === 0) block @else none @endif” >

                <
button class = “btn btn-primary sendOtp” id = “sendOtp” ng-click = “sendOTP ({ {$ users [‘id’]}}) “ > Enviar OTP < / button >

            <
/ div >


            <
div id = ” verifyOtpSection ” class = ” verifyOtpSection ” style = ” display: none “ >

                <
tipo de
entrada = “número” clase = “-control de formulario” ID = “OTP” marcador de posición = “Enter OTP” -modelo ng = “enteredOtp” >

                <
br / >

                <
botón de clase = “btn btn-primaria verifyOtp” ID = “verifyOtp” NG-clic = “verifyOTP () “ > Verificar OTP < / botón >

            <
/ div >

        <
/ div >

    <
/ div >

    <
tipo de
secuencia de comandos = “texto / javascript” >
        ‘usar estricto’ ;

        const BASE_URL
= ‘{!! url (). ‘ / ‘!!}’ ;

    <
/ script >


    <
script src = “{{asset (‘/ js / angular.min.js’)}}” > < / script >

    <
script src = “{{asset (‘/ js / home.js’) }} “ > < / script >

<
/ body >

<
/ html >

En esta aplicación, JavaScript se usa solo para realizar algunas solicitudes Ajax. Puede encontrar JavaScript y CSS en GitHub.

Pensamientos finales

Bueno, estamos al final del túnel y sí, ¿hay luz, no? Verificar el número de teléfono móvil de un usuario es importante desde una perspectiva de seguridad y ahora sabe cómo crear una aplicación de este tipo. Repasemos lo que hemos tratado, en este artículo:

  • 1. Vimos el concepto de Migraciones y Siembra.
  • 2. Middleware añadido.
  • 3. Creé una cuenta en MSG91 y aprendí cómo integrarla en la aplicación Laravel.
  • 4. Controladores y vistas agregados.

Háganos saber su opinión sobre este artículo, nos gustaría saber de usted.

Este artículo está escrito por Shashank Tiwari de Codershood.info

Publicada en PHP

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *