.:: RolandoPalermo ::.

Getting Cannot create a session after the response has been committed in Camunda

2020-02-14T16:07:00.004-05:00

Solution for Camunda error Cannot create a session after the response has been committed.

Ejecutar script SQL con Postgres & Docker

2019-06-06T14:50:00.000-05:00

Muchas veces, al ejecutar un contenedor Docker para Postgres, deseamos inicializar el servidor o la base de datos creada con ciertos scripts previamente creados. En este artículo les mostraré cómo ejecutar un contenedor para Postgres agregando las dos siguientes actividades:

1. Ejecutar un script para inicializar las tablas maestras
Esto normalmente se realiza con la instrucción:

psql -U postgres veronica < veronica.sql

Pero en el caso de Docker, podemos agregar el script al directorio /docker-entrypoint-initdb.d/ y Docker ejecutará automáticamente dicho script luego de iniciar el servicio de base de datos.

2. Agregar una llave para encriptación que será utilizada por la extensión pgcrypto.
Si no utilizamos docker, bastaría con realizar lo siguiente

postgres -c encrypt.key=a_secret_key

Ahora, ambas configuraciones se pueden hacer también directamente con Docker tal como se muestra en el siguiente Dockerfile:

FROM postgres:11.3

# About the author
MAINTAINER Rolando Rodríguez <rolando.roc@gmail.com>

# Environment variables

# Set Postgres environment variables
ENV POSTGRES_PASSWORD=123456 
    POSTGRES_USER=postgres 
    POSTGRES_DB=sample

# Get a sql script and move it to initialization scripts folder
ADD https://raw.githubusercontent.com/rolandopalermo/veronica/master/veronica-app/src/main/postgres/veronica.sql /docker-entrypoint-initdb.d/

# Make sql script executable
RUN chmod 744 /docker-entrypoint-initdb.d/veronica.sql

# Expose the PostgreSQL port
EXPOSE 5432

# Run a command, for example: $ postgres -c encrypt.key=8qxBjzCdQkwdpu
CMD ["postgres", "-c", "encrypt.key=8qxBjzCdQkwdpu"]

Para más información, puedes revisar el siguiente repositorio: https://github.com/rolandopalermo/dockerfiles/tree/master/postgres-run-sql-command

Clean out your Docker images, containers and volumes

2019-05-22T19:26:00.001-05:00

Cleaning up containers
Kill all running containers

> docker kill $(docker ps -q)

Delete all stopped containers

> docker rm $(docker ps -a -q)

Cleaning up images
Delete an image

> docker rmi <image name>

Delete all 'untagged/dangling' images

> docker rmi $(docker images -q -f dangling=true)

Delete all images

> docker rmi $(docker images -q)

Cleaning up volumnes
Once a volume is not longer associated with a container, it is considered 'dangling'

> docker volume rm $(docker volume ls -f dangling=true -q)

How to remove namespaces from XML using XSLT

2019-05-16T22:20:00.000-05:00

Sometimes, XML documents you receive could contain unneeded or incorrect namespace information. You can use XSLT stylesheets to remove the namespace information in these documents.

XML Input

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<ns1:reportRequest xmlns:ns1="http://v1.dto.reports.rolandopalermo.com">
    <ns1:metadata>
        <ns1:account>12345678</ns1:account>
        <ns1:reportName>Current_Payment</ns1:reportName>
    </ns1:metadata>
    <ns1:report>
        <ns1:reportId>1</ns1:reportId>
        <ns1:header>
            <ns1:id>999999999</ns1:id>
            <ns1:name>John Smith</ns1:name>
        </ns1:header>
        <ns1:invoices>
            <ns1:invoice>
                <ns1:invoiceNumber>0000000000</ns1:invoiceNumber>
                <ns1:dueDate>07/01/18</ns1:dueDate>
                <ns1:invoiceAmount>14.00</ns1:invoiceAmount>
                <ns1:amountPaid>14.00</ns1:amountPaid>
            </ns1:invoice>
        </ns1:invoices>
        <ns1:paymentMethodInformation>
            <ns1:cardType>VISA</ns1:cardType>
            <ns1:cardName>************1111</ns1:cardName>
            <ns1:cardHolder>Juan Pérez</ns1:cardHolder>
            <ns1:authorizationCode>dd92c0f864ea9ff1016501e880d03451</ns1:authorizationCode>
        </ns1:paymentMethodInformation>
    </ns1:report>
</ns1:reportRequest>

XSLT

<?xml version="1.0" encoding="UTF-8"?>
<xsl:stylesheet
    xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0"
    xmlns:ns1="http://v1.dto.reports.rolandopalermo.com">
    <xsl:template match="/">
        <xsl:apply-templates
            select="ns1:reportRequest/ns1:report" />
    </xsl:template>
    <xsl:template match="*">
        <xsl:element name="{local-name(.)}">
            <xsl:apply-templates />
        </xsl:element>
    </xsl:template>
    <xsl:template match="@*">
        <xsl:copy />
    </xsl:template>
</xsl:stylesheet>

XML Output

<?xml version="1.0" encoding="UTF-8"?>
<report>
    <reportId>1</reportId>
    <header>
        <id>999999999</id>
        <name>John Smith</name>
    </header>
    <invoices>
        <invoice>
            <invoiceNumber>0000000000</invoiceNumber>
            <dueDate>07/01/18</dueDate>
            <invoiceAmount>14.00</invoiceAmount>
            <amountPaid>14.00</amountPaid>
        </invoice>
    </invoices>
    <paymentMethodInformation>
        <cardType>VISA</cardType>
        <cardName>************1111</cardName>
        <cardHolder>Juan Pérez</cardHolder>
        <authorizationCode>dd92c0f864ea9ff1016501e880d03451</authorizationCode>
    </paymentMethodInformation>
</report>

How to reset a remote git repository to remove all commits

2018-10-25T11:46:00.002-05:00

Delete the .git directory locally and recreate the git repostory:

$ cd (project-directory)
$ git init
$ (add some files)
$ git add .
$ git commit -m 'Initial commit'

Push to remote server, overwriting. Remember you're going to mess everyone else up doing this so you better be the only client.

$ git remote add origin <url>
$ git push --force --set-upstream origin master

How to Create an Executable JAR with Maven

2018-10-21T01:08:00.000-05:00

In this quick article we will focus on packaging a Maven project into an executable Jar file. In order to create an executable jar, we don’t need any additional dependencies. We just need to create Maven Java project, and have at least one class with the main(…) method.

We also need to make sure that our pom.xml contains the the following elements:

<build>
    <finalName>anjus-invoicing-${project.version}</finalName>
    <plugins>
        <plugin>
            <artifactId>maven-assembly-plugin</artifactId>
            <configuration>
                <descriptorRefs>
                    <descriptorRef>jar-with-dependencies</descriptorRef>
                </descriptorRefs>
                <appendAssemblyId>false</appendAssemblyId>
                <archive>
                    <manifest>
                        <mainClass>com.rolandopalermo.example.Main</mainClass>
                    </manifest>
                </archive>
            </configuration>
            <executions>
                <execution>
                    <id>make-assembly</id>
                    <phase>package</phase>
                    <goals>
                        <goal>assembly</goal>
                    </goals>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>

Deserialización JSON de tipos genéricos usando Jackson

2018-03-20T23:59:00.002-05:00

Como parte de las buenas prácticas en la reutilización de clases, es común encontrar el uso de tipos genéricos en Java. Sin embargo, cuando estas forman parte de una respuesta JSON, pueden ser un dolor de cabeza. Imaginemos que tenemos como respuestas de un API Rest los dos siguientes escenarios:

PersonaResponse

{
   "codigo":1,
   "mensaje":"ok",
   "data":{
      "nombres":"Rolando Palermo",
      "edad":29
   }
}

ProductoResponse

{
   "codigo":1,
   "mensaje":"ok",
   "data":{
      "codigo":"FX-536",
      "precio":56.98,
      "moneda":"PEN",
   }
}

Ambos Json tienen propiedades comunes, sin embargo sólo el objeto data es diferente. Para deserializar estos jsons sin tipos genéricos, tendríamos que crear 2 envoltorios con 2 clases de datos diferentes. Pero con los tipos genéricos solo necesitamos crear una clase genérica para las propiedades de la raíz y una clase específica para cada objeto en la clave de data.

GenericResponse.java

public class GenericResponse<T> {

    private String codigo;
    private String mensaje;
    T data;

    public String getCodigo() {
        return codigo;
    }

    public void setCodigo(String codigo) {
        this.codigo = codigo;
    }

    public String getMensaje() {
        return mensaje;
    }

    public void setMensaje(String mensaje) {
        this.mensaje = mensaje;
    }

    public T getData() {
        return data;
    }

    public void setData(T data) {
        this.data = data;
    }
    
}

PersonaResponse

public class PersonaResponse {

    private String nombres;
    private int edad;

    public String getNombres() {
        return nombres;
    }

    public void setNombres(String nombres) {
        this.nombres = nombres;
    }

    public int getEdad() {
        return edad;
    }

    public void setEdad(int edad) {
        this.edad = edad;
    }
}

ProductoResponse

public class ProductoResponse {

    private String codigo;
    private double precio;
    private String moneda;

    public String getCodigo() {
        return codigo;
    }

    public void setCodigo(String codigo) {
        this.codigo = codigo;
    }

    public double getPrecio() {
        return precio;
    }

    public void setPrecio(double precio) {
        this.precio = precio;
    }

    public String getMoneda() {
        return moneda;
    }

    public void setMoneda(String moneda) {
        this.moneda = moneda;
    }

}

Ahora, la deserialización JSON nos quedaría de la siguiente manera:

ObjectMapper mapper = new ObjectMapper();
//Para persona
GenericResponse<PersonaResponse> response1 = mapper.readValue(jsonString, new TypeReference<GenericResponse<PersonaResponse>>() {});
//Para producto
GenericResponse<ProductoResponse> response2 = mapper.readValue(jsonString, new TypeReference<GenericResponse<ProductoResponse>>() {});

Bloqueo de recursos en SQL Server

2018-02-24T12:56:00.001-05:00

En los últimos años hemos sido testigos de un crecimiento exponencial de aplicaciones distribuidas, con infinidad de componentes concurrentes de propósito específico interactuando unos con otros en tiempo real y a grandes velocidades. Estos nuevos enfoques de arquitecturas asíncronas han traído consigo antiguos problemas que nosotros, los desarrolladores, debemos resolver en nuestro día a día; uno de ellos, el mítico bloqueo mutuo.

Escenarios tales como accesos a interfaces de hardware, aplicaciones IOT o hasta la simple generación de números de secuencia de tickets son casos donde el interbloqueo o bloqueo mutuo es un problema que de no ser resuelto, podría comprometer el éxito de un proyecto de software. Si bien es cierto, existen soluciones que van desde complejas arquitecturas distribuidas hasta increíbles artimañanas inventadas por algún programador adicto al café, en este artículo nos centraremos en una propuesta que manejará el interbloqueo desde base de datos haciendo uso de un procedimiento almacenado de sistema, el sp-getapplock.

El problema se planteará de la siguiente manera: "Debemos desarrollar un procedimiento almacenado que garantice la inserción de registros en una tabla determinada, cada uno de los cuales estará identificado por un id que deberá generarse de manera secuencial sin dejar ningún vacío, esto quiere decir que de presentarse algún error, se deberá ejecutar una instrucción de rollback y la siguiente inserción deberá hacer uso de esta secuencia".

El primer paso será crear nuestra tabla, para lo cual haremos ejecutaremos la siguiente consulta en SQL Server.

CREATE TABLE dbo.Registros  
   (Registro_Seq_ID int PRIMARY KEY NOT NULL,  
    Registro_Descripcion varchar(25) NOT NULL)  
GO

El siguiente paso será crear un procedimiento almacenado que se encargue de la inserción, esto con el fin de tener un punto de entrada dónde poder aplicar nuestro control contra los interbloqueos.

SET ANSI_NULLS ON
GO
SET QUOTED_IDENTIFIER ON
GO

ALTER PROCEDURE spInsertarRegistro
 @Descripcion VARCHAR(25),
 @RegistroSeq INT OUT
AS
BEGIN
 SET NOCOUNT ON;
 SELECT @RegistroSeq = ISNULL(MAX(Registro_Seq_ID), 0) + 1  from Registros;
 INSERT INTO Registros(Registro_Seq_ID, Registro_Descripcion) VALUES (@RegistroSeq, @Descripcion);
END
GO

Y ahora utilizaremos Java para probar nuestro procedimiento almacenado.

package com.rolandopalermo.sql;
import java.sql.CallableStatement;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

public class App {
    
 public String driver = "com.microsoft.sqlserver.jdbc.SQLServerDriver";
 public void insertRegistro(String descripcion) throws SQLException,
 ClassNotFoundException {
  String connectionUrl = "jdbc:sqlserver://localhost:55418;databaseName=BD_TEST;user=user_test_app;password=12345678";
  try (
  Connection connection = DriverManager.getConnection(connectionUrl);
  CallableStatement cstmt = connection.prepareCall("{call spInsertarRegistro(?,?)}")) {
   Class.forName(driver);
   cstmt.setString(1, descripcion);
   cstmt.registerOutParameter(2, java.sql.Types.INTEGER);
   cstmt.execute();
   System.out.println("Se creó el registro [" + cstmt.getInt(2) + "]");
  }
 }
 
 public static void main(String[] args) throws Exception {
  App app = new App();
  app.insertRegistro("Registro sin interbloqueo");
 }
 
}

Al ejecutar dicha clase, veremos que nuestro registro se insertó correctamente, sin embargo ahora realizaremos una pequeña mofidicación al método main para que inserte registros de manera continua, estableciendo una pausa de 200 milisegundos entre cada inserción. Al ejecutar un sólo proceso, el resultado será el siguiente:

Sin embargo, al ejecutar tres procesos, la historia cambia:

Es aquí donde sp-getapplock viene a salvarnos el día. Nuestro procedimiento sufrirá una ligera modifación, la cual evitará que más de una petición intente ejecutarlo de manera concurrente. El recurso de bloqueo creado por sp_getapplock se crea en la base de datos actual para la sesión.

SET ANSI_NULLS ON  
 GO  
 SET QUOTED_IDENTIFIER ON  
 GO  
 ALTER PROCEDURE spInsertarRegistro2  
      @Descripcion VARCHAR(25),  
      @RegistroSeq INT OUT  
 AS  
 DECLARE  
      @rc int = 0,  
      @msg varchar(2000)  
 SET @msg = CONVERT(varchar, GETDATE(), 114) + ' Se incia el segmento a sincronizar'  
 RAISERROR (@msg, 0, 1) WITH NOWAIT  
 BEGIN TRY  
      BEGIN TRAN  
           SET @msg = CONVERT(varchar, GETDATE(), 114) + ' Tratando de obtener el candado'  
           RAISERROR (@msg, 0, 1) WITH NOWAIT  
           -- Se solicita el candado  
           EXEC @rc = sp_getapplock   
                @Resource = 'spInsertarRegistro2', -- Nombre del recurso a bloquear  
                @LockMode = 'Exclusive', -- Tipo de candado  
                @LockOwner = 'Transaction', -- Transaction or Session  
                @LockTimeout = 15000 -- Tiempo de espera máximo, 15 seconds  
           -- Se verifica si se pudo obtener el candado  
           SET @msg =   
                CONVERT(varchar, GETDATE(), 114) +   
                ' sp_getapplock retornó ' +   
                CONVERT(varchar(30), @rc) +   
                ' -- ' +   
                CASE  
                     WHEN @rc < 0 THEN 'No se pudo obtener el candado'  
                     ELSE 'Candado obtenido'  
                END  
           RAISERROR (@msg, 0, 1) WITH NOWAIT  
           IF @rc >= 0  
                BEGIN  
                     SET @msg = CONVERT(varchar, GETDATE(), 114) + ' Se iniciará con la sección crítica '  
                     RAISERROR (@msg, 0, 1) WITH NOWAIT  
                     -- Inserciones protegias por código  
                     SET NOCOUNT ON;  
                     SELECT @RegistroSeq = ISNULL(MAX(Registro_Seq_ID), 0) + 1 from Registros;  
                     INSERT INTO Registros(Registro_Seq_ID, Registro_Descripcion) VALUES (@RegistroSeq, @Descripcion);  
                     --   
                     COMMIT TRAN -- Se libera el candado  
                     SET @msg = CONVERT(varchar, GETDATE(), 114) + ' Trabajo completado, se libera el candado'  
                     RAISERROR (@msg, 0, 1) WITH NOWAIT  
                END  
           ELSE  
                BEGIN  
                ROLLBACK TRAN  
                SET @rc = 50000  
           END  
 END TRY  
 BEGIN CATCH  
      set @msg = 'ERROR: ' + ERROR_MESSAGE() + ' en '   
       + coalesce(ERROR_PROCEDURE(), '')  
       + coalesce (' la línea:' + convert(varchar(30), ERROR_LINE()), '')  
      IF @@Trancount > 1  
           ROLLBACK TRAN;  
      RAISERROR (@msg, 0, 1)  
 END CATCH

Ahora realizaremos una modificación a la clase Java para que inserte de manera concurrente registros sin ninguna pausa. Al ser la columna Registro_Seq_ID una clave primaria, si en algún momento llegase a duplicarse, se deberá lanzar un error. El siguiente video evidencia que, a pesar de la concurrencia, todos los registros se están insertando de manera correcta.

Espero que este post les sea de utilidad y cualquier consulta adicional, no duden en comentarla.

API Rest con PHP y MySQL para el manejo de imágenes

2017-12-05T14:26:00.001-05:00

Las cargas de imágenes son una cosa que siempre se torna bastante complicada y manejar esto a través de una API Rest es aún más retador. En este artículo vamos a ver cómo insertar imágenes y demás datos en una tabla de MySQL a través de servicios web de tipo REST que permitirán ejecutar las diferentes operaciones sobre la base de datos. Como consideraciones iniciales, es importante mencionar que debamos revisar antes el siguiente artículo:
http://blog.rolandopalermo.com/2017/12/slim-composer-php-rest-api-install.html.

También tendremos que configurar nuestro servidor Apache para poder tener URL más amigables. Para esto modificar los archivos:

C:\xampp\apache\conf\extra\httpd-vhosts.conf
C:\Windows\System32\drivers\etc\hosts

Los cuales deberán quedarnos con el siguiente contenido:

Archivo httpd-vhosts.conf

NameVirtualHost *:80

<VirtualHost *:80>
    DocumentRoot "C:/xampp/htdocs/rest-api/public"
    ServerName rest-api
</VirtualHost>

<VirtualHost *:80>
    DocumentRoot "C:/xampp/htdocs/rest-api-demo/public"
    ServerName rest-api-demo
</VirtualHost>

Archivo hosts

127.0.0.1 rest-api-demo

Recuerden que a lo largo de todo el artículo haré referencia a la ruta C:/xampp que es donde tengo instalado a mi servidor Xampp.

Como primera parte, tendremos una base de datos con una tabla para gestionar usuarios. El script es el siguiente:

CREATE DATABASE IF NOT EXISTS rest_api_base;
USE rest_api_base;

--
-- Definition of table `user`
--

DROP TABLE IF EXISTS `user`;
CREATE TABLE `user` (
  `id_user` int(10) unsigned NOT NULL AUTO_INCREMENT,
  `name` varchar(100) NOT NULL,
  `avatar` blob NOT NULL,
  PRIMARY KEY (`id_user`)
) ENGINE=InnoDB AUTO_INCREMENT=5 DEFAULT CHARSET=utf8;

Ahora la clase PHP para conectarnos a la base de datos:

<?php

class DB {

    private $db_host = 'localhost';
    private $db_user = 'root';
    private $db_pass = '123456';
    private $db_name = 'rest_api_base';

    public function connect() {
        $mysql_connect_str = "mysql:host=$this->db_host;dbname=$this->db_name";
        $dbConnection = new PDO($mysql_connect_str, $this->db_user, $this->db_pass);
        $dbConnection->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
        return $dbConnection;
    }

}

Y la clase que mapea a la tabla users de la base de datos.

<?php

class User {

    public $idUser;
    public $name;
    public $avatar;

    function __construct($idUser, $name, $avatar) {
        $this->idUser = $idUser;
        $this->name = $name;
        $this->avatar = $avatar;
    }

}

También las clase DAO donde se implementarán las operaciones sobre la base de datos.

<?php

require '../src/model/user.php';

class UserDAO {

    public function findAll() {
        $sql = "SELECT * FROM user;";
        try {
            $db = new DB();
            $db = $db->connect();
            if (is_null($db)) {
                echo '{"error": true, "message": "text": "No se pudo conectar a la base de datos."}';
            } else {
                $stmt = $db->query($sql);
                $usuarios = $stmt->fetchAll();
                $arr_usuarios = array();  //array to parse jason from
                $db = null;
                foreach ($usuarios as $row) {
                    $usr = new User($row[0], $row[1], base64_encode($row[2]));
                    $arr_usuarios[] = $usr;
                }
                echo '{"error": false, "data": ' . json_encode($arr_usuarios) . '}';
            }
        } catch (PDOException $ex) {
            echo '{"error": true, "message": "' . $ex->getMessage() . '"}}';
        }
    }

    public function findOne($idUser) {
        $sql = "SELECT * FROM user WHERE id_user=?;";
        try {
            $db = new DB();
            $db = $db->connect();
            if (is_null($db)) {
                echo '{"error": true, "message": "text": "No se pudo conectar a la base de datos."}';
            } else {
                $stmt = $db->prepare($sql);
                $array = array($idUser);
                $stmt->execute($array);
                $usuarios = $stmt->fetchAll();
                $arr_usuarios = array();  //array to parse jason from
                foreach ($usuarios as $row) {
                    $usr = new User($row[0], $row[1], base64_encode($row[2]));
                    $arr_usuarios[] = $usr;
                }
                echo '{"error": false, "data": ' . json_encode($arr_usuarios) . '}';
            }
        } catch (PDOException $ex) {
            echo '{"error": true, "message": "' . $ex->getMessage() . '"}}';
        }
    }

    public function put($user) {
        $sql = "INSERT INTO user(name, avatar) VALUES (?,?)";
        try {
            $db = new DB();
            $db = $db->connect();
            if (is_null($db)) {
                echo '{"error": true, "message": "text": "No se pudo conectar a la base de datos."}';
            } else {
                $stmt = $db->prepare($sql);
                $array = array($user->name, base64_decode($user->avatar));
                $stmt->execute($array);
                $id_producto_insertado = $db->lastInsertId();
                $db = null;
                echo '{"error": false, "data": ' . $id_producto_insertado . '}';
            }
        } catch (PDOException $ex) {
            echo '{"error": true, "message": "' . $ex->getMessage() . '"}}';
        }
    }
    
    public function update($user) {
        $sql = "UPDATE user SET name=?, avatar=? WHERE id_user=?";
        try {
            $db = new DB();
            $db = $db->connect();
            if (is_null($db)) {
                echo '{"error": true, "message": "text": "No se pudo conectar a la base de datos."}';
            } else {
                $stmt = $db->prepare($sql);
                $array = array($user->name, base64_decode($user->avatar),$user->idUser);
                $stmt->execute($array);
//                $id_producto_insertado = $db->lastInsertId();
                $db = null;
                echo '{"error": false, "data": "Usuario actualizado"}';
            }
        } catch (PDOException $ex) {
            echo '{"error": true, "message": "' . $ex->getMessage() . '"}}';
        }
    }

}

Ahora, como mencioné al inicio del artículo, utilizaremos el Framework Slim cuya instalación la expliqué en el post del cual hice referencia al inicio de este artículo. En esta clase se definirán las rutas y los métodos a través de los cuales se accederá a las distintas opciones de nuestra API.

<?php

use PsrHttpMessageServerRequestInterface as Request;
use PsrHttpMessageResponseInterface as Response;

//$app_productos = new SlimApp;

require '../src/dao/user_dao.php';

$app_dapp->get('/api/users/findall', function(Request $request, Response $response) {
    $dao = new UserDAO();
    $dao->findAll();
});

$app_dapp->get('/api/users/find/{idUser}', function(Request $request, Response $response) {
    $dao = new UserDAO();
    $dao->findOne($request->getAttribute('idUser'));
});

$app_dapp->post('/api/users/put', function(Request $request, Response $response) {
    $dao = new UserDAO();
    $user = new User(null, $request->getParam('name'), $request->getParam('avatar'));
    $dao->put($user);
});

$app_dapp->post('/api/users/update', function(Request $request, Response $response) {
    $dao = new UserDAO();
    $user = new User($request->getParam('idUser'), $request->getParam('name'), $request->getParam('avatar'));
    $dao->update($user);
});

Si todo ha marchado bien, podremos acceder desde cualquier cliente y visualizar la información que se solicite. Por ejemplo, lanzado una petición a través de POSTMAN a la opción de listar los usuarios, tendremos lo siguiente:

En este caso, las imágenes fueron tratas en su codificación de Base64. Ahora, si queremos más de cerca nuestra API en acción, podemos utilizar POSTMAN para insertar una imagen:

También podemos escribir un sencillo cliente en PHP. El código sería el siguiente:

<?php

$url = "http://rest-api-demo/api/users/findall";
$client = curl_init($url);
curl_setopt($client, CURLOPT_RETURNTRANSFER, 1);
$curl_response = curl_exec($client);
//echo $curl_response;
$obj_response = json_decode($curl_response);
$array_data = $obj_response->data;
//header("Content-type: image/gif");
foreach($array_data as $item) {
 echo $item->name . '<br>';
 echo '<img width="150" src="data:image/gif;base64,' . $item->avatar . '" />';
 echo '<br>';
}

Y deberíamos tener algo similar a esto:

El proyecto completo lo pueden encontrar en Github y lo pueden descargar del siguiente enlace:
https://github.com/rolandopalermo/rest-api-demo

Espero que este artículo les sea de utilidad y no olviden seguirme a través de Facebook.

String split with Transact-SQL

2017-12-04T10:30:00.001-05:00

In spite of The STRING_SPLIT function is now available under compatibility level 130, knowing how to implement this function is something that is definitely worthwhile.

CREATE FUNCTION [dbo].[fnSplitString] 
( 
    @string NVARCHAR(MAX), 
    @delimiter CHAR(1) 
) 
RETURNS @output TABLE(splitdata NVARCHAR(MAX) 
) 
BEGIN 
    DECLARE @start INT, @end INT 
    SELECT @start = 1, @end = CHARINDEX(@delimiter, @string) 
    WHILE @start < LEN(@string) + 1 BEGIN 
        IF @end = 0  
            SET @end = LEN(@string) + 1
       
        INSERT INTO @output (splitdata)  
        VALUES(SUBSTRING(@string, @start, @end - @start)) 
        SET @start = @end + 1 
        SET @end = CHARINDEX(@delimiter, @string, @start)
        
    END 
    RETURN 
END
GO

How to use:

DECLARE
    @_txt_tmp  NVARCHAR(MAX),
    @full_string NVARCHAR(MAX) = "Hello World From Transact-SQL"
DECLARE
    @cursor_for_spliting CURSOR
    SET @cursor_for_spliting = CURSOR FOR SELECT splitdata FROM [dbo].[fnSplitString](@full_string,'')
    OPEN @cursor_for_spliting FETCH NEXT FROM @cursor_for_spliting INTO @_txt_tmp
    WHILE @@FETCH_STATUS = 0
    BEGIN
        -- Do whatever with @_txt_tmp
    FETCH NEXT FROM @cursor_for_spliting INTO @_txt_tmp
END;
CLOSE @cursor_for_spliting ;
DEALLOCATE @cursor_for_spliting;

Creando una REST Api para PHP con el Framework Slim 3

2017-12-02T15:44:00.002-05:00

Slim es un framework para crear microservicios REST utilizando PHP. En este post se va a mostrar la manera cómo instalar Slim utilizando una herramienta para la gestión de dependencias en PHP llamada Composer. Resumiento, para poder seguir este artículo, necesitaremos lo siguiente:

XAMPP/Apache
Slim (https://www.slimframework.com/)
Composer (https://getcomposer.org/)
SublimeText (ocpional)

Una vez tengamos instaladas todas estas herramientas, procederemos a descargar Slim vía Composer. Para esto, primero debemos crear nuestra carpeta de trabajo llamada rest-api dentro del directo C:\xampp\htdocs (La ruta dependerá de dónde hayan instalado Xampp pero se recomiendo no utilizar nombres muy largos), situarnos en la carpeta utilizando un CDM y descargar la versión 3 del Framework Slim.

C:\xampp\htdocs\rest-api>cd C:\xampp\htdocs\rest-api
C:\xampp\htdocs\rest-api>composer require slim/slim "^3.0"

Ahora utilizaremos SublimeText para abrir la carpeta, en donde podremos visualizar todos los archivos de dependencias que se nos ha creado. Dentro de la carpeta rest-api crearemos dos subcarpetas: public y src. La siguiente imagen ilustra lo descrito anteriormente:

Ahora crearemos un archivo en la carpeta public llamada index.php cuyo contenido será el siguiente:

<?php
use PsrHttpMessageServerRequestInterface as Request;
use PsrHttpMessageResponseInterface as Response;

require '../vendor/autoload.php';

$app = new SlimApp;
$app->get('/hello/{name}', function (Request $request, Response $response) {
    $name = $request->getAttribute('name');
    $response->getBody()->write("Hello, $name");

    return $response;
});
$app->run();

El código anterior es un ejemplo sencillo de un servicio Rest que recibe como parámetro un nombre y retorna un saludo. Y ahora, para poder verificar el funcionamiento de nuestra api podemos ingresar a la siguiente URL: http://localhost/rest-api/public/index.php/hello/rolando. En este punto quiero hacer algunas anotaciones, en primer lugar la ruta depende de la carpeta que hayan creado, en mi caso dicha carpeta se llama rest-api. Es importante también no olvidar que debemos escribir la ruta completa incluído el nombre del archivo index.php sino obtendremos de respuesta un error 404.

Espero que este post les sea de ayuda para iniciarse en el mundo de los Microservicios con PHP. No se olviden seguirme a través de mis redes sociales de Facebook haciendo clic aquí.

Diferencia entre git push -u y git push

2017-11-28T14:15:00.003-05:00

En el post de hoy vamos a explicar las diferencias entre los comandos git push -u origin master y git push origin master. Aunque ambos comandos sirven para enviar nuestros cambios a un repositorio remoto, la bandera -u permite también agregar referencias ascendentes de seguimiento; en otras palabras, a partir de este punto, Git sabrá hacia dónde enviar y de dónde obtener los cambios sin la necesidad de utilizar argumentos en los comandos git push y git pull.

Si no establecemos el upstream para el seguimiento, cuando invoquemos al comando git pull, se nos presentará un error indicándonos que no existe información de seguimiento para la rama actual. La siguiente imagen ilustra este escenario.

Por otra parte, si ejecutamos el comando con la bandera -u, a partir de ese momento se creará una referencia de trazabilidad que nos permitirá invocar, por ejemplo, al comando git pull sin la necesidad de argumentos.

Crear dominio en Servidor Glassfish

2017-11-25T00:40:00.001-05:00

Un dominio Glassfish es un conjunto de instancias o espacio de nombres administrativos que se pueden administrar de forma conjunta. Este mismo proporciona una configuración preconfigurada para todas las aplicaciones del usuario o cliente, en este caso se pueden editar acorde a lo que necesitemos. Para crear un dominio, lo primero que debemos hacer es ubicarnos en la instalación de nuestro Glassfish y a continuación ejecutar el comando:

asadmin create-service domain1

Si todo se realizó correctamente, obtendremos el mensaje mostrado en la siguiente imagen:

Ahora inicimos nuestro Glassfish a través del comando:

asadmin start-domain

Si todo se ejecutó correctamente, al acceder a la ruta http://localhost:8080, podremos visualizar la consola de administración de nuestro contenedor de aplicaciones.
Para reiniciar nuestro dominio podemos usar el comando:

asadmin restart-domain domain1

RestController con Spring Boot

2017-11-22T17:58:00.000-05:00

En este post vamos a revisar un ejemplo sencillo de lo que sería los servicios Rest utilizando Spring Framework. Las tecnologías requeridas para este proyecto son:

Spring Boot
H2
Maven
JDK 8

A continuación se muestra la estructura del proyecto Maven. En este proyecto, utilizaremos una base de datos H2 la cual podremos manipular a través de tres servicios Rest ya sea para insertar, consultar un registro o listar una tabla.

El archivo POM de dependencias Maven es el siguiente:

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
 <modelVersion>4.0.0</modelVersion>
 <groupId>com.rolandopalermo.git</groupId>
 <artifactId>base-api-rest-springboot</artifactId>
 <version>0.0.1-SNAPSHOT</version>
 <packaging>jar</packaging>
 
 <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.4.0.RELEASE</version>
    </parent>
    
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
    </properties>
    
 <dependencies>
  
  <dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-data-jpa</artifactId>
  </dependency>
 
  <dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-web</artifactId>
  </dependency>
  
  <dependency>
   <groupId>com.h2database</groupId>
   <artifactId>h2</artifactId>
  </dependency>
 </dependencies>
 <build>
  <finalName>base-api-rest-springboot</finalName>
 </build>
</project>

La clase principal utilizada para iniciar Spring Boot es la siguiente:

package com.rolandopalermo.rest.base;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class Application {

 public static void main(String[] args) {
  SpringApplication.run(Application.class, args);
 }

}

La siguiente clase representa el bean que será utilizado para manipular nuestra base de datos. Este bean utilizará anotaciones las cuales le permitirán validar la correcta estructura de campos en cualquier instancia así como también manipular este bean como objeto JSON.

package com.rolandopalermo.rest.base.model;

import java.util.Date;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.validation.constraints.Max;
import javax.validation.constraints.Min;
import javax.validation.constraints.NotNull;
import javax.validation.constraints.Past;

import org.hibernate.validator.constraints.NotBlank;

import com.fasterxml.jackson.annotation.JsonFormat;
import com.fasterxml.jackson.annotation.JsonProperty;

@Entity
public class User {

 @Id
 @GeneratedValue(strategy = GenerationType.AUTO)
 private Long id;

 @JsonProperty("user_name")
 @NotBlank
 private String userName;

 @JsonProperty("last_name")
 @NotBlank
 private String lastName;

 @JsonProperty("gender")
 @NotNull
 private Gender gender;

 @JsonProperty("age")
 @Min(value = 18)
 @Max(value = 150)
 @NotNull
 private Integer age;

 @JsonProperty("birth")
 @JsonFormat(shape = JsonFormat.Shape.STRING, pattern = "dd-MM-yyyy")
 @Past
 @NotNull
 private Date dateOfBirth;

 public Long getId() {
  return id;
 }

 public void setId(Long id) {
  this.id = id;
 }

 public String getUserName() {
  return userName;
 }

 public void setUserName(String userName) {
  this.userName = userName;
 }

 public String getLastName() {
  return lastName;
 }

 public void setLastName(String lastName) {
  this.lastName = lastName;
 }

 public Gender getGender() {
  return gender;
 }

 public void setGender(Gender gender) {
  this.gender = gender;
 }

 public Integer getAge() {
  return age;
 }

 public void setAge(Integer age) {
  this.age = age;
 }

 public Date getDateOfBirth() {
  return dateOfBirth;
 }

 public void setDateOfBirth(Date dateOfBirth) {
  this.dateOfBirth = dateOfBirth;
 }

}

package com.rolandopalermo.rest.base.model;

public enum Gender {
    MALE, FEMALE;
}

Esta clase se encargá de definir los métodos para acceder a base de datos. En este caso se reutilizará la clase genérica CrudRepository.

package com.rolandopalermo.rest.base.repository;

import org.springframework.data.repository.CrudRepository;

import com.rolandopalermo.rest.base.model.User;
 
public interface UserRepository extends CrudRepository<User, Long> {
 
}

La clase UserService conformará la capa de servicio y es en donde se invocará a los métodos definidos en la clase UserRepository que vendría siendo nuestra capa de datos.

package com.rolandopalermo.rest.base.service;

import java.util.ArrayList;
import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import com.rolandopalermo.rest.base.model.User;
import com.rolandopalermo.rest.base.repository.UserRepository;

@Service
public class UserService {

 @Autowired
 private UserRepository repository;

 public User get(long userId) {
  return repository.findOne(userId);
 }

 public List<User> list() {
  Iterable<User> users = repository.findAll();
  List<User> list = new ArrayList<User>();
  for(User user : users) {
   list.add(user);
  }
  return list;
 }

 public User create(User user) {
  return repository.save(user);
 }
}

La clase UserController expondrá los diversos métodos para manipular la tabla de Usuarios. Estos serán para insertar, consultar un registro o listarlos todos. Estos servicios serán expuestos a través de los métodos POST y GET.

package com.rolandopalermo.rest.base.controller;

import java.util.List;

import javax.validation.Valid;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import com.rolandopalermo.rest.base.model.User;
import com.rolandopalermo.rest.base.service.UserService;

@RestController
public class UserController {

 @Autowired
 private UserService userService;

 @RequestMapping(value = "/users", method = RequestMethod.GET)
 public ResponseEntity<User> list() {
  List<User> users = userService.list();
  return new ResponseEntity(users, HttpStatus.OK);
 }

 @RequestMapping(value = "/user", method = RequestMethod.GET)
 public ResponseEntity<User> userById(@RequestParam(value = "id") long id) {
  User user = userService.get(id);
  return new ResponseEntity(user, HttpStatus.OK);
 }

 @RequestMapping(value = "/create", method = RequestMethod.POST)
 public ResponseEntity<User> create(@Valid @RequestBody User user) {
  User userCreated = userService.create(user);
  return new ResponseEntity(userCreated, HttpStatus.CREATED);
 }

}

Al ejecutar el proyecto, tendremos lo siguiente:

Al enviar la siguiente petición utilizando POSTMAN, el resultado será el siguiente:

{
   "id":1,
   "user_name":"Juan",
   "last_name":"Perez",
   "gender":"MALE",
   "age":23,
   "birth":"12-10-1994"
}

Cuando consultemos los registros ingresados, obtendremos lo siguiente:

[
    {
        "id": 1,
        "user_name": "Juan",
        "last_name": "Perez",
        "gender": "MALE",
        "age": 23,
        "birth": "12-10-1994"
    },
    {
        "id": 2,
        "user_name": "Juan",
        "last_name": "De Arco",
        "gender": "FEMALE",
        "age": 23,
        "birth": "12-10-1994"
    }
]

Creating Web Services with PHP and SOAP

2017-11-14T21:37:00.000-05:00

There are two basic approaches that are used to create web services from scratch. In this first of a two part series on web services I’ll talk about the 'top-down' approach. According with this approach, we need to produce the XML description of the service before it is implemented. So the service is fully described in terms of what it does, how it can be called and what result(s) it returns, but is not actually implemented. This (WSDL) specification is then used as a guide to writing the code that implements the service.

The project structure

The webservice will receive a string parameter and it will return the 'hello' string concatenated with the input parameter. For example, if the input is 'Andrea', then the output will be 'Hello Andrea'. In order to achieve this, we need to define the WSDL descriptor.

The descriptor.wsdl

<?xml version="1.0" encoding="UTF-8"?>
<wsdl:definitions name="HelloWS"
      targetNamespace="http://ws.rolandopalermo.com/"
      xmlns:tns="http://ws.rolandopalermo.com/"
                  xmlns:xsd="http://www.w3.org/2001/XMLSchema"
                  xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/"
                  xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/">

 <wsdl:types>
 </wsdl:types>
  
 <wsdl:message name="helloRequest">
  <wsdl:part name="name" type="xsd:string"></wsdl:part>
 </wsdl:message>
 
 <wsdl:message name="helloResponse">
  <wsdl:part name="result" type="xsd:string"></wsdl:part>
 </wsdl:message>
  
 <wsdl:portType name="HelloWS">
  <wsdl:operation name="hello">
            <wsdl:input message="tns:helloRequest"/>
            <wsdl:output message="tns:helloResponse"/>
        </wsdl:operation>
 </wsdl:portType>
  
 <wsdl:binding name="HelloWSPortBinding" type="tns:HelloWS">
  <soap:binding style="rpc" transport="http://schemas.xmlsoap.org/soap/http"/>
  <wsdl:operation name="hello">
   <soap:operation soapAction="http://localhost/soap_demo/server.php"/>
   <wsdl:input>
    <soap:body use="literal"/>
   </wsdl:input>
   <wsdl:output>
    <soap:body use="literal"/>
   </wsdl:output>
  </wsdl:operation>
 </wsdl:binding>
  
 <wsdl:service name="HelloWS">
  <wsdl:port name="HelloWSPort" binding="tns:HelloWSPortBinding">
   <soap:address location="http://localhost/soap_demo/server.php"/>
  </wsdl:port>
 </wsdl:service>
 
</wsdl:definitions>

We also need to implement the hello method in a php file.

The server.php file

<?php
// turn off WSDL caching
ini_set("soap.wsdl_cache_enabled","0");

function hello($name)
{
 return 'Hello '.' '.$name;
}

// initialize SOAP Server
$server = new SoapServer("descriptor.wsdl",[]);
// register available functions
$server->addFunction('hello');
// start handling requests
$server->handle();

Now, we can import the WSDL file into SoapUI for example and the results should look like this:

The SOAP request.

<soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/" xmlns:ws="http://ws.rolandopalermo.com/">
   <soapenv:Header/>
   <soapenv:Body>
      <ws:hello>
         <name>Andrea</name>
      </ws:hello>
   </soapenv:Body>
</soapenv:Envelope>

The SOAP response.

<SOAP-ENV:Envelope xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/">
   <SOAP-ENV:Body>
      <SOAP-ENV:helloResponse>
         <result>Hello  Andrea</result>
      </SOAP-ENV:helloResponse>
   </SOAP-ENV:Body>
</SOAP-ENV:Envelope>

Do not forget to enable the SOAP extension in the php.ini file. To do this, you have to find extension=php_soap.dll in php.ini, remove the semicolon(;) and restart the server.

Nuevo Esquema Offline de Documentos Electrónicos | SRI

2017-07-09T21:44:00.003-05:00

Desde la publicación de la Resolución NAC-DGERCGC14-00790, el SRI puso en marcha un nuevo esquema para la emisión de comprobantes electrónicos: el esquema Off-line. Actualmente este esquema, con el propósito de que los emisores de comprobantes que lo deseen puedan realizar pruebas y ajustar sus servicios a este nuevo esquema, está disponible en las siguientes URL's:

Uno es para el ambiente de Pruebas en donde cada contribuyente certificará que su aplicación funcione correctamente con cada tipo de comprobante electrónico.

https://celcer.sri.gob.ec/comprobantes-electronicos-ws/RecepcionComprobantesOffline?wsdl
https://celcer.sri.gob.ec/comprobantes-electronicos-ws/AutorizacionComprobantesOffline?wsdl

El segundo es para el ambiente de Producción, al cual cada contribuyente deberá acceder una vez que ha realizado las pruebas y esté seguro que su aplicación funciona correctamente, las direcciones del los WS son las siguientes:

https://cel.sri.gob.ec/comprobantes-electronicos-ws/RecepcionComprobantesOffline?wsdl
https://cel.sri.gob.ec/comprobantes-electronicos-ws/AutorizacionComprobantesOffline?wsdl

Con el nuevo esquema Off-line, se puede generar un comprobante en tres sencillos pasos; ya que el cambio más significativo se encuentra en que los comprobantes serán enviados al mismo tiempo tanto al receptor como al SRI. Es decir, el mismo comprobante que recibe el SRI para su validación es el que recibirán sus socios de negocio.

Figura 1. Diferencias entre el esquema ONLINE y el nuevo esquema OFFLINE (Fuente: SRI)

En RP Consulting ya disponemos del nuevo esquema Off-line. Más de 20 clientes en Ecuador confirman la calidad de nuestro servicio de consultoría y capacitación en temas de facturación electrónica.

Te invitamos a ponerte en contacto con nosotros en el siguiente formulario para evaluar la integración de este nuevo esquema, ya sea a través de librerías, dll, apis o servicios Web. Contamos con los consultores más especializados en el tema.

Datos de contacto

Skype	rolandopalermo
Email	rolando.roc@gmail.com
Facebook	fb.com/rolandopalermo
Licenciamiento	No posee restricciones de licencia

HTML y Latex: MathJax

2017-05-01T10:50:00.001-05:00

MathJax es un motor de visualización JavaScript de código abierto para la notación LaTeX, MathML y AsciiMath que funciona en todos los navegadores modernos. Para utilizar este motor, basta con agregarel código que muestro a continuación:

<script type="text/x-mathjax-config">
   MathJax.Hub.Config({"HTML-CSS": { preferredFont: "TeX", availableFonts: ["STIX","TeX"], linebreaks: { automatic:true }, EqnChunk: (MathJax.Hub.Browser.isMobile ? 10 : 50) },
       tex2jax: { inlineMath: [ ["$", "$"], ["\\(","\\)"] ], displayMath: [ ["$$","$$"], ["\[", "\]"] ], processEscapes: true, ignoreClass: "tex2jax_ignore|dno" },
       TeX: { 
           noUndefined: { attributes: { mathcolor: "red", mathbackground: "#FFEEEE", mathsize: "90%" } }, Macros: { href: "{}" } },
       messageStyle: "none"
   });
</script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/MathJax.js?config=TeX-AMS_HTML-full"></script>

Los resultados son tan asombrosos como los ejemplos que muestro a continuación:

<p>
When (a ne 0), there are two solutions to (ax^2 + bx + c = 0) and they are
$$x = {-b pm sqrt{b^2-4ac} over 2a}.$$
</p>

$$\text{When }(a \ne 0)\text{, there are two solutions to }(ax^2 + bx + c = 0)\text{ and they are}$$ $$x = {-b \pm \sqrt{b^2-4ac} \over 2a}.$$

<p>
$$sum_{i=0}^n i^2 = frac{(n^2+n)(2n+1)}{6}$$
</p>

$$\sum_{i=0}^n i^2 = \frac{(n^2+n)(2n+1)}{6}$$

<p>
$$sum_{i=0}^n i^2 = frac{(n^2+n)(2n+1)}{6}$$
</p>

$$\sum_{i=0}^n i^2 = \frac{(n^2+n)(2n+1)}{6}$$

<p>
$$
begin{array}{c|lcr}
n & text{Left} & text{Center} & text{Right} \
hline
1 & 0.24 & 1 & 125 \
2 & -1 & 189 & -8 \
3 & -20 & 2000 & 1+10i
end{array}
$$
</p>

$$ \begin{array}{c|lcr} n & \text{Left} & \text{Center} & \text{Right} \\ \hline 1 & 0.24 & 1 & 125 \\ 2 & -1 & 189 & -8 \\ 3 & -20 & 2000 & 1+10i \end{array} $$

<p>
$$underset{j=1}{overset{infty}{LARGEmathrm K}}frac{a_j}{b_j}=cfrac{a_1}{b_1+cfrac{a_2}{b_2+cfrac{a_3}{b_3+ddots}}}$$
</p>

$$\underset{j=1}{\overset{\infty}{\LARGE\mathrm K}}\frac{a_j}{b_j}=\cfrac{a_1}{b_1+\cfrac{a_2}{b_2+\cfrac{a_3}{b_3+\ddots}}}$$

<p>
$require{AMScd}$
begin{CD}
A @&gt;a&gt;&gt; B\
@V b V V= @VV c V\
C @&gt;&gt;d&gt; D
end{CD}
</p>

$\require{AMScd}$ \begin{CD} A @>a>> B\\ @V b V V= @VV c V\\ C @>>d> D \end{CD}

Un claro ejemplo donde podemos visualizar MathJax en todo su potencial es en math.stackexchange.com. Les invito a revisar el proyecto que definitivamente es de mucha ayuda a la publicación de resultados para la gente inmersa en la ciencia.

Raphael JS Pie Chart and Spring MVC

2017-04-30T23:34:00.001-05:00

Raphael JS is a lightweight JavaScript framework which allows you to draw vector graphics in a browser. In this post, I will introduce you a basic example in order to explain how to create a Pie Chart from a given set of data which will be provided by a Spring Controller and a Ajax calling.

Required Software to Run Example:

Java 7
Eclipse Mars
Apache Tomcat 8.0
Maven
Raphael JS

Project Structure in Netbeans

POM.xml

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
 <modelVersion>4.0.0</modelVersion>
 <groupId>com.rolandopalermo.web</groupId>
 <artifactId>spring-raphael</artifactId>
 <packaging>war</packaging>
 <version>0.0.1-SNAPSHOT</version>
 <name>spring-raphael Maven Webapp</name>
 <url>http://maven.apache.org</url>
 <dependencies>
  <dependency>
   <groupId>javax.servlet</groupId>
   <artifactId>jstl</artifactId>
   <version>1.2</version>
  </dependency>
  <dependency>
   <groupId>junit</groupId>
   <artifactId>junit</artifactId>
   <version>3.8.1</version>
   <scope>test</scope>
  </dependency>
  <!-- Spring -->
  <dependency>
   <groupId>org.springframework</groupId>
   <artifactId>spring-core</artifactId>
   <version>4.3.5.RELEASE</version>
  </dependency>
  <dependency>
   <groupId>org.springframework</groupId>
   <artifactId>spring-webmvc</artifactId>
   <version>4.3.5.RELEASE</version>
  </dependency>
  <!-- JSON -->
  <dependency>
   <groupId>com.fasterxml.jackson.core</groupId>
   <artifactId>jackson-core</artifactId>
   <version>2.7.3</version>
  </dependency>
  <dependency>
   <groupId>com.fasterxml.jackson.core</groupId>
   <artifactId>jackson-databind</artifactId>
   <version>2.7.3</version>
  </dependency>
 </dependencies>
 <build>
  <finalName>spring-raphael</finalName>
 </build>
</project>

Pie.js

Raphael.fn.pieChart = function(cx, cy, r, values, labels, stroke) {
 var paper = this;
 var rad = Math.PI / 180;// degrees to radians
 var chart = this.set();
 var angle = 0, total = 0, start = 0;
 // Draw a sector
 function sector(cx, cy, r, startAngle, endAngle, params) {
  console.log(params.fill);
  var x1 = cx + r * Math.cos(-startAngle * rad), x2 = cx + r
    * Math.cos(-endAngle * rad), y1 = cy + r
    * Math.sin(-startAngle * rad), y2 = cy + r
    * Math.sin(-endAngle * rad);
  return paper.path(
    [ "M", cx, cy, "L", x1, y1, "A", r, r, 0,
      +(endAngle - startAngle > 180), 0, x2, y2, "z" ]).attr(
    params);
 }

 process = function(j) {
  var value = values[j], angleplus = 360 * value / total, popangle = angle
    + (angleplus / 2), color = Raphael.hsb(start, .75, 1), ms = 500, delta = 30, bcolor = Raphael
    .hsb(start, 1, 1), p = sector(cx, cy, r, angle, angle
    + angleplus, {
   fill : "90-" + bcolor + "-" + color,
   stroke : stroke,
   "stroke-width" : 3
  }), txt = paper.text(cx + (r + delta + 55) * Math.cos(-popangle * rad),
    cy + (r + delta + 25) * Math.sin(-popangle * rad), labels[j])
    .attr({
     fill : bcolor,
     stroke : "none",
     opacity : 0,
     "font-size" : 20
    });
  p.mouseover(function() {
   p.stop().animate({
    transform : "s1.1 1.1 " + cx + " " + cy
   }, ms, "elastic");
   txt.stop().animate({
    opacity : 1
   }, ms, "elastic");
  }).mouseout(function() {
   p.stop().animate({
    transform : ""
   }, ms, "elastic");
   txt.stop().animate({
    opacity : 0
   }, ms);
  });
  angle += angleplus;
  chart.push(p);
  chart.push(txt);
  start += .1;
 };
 for (var i = 0, ii = values.length; i < ii; i++) {
  total += values[i];
 }
 for (i = 0; i < ii; i++) {
  process(i);
 }
 return chart;
};

$(function() {
 $.ajax({
  method: "POST",
        url: 'get-full-report',
        dataType: 'json',
        crossDomain: true,
        beforeSend: function (xhr) {
            //Set authentication headers
        },
        success: function (data, textStatus, jqXHR) {
         if (data.error) {
                alert(data.message);
            } else {
             var values = [], labels = [];
             $.each(data, function(i, item) {
              values.push(parseInt(data[i].percentageOfUse, 10));
              labels.push(data[i].name);
             });
             Raphael("holder", 700, 700).pieChart(350, 350, 200, values, labels, "#fff");
            }
        },
        error: function (xhr) { // if error occured
            alert('No se pudo procesar la solicitud.');
        },
        complete: function () {
        },
        xhrFields: {
            withCredentials: true
        }
 });
});

Spring Controller

package com.rolandopalermo.web.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.CrossOrigin;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.servlet.ModelAndView;

import com.rolandopalermo.web.bean.Language;
import com.rolandopalermo.web.util.ReportUtil;
import com.rolandopalermo.web.util.ResponseList;

@Controller
public class HomeController {

 @RequestMapping(value = { "/", "/home" }, method = RequestMethod.GET)
 public ModelAndView home() {
  ModelAndView model = new ModelAndView();
  model.setViewName("index");
  return model;
 }

 @RequestMapping(value = { "get-full-report" }, method = RequestMethod.POST)
 @CrossOrigin(origins = "*", allowCredentials = "true")
 @ResponseBody
 public String getReport() {
  String jsonResponse = "";
  ResponseList<Language> list = ReportUtil.generateReport();
  if (list == null || list.isEmpty()) {
   jsonResponse = "{"error" : true, "message": "No available data"}";
  } else {
   jsonResponse = list.toString();
  }
  return jsonResponse;
 }

}

And your output should look like:

Download the full source code from Github and enjoy it! https://github.com/rolandopalermo/spring-raphael

How to use Jquery datatable in Spring MVC

2017-04-24T21:47:00.002-05:00

Creating a table data along with features like pagination, filtering the records, sorting, no of records to show etc. is a challenger job for developers because it involves lot of designs and coding. But now it becomes very easy to develop with the help of jQuery datatable plugin. In this post we will show how to use jQuery datatable in Spring MVC 4 application.

Required Software to Run Example:

Java 7
Netbeans
Maven
MySQL

Project Structure in Netbeans

POM.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.rolandopalermo.web</groupId>
    <artifactId>spring-datatable</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>war</packaging>

    <name>spring-datatable</name>

    <properties>
        <endorsed.dir>${project.build.directory}/endorsed</endorsed.dir>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>
    
    <dependencies>
        <dependency>
            <groupId>javax</groupId>
            <artifactId>javaee-web-api</artifactId>
            <version>7.0</version>
            <scope>provided</scope>
        </dependency>
        
        <!-- Spring -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>4.3.5.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>4.3.5.RELEASE</version>
        </dependency>
        
        <!-- Jackson -->
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-core</artifactId>
            <version>2.7.3</version>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>2.7.3</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.1</version>
                <configuration>
                    <source>1.7</source>
                    <target>1.7</target>
                    <compilerArguments>
                        <endorseddirs>${endorsed.dir}</endorseddirs>
                    </compilerArguments>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-war-plugin</artifactId>
                <version>2.3</version>
                <configuration>
                    <failOnMissingWebXml>false</failOnMissingWebXml>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-dependency-plugin</artifactId>
                <version>2.6</version>
                <executions>
                    <execution>
                        <phase>validate</phase>
                        <goals>
                            <goal>copy</goal>
                        </goals>
                        <configuration>
                            <outputDirectory>${endorsed.dir}</outputDirectory>
                            <silent>true</silent>
                            <artifactItems>
                                <artifactItem>
                                    <groupId>javax</groupId>
                                    <artifactId>javaee-endorsed-api</artifactId>
                                    <version>7.0</version>
                                    <type>jar</type>
                                </artifactItem>
                            </artifactItems>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
</project>

POJO Class used in Example

package com.rolandopalermo.domain;

import com.rolandopalermo.util.EmployeeStatus;
import com.rolandopalermo.util.JsonConverter;
import java.io.Serializable;

/**
 *
 * @author rolan
 */
public class Employee implements Serializable {

    private int id;
    private String name;
    private String surname;
    private int age;
    private String address;
    private EmployeeStatus status;

    public Employee(int id, String name, String surname, int age, String address, EmployeeStatus status) {
        this.id = id;
        this.name = name;
        this.surname = surname;
        this.age = age;
        this.address = address;
        this.status = status;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getSurname() {
        return surname;
    }

    public void setSurname(String surname) {
        this.surname = surname;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }
    
    public EmployeeStatus getStatus() {
        return status;
    }

    public void setStatus(EmployeeStatus status) {
        this.status = status;
    }

    @Override
    public String toString() {
        String json = JsonConverter.INSTANCE.asJsonString(this);
        return json;
    }

}

Spring MVC Controller

package com.rolandopalermo.controller;

import com.rolandopalermo.domain.Employee;
import com.rolandopalermo.test.DummyDAO;
import com.rolandopalermo.util.ResponseList;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.CrossOrigin;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.servlet.ModelAndView;

/**
 *
 * @author rolan
 */
@Controller
public class HomeController {

    @RequestMapping(value = {"/", "/home"}, method = RequestMethod.GET)
    public ModelAndView home() {
        ModelAndView model = new ModelAndView();
        model.setViewName("home");
        return model;
    }

    @RequestMapping(value = {"/get-all-employees"}, method = RequestMethod.POST)
    @CrossOrigin(origins = "*", allowCredentials = "true")
    @ResponseBody
    public String getAllEmployees(HttpServletRequest request, HttpServletResponse response) {
        String json;
        try {
            ResponseList<Employee> lstInvoices = DummyDAO.getAllEmployees();
            json = lstInvoices.toString();
        } catch (Exception e) {
            json = "{"error" : true, "message": "" + e.getMessage() + "."}";
        }
        return json;
    }
}

Javascript

$(document).ready(function () {
    $.ajax({
        method: "POST",
        url: 'get-all-employees',
        dataType: 'json',
        crossDomain: true,
        beforeSend: function (xhr) {
            //Set authentication headers
        },
        success: function (data, textStatus, jqXHR) {
            if (data.error) {
                alert(data.message);
            } else {
                var selector = $("#applications");
                selector.html("");
                selector.append(JSON.stringify(data));
                data = $.parseJSON(selector.text());
                console.log(data);
                table = $("#employees").DataTable({
                    data: data,
                    scrollX: true,
                    scrollCollapse: true,
                    fixedColumns: true,
                    columns: [{
                            data: "id",
                            visible: false
                        }, {
                            data: "name"
                        }, {
                            data: "surname"
                        }, {
                            data: "age"
                        }, {
                            data: "address"
                        }, {
                            data: "status",
                            render: function (value) {
                                switch (value) {
                                    case "ACTIVE":
                                        return '<span class=active></span>';
                                    case "PENDING":
                                        return '<span class=pending></span>';
                                    case "INACTIVE":
                                        return '<span class=inactive></span>';
                                    case "DELETED":
                                        return '<span class=deleted></span>';
                                    default:
                                        return '<span class=active></span>';
                                }
                            }
                        }
                    ]
                });
            }
        },
        error: function (xhr) { // if error occured
            alert('No se pudo procesar la solicitud.');
        },
        complete: function () {
        },
        xhrFields: {
            withCredentials: true
        }
    });
});

WebAppInitializer

<%-- 
    Document   : view
    Created on : Jan 20, 2017, 7:15:31 PM
    Author     : Rolando
--%>

<%@ page language="java" pageEncoding="UTF-8" contentType="text/html;charset=UTF-8" %>
<%@taglib prefix="spring" uri="http://www.springframework.org/tags"%>
<%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
<script type="text/javascript" src="<c:url value='/static/app/third-party/js/jquery-1.12.4.js' />"></script>
<script type="text/javascript" src="<c:url value='/static/app/third-party/datatables/js/jquery.dataTables.min.js' />"></script>
<script type="text/javascript" src="<c:url value='/static/app/third-party/datatables/js/dataTables.buttons.min.js' />"></script>
<script type="text/javascript" src="<c:url value='/static/app/js/home.js' />"></script>
<link href="<c:url value='/static/app/third-party/datatables/css/jquery.dataTables.min.css'/>" rel="stylesheet"/>
<link href="<c:url value='/static/app/third-party/datatables/css/buttons.dataTables.min.css'/>" rel="stylesheet"/>
<link href="<c:url value='/static/app/css/master.css'/>" rel="stylesheet"/>

<!DOCTYPE html>
<html>
    <head>
        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"/>
        <title>How to use Jquery datatable in Spring MVC</title>
    </head>
    <body>
        <div id="applications" style="display: none"></div>
        <table id="employees" cellspacing="0" width="100%">
            <thead>
                <tr>
                    <th>ID</th>
                    <th>Name</th>
                    <th>Surname</th>
                    <th>Age</th>
                    <th>Address</th>
                    <th>Status</th>
                </tr>
            </thead>
            <tbody>
            </tbody>
        </table>
    </body>
</html>

And your output should looks like:

Download the full source code from Github and enjoy it! https://github.com/rolandopalermo/spring-datatable

Spring 4 and MyBatis Java Full Annotations

2017-04-23T18:06:00.000-05:00

In this post, we will provide MyBatis 3 annotations example with a simple application example. These annotations are declared in interface on methods for select, insert, update and delete operation. Now this interface will act as Mapper for SQL queries. We need to register mapper interface in MyBatis configuration XML. To map POJO and table columns, MyBatis provides Results annotation which works same as Resultmap tag in XML mapper. @Results helps to get query result by @Select annotation.

Required Software to Run Example:

Java 7
Netbeans
Maven
MySQL

Project Structure in Netbeans

Table Schema

CREATE TABLE `mybatis-spring`.`product` (
  `id` INTEGER UNSIGNED NOT NULL AUTO_INCREMENT,
  `name` VARCHAR(45) NOT NULL,
  `price` DOUBLE NOT NULL,
  `description` TEXT NOT NULL,
  PRIMARY KEY (`id`)
)
ENGINE = InnoDB;

POM.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.rolandopalermo.web</groupId>
    <artifactId>spring-mybatis</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>war</packaging>

    <name>spring-mybatis</name>

    <properties>
        <endorsed.dir>${project.build.directory}/endorsed</endorsed.dir>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <mysql.connector.version>5.1.31</mysql.connector.version>
    </properties>
    
    <dependencies>
        <dependency>
            <groupId>javax</groupId>
            <artifactId>javaee-web-api</artifactId>
            <version>7.0</version>
            <scope>provided</scope>
        </dependency>
        
        <!-- Spring -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>4.3.5.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>4.3.5.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>4.2.1.RELEASE</version>
            <type>jar</type>
            <scope>compile</scope>
        </dependency>
        
        <!-- Mybatis -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.3.0</version>
        </dependency>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>1.2.2</version>
        </dependency>
        
        <!-- MySQL -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>${mysql.connector.version}</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.1</version>
                <configuration>
                    <source>1.7</source>
                    <target>1.7</target>
                    <compilerArguments>
                        <endorseddirs>${endorsed.dir}</endorseddirs>
                    </compilerArguments>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-war-plugin</artifactId>
                <version>2.3</version>
                <configuration>
                    <failOnMissingWebXml>false</failOnMissingWebXml>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-dependency-plugin</artifactId>
                <version>2.6</version>
                <executions>
                    <execution>
                        <phase>validate</phase>
                        <goals>
                            <goal>copy</goal>
                        </goals>
                        <configuration>
                            <outputDirectory>${endorsed.dir}</outputDirectory>
                            <silent>true</silent>
                            <artifactItems>
                                <artifactItem>
                                    <groupId>javax</groupId>
                                    <artifactId>javaee-endorsed-api</artifactId>
                                    <version>7.0</version>
                                    <type>jar</type>
                                </artifactItem>
                            </artifactItems>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
</project>

POJO Class used in Example

package com.rolandopalermo.web.domain;

/**
 *
 * @author rolan
 */
public class Product {

    private long id;
    private String name;
    private double price;
    private String description;

    public long getId() {
        return id;
    }

    public void setId(long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    public String getDescription() {
        return description;
    }

    public void setDescription(String description) {
        this.description = description;
    }

}

Mapper Interface Using MyBatis Annotation

package com.rolandopalermo.web.mapper;

import com.rolandopalermo.web.domain.Product;
import java.util.List;
import org.apache.ibatis.annotations.Delete;
import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Result;
import org.apache.ibatis.annotations.Results;
import org.apache.ibatis.annotations.Select;
import org.apache.ibatis.annotations.Update;

/**
 *
 * @author rolan
 */
public interface ProductMapper {

    @Results({
        @Result(property = "id", column = "id"),
        @Result(property = "name", column = "name"),
        @Result(property = "price", column = "price"),
        @Result(property = "description", column = "description")
    })
    @Select("SELECT id, name, price, description from product WHERE id = #{id}")
    Product selectProduct(int id);

    @Insert("INSERT into product(name, price, description) VALUES(#{name}, #{price}, #{description})")
    void insertProduct(Product product);

    @Update("UPDATE product SET name=#{name}, price =#{price}, description =#{description} WHERE id =#{id}")
    void updateProduct(Product product);

    @Delete("DELETE FROM product WHERE id =#{id}")
    void deleteProduct(int id);
    
    @Results({
        @Result(property = "id", column = "id"),
        @Result(property = "name", column = "name"),
        @Result(property = "price", column = "price"),
        @Result(property = "description", column = "description")
    })
    @Select("SELECT id, name, price, description from product")
    List<Product> selectAllProduct();

}

DataConfig

import javax.sql.DataSource;
import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
//import org.apache.commons.dbcp.BasicDataSource;
import org.mybatis.spring.annotation.MapperScan;
import org.mybatis.spring.transaction.SpringManagedTransactionFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.jdbc.datasource.DriverManagerDataSource;

/**
 *
 * @author Rolando
 */
@Configuration
@PropertySource("classpath:data.properties")
@MapperScan(basePackages = {"com.rolandopalermo.web.mapper"}, sqlSessionFactoryRef = "sqlSessionFactory")
public class DataConfig {

    @Value("${mysql.driver}")
    private String driver;

    @Value("${mysql.url}")
    private String url;

    @Value("${mysql.user}")
    private String username;

    @Value("${mysql.password}")
    private String password;

    @Bean
    public DataSource dataSource() {
        DriverManagerDataSource dataSource = new DriverManagerDataSource();
        dataSource.setDriverClassName(driver);
        dataSource.setUrl(url);
        dataSource.setUsername(username);
        dataSource.setPassword(password);
        return dataSource;
    }

    @Bean
    public DataSourceTransactionManager transactionManager() {
        return new DataSourceTransactionManager(dataSource());
    }

    @Bean
    public SqlSessionFactory sqlSessionFactory(DataSource dataSource) throws Exception {
        SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
        sqlSessionFactoryBean.setDataSource(dataSource);
        sqlSessionFactoryBean.setTransactionFactory(new SpringManagedTransactionFactory());
        return sqlSessionFactoryBean.getObject();
    }

}

MvcConfig

package com.rolandopalermo.web.config;

import org.springframework.context.MessageSource;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.support.ReloadableResourceBundleMessageSource;
import org.springframework.web.servlet.config.annotation.DefaultServletHandlerConfigurer;
import org.springframework.web.servlet.config.annotation.EnableWebMvc;
import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;
import org.springframework.web.servlet.view.InternalResourceViewResolver;

/**
 *
 * @author Rolando
 */
@Configuration
@EnableWebMvc
@ComponentScan(basePackages = {"com.rolandopalermo.web"})
public class MvcConfig extends WebMvcConfigurerAdapter {

    @Override
    public void addResourceHandlers(ResourceHandlerRegistry registry) {
        registry.addResourceHandler("/resources/**").addResourceLocations("/resources/");
    }

    @Override
    public void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) {
        configurer.enable();
    }

    @Bean
    public InternalResourceViewResolver jspViewResolver() {
        InternalResourceViewResolver bean = new InternalResourceViewResolver();
        bean.setPrefix("/WEB-INF/jsp/");
        bean.setSuffix(".jsp");
        return bean;
    }

    @Bean
    public MessageSource messageSource() {
        ReloadableResourceBundleMessageSource messageSource = new ReloadableResourceBundleMessageSource();
        messageSource.setBasename("classpath:messages");
        messageSource.setDefaultEncoding("UTF-8");
        return messageSource;
    }

}

WebAppInitializer

package com.rolandopalermo.web.config;

import javax.servlet.ServletContext;
import javax.servlet.ServletRegistration;
import org.springframework.web.WebApplicationInitializer;
import org.springframework.web.context.ContextLoaderListener;
import org.springframework.web.context.support.AnnotationConfigWebApplicationContext;
import org.springframework.web.servlet.DispatcherServlet;

/**
 *
 * @author Rolando
 */
public class WebAppInitializer implements WebApplicationInitializer {

    @Override
    public void onStartup(ServletContext container) {
        // Create the 'root' Spring application context
        AnnotationConfigWebApplicationContext rootContext = new AnnotationConfigWebApplicationContext();
//        rootContext.register(ServiceConfig.class, JPAConfig.class, SecurityConfig.class);
        rootContext.register(MvcConfig.class, DataConfig.class);
        // Manage the lifecycle of the root application context
        container.addListener(new ContextLoaderListener(rootContext));
        // Create the dispatcher servlet's Spring application context
        AnnotationConfigWebApplicationContext dispatcherServlet = new AnnotationConfigWebApplicationContext();
        dispatcherServlet.register(MvcConfig.class);
        // Register and map the dispatcher servlet
        ServletRegistration.Dynamic dispatcher = container.addServlet("dispatcher", new DispatcherServlet(dispatcherServlet));
        dispatcher.setLoadOnStartup(1);
        dispatcher.addMapping("/");
    }

}

Home.jsp
Now we will test our application.

<%@page contentType="text/html" pageEncoding="UTF-8"%>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<!DOCTYPE html>
<html>
    <head>
        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
        <title>JSP Page</title>
    </head>
    <body>
        <h1>Products</h1>
        <c:forEach var="item" items="${products}">
            <c:out value="${item.name} ${item.price}"/>
            <br>
        </c:forEach>
    </body>
</html>

And your output should looks like:

Download the full source code from Github and enjoy it! https://github.com/rolandopalermo/spring-mybatis

Integración Java+Azure utilizando REST

2016-10-26T13:45:00.004-05:00

Cuando escuchamos de Azure, inmediatamente se nos viene a la mente el SDK de esta ~~interesante~~ plataforma de Microsoft, sin embargo algunos desarrolladores preferimos invocar a los servicios de Azure directamente desde su API REST, sin utilizar bibliotecas específicas. En este artículo encontrarás un ejemplo completo de cómo comunicarnos con Azure Blob Storage.

A continuación, se muestra la clase java que se encarga de realizar la comunicación:

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
package util;

import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.TimeZone;
import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
import org.apache.commons.codec.binary.Base64;

/**
 *
 * @author Rolando
 */
public class Util {

    private static Base64 base64 = new Base64();

    public static void signRequestSK(HttpURLConnection request, String account, String key) throws Exception {
        SimpleDateFormat fmt = new SimpleDateFormat("EEE, dd MMM yyyy HH:mm:ss");
        fmt.setTimeZone(TimeZone.getTimeZone("GMT"));
        String date = fmt.format(Calendar.getInstance().getTime()) + " GMT";

        StringBuilder sb = new StringBuilder();
        sb.append("GET\n"); // method
        sb.append("\n"); // content encoding
        sb.append("\n"); // content language
        sb.append("\n"); // content length
        sb.append("\n"); // md5 (optional)
        sb.append("\n"); // content type
        sb.append("\n"); // legacy date
        sb.append("\n"); // if-modified-since
        sb.append("\n"); // if-match
        sb.append("\n"); // if-none-match
        sb.append("\n"); // if-unmodified-since
        sb.append("\n"); // range
        sb.append("x-ms-date:" + date + "\n"); // headers
        sb.append("x-ms-version:2015-12-11\n");
        sb.append("/" + account + request.getURL().getPath() + "\ncomp:list");
        Mac mac = Mac.getInstance("HmacSHA256");
        mac.init(new SecretKeySpec(base64.decode(key), "HmacSHA256"));
        String authKey = new String(base64.encode(mac.doFinal(sb.toString().getBytes("UTF-8"))));
        String auth = "SharedKey " + account + ":" + authKey;
        request.setRequestProperty("x-ms-date", date);
        request.setRequestProperty("x-ms-version", "2015-12-11");
        request.setRequestProperty("Authorization", auth);
        request.setRequestProperty("Accept-Charset", "UTF-8");
        request.setRequestProperty("Accept", "application/atom+xml,application/xml");
        request.setRequestMethod("GET");
    }

    public static void main(String args[]) throws Exception {
        //To use fiddler
        System.setProperty("http.proxyHost", "127.0.0.1");
        System.setProperty("https.proxyHost", "127.0.0.1");
        System.setProperty("http.proxyPort", "8888");
        System.setProperty("https.proxyPort", "8888");
        //--
        //Inputs
        String account = "<Nombre_Cuenta>";
        String key = "<Access_Key>";
        //--
        HttpURLConnection connection = (HttpURLConnection) (new URL("http://" + account + ".blob.core.windows.net/?comp=list")).openConnection();
        signRequestSK(connection, account, key);
        connection.connect();
        StringBuffer text = new StringBuffer();
        InputStreamReader in = new InputStreamReader((InputStream) connection.getContent());
        BufferedReader buff = new BufferedReader(in);
        String line;
        do {
            line = buff.readLine();
            text.append(line + "\n");
        } while (line != null);
        System.out.println(text);
    }
}

Entonces, si utilizamos Fiddler, podremos ver que este sería el Request:

GET http://"<Nombre_Cuenta>".blob.core.windows.net/?comp=list HTTP/1.1
x-ms-date: Wed, 26 Oct 2016 18:35:49 GMT
x-ms-version: 2015-12-11
Authorization: SharedKey "<Nombre_Cuenta>":psyT2FlwpU3BU7/kKqtfi+ZBTuUpEX8bnsZ45O/1rUk=
Accept-Charset: UTF-8
Accept: application/atom+xml,application/xml
User-Agent: Java/1.8.0_92
Host: "<Nombre_Cuenta>".blob.core.windows.net
Connection: keep-alive

Y el response quedaría de la siguiente manera:

<?xml version="1.0" encoding="UTF-8" ?>
<EnumerationResults ServiceEndpoint="http://"<Nombre_Cuenta>".blob.core.windows.net/">
    <Containers>
        <Container>
            <Name>sas</Name>
            <Properties>
                <Last-Modified>Tue, 25 Oct 2016 19:19:46 GMT</Last-Modified>
                <Etag>"0x8D3FD0BE1F7E8D0"</Etag>
                <LeaseStatus>unlocked</LeaseStatus>
                <LeaseState>available</LeaseState>
            </Properties>
        </Container>
    </Containers>
    <NextMarker />
</EnumerationResults>

Servicios Web REST y PHP

2016-10-21T10:38:00.000-05:00

En este artículo les mostraré cómo implementar una aplicación CRUD con PHP y servicios Web RESTFul. Los requisitos son los siguientes:

PHP 4.0 o superior
MySQL 4.0 o superior
Integración PHP+MySQL realizada correctamente.

Y la estructura de archivos es como se muestra a continuación:

rest_api
|-- dao.php
|-- index.php
|-- model.php
|-- service.php

Como primer paso, crear una base de datos y crear la tabla test con la estructura que se muestra a continuación.

Crear el archivo model.php, en donde se especificará una "clase entidad" que corresponderá con la tabla test de nuestra base de datos [Lo sé, no es java =(]. El hecho de no utilizar el concepto de encapsulación es debido a la versión de PHP que se utilizó para este post (4.0).

<?php

class Test {

    var $id;
    var $nombres;
    var $apellidos;

}

También tendremos una clase PHP exclusivamente para el acceso a base de datos. En el archivo dao.php, se implementarán todas las operaciones sobre base de datos.

<?php

class DAO {

    var $server;
    var $db;
    var $dblog;
    var $dbpass;

    function DAO() {
        $this->server = 'localhost';
        $this->db = 'test';
        $this->dblog = 'root';
        $this->dbpass = '123456';
    }

    function connect() {
        $this->cnn = new MySQL(array('host' => $this->server, 'user' => $this->dblog, 'password' => $this->dbpass, 'database' => $this->db));
    }

    function insert($test) {
        $this->connect();
        $sql = "INSERT INTO test(nombres, apellidos) VALUES ('" . $test->nombres . "','" . $test->apellidos . "'" . ")";
        $rs = $this->cnn->query($sql);
    }

    function findAll() {
        $this->connect();
        $sql = "SELECT * FROM test";
        $result = $this->cnn->query($sql);
        $rs = $result->fetchall(MYSQL_ASSOC);
        return $rs;
    }

    function find($id) {
        $this->connect();
        $sql = "SELECT * FROM test WHERE id=" . $id;
        $result = $this->cnn->query($sql);
        $rs = $result->fetchRow(MYSQL_ASSOC);
        return $rs;
    }

    function update($test) {
        $this->connect();
        $sql = "UPDATE test SET nombres ='" . $test->nombres . "', apellidos='" . $test->apellidos . "' WHERE id='" . $test->id . "'";
        $this->cnn->query($sql);
    }

    function delete($id) {
        $this->connect();
        $sql = "DELETE FROM test WHERE id='" . $id . "'";
        $this->cnn->query($sql);
    }

}

Las funciones de la clase DAO serán invocadas a través de una capa de servicio, la cual se encargará de procesar las peticiones y determinar qué tipo de servicio REST es el consultado. El archivo tendrá el nombre service.php.

<?php

require_once("dao.php");
require_once("model.php");

$method = $_SERVER['REQUEST_METHOD'];

$dao = new DAO();
$json_service = new Services_JSON();

//call DAO based on HTTP method
switch ($method) {
    case 'GET':
        $result = $dao->findAll();
        $json_response = $json_service->encode($result);
        echo $json_response;
        break;
    case 'POST':
        $test = new Test();
        $test->nombres = $_POST['nombres'];
        $test->apellidos = $_POST['apellidos'];
        $dao->insert($test);
        break;
    case 'PUT':
        parse_str(file_get_contents("php://input"), $post_vars);
        $test = new Test();
        $test->id = $post_vars['id'];
        $test->nombres = $post_vars['nombres'];
        $test->apellidos = $post_vars['apellidos'];
        $dao->update($test);
        break;
    case 'DELETE':
        parse_str(file_get_contents("php://input"), $post_vars);
        $id = $post_vars['id'];
        $dao->delete($id);
        break;
}

Finalmente, escribimos la parte de código correspondiente al lado del cliente en el archivo index.php. A través de una URL, accedemos a los servicios publicados y utilizamos sus funcionalidades dependiendo de la manera en cómo los invoquemos. (GET/POST/PUT/DELETE).

<?php

$url = "http://localhost/res_api/service.php";

if (!function_exists('http_build_query')) {

    function http_build_query($data, $prefix = null, $sep = '', $key = '') {
        $ret = array();
        foreach ((array) $data as $k => $v) {
            $k = urlencode($k);
            if (is_int($k) && $prefix != null) {
                $k = $prefix . $k;
            }

            if (!empty($key)) {
                $k = $key . "[" . $k . "]";
            }

            if (is_array($v) || is_object($v)) {
                array_push($ret, http_build_query($v, "", $sep, $k));
            } else {
                array_push($ret, $k . "=" . urlencode($v));
            }
        }

        if (empty($sep)) {
            $sep = ini_get("arg_separator.output");
        }

        return implode($sep, $ret);
    }

}

/* GET Client */
$client = curl_init($url);
curl_setopt($client, CURLOPT_RETURNTRANSFER, 1);
$curl_response = curl_exec($client);
echo $curl_response;

/* POST Client */
$curl_post_data = array(
    'nombres' => 'Roger Manuel',
    'apellidos' => 'Rodriguez Alfaro'
);
$client = curl_init($url);
curl_setopt($client, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($client, CURLOPT_POST, 1);
curl_setopt($client, CURLOPT_POSTFIELDS, $curl_post_data);
$curl_response = curl_exec($client);
echo $curl_response;

/* PUT Client */
$client = curl_init($url);
curl_setopt($client, CURLOPT_RETURNTRANSFER, true);
curl_setopt($client, CURLOPT_CUSTOMREQUEST, "PUT");
$curl_put_data = array(
    'id' => '14',
    'nombres' => 'Enma',
    'apellidos' => 'Cruz Ticle'
);
curl_setopt($client, CURLOPT_POSTFIELDS, http_build_query($curl_put_data));
$curl_response = curl_exec($client);
if ($response === false) {
    $info = curl_getinfo($client);
    curl_close($client);
    die('error occured during curl exec. Additioanl info: ' . var_export($info));
}
curl_close($client);
echo $curl_response;


/* DELETE Client */
$client = curl_init($url);
curl_setopt($client, CURLOPT_RETURNTRANSFER, true);
curl_setopt($client, CURLOPT_CUSTOMREQUEST, "DELETE");
$curl_post_data = array(
    'id' => '15'
);
curl_setopt($client, CURLOPT_POSTFIELDS, http_build_query($curl_post_data));
$curl_response = curl_exec($client);
curl_close($client);
echo $curl_response;

Evidentemente, estaría restando la parte de la vista, pero eso ya será tema de otro post. Recuerden que es mi primer post de PHP, por lo que les pido comprensión si algunos conceptos o separaciones de capas no las hago correctamente, la idea es aportar no? :D

Columnas virtuales con MySQL

2016-09-27T23:00:00.002-05:00

Las columnas virtuales son una de las características más resaltantes de MySQL 5.7. Estas columnas tienen la característica de ser definidas en la tabla como el resultado de funciones de otras columnas, por ejemplo:

create database demo;
use demo;
create table tabla(campo1 int, campo2 int, campo3 int generated always as (campo1*campo2) virtual);
insert into tabla values (10, 20, default);
select * from tabla;
+--------+--------+--------+
| campo1 | campo2 | campo3 |
+--------+--------+--------+
|     10 |     20 |    200 |
+--------+--------+--------+

La tabla creada con estas sentencias SQL tendrá dos columnas que almacenarán números enteros y una tercera columna que será el resultado de la multiplicación de las dos columnas anteriores, tal como se muestra en la siguiente figura:

Dichas columnas virtuales son cálculadas sobre la marcha, cada vez que los campos son recuperados. Una de las limitantes es que no podemos utilizar columnas virtuales definidas después de la actual, esto debido a que las columnas virtuales se calculan en el orden en que se definen.

Existe otro tipo de columnas generadas, llamadas columnas almancenadas, pero éstas serán revisadas en otro artículo.

Secure Admin must be enabled to access the DAS remotely

2016-09-19T11:27:00.004-05:00

En este corto artículo les presento la solución al error:

Secure Admin must be enabled to access the DAS remotely

Que ocurre cuando queremos acceder remotamente a un servidor glassfish recientemente instalado. La solución es tan sencilla como ejecutar el siguiente comando:

asadmin --host [host] --port [port] enable-secure-admin

Recuerden reiniciar el servicio para que los cambios tomen efecto. Saludos!

How to Install and Configure MySQL Cluster on Windows

2016-09-13T23:25:00.000-05:00

MySQL Clúster es una versión de alta disponibilidad, alta redundancia de MySQL adaptada para el entorno de computación distribuida. Usa el motor de almacenamiento NDB Cluster para permitir la ejecución de varios servidores MySQL en un clúster. Este motor de almacenamiento está disponible en las distribuciones binarias de MySQL 5.0, Los sistemas en los que está disponible son Linux, Solaris y Windows. En este artículo vamos a revisar la manera cómo configurarlo.

La infraestructura que utilizaremos será la siguiente:

Los requerimientos son los siguientes:

MySQL cluster. En este artículo se usó la versión 7.2.10. (https://downloads.mysql.com/archives/cluster/)
3 computadoras con Windows XP con configuración de IP's por DHCP

Las recomendaciones son estas:

Desactivar firewall
Desactivar antivirus
Desinstalar y limpiar versiones anteriores de MySQL

Una vez descargada la versión, descomprimir el contenido en una carpeta en el disco C, a la cual llamaremos mysqlc.

En cada uno de los tres nodos de la figura mostrada anteriormente, crear la estructura de carpetas y su contenido a partir del comando:

C:\>mkdir my_cluster my_cluster\ndb_data my_cluster\mysqld_data my_cluster\conf
C:\>mkdir my_cluster\mysqld_data\mysql my_cluster\mysqld_data\ndbinfo
C:\>copy c:\mysqlc\data\mysql my_cluster\mysqld_data\mysql 
C:\>copy c:\mysqlc\data\ndbinfo my_cluster\mysqld_data\ndbinfo

Nodo Administrador
Crear el archivo config.ini en la carpeta c:\my_cluster\conf con el siguiente contenido:

[ndb_mgmd]
HostName=192.168.1.100
DataDir=c:\my_cluster\ndb_data
Nodeid=1

[Ndbd default]
NoOfReplicas=2

[Ndbd]
HostName=192.168.1.101
Nodeid=3

[Ndbd]
HostName=192.168.1.102
Nodeid=4
[Mysqld]
[Mysqld]

Iniciar el nodo administrador ejecutando el siguiente comando y dejando la consola abierta.

C:\my_cluster>/mysqlc/bin/ndb_mgmd -f conf/config.ini --initial --configdir=c:\my_cluster\conf\

En otra consola de comandos del nodo administrador, ejecutar el programa para verificar el estado de nuestro cluster.

C:\>C:\mysqlc\bin\ndb_mgm -e show

El resultado deberá ser similar al mostrado a continuación:

Nodos de Datos

En cada uno de los nodos de datos, crear el archivo my.cnf en la carpeta c:\my_cluster\conf. El puerto debe ser diferente para cada nodo de dato y de preferencia mayor a 5000.

[mysqld]
ndbcluster
datadir=c:\my_cluster\mysqld_data
port=15002
ndb-connectstring = 192.168.1.100

[mysql_cluster]
ndb-connectstring = 192.168.1.100

Ahora nos conectamos con el nodo administrador ejecutando el siguiente comando en cada uno de los dos nodos de datos

C:\>c:\mysqlc\bin\ndbd -c 192.168.1.100:1186

Sin embargo, al ejecutar en el nodo administrador el siguiente comando.

C:\>C:\mysqlc\bin\ndb_mgm -e show

Podemos notar que, a pesar que la conexión al nodo administrador ha sido hecha, los nodos SQL aún no están habilitados (not connected, accepting connect from any host).

Para levantar las API's, ejecutar en cada nodo de datos el siguiente comando en una consola nueva:

C:\my_cluster>c:\mysqlc\bin\mysqld --defaults-file=conf/my.cnf --console

Al volver a ejecutar el comando de visualización de conexiones en el nodo administrador, la salida será la siguiente:

Ahora sólo resta conectarnos al motor de base de datos de cada nodo utilizando una nueva consola para ejecutar el siguiente comando, teniendo en cuenta el puerto establecido en el archivo my.cnf. En este caso, mostraremos la conexión en el nodo que utiliza el puerto 15002.

c:\my_cluster>c:\mysqlc\bin\mysql -P15002 -u root

Al levantar los dos motores, cualquier sentencia SQL ejecuta en uno de ellos deberá verse automáticamente reflejada en la otra instancia. La siguiente imagen ilustra esto:

Inicialmente, en la consola azul habían las mismas base de datos que en la consola blanca, sin embargo al crear la base de datos clusterdb en esta última, la instancia azul reflejó automáticamente los cambios.

Para finalizar, les dejo los comandos para finalizar el servicio de manera segura:

#Ejecutar por cada nodo de datos, teniendo en cuenta el puerto
C:\my_cluster>c:\mysqlc\bin\mysqladmin -u root -h 127.0.0.1 -P15000 shutdown
#Nodo administrador
C:\my_cluster>c:\mysqlc\bin\ndb_mgm -e shutdown
#Ver puertos
netstat -oan