Crear API Rest Laravel + Postgres

Laravel_logo

Para quienes me conocen, saben que no soy amante de los framework en PHP sin embargo este ha captado bastante mi atención, tomemos unos minutos para crear un API sencillo tomando los datos desde Postgres.

Comencemos por crear el proyecto Laravel.

~$ git clone https://github.com/laravel/laravel.git

Renombramos la carpeta del proyecto clonado y nos ubicamos dentro de ella.

~$ mv laravel ApiPostgre
~$ cd ApiPostgre

En esta ocasión llamaremos al ejemplo ApiPostgre, uds son libres de colocarle el nombre que quieran a la carpeta.

Actualizaremos la carpeta vendor, que nos contiene todo el core del Framework.

~$ sudo composer update

Luego de haber hecho esto, modificaremos nuestro archivo .env que se encuentra dentro de la carpeta del proyecto, este es un archivo de configuración donde puedes definir variables globales que podrán ser utilizadas dentro del proyecto.

Generaremos la llave de la aplicación con el siguiente comando.

~$ php artisan key:generate

Esta llave generada, la colocaremos dentro del archivo .env de la siguiente manera.

APP_ENV=local
APP_KEY=base64:rQmQ+atSNYz2L4TvjixwJZh/i9kFSrhiH/+GyyNmEcY=
APP_DEBUG=true
APP_LOG_LEVEL=debug
APP_URL=http://localhost

Configuraremos dentro del mismo archivo .env la conexión a nuestra base de datos Postgre.

PG_HOST = localhost
PG_DATABASE = nombreBD
PG_USERNAME = usuarioBD
PG_PASSWORD = claveBD
PG_PORT = 5432

Le indicaremos al archivo database.php dentro de la carpeta config, cual será la conexión que utilizaremos.

'default' => 'elefante',

'connections' => [
     'elefante' => [
          'driver' => 'pgsql',
          'host' => env('PG_HOST', 'localhost'),
          'database' => env('PG_DATABASE', 'forge'),
          'username' => env('PG_USERNAME', 'forge'),
          'password' => env('PG_PASSWORD', ''),
          'charset' => 'utf8',
          'prefix' => '',
          'schema' => 'public',
     ],
]

Asignaremos el pseudonimo para los namespace de nuestras clases, dentro del arreglo global llamado «psr-4» esto lo haremos en el archivo composer.json de nuestro proyecto.

"autoload": {
     "classmap": [
          "database"
     ],
     "psr-4": {
          "apipg\\": "app/"
     }
 },

Crearemos dentro de app la carpeta donde contendremos nuestros archivos modelos.

~$ mkdir -p Models/TablesDB/

Creamos el modelo para obtener todos los usuarios registrados en BD.

<?php namespace apipg\Models\TablesDB;

use Illuminate\Database\Eloquent\Model;
use DB;

class Usuarios extends Model {

     /**
      * Table from DB.
      */
     protected $connection = 'elefante';

     protected $table = 'usuarios';

     public function scopeGetUsers($query)
     {
          return Usuarios::all();
     }
}

Ahora crearemos el controlador que se encargará de retornar los usuarios consultados, este controlador lo ubicaremos dentro de la ruta : app/Http/Controllers/Users

<?php namespace apipg\Http\Controllers\Users;

use apipg\Models\TablesDB\Usuarios;
use apipg\Http\Controllers\Controller;
use Request;
use apipg\Http\Requests;

class UsuariosController extends Controller
{
     public function __construct() {}

     public function getUsers()
     {
        return Usuarios::GetUsers();
     }
}

Crearemos la ruta para poder obtener el JSON de estos valores via GET, para esto debemos modificar el archivo routes.php dentro de app/Http/

Route::resource('api/backend/users','Users\UsuariosController');
Route::get('api/backend/users/getusers','Users\UsuariosController@getUsers');

Listo, ya podemos acceder desde el explorador, o desde Postman a la ruta para obtener los valores del API que acabamos de crear. Ejemplo:

laravel.postgres.dev/api/backend/users/getusers

Espero les haya sido de gran utilidad.

Como instalar composer

composer

Composer es un gestor de paquetes a nivel de aplicación para PHP que proporciona un formato estándar para la gestión de dependencias de software PHP y librerías necesarias. Veamos un paso a paso muy sencillo para instalarlo en nuestro Debian o cualquier otra distribución Linux.

1.- Actualizamos nuestro repositorio ( Para este post estoy utilizando Debian 8 y PHP 5.6.X )

$ sudo aptitude update

2.- Instalamos las siguientes librerías.

$ sudo aptitude install curl php5-cli git

3.- Descargamos e instalamos Composer ( La instalación composer es muy simple y se puede hacer en un solo comando )

$ curl -sS https://getcomposer.org/installer | sudo php -- --install-dir=/usr/local/bin --filename=composer

Esto descargará e instalará composer como un comando llamado composer en todo el sistema, bajo /usr/local/bin.

4.- Probamos nuestra instalación :

$ composer

Licencia para IDEs JetBrains

Saludo amigos, en esta oportunidad me tomo un momento para compartir un post de gran valor para todo programador, hace unos meses me tope con la necesidad de conseguir una licencia para el editor PhpStorm, y pues me pase unas horas de ardua busqueda para conseguir lo deseado.

En esta oportunidad, tenemos la dicha de utilizar el vinculo de este servidor, para adquirir la activación de cualquier IDE de JetBrains

A continuación un breve paso a paso:

1.- Descargar PhpStorm.

2.– Instalar.

2.1.- Seleccionar License Server y colocar http://idea.lanyus.com

3.- En caso de estar instalado.

3.1.- Ir a Help / Register … -> License server.

3.2.- colocar http://idea.lanyus.com

Sin más, espero les haya servido.

Como leer properties desde cualquier ruta. Java

Saludo amigos, en esta oportunidad crearemos un proyecto en Java que nos permita leer archivos con parámetros de configuración, mejor conocidos como archivos .properties. Estos archivos mantendrán valores en forma de llave = valor, y de esta manera evitaremos tener datos quemados en nuestro código, que luego necesiten ser cambiados.

proyecto

El primer paso que debemos hacer, será crear un proyecto Java con un paquete llamado util el cual contendrá nuestra clase manejadora, la cual llamaremos AmbienteDesarrollo, esta clase tendrá un grupo de funciones y métodos capaces de interpretar rutas y el contenido del archivo :


package util;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.InputStream;
import java.util.ResourceBundle;

public class AmbienteDesarrollo {
 
     public static final String APP_DESCRIPTION = "app.description";
     public static final String APP_VERSION = "app.version";
     public static final String APP_PATH = "app.path";
     public static final String APP_NAME = "app.name";
 
     private static ResourceBundle rsr;
 
     static
     {
         try
         {
            rsr = ResourceBundle.getBundle("util.initconfig");
         }
         catch (Throwable e) {}
     }
 
 /**
 * Recibe el nombre del archivo de configuración 
 * Devuelve una cadena de caracteres (String), con la ruta absoluta del archivo
 * 
 * @param resourceName
 * @return String
 */
 
 public static String getAbsoluteResourceName(String resourceName)
 {
     return rsr.getString("app.path") + System.getProperty("file.separator") + resourceName;
 }
 
 /**
 * Recibe el nombre del archivo que contiene las propiedades que se quieren leer
 * Devuelve un objeto de tipo InputStream que será utilizado por la función load
 * de la clase Properties, para cargar todas las propiedades definidas en el archivo.
 * @param resourceName
 * @return InputStream
 */
 
 public static InputStream getResourceAsStream(String resourceName)
 {
     try
     {
         return new FileInputStream(getResourceAsFile(resourceName));
     }
     catch (FileNotFoundException e1)
     {
        e1.printStackTrace();
        throw new RuntimeException(e1);
     }
 }
 
 /**
 * Recibe el nombre del archivo, 
 * Devuelve un objeto File con la ruta que se le haya indicado a la aplicación
 * en el archivo initconfig.properties
 * @param resourceName
 * @return File
 */
 
 public static File getResourceAsFile(String resourceName)
 {
     String var = getAbsoluteResourceName(resourceName);
     return new File(var);
 }
 
 public static String getApplicationName()
 {
     return rsr.getObject("app.name").toString();
 }
 
 public static String getApplicationVersion()
 {
     return rsr.getObject("app.version").toString();
 }

public static String getApplicationDescription()
 {
     return rsr.getObject("app.description").toString();
 }
 
 public static String getStringResource(String recurso) throws Exception
 {
     StringBuffer buf = new StringBuffer(5000);
     byte[] data = hexStringToByteArray( recurso );
 
     InputStream in = getResourceAsStream(recurso);
     try
     {
        if (in != null)
        {
           int len;
           for (;;)
           {
               len = in.read(data);
               if (len == -1) { break; }
               buf.append(new String(data, 0, len));
           }
       return buf.toString();
       }
 
       System.out.println("\tRuta incorrecta de la plantilla o recurso estatico: " + recurso + "");
       throw new Exception(AmbienteDesarrollo.class.getName() + ".getResource:\tRuta incorrecta de la plantilla o recurso estatico: " + recurso);
     }
     catch (Throwable e)
     {
         throw new Exception(e);
     }
     finally
     {
        if (in != null) 
        {
           try
           {
              in.close();
           }
           catch (Exception e)
           {
              throw new Exception(e);
           }
        }
     }
 }
 
 /**
 * Esta función fue desarrollada por Dave.L 
 * con la intensión de obtener la cantidad de bytes necesarias
 * para intercambiar los valores que se leen desde el recurso.
 * 
 * http://stackoverflow.com/questions/140131/convert-a-string-representation-of-a-hex-dump-to-a-byte-array-using-java
 * 
 * @param s
 * @return byte[] data
 */
 public static byte[] hexStringToByteArray(String s)
 {
     int len = s.length();
     byte[] data = new byte[len / 2];
 
     for (int i = 0; i < len; i += 2)
     {
        data[i / 2] = (byte) ((Character.digit(s.charAt(i), 16) << 4) + Character.digit(s.charAt(i+1), 16));
     }
 
     return data;
 }

}

Luego de esto el siguiente y segundo paso será crear dentro de nuestro paquete util una clase llamada Propiedades, la cual nos servirá para instanciar el objeto con el cual vamos a acceder a la función getPropiedades() que nos devolverá los properties de acuerdo a la ruta especificada en el archivo initconfig.properties.


package util;

import java.io.IOException;
import java.util.Properties;
import util.AmbienteDesarrollo;

public class Propiedades {
 
     static Properties propiedades;
 
     public static Properties getPropiedades() 
     {
          propiedades = new Properties();
          try
          {
              propiedades.load(AmbienteDesarrollo.getResourceAsStream("config.properties") );
          }
          catch (IOException e) 
          {
              e.printStackTrace();
          }
          return propiedades;
     }
}

Por ultimo no queda más que instanciar el objeto desde el sitio que queramos para poder acceder a nuestros parámetros de configuración. En el siguiente ejemplo, instanciaremos desde nuestra clase main.


package util;

import java.util.Properties;

public class Principal {

     public static void main(String[] args){
 
        Properties p = Propiedades.getPropiedades();
 
        System.out.println( p.getProperty( "clave" ));

     }
}

 

Nuestros archivos .properties quedan de la siguiente manera:

initconfig.properties

app.name=Proyecto
app.path=/home/andres/workspace/Proyecto
app.version=1.0
app.description=Ejemplo para leer archivos *.properties

config.properties

usuario=codificate
clave=alfabeto

Sin más, espero que haya sido de gran provecho para ustedes. Aca les dejo el enlace para que puedan descargar el archivo fuente.

Descompilar *.class en Debian

 

jdGUI

Quienes hemos trabajado con Java nos hemos topado con el desagradable momento en que nos toca descompilar un archivo binario *.class para poder acceder a su código fuente, de lo contrario nos toca invertir un valioso tiempo en comernos los libros, ver e investigar todos los tutoriales habidos y por haber, para poder hallar una solución a nuestro problema.

Hace unos meses me tope con la herramienta JD-GUI pero, nunca falta el condenado pero, lo estaba utilizando sobre ambiente GUINDOUS y pues, me di a la tarea a intentar instalarlo sobre Debian Wheezy.

A continuación procedemos a descargar el archivo *.jar de la pagina de http://jd.benow.ca/

Posterior abriremos nuestro menú principal y añadiremos un nuevo elemento.

MenuPrincipal

LanzadorJDGui

En la sección de comando añadiremos lo siguiente:

java -jar RUTA/jd-gui-1.0.0.jar

Quepa acotar que el archivo *.jar debe tener permisos de ejecución. Por ultimo ejecutamos nuestro programa y comenzamos a utilizarlo.

JavaDecompiler

JavaDecompileUse

Sin más, espero sea de su agrado. Éxitos.

Como saber versión de GTK + Debian Wheezy

MiEscritorio

Cuando las ideas surgen y chocan con otras, es cuando salen post como este, producto de ciertas interrogantes para resolver otro problema que mas adelante publicaré. En esta oportunidad aprenderemos a como verificar la versión exacta de nuestro entorno gráfico GTK+ en Debian Wheezy.

Listar las librerias de GTK instaladas :

dpkg -l | grep libgtk

Verificar versión de GTK 2 :

dpkg -s libgtk2.0-0 | grep '^Version'

Verificar versión de GTK 3 :

dpkg -s libgtk-3-0 | grep '^Version'

Sin más, espero que les haya sido de gran utilidad. Éxito.

Clase manejador de Base de datos. PHP + PDO + PostgreSQL

DBManejador

Saludo amigos, ya sabemos que en la web hay cientos de ejemplos, existen Frameworks, generadores de código, e incluso clientes web que nos hacen la interacción con la base de datos un poco más fácil, pero nunca está demás hacer un humilde aporte, en ayuda a los aprendices, y a quienes disfrutan de la programación creativa, rebelde e «innovadora», fuera de la ya cuadrada que nos obliga el mercado.

A continuación les presento mi clase manejador de base de datos utilizando la extensión PDO nativa de PHP a partir de su versión 5.1.

Estos serán los archivos que crearemos.

ver: constantes.php


<?php

/*
 * Autor: Servando Reyes - @zervanstyle - andres92898@gmail.com
 * 
 * Licencia: LGPL 
 * 
 * Web : codificate.wordpress.com
 * 
 */

 define( "SRV", "127.0.0.1");
 define( "USR", "postgres");
 define( "PAS", "TuClave");
 define( "BDA", "TuBaseDeDatos");
 define( "PRT", "5432");

?>

ver: DBManejador.php


<?php

/*
 * Autor: Servando Reyes - @zervanstyle - andres92898@gmail.com
 * 
 * Licencia: LGPL 
 * 
 * Web : codificate.wordpress.com
 * 
 */

include_once('constantes.php');

class DBManejador extends PDO
{
 
 public $srv = SRV; // PostgreSQL server host
 public $usr = USR; // PostgreSQL user
 public $pas = PAS; // PostgreSQL password
 public $dba = BDA; // PostgreSQL database
 private $prt = PRT; // PostgreSQL port
 private $numrows= null;
 private $conexion;
 private $manejador;

public function __construct() { $this->conectar(); }

/**
 *
 * @todo Establece la conexión a la Base de datos utilizando PDO.
 *
 * @access private
 *
 **/


 private final function conectar() 
 {
 $conex = null;

try
 {
 if( is_array( PDO::getAvailableDrivers() ) )
 {
 if( in_array( "pgsql",PDO::getAvailableDrivers() ) )
 {
 $conex = new PDO("pgsql:host = $this->srv;port= $this->prt;dbname= $this->dba;user= $this->usr;password= $this->pas");
 $this->setManejador('pgsql');
 }
 else
 throw new PDOException ("No se puede trabajar sin establecer una conexión adecuada con la base de datos de mysql");
 }

}catch(PDOException $e) 
 {
 error_log( $e->getMessage() ); 
 }

$this->setConexion( $conex );
 }

/**
 *
 * @todo Permite obtener datos mediante un arreglo asociativo o de objetos, concatenando las columnas y las tablas.
 *
 * @access public
 * @param string $columnas
 * @param string $tabla
 * @param bool $getObjects
 *
 * @return mixed
 *
 **/
 
 public final function consultar($columnas, $tabla, $getObjects=false)
 {

$rt = null;

try
 {

$query = $this->conexion->prepare( " SELECT " . $columnas . " FROM " . $tabla );
 $query->execute();
 $this->setNumRows( $query->rowCount() );
 $this->conexion->cerrarConexion();

if( $getObjects )
 $rt = $query->fetchAll(PDO::FETCH_ASSOC);
 else
 $rt = $query->fetchAll(PDO::FETCH_OBJ);

} catch(PDOException $e) {
 
 error_log( $e->getMessage() ); 
 
 }

return $rt;
 }

/**
 *
 * @todo Permite obtener datos mediante un arreglo asociativo o de objetos, concatenando las columnas, las tablas, condición y los valores que serán utilizados.
 *
 * @access public
 * @param string $columnas
 * @param string $tabla
 * @param string $condicion
 * @param mixed $valores
 *
 * @return mixed
 *
 **/

public final function consultarCondicion($columnas, $tabla, $condicion, $valores)
 {

$rt = null;

try
 {

$query = $this->conexion->prepare( " SELECT " . $columnas . " FROM " . $tabla . " WHERE " . $condicion );

foreach ($valores as $key => $value) 
 {
 if( !empty( $value ) )
 $query->bindParam( $key, $value, $this->getPDOConstantType( $value ) );
 }

$query->execute();
 $this->setNumRows( $query->rowCount() );
 $this->conexion->cerrarConexion();
 
 $rt = $query->fetchAll(PDO::FETCH_ASSOC);

} catch(PDOException $e) {
 
 error_log( $e->getMessage() ); 
 
 }

return $rt;
 }

/**
 *
 * @todo Guarda valores en la tabla que se desee, concatenando las columnas, tabla, campos y los valores que serán utilizados.
 *
 * @access public
 * @param string $tabla
 * @param string $columnas
 * @param string $campos
 * @param mixed $valores
 *
 * @return int
 *
 **/
 
 public final function agregar($tabla, $columnas, $campos, $valores)
 {
 $rt = null;

try
 {

$query = $this->conexion->prepare( "INSERT INTO ".$tabla." (".$columnas.") VALUES (".$campos.")" );

foreach ($valores as $key => $value) 
 {
 if( !empty( $value ) )
 $query->bindParam( $key, $value, $this->getPDOConstantType( $value ) );
 }

$rt = $query->execute();
 $this->setNumRows( $query->rowCount() );
 $this->conexion->cerrarConexion();

} catch(PDOException $e){

error_log( $e->getMessage() ); 
 }

return $rt; 
 }

/**
 *
 * @todo Modifica valores en la tabla que se desee, concatenando la tabla, campos, valores y la condicion que sera utilizada para ejecutar esta consulta.
 *
 * @access public
 * @param string $tabla
 * @param string $campos
 * @param mixed $valores
 * @param string $condicion
 *
 * @return int
 *
 **/
 
 public final function actualizar($tabla, $campos, $valores, $condicion)
 {

$rt = null;

try
 {

$query = $this->conexion->prepare( "UPDATE ".$tabla." SET ".$campos." WHERE ".$condicion );

foreach ($valores as $key => $value) 
 {
 if( !empty( $value ) )
 $query->bindParam( $key, $value, $this->getPDOConstantType( $value ) );
 }

$rt = $query->execute();
 $this->setNumRows( $query->rowCount() );
 $this->conexion->cerrarConexion();

} catch(PDOException $e){
 
 error_log( $e->getMessage() ); 
 }

return $rt; 
 
 }

/**
 *
 * @todo Elimina valores en la tabla que se desee, concatenando la tabla, condicion y los valores que seran utilizados en esta consulta.
 *
 * @access public
 * @param string $tabla
 * @param string $condicion
 * @param mixed $valores
 *
 * @return int
 *
 **/

public final function eliminar($tabla, $condicion, $valores)
 {
 $rt = null;

try
 {

$query = $this->conexion->prepare( "DELETE FROM ".$tabla." WHERE ".$condicion );

foreach ($valores as $key => $value) 
 {
 if( !empty( $value ) )
 $query->bindParam( $key, $value, $this->getPDOConstantType( $value ) );
 }

$rt = $query->execute();
 $this->setNumRows( $query->rowCount() );
 $this->conexion->cerrarConexion();

} catch(PDOException $e){
 
 error_log( $e->getMessage() ); 
 }

return $rt;
 
 }

/**
 *
 * @todo Muestra la estructura de las tablas de la Base de datos
 *
 * @access public
 *
 * @return mixed $rt
 *
 **/

public final function estructuraBD()
 {
 $rt = array( $this->dba => array() );

if( $this->getManejador() == 'pgsql' )
 {
 $query = $this->conexion->prepare("SELECT table_schema FROM information_schema.tables WHERE table_schema NOT IN ( 'pg_catalog', 'information_schema' ) AND table_catalog = '" . $this->dba . "' GROUP BY table_schema ORDER BY table_schema");

$query->execute();

$esquemas = $query->fetchAll(PDO::FETCH_ASSOC);

foreach ($esquemas as $indice_esquema => $valor_esquema) 
 {
 if( !empty( $valor_esquema ) )
 {
 $rt[ $this->dba ][ $valor_esquema['table_schema'] ] = array();

$query = $this->conexion->prepare("SELECT table_name FROM information_schema.tables WHERE table_schema NOT IN ( 'pg_catalog', 'information_schema' ) AND table_catalog = '" . $this->dba . "' AND table_schema = '" . $valor_esquema['table_schema'] . "' ORDER BY table_schema");

$query->execute();

$tablas = $query->fetchAll(PDO::FETCH_ASSOC);

foreach ($tablas as $indice_tabla => $valor_tabla) 
 {
 if( !empty( $valor_tabla ) )
 {
 $rt[ $this->dba ][ $valor_esquema['table_schema'] ][ $valor_tabla['table_name'] ] = array();
 
 $query = $this->conexion->prepare(" SELECT * FROM " . $valor_esquema['table_schema'] . "." . $valor_tabla['table_name'] . " LIMIT 1" );

$query->execute();

$columnas = $query->fetchAll(PDO::FETCH_ASSOC);

$constrains = $this->conexion->prepare(" SELECT ccu.column_name AS columna, ccu.constraint_name AS alias, tc.constraint_type AS restrinccion FROM information_schema.key_column_usage AS ccu, information_schema.table_constraints AS tc WHERE ccu.constraint_name = tc.constraint_name AND ccu.table_name = '" . $valor_tabla['table_name'] . "' AND tc.table_name = '" . $valor_tabla['table_name'] . "'" );

$constrains->execute();

$restrincciones = $constrains->fetchAll(PDO::FETCH_ASSOC);

foreach ($columnas as $indice_columnas => $valor_columnas) 
 {
 if( !empty( $valor_columnas ) )
 {
 $cantidad_columnas = $query->columnCount();

for($i = 0; $i < $cantidad_columnas; $i++) 
 {
 $detalles = $query->getColumnMeta( $i );

foreach ($restrincciones as $key => $value) 
 {
 if( !empty( $value ) )
 {
 if( $detalles['name'] == $value['columna'] )
 {
 $detalles['alias'] = $value['alias'];
 $detalles['restrinccion'] = $value['restrinccion'];
 }
 }
 }

$rt[ $this->dba ][ $valor_esquema['table_schema'] ][ $valor_tabla['table_name'] ][$i] = $detalles;
 }
 }
 }
 }
 }
 }
 }
 }

return $rt;
 }

/**
 *
 * @todo Borra la información de la conexión
 *
 * @access public
 *
 **/
 
 public final function cerrarConexion()
 {
 $this->setConexion(null);
 }

/**
 *
 * @todo Devuelve la información de la conexión. 
 *
 * @access public
 *
 * @return int
 *
 **/
 
 public final function getConexion()
 {
 return $this->conexion; 
 }

/**
 *
 * @todo Guarda la información de la conexión a la base de datos. 
 *
 * @access private
 *
 * @param mixed $conexion
 *
 **/
 
 private final function setConexion($conexion)
 {
 $this->conexion = $conexion;
 }

/**
 *
 * @todo Devuelve el alias del manejador de la base de datos. 
 *
 * @access public
 *
 * @return string
 *
 **/
 
 public final function getManejador()
 {
 return $this->manejador; 
 }

/**
 *
 * @todo Guarda la información del alias del manejador de la base de datos. 
 *
 * @access private
 *
 * @param string $manejador
 *
 **/
 
 private final function setManejador($manejador)
 {
 $this->manejador = $manejador;
 }

/**
 *
 * @todo Guarda la cantidad de filas afectadas en una consulta. 
 *
 * @access public
 *
 * @param int $rows
 *
 **/

private final function setNumRows( $rows )
 {
 $this->numrows = $rows;
 }


 /**
 *
 * @todo Devuelve la cantidad de filas afectadas en una consulta. 
 *
 * @access public
 *
 * @return int $this->numrows
 *
 **/

public final function getNumRows()
 {
 return $this->numrows;
 }

public final function getDba()
 {
 return $this->dba;
 }

/**
 *
 * @todo Devuelve las constantes definidas por la extensión PDO
 *
 * @access private
 *
 * @param mixed $var
 *
 * @return mixed PDO::PARAM_
 *
 **/

private function getPDOConstantType( $var )
 {
 if( is_int( $var ) )
 return PDO::PARAM_INT;
 if( is_bool( $var ) )
 return PDO::PARAM_BOOL;
 if( is_null( $var ) )
 return PDO::PARAM_NULL;
 
 return PDO::PARAM_STR;
 }
}

?>

ver: implementacion.php

<?php

/*
 * Autor: Servando Reyes - @zervanstyle - andres92898@gmail.com
 * 
 * Licencia: LGPL 
 * 
 * Web : codificate.wordpress.com
 * 
 */

 include_once('DBManejador.php');

 $manejador = new DBManejador();

 $consulta = $manejador->consultar( "nombre", "persona" );

?>

Me disculpan la identación pero aun no domino como publicar código fuente a través de wordpress sin plugin alguno. Si quieren ser parte de las mejoras de esta clase, pueden acceder al repositorio y hacer los cambios pertinentes, siempre y cuando sean para mejor.

Sin más, espero que les haya sido de gran provecho. Éxito.

Repositorio : https://github.com/codificate/DBM

 

Crear web service a partir de un wsdl con axis2 + java + tomcat + eclipse

Axis2

Saludos amigos, he estado alejado de los post, y prácticamente el presente sería el primer post de programación en Java en la historia de este humilde blog. A continuación crearemos un web service partiendo de un wsdl ya generado. En esta oportunidad, tomaremos un wsdl llamado calculator desde el portal http://service-repository.com/

Para lograr los objetivos, utilizaremos Eclipse (Luna) como entorno de Desarrollo para Java, JDK (v1.8) ultima versión para nuestro kit de desarrollo, Axis2 (v1.6) como motor nuclear para los servicios web, Tomcat 7 el servidor para ejecutar nuestros servicios,  SOAPUI como herramienta para consumir y probar nuestro servicio.

Paso 1 : Creamos el servidor.

Nuevo servidor

Paso 2 : Configuramos el servidor

Configurando el runtime del servidor

Paso 3 : Agregamos el servidor

servidor instalado

Paso 4 : Descargamos Axis2 y descomprimimos el archivo

http://apache.claz.org//axis/axis2/java/core/1.6.2/axis2-1.6.2-bin.zip

Paso 5 : Configuramos Axis2 en Eclipse

Preferences

axis-loaded

Paso 6 : Descargamos el WSDL de ejemplo

http://soaptest.parasoft.com/calculator.wsdl

calculator.wsdl

Paso 7 : Creamos el archivo wsdl dentro de un proyecto vacío, posterior haremos un copy – paste, y reemplazaremos el creado por el que acaba de ser descargado.

wsdl-archivo

calculador-wsdl

Paso 8 : Crearemos un proyecto web dinámico, modificando sus características o Project Facets

Nuevo archivo

DynamicWebProject

Module version

axis2-projects-faces

Paso 9 : Hacemos clic derecho sobre el archivo wsdl ya creado, y seleccionamos Generate Java Bean Skeleton, que será la clase que tendrá toda nuestra lógica de negocio.

generate-java-bean-skeleton

configurando el despliegue del servicio

Paso 10 : Una vez generadas las clases, procedemos a modificar la clase skeleton, la cual la modifique de manera muy sencilla para este post.

http://www.codeshare.io/pPjxT

Paso 11 : Boton derecho sobre el proyecto, y a correr el servicio en Tomcat.

run on server

calculadora-deployed-on-server

lista-servicios

calculador-wsdl-deployed

Paso 12 : Crearemos un proyecto SOAP desde SOAPUI para consumir y ver el comportamiento de nuestro servicio.

Crear un nuevo proyecto SOAP

Nombre del proyecto SOAP

Paso 13 : Enviamos valores desde el request del servicio que queramos probar, para obtener su response.

calculadora-request-response

Sin más, espero que haya sido de su agrado y provecho. Vendrán nuevos y mejores post, con distintas tecnologías.

Como cifrar archivos en linux

gpg-logo

GNU Privacy Guard (GPG, también GnuPG), alternativa libre del proyecto GNU a PGP, es un software de encriptación que es compatible con la OpenPGP (RFC 4880) estándar. El uso de GPG puede cifrar (y descifrar) los archivos que contienen datos confidenciales para cualquier organización.

Comenzaremos a aprender como cifrar archivos, utilizando nuestra consola de comandos, bajo Debian. Lo primero que debemos hacer será buscar, e instalar el paquete que nos permita ejecutar tales funciones.

aptitude search gnupg
aptitude install gnupg

A continuación, crearemos una llave para cifrar:

Nos aseguramos de que gpg-agent se está ejecutando en la línea de comandos, y escribimos lo siguiente:

gpg-agent -s --daemon --write-env-file --use-standard-socket

Una vez ejecutado el comando anterior, usted verá algo como lo siguiente (en cuyo nombre de usuario es su nombre de usuario o ID de red y la máquina es el nombre del sistema):

GPG_AGENT_INFO=/N/u/username/Machine/.gnupg/S.gpg-agent:22743:1; export GPG_AGENT_INFO;

posterior . . .

gpg --gen-key

Al ejecutar este comando, este sería el resultado:

 gpg (GnuPG) 2.0.14; Copyright (C) 2009 Free Software Foundation, Inc.
 This is free software: you are free to change and redistribute it.
 There is NO WARRANTY, to the extent permitted by law.
 
 gpg: keyring `/N/u/username/Machine/.gnupg/secring.gpg' created
 gpg: keyring `/N/u/username/Machine/.gnupg/pubring.gpg' created
 Please select what kind of key you want:
 (1) RSA and RSA (default)
 (2) DSA and Elgamal
 (3) DSA (sign only)
 (4) RSA (sign only)
 Your selection?

Procedemos a seleccionar la opción (1)

GPG le pedirá que elija un tamaño de la llave (en bits). Introducimos 1024, probablemente veremos lo siguiente:

 Requested keysize is 1024 bits
 Please specify how long the key should be valid.
 0 = key does not expire
 <n> = key expires in n days
 <n>w = key expires in n weeks
 <n>m = key expires in n months
 <n>y = key expires in n years
 Key is valid for? (0)

Introduzca un valor para especificar el tiempo que la llave seguirá siendo válida (por ejemplo, 2 durante dos días, 3w durante tres semanas, 10m por 10 meses, o 0 para ninguna fecha de caducidad).

GPG le pedirá que confirme la fecha de caducidad. Si se muestra la fecha correcta, presione la tecla y. GPG solicitará información se utilizará para la construcción de un ID de usuario para identificar su clave. Cuando se le pida, introduzca su nombre, dirección de correo electrónico, y un comentario. GPG le pedirá que confirme o corrija su información. Verá en la consola algo como esto:

You selected this USER-ID:
 "Full Name (comment) <username@iu.edu>"
Change (N)ame, (C)omment, (E)mail or (O)kay/(Q)uit?

Si la información mostrada es correcta, ingrese o para aceptar el ID de usuario. Para corregir errores o abandonar el proceso, introduzca la alternativa apropiada (n, c, e, o q). Si acepta el ID de usuario, GPG le pedirá que introduzca y confirme una contraseña. Después, GPG comenzará a generar una llave:

  We need to generate a lot of random bytes. It is a good idea to
  perform some other action (type on the keyboard, move the mouse,
  utilize the disks) during the prime generation; this gives the
  random number generator a better chance to gain enough entropy.

Este proceso puede tardar varios minutos en completarse. Cuando esté terminado, verá algo como esto:

  gpg: key 09D2B839 marked as ultimately trusted
  public and secret key created and signed.
  
  gpg: checking the trustdb
  gpg: 3 marginal(s) needed, 1 complete(s) needed, PGP trust model
  gpg: depth: 0  valid:   4  signed:   0  trust: 0-, 0q, 0n, 0m, 0f, 4u
  gpg: next trustdb check due at <expiration_date>
  pub   1024R/09D2B839 2013-06-25 [expires: <expiration_date>]
        Key fingerprint = 6AB2 7763 0378 9F7E 6242  77D5 F158 CDE5 09D2 B839
  uid                  Full Name (comment) <username@indiana.edu>
  sub   1024R/7098E4C2 2013-06-25 [expires: <expiration_date>]

Ahora puede utilizar la llave (hasta que caduque) para cifrar archivos.

Cifrando un archivo:

Para cifrar un archivo mediante una llave GPG ya creada, escriba en la línea de comandos lo siguiente:  (reemplace user_id con la dirección de correo electrónico que especificó al crear su llave y mi_archivo con el nombre del archivo a cifrar):

gpg -e -r user_id mi_archivo

GPG creará una versión cifrada del archivo que ha especificado; el archivo cifrado tendrá una extensión de archivo .gpg (por ejemplo, mi_archivo.gpg). Después de confirmar la versión cifrada se ha creado, puede eliminar el archivo original sin cifrar.

Descifrando un archivo:

Para descifrar un archivo .gpg (por ejemplo, mi_archivo.gpg), en la línea de comandos, escriba:

gpg mi_archivo.gpg

GPG le pedirá la contraseña asociada a la llave que utilizó para cifrar el archivo. Cuando se introduce la contraseña correcta, GPG recreará la versión original, sin cifrar del archivo (por ejemplo, mi_archivo). Este proceso no elimina ni modifica la versión cifrada del archivo (mi_archivo.gpg).

Configurar certificados digitales en Debian.

ssl_300_300

Según la Universidad Politécnica de Valéncia El Certificado Digital es el único medio que permite garantizar técnica y legalmente la identidad de una persona en Internet. Se trata de un requisito indispensable para que las instituciones puedan ofrecer servicios seguros a través de Internet.

Para lograr esto, debemos instalar e utilizar openssl que provee un conjunto de herramientas criptográficas capaces de brindarnos la flexibilidad que necesitemos para configurar nuestro servidor. Una vez entendido esto, comencemos:

Instalar openssl :

# aptitude install openssl

Generamos una clave privada, utilizando el algoritmo de encriptación DES3, con un tamaño de 4096 bits, almacenando esta en un archivo llamado: “clave_privada.key”

# openssl genrsa -des3 -out clave_privada.key 4096

Crearemos un certificado ssl utilizando la clave privada previamente generada, este certificado expirará en unos 20 años aproximadamente, lo que equivale a 7300 días, además este comando utiliza un argumento que define el estándar x509 de infraestructura para clave publica.

# openssl req -new -x509 -days 7300 -key clave_privada.key -out clave_publica.crt

Antes de continuar, es propio comprender el significado de autoridad certificadora:  Esta es la responsable de emitir y revocar los certificados digitales. En este caso, algunas autoridades tipo COMODO proponen un comando de generación, para solicitar una petición de firma de certificado, o mejor conocido como CSR (Certificate Signing Request) ejemplo:

# openssl req -nodes -newkey rsa:2048 -keyout clave_privada.key -out certificado.csr

Una vez tecleado estos comandos, procedemos a llenar los siguientes campos. En el campo FQDN debemos colocar exactamente la dirección IP o la dirección de dominio que queremos certificar :

Country Name (2 letter code) [AU]: VE
State or Province Name (full name) [Some-State]: Distrito Capital
Locality Name (eg, city) [ ]: Caracas
Organization Name (eg, company) [Internet Widgits Pty Ltd]: MiCompañia c.a
Organizational Unit Name (eg, section) [ ]: Redes
Common Name (e.g. server FQDN or YOUR name) [ ]: tudominio.com
Email Address [ ]:

 NOTA: Es indispensable ser dueño o administrador del dominio, por tanto, si nos fue bien generando los certificados u obteniendo el certificado temporal a través de la pagina de COMODO, solo nos resta configurar nuestro servidor.

Habilitamos el módulo SSL

# a2enmod ssl

Editaremos el siguiente archivo:

# nano /etc/apache2/sites-available/tudominio.com

Colocaremos lo siguiente:

<VirtualHost *:443>
     ServerName www.tudominio.com
     DocumentRoot /var/www/shopping
     SSLEngine on
     SSLCertificateFile /etc/apache2/ssl/tudominio.com/certificadoCOMODO.crt
     SSLCertificateKeyFile /etc/apache2/ssl/tudominio.com/clave_privada.key
     SSLCertificateChainFile /etc/apache2/ssl/tudominio.com/certificadoCOMODO.ca-bundle
</VirtualHost>

Lo que acabamos de hacer es: Definir nuestro VirtualHost para que atienda peticiones por el puerto 443 y certifique nuestro servidor, valiéndose de los certificados generados. En este ejemplo me valgo de los certificados obtenidos a través de COMODO, para que sea esta la autoridad certificadora, que valide mi existencia en la red.

A continuación habilitaremos nuestro archivo, para que pueda ser procesado por el servidor apache.

# a2ensite tudominio.com

Editamos el archivo ubicado en la ruta: /etc/hosts y colocamos lo siguiente, donde X.X.X.X será nuestra IP:

127.0.0.1 tudominio.com
X.X.X.X tudominio.com

Antes de culminar, reiniciamos el servidor, con la intención de que este tome los cambios que hemos hecho.

#  /etc/init.d/apache2 restart

Ya hecho todo lo anterior, visualizamos nuestra configuración del lado del servidor, a través del navegador, accediendo de la siguiente manera.

https://tudominio.com

Si nuestros intentos son fallidos y aun sigue apareciendo la excepción en el explorador, debemos generar un certificado autofirmado y luego instalarlo en nuestro navegador. Comencemos:

# openssl genrsa -out clave_cliente.key
# openssl req -new -out tudominio_reqout.txt -key clave_cliente.key
# openssl x509 -req -in tudominio_reqout.txt -days 365 -sha1 -CAcreateserial -CA clave_publica.crt -CAkey clave_privada.key -out navegador_cliente.crt
# openssl pkcs12 -export -clcerts -in certificado_navegador_cliente.crt -inkey clave_cliente.key -out navegador.p12

Si usas Firefox, debes ingresar a Preferencias → Avanzado → Certificados. Clic en el botón de «Certificados» y luego «Importar» el archivo «navegador.p12».  Al seleccionar el archivo del certificado, se mostrará un diálogo que te preguntará si deseas confiar en el certificado. Debes seleccionar la opción de Confiar en esta CA para identificar sitios web y finalmente Aceptar.

Con Chrome, el proceso sigue los mismos pasos.

Con esto el certificado ya queda instalado y te puedes conectar seguramente al sitio web.

Éxitos.