Breaking

Post Top Ad

Your Ad Spot

domingo, 10 de marzo de 2019

Inicio de sesión de usuario y registro con CodeIgniter REST API

Los servicios web RESTful proporcionan una forma sencilla de intercambiar datos entre diferentes aplicaciones. Si su aplicación web necesita comunicarse a través de las plataformas, el servicio web RESTful debe desarrollarse. La aplicación puede conectarse y trabajar con diferentes plataformas (web, móvil, etc.) utilizando la API RESTful. La API REST utiliza las solicitudes GET, PUT, POST y DELETE HTTP para el manejo de datos en todas las plataformas.
El servicio web RESTful CodeIgniter es la forma más fácil de integrar el servicio REST API en la aplicación web. Usando el servidor de descanso CodeIgniter, puede crear fácilmente la API REST en CodeIgniter . En este tutorial, le mostraremos cómo implementar el inicio de sesión y el registro de usuarios con la API REST de CodeIgniter . 
El código de ejemplo mostrará cómo construir la API REST y manejar la autenticación del usuario (inicio de sesión y registro) con CodeIgniter.
Los siguientes pasos se implementarán para crear la API REST en CodeIgniter .
  • Configurar el servidor de descanso en CodeIgniter.
  • Crear método de API para manejar el inicio de sesión de usuario a través de la solicitud POST.
  • Crear método de API para manejar el registro de usuarios a través de la solicitud POST.
  • Cree un método API para obtener los datos de la cuenta de usuario a través de la solicitud GET.
  • Cree un método API para actualizar la información del usuario a través de la solicitud PUT.
  • Interactuar con la API RESTful CodeIgniter.
Antes de comenzar, eche un vistazo a la estructura de archivos de la aplicación REST CodeIgniter.
codeigniter-rest-api-login-system-files-structure-codexworld

Crear tablas de base de datos

Para almacenar la información de la cuenta del usuario, se debe crear una tabla en la base de datos. El siguiente SQL crea una userstabla con algunos campos básicos en la base de datos MySQL.
CREATE  TABLE  `users` (
  ` id`  int ( 11 ) NOT  NULL AUTO_INCREMENT,
  `first_name`  varchar ( 25 ) COLLATE utf8_unicode_ci NOT  NULL ,
  ` last_name`  varchar ( 25 ) COLLATE utf8_unicode_ci NOT  NULL ,
  `email`  varchar ( 50 ) COLLATE utf8_unicodeikci NOT  NULL ,
  `password`  varchar ( 255) COLLATE utf8_unicode_ci NOT  NULL ,
  `phone`  varchar ( 20 ) COLLATE utf8_unicode_ci DEFAULT  NULL ,
  ` created` datetime NOT  NULL ,
  `modified` datetime NOT  NULL ,
  ` status` tinyint ( 1 ) NOT  NULL  DEFAULT  '1'  COMMENT  '1 = Active | 0 = Inactivo ' ,LLAVE 
 PRIMARIA ( `id` )
) MOTOR = InnoDB  DEFAULT  CHARSET = utf8 COLLATE = utf8_unicode_ci;
El siguiente SQL crea una keystabla para almacenar la clave de la API REST para la autenticación.
CREATE  TABLE  `keys` (
  ` id`  int ( 11 ) NOT  NULL AUTO_INCREMENT,
  `user_id`  int ( 11 ) NOT  NULL ,
  ` key`  varchar ( 40 ) NOT  NULL ,
  `level`  int ( 2 ) NOT  NULL ,
  ` ignore_limits` tinyint ( 1 ) NO  NULL  DEFAULT  '0' ,
  `is_private_key` tinyint ( 1 )NO  NULL  DEFAULT  '0' ,
  `ip_addresses`  texto ,
  ` date_created` datetime NOT  NULL ,LLAVE 
 PRIMARIA ( `id` )
) MOTOR = InnoDB  DEFAULT  CHARSET = utf8;
Importe los datos clave de la API en la keystabla, que se utilizarán para validar la llamada a la API.
INSERT  INTO  `keys` ( ` id` , `user_id` , ` key` , `level` , ` ignore_limits` , `is_private_key` , ` ip_addresses` , `date_created` ) VALUES 
( NULL , 1 , 'CODEX @ 123' , 0 , 0 , 0 , NULL , '2018-10-11 13:34:33' );

Configuración del controlador REST CodeIgniter

Usaremos la biblioteca del controlador REST para crear servicios web RESTful en CodeIgniter. Siga los pasos a continuación para integrar el servidor RESTful en CodeIgniter usando la biblioteca del controlador REST.
  • Coloque el archivo de configuración REST ( rest.php ) en la application/config/carpeta y especifique las configuraciones de la API.
    • Habilitar la autenticación API REST.
      $ config [ 'rest_auth' ] =  'basic' ;
    • Establezca el nombre de usuario y la contraseña para la autenticación API.
      $ config [ 'rest_valid_logins' ] = [ 'admin'  =>  '1234' ];
    • Establezca el nombre de la tabla que contiene la clave API.
      $ config [ 'rest_keys_table' ] =  'keys' ;
    • Habilitar clave de API REST.
      $ config [ 'rest_enable_keys' ] =  TRUE ;
  • Coloque la biblioteca de CodeIgniter Rest Controller ( REST_Controller.php ) en la application/libraries/carpeta.
  • Coloque la biblioteca de formatos de CodeIgniter ( Format.php ) en la application/libraries/carpeta.
  • Coloque el idioma del controlador de descanso ( rest_controller_lang.php ) en la application/language/english/carpeta para soporte multilingüe.
Tenga en cuenta que: Todos los archivos requeridos están incluidos en el código fuente, no necesita descargar estos archivos por separado.

Modelo (User.php)

El modelo de usuario maneja las operaciones relacionadas con la base de datos (captura, inserción, actualización y eliminación).
  • __construir () -
    • Cargar la biblioteca de base de datos.
    • Especifique el nombre de la tabla que se utilizará.
  • getRows () : recupera los datos de la base de datos según la condición dada y devuelve los datos como una matriz.
  • insert () - Inserta los datos en la base de datos.
  • update () : actualiza los datos en función de la ID en la base de datos.
  • delete () - Borre datos basados ​​en la ID de la base de datos.
<? php if (! defined ( 'BASEPATH' )) exit ( 'No se permite el acceso directo al script' ); 

clase de  usuario  se extiende  CI_Model  { 

    función pública  __construct () { 
        padres :: __construct (); 
        
        // Cargar la biblioteca de la base de datos 
        $ this -> load -> database (); 
        
        $ this -> userTbl  'users' ; 
    } 

    / * 
     * Obtener filas de la tabla de usuarios 
     * / 
    function  getRows ( $ params = array ()) { 
        $ this -> db -> select ( '*' ); 
        $ this -> db -> from ( $ this -> userTbl ); 
        
        // obtener datos por condiciones 
        si ( array_key_exists ( "conditions" , $ params )) { 
            foreach ( $ params [ 'conditions' ] as  $ key  =>  $ value ) { 
                $ this -> db -> where ( $ key , $ valor ); 
            }
        } 
        
        if ( array_key_exists ( "id" , $ params )) { 
            $ this -> db -> where ( 'id' , $ params [ 'id' ]); 
            $ consulta  $ esto -> db -> get (); 
            $ result  $ query -> row_array (); 
        } else { 
            // establece start y limit 
            if ( array_key_exists ( "start" , $ params ) &&  array_key_exists ( "limit"$ params )) { 
                $ this -> db -> limit ( $ params [ 'limit' ], $ params [ 'start' ]); 
            } elseif (! array_key_exists ( "start" , $ params ) &&  array_key_exists ( "limit" , $ params )) { 
                $ this -> db -> limit ( $ params [ 'limit' ]); 
            } 
            
            if ( array_key_exists ( "returnType" ,) &&  $ params [ 'returnType' ] ==  'count' ) { 
                $ result  $ this -> db -> count_all_results ();    
            } elseif ( array_key_exists ( "returnType" , $ params ) &&  $ params [ 'returnType' ] ==  'single' ) { 
                $ query  $ this -> db -> get (); 
                $ resultado  = ( $ consulta -> num_rows ()> 0 )? $ consulta ->row_array (): false ; 
            } else { 
                $ query  $ this -> db -> get (); 
                $ resultado  = ( $ consulta -> num_rows ()>  0 )? $ consulta -> result_array (): falso ; 
            } 
        } 

        // devolver exagerado los datos 
        de retorno  $ resultado ; 
    } 
    
    / * 
     * Insertar datos de usuario 
     * / 
    inserción de función pública  ( $ datos ) { // agregar fecha creada y modificada si no existe
        
        if (! array_key_exists ( "created" $ data )) { 
            $ data [ 'created' ] =  date ( "Ymd H: i: s" ); 
        } 
        if (! array_key_exists ( "modificado" $ datos )) { 
            $ datos [ 'modificado' ] =  fecha ( "Ymd H: i: s" ); 
        } 
        
        // insertar datos de usuario en la tabla de usuarios 
        $ insert  $ this -> db -> insert ( $ this -> userTbl $ datos ); 
        
        // devolver el estado de 
        retorno  $ insertar ? $ this -> db -> insert_id (): false ; 
    } 
    
    / * 
     * Actualizar datos de usuario 
     * / 
    actualización de función pública  ( $ datos $ id ) { // agregar fecha modificada si no existe si (! Array_key_exists ( 'modificado' $ datos )) { $ datos [ 'modificado' ] =  fecha ( "Ymd H: i: s" );         } // actualizar datos de usuario en la tabla de usuarios
        
        
            

        
        
        $ update  $ this -> db -> update ( $ this -> userTbl $ data , array ( 'id' => $ id )); 
        
        // devolver el estado de 
        retorno  $ actualizar ? verdadero : falso ; 
    } 
    
    / * 
     * Eliminar datos de usuario 
     * / 
    eliminar función pública  ( $ id ) { // actualizar usuario de la tabla de usuarios $ delete  $ this -> db -> delete ( 'users' , array (
        
        'id' => $ id )); 
        // devuelve el estado 
        return  $ delete ? verdadero : falso ; 
    } 

}

Controlador (Authentication.php)

Siempre es mejor crear una carpeta separada para el controlador relacionado con la API. En este ejemplo, colocaremos el controlador API en la controllers/api/carpeta. 
El controlador de API de autenticación maneja las solicitudes de API. Permite implementar una interfaz REST para el inicio de sesión y el registro del usuario a través de las solicitudes GET, POST y PUT.
  • __construct () : carga el modelo de usuario para trabajar con la base de datos.
  • login_post () -
    • Recupere los datos de inicio de sesión de la solicitud POST.
    • Valide el inicio de sesión a través de la base de datos utilizando el getRows()método del modelo de usuario.
    • Establecer la respuesta y salir.
  • registration_post () -
    • Recuperar los datos de registro de la solicitud POST.
    • Valide e inserte datos de usuario en la base de datos utilizando el insert()método del modelo de usuario.
  • user_get () -
    • Obtenga los datos de usuario de la base de datos utilizando el getRows()método del modelo de usuario.
    • Devuelve datos de un solo usuario si se especifica la ID; de lo contrario, todos los datos de los usuarios.
    • Establecer la respuesta y salir.
  • user_put () -
    • Recupere el ID de usuario y los datos de la solicitud PUT.
    • Actualice los datos del usuario en la base de datos según el ID.
<? php if (! defined ( 'BASEPATH' )) exit ( 'No se permite el acceso directo al script' ); 
// Cargar la biblioteca de Rest Controller requiere  APPPATH  '/libraries/REST_Controller.php' ; 

la autenticación de  clase  extiende  REST_Controller  { 

    public function  __construct () {  
        parent :: __construct (); 
        
        // Cargar el modelo de usuario 
        $ esto -> cargar -> modelo ( 'usuario' ); 
    } 
    
    public function  login_post () {
        // Obtener los datos de la entrada 
        $ email  $ this -> post ( 'email' ); 
        $ contraseña  $ esto -> publicar ( 'contraseña' ); 
        
        // Valide los datos de la publicación 
        si (! Empty ( $ email ) &&! Empty ( $ password )) { 
            
            // Verifique si existe algún usuario con las credenciales dadas 
            $ con [ 'returnType' ] =  'single' ; 
            $ con [ 'conditions' ] = array ( 
                'email'  =>  $ email , 
                'password'  => $ contraseña ), 
                'estado'  =>  1 
            ); 
            $ user  $ this -> user -> getRows ( $ con ); 
            
            if ( $ user ) { 
                // Configure la respuesta y salga de 
                $ this -> response ([ 
                    'status'  =>  TRUE , 
                    'message'  =>  'Login de usuario exitoso.' , 
                    'data'  =>  $ user 
                ],  REST_Controller : : HTTP_OK ); 
            } else { 
                // Establecer la respuesta y salir
                // BAD_REQUEST (400) es el código de respuesta HTTP 
                $ this -> response ( "Correo electrónico o contraseña incorrectos" REST_Controller :: HTTP_BAD_REQUEST ); 
            } 
        } else { 
            // Establezca la respuesta y salga de 
            $ this -> response ( "Proporcionar correo electrónico y contraseña" REST_Controller :: HTTP_BAD_REQUEST ); 
        } 
    } 
    
    función pública  registration_post () { 
        // Obtener los datos de la publicación 
        $ first_name  strip_tags ( $ this ->post ( 'first_name' )); 
        $ last_name  strip_tags ( $ this -> post ( 'last_name' )); 
        $ email  strip_tags ( $ this -> post ( 'email' )); 
        $ contraseña  $ esto -> publicar ( 'contraseña' ); 
        $ phone  strip_tags ( $ this -> post ( 'phone' )); 
        
        // Valide los datos de la publicación 
        si (! Empty ( $ first_name ) &&! Empty ($ last_name ) &&! empty ( $ email ) &&! empty ( $ password )) { 
            
            // Compruebe si el correo electrónico dado ya existe 
            $ con [ 'returnType' ] =  'count' ; 
            $ con [ 'conditions' ] = array ( 
                'email'  =>  $ email , 
            ); 
            $ userCount  $ this -> user -> getRows ( $ con ); 
            
            if ( $ userCount  0 ) { 
                // Configure la respuesta y salga de 
                $ this -> response ("El correo electrónico dado ya existe". REST_Controller :: HTTP_BAD_REQUEST ); 
            } else { 
                // Insertar datos de usuario 
                $ userData  = array ( 
                    'first_name'  =>  $ first_name , 
                    'last_name'  =>  $ last_name , 
                    'email'  =>  $ email , 
                    'password'  =>  md5 ( $ password ), 
                    'teléfono '  =>  $ teléfono 
                ); 
                $ insert  $ this -> usuario -> insert ( $ userData );
                
                // Compruebe si los datos del usuario están insertados 
                si ( $ insertar ) { 
                    // Establezca la respuesta y salga de 
                    $ this -> response ([ 
                        'status'  =>  TRUE , 
                        'message'  =>  'El usuario se ha agregado correctamente.' , 
                        'data'  =>  $ insert 
                    ],  REST_Controller :: HTTP_OK ); 
                } else { 
                    // Establezca la respuesta y salga de 
                    $ this -> response ( "Ocurrieron algunos problemas, inténtelo de nuevo." REST_Controller :: HTTP_BAD_REQUEST );
                } 
            } 
        } else else { 
            // Establezca la respuesta y salga 
            $ this -> response ( "Proporcione la información completa del usuario para agregar." REST_Controller :: HTTP_BAD_REQUEST ); 
        } 
    } 
    
    función pública  user_get ( $ id  0 ) { 
        // Devuelve todos los datos de los usuarios si no se especifica la identificación, 
        // De lo contrario, se devolverá un solo usuario. 
        $ con  $ id ? array ( 'id'  =>  $ id ): '' ; 
        $ usuarios  $ this -> usuario -> getRows ( $ con ); 
        
        // Compruebe si los datos del usuario existen 
        si (! Vacío ( $ usuarios )) { 
            // Configure la respuesta y salga 
            // OK (200) siendo el código de respuesta HTTP 
            $ este -> respuesta ( $ usuarios REST_Controller :: HTTP_OK ) ; 
        } else { 
            // Establezca la respuesta y salga 
            // NOT_FOUND (404) siendo el código de respuesta HTTP 
            $ this -> response ([ 
                'status'  =>  FALSE , 
                'message'  => 'No se ha encontrado ningún usuario'. 
            ],  REST_Controller :: HTTP_NOT_FOUND ); 
        } 
    } 
    
    función pública  user_put () { 
        $ id  $ this -> put ( 'id' ); 
        
        // Obtenga los datos de la entrada 
        $ first_name  strip_tags ( $ this -> put ( 'first_name' )); 
        $ last_name  strip_tags ( $ this -> put ( 'last_name' )); 
        $ email  strip_tags ( $ esto-> poner ( 'email' )); 
        $ contraseña  $ esto -> poner ( 'contraseña' ); 
        $ phone  strip_tags ( $ this -> put ( 'phone' )); 
        
        // Valide los datos de la publicación 
        si (! Empty ( $ id ) && (! Empty ( $ first_name ) ||! Empty ( $ last_name ) ||! Empty ( $ email ) ||! Empty ( $ contraseña ) ||! Empty ( $ phone ))) { 
            // Actualizar los datos de la cuenta del usuario 
            $ userData  = array (); 
            si (! vacio ($ first_name )) { 
                $ userData [ 'first_name' ] =  $ first_name ; 
            } 
            if (! empty ( $ last_name )) { 
                $ userData [ 'last_name' ] =  $ last_name ; 
            } 
            if (! empty ( $ email )) { 
                $ userData [ 'email' ] =  $ email ; 
            } 
            if (! empty ( $ password )) { 
                $ userData [ 'password' ] =  md5 ( $ password ); 
            }
            if (! empty ( $ phone )) { 
                $ userData [ 'phone' ] =  $ phone ; 
            } 
            $ update  $ this -> user -> update ( $ userData $ id ); 
            
            // Compruebe si los datos del usuario se actualizan 
            si ( $ actualizar ) { 
                // Configure la respuesta y salga de 
                $ this -> response ([ 
                    'status'  =>  TRUE , 
                    'message'  =>  'La información del usuario se ha actualizado correctamente. ' 
                ],  REST_Controller :: HTTP_OK); 
            } else { 
                // Establezca la respuesta y salga de 
                $ this -> response ( "Ocurrieron algunos problemas, inténtelo de nuevo." REST_Controller :: HTTP_BAD_REQUEST ); 
            } 
        } else else { 
            // Configure la respuesta y salga 
            $ this -> response ( "Proporcione al menos una información de usuario para actualizar." REST_Controller :: HTTP_BAD_REQUEST ); 
        } 
    } 

}

Config

routes.php
Especifique las rutas para las solicitudes de la API REST (inicio de sesión, registro, visualización y actualización).
$ route [ 'api / authentication / login' ] =  'api / authentication / login' ; $ route [ 'api / authentication / registration' ] =  'api / authentication / registration' ; $ ruta [ 'api / authentication / user / (: num) (\.) ([a-zA-Z0-9 _-] +) (. *)' ] =  'api / authentication / user / id / $ 1 / format / $ 3 $ 4 ' ;

Iniciar sesión y registrarse con CodeIgniter RESTful Web Services

Puede interactuar y utilizar los métodos de la API REST de CodeIgniter para integrar el sistema de inicio de sesión del usuario en las diferentes aplicaciones. El cURL le permite hacer solicitudes HTTP en PHP. Usaremos PHP cURL para interactuar con la API REST de CodeIgniter y realizaremos las solicitudes GET, POST y PUT. Los siguientes ejemplos utilizan la autenticación HTTP básica con la clave API para conectarse a la API RESTful.
Registro de usuario a través de la API REST:
El siguiente código realiza una solicitud POST para insertar los datos de usuario para el registro (registro) a través de la API REST de CodeIgniter.
// clave API $ apiKey  'CODEX @ 123' ; 
// API credenciales de autenticación $ apiUser  "admin" ; $ apiPass  "1234" ; 
// URL URL $ url  'http://example.com/codeigniter/api/authentication/registration/' ; 
// Información de la cuenta del usuario $ userData  = array ( 
    'first_name'  =>  'John' , 
    'last_name'  =>  'Doe' , 
    'email'  =>  'john@example.com' , 
    'password'  =>  'login_pass'
    '123-456-7890' ); 
// Crear un nuevo recurso cURL $ ch  curl_init ( $ url ); 
curl_setopt ( $ ch CURLOPT_TIMEOUT 30 ); curl_setopt ( $ ch CURLOPT_RETURNTRANSFER , 1 ); curl_setopt ( $ ch CURLOPT_HTTPAUTH CURLAUTH_ANY ); curl_setopt ( $ ch CURLOPT_HTTPHEADER , array ( "X-API-KEY:"  $ apiKey )); curl_setopt( $ ch CURLOPT_USERPWD " $ apiUser : $ apiPass " ); curl_setopt ( $ ch CURLOPT_POST 1 ); curl_setopt ( $ ch CURLOPT_POSTFIELDS $ userData ); 
$ resultado  curl_exec ( $ ch ); 
// Cerrar el recurso cURL curl_close ( $ ch );
Inicio de sesión del usuario a través de la API REST:
El siguiente código realiza una solicitud POST para validar la credencial para el inicio de sesión (inicio de sesión) a través de la API REST CodeIgniter.
// clave API $ apiKey  'CODEX @ 123' ; 
// API credenciales de autenticación $ apiUser  "admin" ; $ apiPass  "1234" ; 
// URL de la API $ url  'http://example.com/codeigniter/api/authentication/login/' ; 
// Información de inicio de sesión de la cuenta de usuario $ userData  = array ( 
    'email'  =>  'john@example.com' , 
    'password'  =>  'login_pass' ); 
// Crear un nuevo recurso cURL $ ch  curl_init ( $ url );
CURLOPT_TIMEOUT 30 ); curl_setopt ( $ ch CURLOPT_RETURNTRANSFER , 1 ); curl_setopt ( $ ch CURLOPT_HTTPAUTH CURLAUTH_ANY ); curl_setopt ( $ ch CURLOPT_HTTPHEADER , array ( "X-API-KEY:"  $ apiKey )); curl_setopt ( $ ch CURLOPT_USERPWD " $ apiUser : $ apiPass " ); curl_setopt ( $ chCURLOPT_POST 1 ); curl_setopt ( $ ch CURLOPT_POSTFIELDS $ userData ); 
$ resultado  curl_exec ( $ ch ); 
// Cerrar el recurso cURL curl_close ( $ ch );
Recupere los datos de la cuenta de usuario a través de la API REST:
El siguiente código realiza una solicitud GET para recuperar los datos de la cuenta del usuario a través de la API REST de CodeIgniter.
// clave API $ apiKey  'CODEX @ 123' ; 
// API credenciales de autenticación $ apiUser  "admin" ; $ apiPass  "1234" ; 
// Especifique el ID del usuario $ userID  1 
// URL de la API $ url  'http://example.com/codeigniter/api/authentication/user/' . $ userID ; 
// Crear un nuevo recurso cURL $ ch  curl_init ( $ url ); 
curl_setopt ( $ ch CURLOPT_TIMEOUT 30 );curl_setopt ( $ ch CURLOPT_RETURNTRANSFER , 1 ); curl_setopt ( $ ch CURLOPT_HTTPAUTH CURLAUTH_ANY ); curl_setopt ( $ ch CURLOPT_HTTPHEADER , array ( "X-API-KEY:"  $ apiKey )); curl_setopt ( $ ch CURLOPT_USERPWD " $ apiUser : $ apiPass " ); 
$ resultado  curl_exec ( $ ch ); 
// Cerrar el recurso cURLcurl_close ( $ ch );
Actualizar cuenta de usuario a través de REST API:
el siguiente código realiza una solicitud PUT para actualizar los datos de usuario a través de CodeIgniter REST API.
// clave API $ apiKey  'CODEX @ 123' ; 
// API credenciales de autenticación $ apiUser  "admin" ; $ apiPass  "1234" ; 
// Especifique el ID del usuario $ userID  1 
// URL de la API $ url  'http://example.com/codeigniter/api/authentication/user/' ; 
// Información de la cuenta del usuario $ userData  = array ( 
    'id'  =>  1 , 
    'first_name'  =>  'John2' , 
    'last_name'  =>  'Doe2' , 
    'john2@example.com' , 
    'password'  =>  'user_new_pass' , 
    'phone'  =>  '545-856-3439' ); 
// Crear un nuevo recurso cURL $ ch  curl_init ( $ url ); 
curl_setopt ( $ ch CURLOPT_TIMEOUT 30 ); curl_setopt ( $ ch CURLOPT_RETURNTRANSFER , 1 ); curl_setopt ( $ ch CURLOPT_HTTPAUTH CURLAUTH_ANY ); curl_setopt ( $ ch CURLOPT_HTTPHEADER , array ( 'X-API-KEY:' . $ ApiKey 'Tipo de contenido: application / x-www-form-urlencoded' )); curl_setopt ( $ ch CURLOPT_USERPWD " $ apiUser : $ apiPass " ); curl_setopt ( $ ch CURLOPT_CUSTOMREQUEST "PUT" ); curl_setopt ( $ ch CURLOPT_POSTFIELDS http_build_query ( $ userData )); 
$ resultado  curl_exec ( $ ch); 
// Cerrar el recurso cURL curl_close ( $ ch );

No hay comentarios.:

Publicar un comentario

Dejanos tu comentario para seguir mejorando!

Post Top Ad

Your Ad Spot

Páginas