Web service SOAP con PHP

SOAP es un protocolo de intercambio de datos entre diferentes procesos basado en XML. Una definición bastante completa la podéis encontrar en wikipedia. Una vez dicho esto vamos a empezar a ver cómo creamos un web service básico en PHP y que use dicho protocolo.

Lo primero que necesitaremos será descargar NuSOAP a nuestro proyecto. Se trata de un pequeño toolkit que nos facilitará la vida con varias clases para trabajar con este protocolo en PHP. Una vez descargado y descomprimido dentro de una carpeta de nuestro proyecto, simplemente la deberemos incluir en el archivo PHP que va a funcionar de web service.

A continuación veremos un ejemplo básico. A nuestro fichero le llamaremos test.php y lo que hará será recibir dos números enteros, multiplicarlos y devolver el resultado.

require_once("nusoap.php"); 

$server = new soap_server();

$server->register('multiplicarNumeros'); 

function multiplicarNumeros($valor1, $valor2){ 
 $res = $valor1 * $valor2; 
 return $res; 
} 

$server->service($HTTP_RAW_POST_DATA);

A continuación nos hará falta un cliente del web service al que llamaremos cliente.php. Lo que haremos será en el constructor llamar a la url del servidor y mediante la función call() llamar al método que nos multiplicarla los números. Los parámetros de la función los pasaremos en forma de array.

require_once("nusoap.php"); 

$cliente = new nusoap_client("http://localhost/test.php");

$error = $cliente->getError(); 
if ($error){ 
 echo "Error: $error"; 
} 

$res = $cliente->call("multiplicarNumeros", array("valor1" => "10", "valor2" => "15")); 

$error = $cliente->getError(); 
if ($error){ 
 echo "Error: $error"; 
} else { 
 echo "Resultado: $res"; 
}

Hasta aquí tendríamos un cliente y servidor básico pero para que sea un web service más correcto nos haría falta definir el WSDL en la parte del servidor y así tener una definición de los métodos y parámetros que contiene. Para que NuSoap nos lo genere deberemos cambiar un poco la parte del servidor y nos quedaría de la siguiente forma.

require_once("nusoap.php"); 

$server = new soap_server(); 

// Configuramos el namespace y el WSDL 
$ns = "test"; 
$server->configureWSDL('test', $ns); 
$server->wsdl->schemaTargetNamespace = $ns; 

// Cambiamos la llamada para añadirle los parámetros de entrada y salida y el namespace 
$server->register('multiplicarNumeros', array('valor1' => 'xsd:integer', 'valor2' => 'xsd:integer'), array('return' => 'xsd:integer'), $ns); 

function multiplicarNumeros($valor1, $valor2){ 
 $res = $valor1 * $valor2; 
 return $res; 
} 

$server->service($HTTP_RAW_POST_DATA);

Ahora simplemente debes acceder a tu navegador y llamar a la URL http://localhost/test.php?wsdl y verás el WSDL que se ha generado.

Obtener la extensión de un fichero con PHP

Para obtener la extensión de un archivo en PHP tenemos varias posibilidades. Os dejo una muy sencilla a continuación:

function getExtension($file) {
  $pos = strrpos($file, '.');
  if($pos===false){
    return false;
  } else {  
    return substr($file, $pos+1);
  }
}

Web Services JSON con PHP

En este ejemplo vamos a intentar explicar cómo realizar un simple web service que utiliza JSON como formato de intercambio, en lugar del clásico XML que utilizan los web services SOAP. Con JSON además de su sencillez para manejarlo con Javascript y PHP tenemos un formato ligero y muy simple de notación literal.

Lo primero que tendremos en cuenta es que el formato de intercambio será JSON, por lo que la información enviada y recibida será de tipo application/json.

El código de la clase del web service y la implementación de una función básica para obtener la hora del servidor sería este:

class JSON_WebService {
    private $methods, $args, $strcall;
    public function __construct($rawData) {
        $this->strcall = str_replace($_SERVER["SCRIPT_NAME"]."/", "", $_SERVER["REQUEST_URI"]);
        $this->args = $rawData;
        $this->methods = array();
        header('Access-Control-Allow-Origin: *');
        header('Access-Control-Allow-Methods', 'PUT, GET, POST, DELETE, OPTIONS');
        header('Cache-Control: no-cache, must-revalidate');
        header('Content-type: application/json; charset=utf-8');
    }

    public function Register($name) {
        $this->methods[$name] = true;
    }

    public function Remove($name) {
        $this->methods[$name] = false;
    }

    private function call($name, $args) {
        if ($this->methods[$name] == true) {
            $result = call_user_func_array($name, $args);
           return json_encode($result);
        }
    }

    function start() {
        try{
            if(!function_exists($this->strcall))
                throw new Exception("Function '".$this->strcall."' does not exist.");
            if (!$this->methods[$this->strcall])
                throw new Exception("Access denied for function '".$this->strcall."'.");

            header("HTTP/1.0 200 OK");
            print $this->call($this->strcall, json_decode($this->args));
        }
        catch(Exception $e){
            header("HTTP/1.0 500 Internal server error");
            print json_encode(
                array(
                    "message" => $e->getMessage(),
                    "code" => $e->getCode(),
                    "file" => $e->getFile(),
                    "line" => $e->getLine(),
                    "stackTrace" => $e->getTrace(),
                    "status" => array("message" => "Internal server error", "code" => "500")
                )
            );
        }
    }
}

//Obtiene el contenido de la solicitud POST
$HTTP_RAW_POST_DATA = isset($HTTP_RAW_POST_DATA) ? $HTTP_RAW_POST_DATA : ''; 
 
//Instancia de la clase JSON_WebService
$server = new JSON_WebService($HTTP_RAW_POST_DATA);
 
//Registra los metodos del servicio web
$server->register("getServerTime");
 
//Inicializa el servicio
$server->start();
 
//Define los metodos del servicio web
function getServerTime($format){
     return date($format);
}

Para la llamada al web service implementamos una clase cliente. Realmente lo que hacemos es utilizar las funciones de la librería libcurl pasándole por POST los parámetros a la página PHP que hace de servidor. El código lo tenemos a continuación:

class JSON_WebClient{
    private $URL;
    public function __construct($url){
        $this->URL = $url;
    }

    public function call($method, $args, $successCallback = false, $errorCallback = false){
        $ch = curl_init();
        curl_setopt($ch, CURLOPT_HTTPHEADER, Array("Content-Type: application/json"));
        curl_setopt($ch, CURLOPT_URL, $this->URL."/".$method);
        curl_setopt($ch, CURLOPT_RETURNTRANSFER,1);
        curl_setopt($ch, CURLOPT_TIMEOUT, 30);
        curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($args));
        $resposeText = curl_exec($ch);
        $resposeInfo = curl_getinfo($ch);
        
        if($resposeInfo["http_code"] == 200){
            if($successCallback)
                call_user_func($successCallback, json_decode($resposeText));
        } else {
            if($errorCallback)
                call_user_func($errorCallback, json_decode($resposeText));
        }
    }
}

Y la llamada la tendríamos con este código:

    $client = new JSON_WebClient("http://localhost/service.php");
    $client->call("getServerTime", array("format"=>"d/m/o H:i:s"), "onSucceededCallback", "onErrorCallback");
    
    function onSucceededCallback($result){
        print $result;
    }
    
    function onErrorCallback($error){
        print "Error: ".$error->{"message"};
    }

Obtener el factorial de un número con PHP

Calcular el factorial de un número es un algoritmo muy simple. Aquí abajo os dejo una implementación realizada en PHP

 function factorial($valor) {
  $res = 1;
  while ($valor > 1) {
   $res*= $valor--;
  }
  return $res;
 }

Eliminar el contenido de un directorio en PHP

Con el código que os dejo a continuación podemos eliminar fácilmente el contenido completo de un directorio mediante PHP.

 function eliminarDirectorio($dir) {
  // Obtenemos un manejador del directorio
  if ($handle = opendir("$dir")) {
   $res = true;

   // Recorremos los archivos del directorio
   while ((($fich = readdir($handle)) !== false) && ($res)) {
    if ($fich != '.' && $fich != '..') {
     // Si el archivo es un directorio llamo recursivamente a la función
     if (is_dir("$dir/$fich")) {
      $res = eliminarDirectorio("$dir/$fich");
     } else { // Eliminamos el fichero
      $res = unlink("$dir/$fich");
     }
    }
   }
   
   // Cerramos el manejador del directorio
   closedir($handle);
   
   // Si se ha eliminado correctamente eliminamos el propio directorio
   if ($res)
    $res = rmdir($dir);
  } else {
   $res = false;
  }
  
  // Devolvemos si se ha podido eliminar el directorio por completo correctamente
  return $res;
 }

Oscurecer el color de un objeto HTML mediante Javascript o PHP

Una función que puede ser bastante útil es la de oscurecer un color que tenemos en formato hexadecimal. Yo lo uso para cambiar el color de un objeto HTML al pasar por encima de él y así obtengo el mismo color que el original pero más oscuro.
La función en PHP sería la siguiente:

 function oscurecerColor($color, $cant){
  //voy a extraer las tres partes del color
  $rojo = substr($color,1,2);
  $verd = substr($color,3,2);
  $azul = substr($color,5,2);

  //voy a convertir a enteros los string, que tengo en hexadecimal
  $introjo = hexdec($rojo);
  $intverd = hexdec($verd);
  $intazul = hexdec($azul);

  //ahora verifico que no quede como negativo y resto
  if($introjo-$cant>=0) $introjo = $introjo-$cant;
  if($intverd-$cant>=0) $intverd = $intverd-$cant;
  if($intazul-$cant>=0) $intazul = $intazul-$cant;

  //voy a convertir a hexadecimal, lo que tengo en enteros
  $rojo = dechex($introjo);
  $verd = dechex($intverd);
  $azul = dechex($intazul);

  //voy a validar que los string hexadecimales tengan dos caracteres
  if(strlen($rojo)<2) $rojo = "0".$rojo;
  if(strlen($verd)<2) $verd = "0".$verd;
  if(strlen($azul)<2) $azul = "0".$azul;

  //voy a construir el color hexadecimal
  $oscuridad = "#".$rojo.$verd.$azul;

  //la función devuelve el valor del color hexadecimal resultante
  return $oscuridad;
 }

Y su equivalente en Javascript

function oscurecerColor(color, cant){
 //voy a extraer las tres partes del color
 var rojo = color.substr(1,2);
 var verd = color.substr(3,2);
 var azul = color.substr(5,2);

 //voy a convertir a enteros los string, que tengo en hexadecimal
 var introjo = parseInt(rojo,16);
 var intverd = parseInt(verd,16);
 var intazul = parseInt(azul,16);

 //ahora verifico que no quede como negativo y resto
 if (introjo-cant>=0) introjo = introjo-cant;
 if (intverd-cant>=0) intverd = intverd-cant;
 if (intazul-cant>=0) intazul = intazul-cant;

 //voy a convertir a hexadecimal, lo que tengo en enteros
 rojo = introjo.toString(16);
 verd = intverd.toString(16);
 azul = intazul.toString(16);

 //voy a validar que los string hexadecimales tengan dos caracteres
 if (rojo.length<2) rojo = "0"+rojo;
 if (verd.length<2) verd = "0"+verd;
 if (azul.length<2) azul = "0"+azul;

 //voy a construir el color hexadecimal
 var oscuridad = "#"+rojo+verd+azul;

 //la función devuelve el valor del color hexadecimal resultante
 return oscuridad;
}

Llenar una cadena con ceros a la izquierda mediante PHP

Aquí os dejo una función muy simple para añadir ceros a la izquierda hasta una determinada longitud.

 function zerofill($valor, $longitud){
  $res = str_pad($valor, $longitud, '0', STR_PAD_LEFT);
  return $res;
 }

Obtener la dirección IP que solicita una página PHP

A continuación os dejo una función hecha en PHP que permite obtener la dirección IP de quien solicita una página. En esta función se tienen en cuenta las posibles direcciones de los proxys por los que pasa la petición. Para localizar la ip real del usuario se comienza a mirar por el principio hasta encontrar una dirección ip que no sea del rango privado. En caso de no encontrarse ninguna se toma como valor el REMOTE_ADDR.

 function getRealIP(){
  if( $_SERVER['HTTP_X_FORWARDED_FOR'] != '' ){
   $client_ip =
    ( !empty($_SERVER['REMOTE_ADDR']) ) ?
     $_SERVER['REMOTE_ADDR']
    :
             ( ( !empty($_ENV['REMOTE_ADDR']) ) ?
     $_ENV['REMOTE_ADDR']
     :
     "unknown" );

   $entries = split('[, ]', $_SERVER['HTTP_X_FORWARDED_FOR']);

   reset($entries);
   while (list(, $entry) = each($entries)){
    $entry = trim($entry);
    if ( preg_match("/^([0-9]+\.[0-9]+\.[0-9]+\.[0-9]+)/", $entry, $ip_list) ){
     // http://www.faqs.org/rfcs/rfc1918.html
     $private_ip = array(
      '/^0\./',
      '/^127\.0\.0\.1/',
      '/^192\.168\..*/',
      '/^172\.((1[6-9])|(2[0-9])|(3[0-1]))\..*/',
      '/^10\..*/');

     $found_ip = preg_replace($private_ip, $client_ip, $ip_list[1]);

     if ($client_ip != $found_ip){
      $client_ip = $found_ip;
      break;
     }
    }
   }
  } else {
   $client_ip =
    ( !empty($_SERVER['REMOTE_ADDR']) ) ?
     $_SERVER['REMOTE_ADDR']
    :
     ( ( !empty($_ENV['REMOTE_ADDR']) ) ?
     $_ENV['REMOTE_ADDR']
     :
     "unknown" );
  }
  return $client_ip;
 }