Stuck in the sound - Pursuit

Esta es una ocasión especial.... Llevaba tiempo buscando la letra de una canción que no parecía estar en la red. Entonces recibí ayuda y finalmente di con ella. La canción es "Pursuit", de un grupo francés llamado "Stuck in the sound".

Run Away from the underworld
Just don't look back and hold my hand
We're joining the underground...
Embracing the cause of the Lonely

We'll be always on the run We'll be always on the run Will somebady spread the word Somewhere there is a ship for the sad ones. But when the lights hit the ground Will everybody be safe in the shadow We'll be always on the run We'll be always on the run

Baby the world seems to be fake
When I'm without you and I
Will set you on fire.
We'll never go back
We left behind the doubt
Decide to live without a sound
Oh we gotta go

...

Agregando código a un proyecto git existente

Hola!

Hablar sobre git se ha vuelto algo ya del diario en el mundo de la programación, entonces hacer un tutorial sería ya algo trillado.

Por ende, de lo que vamos a platicar es cómo inicializar un repositorio de git.

Imaginemos el escenario donde acabamos de crear un proyecto en github. Para iniciar la magia, deberíamos clonar el proyecto a nuestra computadora, situarnos en el directorio y listo. Empezar el código.

Pero, ¿qué pasa cuando ya tenemos un proyecto y queremos "vincularlo"?. Por ejemplo, estaba creando un proyecto de laravel mediante composer. Entonces, ¿debería copiar y pegar todo?, ¡para nada!.

Primero, hay que posicionarnos en la raiz del proyecto, digamos "cd laravel" y seguimos los siguientes pasos:

• git init
• git remote add origin https://github.com/dazamar01/laravel.git 
• git add .
• git commit -m 'Primer commit'
• git push -u origin master

Y listo. Con esto hemos apuntado nuestro código al repositorio donde queremos administrar el proyecto.

La línea mas completa es la de "git remote add origin", sin embargo lo único que deberías hacer es reemplazar la url por la de tu proyecto git.

Por cierto, mi repositorio es https://github.com/dazamar01, por si necesitas mas códigos.

Espero te sea de utilidad ;)

Código fuente React-Java

Hola,

En esta ocasión voy a ser un poco mas breve que en otras ocasiones, ya que me he visto envuelto en varios proyectos.

Dándole continuidad al proyecto de migración entre vb6 y java, les comento que he estado trabajando también con React.js (si, esa librería de fb).

Así que les comparto el código para trabajar el backend y el front end. Es decir, con esto pueden iniciar.

Back end:
https://github.com/dazamar01/react-backend-java

Front end:
https://github.com/dazamar01/react-frontend

Estoy siendo súmamente breve porque pronto quiero hacer otra versión de estos dos proyectos, y en ese entonces, voy a hacer un nuevo post.


Espero te sea de utilidad ;)

Implementación de Consultas dinámicas en JPA

Hola.

Últimamente he estado trabajando en una migración de un sistema desde Visual Basic 6 (si, de cuando los perros se amarraban con longanizas) a Java 8.

Pensé que todo iría bien hasta que me tocó enfrentarme a las consultas con parámetros dinámicos. En este caso, se utiliza al Entity Manager y las Criteria Querys.

Y como soy de pocas palabras y mas acciones, dejo a continuación, el código con los imports necesarios para efectuar un método, traer un resultset paginado, el count del total de registros, generar los criterias y efectuar la lista de parámetros a manera de módulo separado para ahorrar trabajo.

import java.time.LocalDate;

import java.util.ArrayList;

import java.util.List;

import java.util.logging.Logger;

import javax.persistence.EntityManager;

import javax.persistence.PersistenceContext;

import javax.persistence.TypedQuery;

import javax.persistence.criteria.CriteriaBuilder;

import javax.persistence.criteria.CriteriaQuery;

import javax.persistence.criteria.Predicate;

import javax.persistence.criteria.Root;

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

import org.springframework.beans.factory.annotation.Qualifier;

import org.springframework.stereotype.Service;

import org.springframework.transaction.annotation.Transactional;

@Service("controlFechaOrdeniaServiceImpl")

@Transactional

public class ControlFechaOrdeniaServiceImpl implements ControlFechaOrdeniaService {

    private final static Logger LOGGER = Logger.getLogger("");

    @PersistenceContext

    private EntityManager entityManager;

    @Autowired

    @Qualifier("controlFechaOrdeniaRepository")

    private ControlFechaOrdeniaRepository controlFechaOrdeniaRepository;

    private CriteriaBuilder criteriaBuilder;

    @Override

    public ControlFechaOrdeniaVO buscar(Integer paginaActual, Integer activos) throws Exception {

        ControlFechaOrdeniaVO controlFechaOrdenia = new ControlFechaOrdeniaVO();

        ControlFechaOrdenia filtro = new ControlFechaOrdenia();

        List<ControlFechaOrdenia> listaControlFechaOrdenia = null;

        controlFechaOrdenia.iniciarPaginador(paginaActual);

        if (activos != null) {

            filtro.setActivo(activos);

        }

        try {

            criteriaBuilder = entityManager.getCriteriaBuilder();

            listaControlFechaOrdenia = getRegistros(controlFechaOrdenia.getDesde(), filtro);

            controlFechaOrdenia.setListaControlOrdenia(listaControlFechaOrdenia);

            long totalRegistros = getCantidadRegistros(filtro);

            controlFechaOrdenia.setPaginado(totalRegistros);

            listaControlFechaOrdenia.stream().forEach(item -> { LOGGER.log(Constantes.LOG_LEVEL_INFO, "Id: "

            + item.getId()); });

            

        } catch (Exception ex) {

            LOGGER.log(Constantes.LOG_LEVEL_ERROR, "ControlFechaOrdeniaImpl.buscar");

            LOGGER.log(Constantes.LOG_LEVEL_ERROR, ex.getMessage());

        }

        return controlFechaOrdenia;

    }

    private List<ControlFechaOrdenia> getRegistros(int desde, ControlFechaOrdenia filtro) {

        

        List<Predicate> predicates = new ArrayList<Predicate>();

        List<ControlFechaOrdenia> listaControlFechaOrdenia = new ArrayList<>();

        TypedQuery<ControlFechaOrdenia> typedQuery;

        

        try {

            

            final CriteriaQuery<ControlFechaOrdenia> criteriaQuery = criteriaBuilder

                    .createQuery(ControlFechaOrdenia.class);

            final Root<ControlFechaOrdenia> entityRoot = criteriaQuery.from(ControlFechaOrdenia.class);

            predicates = this.getPredicateList(entityRoot, criteriaBuilder, filtro);

            

            criteriaQuery.orderBy(criteriaBuilder.asc(entityRoot.get("id")));

            criteriaQuery.where(criteriaBuilder.and(predicates.toArray(new Predicate[0])));

            typedQuery = entityManager.createQuery(criteriaQuery);

            typedQuery.setFirstResult(desde);

            typedQuery.setMaxResults(Constantes.REGISTROS_POR_PAGINA);

            listaControlFechaOrdenia = typedQuery.getResultList();

            return listaControlFechaOrdenia;

            

        } catch (Exception ex) {

            throw ex;

        }

    }

    public long getCantidadRegistros(ControlFechaOrdenia filtro) {

        List<Predicate> predicates = new ArrayList<Predicate>();

        try {

            final CriteriaQuery<Long> criteriaQuery = criteriaBuilder.createQuery(Long.class);

            Root<ControlFechaOrdenia> entityRoot = criteriaQuery.from(ControlFechaOrdenia.class);

            criteriaQuery.select(criteriaBuilder.count(entityRoot));

            predicates = this.getPredicateList(entityRoot, criteriaBuilder, filtro);

            

            criteriaQuery.where(predicates.toArray(new Predicate[predicates.size()]));

            TypedQuery<Long> typedQuery = entityManager.createQuery(criteriaQuery);

            return typedQuery.getSingleResult();

        } catch (Exception ex) {

            throw ex;

        }

    }

    private List<Predicate> getPredicateList(Root<ControlFechaOrdenia> entityRoot, CriteriaBuilder criteriaBuilder, ControlFechaOrdenia filtro) {

        List<Predicate> predicates = new ArrayList<Predicate>();

        if (filtro.getActivo() != null) {

            Predicate predicateFilter = criteriaBuilder.equal(entityRoot.get("activo"), filtro.getActivo());

            predicates.add(predicateFilter);

        }

        return predicates;

    }

}

Espero te sea de utilidad ;)

Suscripción gratuita a Pluralsight

Hola!

Estaba buscando entre opciones para aprender una tecnología y mientras estaba investigando, un amigo me comentó lo siguiente.

Me dió la opción de registrarse en uno de los sitios de Microsft Dev y, mediante esto, obtener entre otros beneficios, de 3 meses gratis de acceso a Pluralsight.

Lo que tienen que hacer es:

1.       Registrarse gratuitamente al programa “Visual Studio Dev Essentials” en el siguiente enlace:
https://www.visualstudio.com/en-us/products/visual-studio-dev-essentials-vs.aspx

2.       Luego de crear su cuenta verán en la página principal la oferta “Pluralsight 3-month subscription”, denle click al enlace “Get code” y llenen el formulario que les pedirá algunos datos básicos.

En enlace original lo pueden consultar acá

Yo ya tengo mi suscripción activa y funcionando.

Espero te sea de utilidad ;)

Instalación y puesta en Marcha de Ruby on Rails

Hola!

Hace algo de tiempo que no estoy por aquí, sin embargo, hace unos días, me encargaron adentrarme en el mundo de Ruby on Rails y tuve que efectuar las configuraciones necesarias para dejarlo a punto en Windows, por lo que me pareció buena idea compartirlo con ustedes. Por tanto, basta de misterio y ¡a por ello!

Paso 1: Descarga del software necesario.

En primer lugar, será necesario descargar el instalador de Ruby On Rails desde la página de Rails Installer (http://railsinstaller.org/en). Al momento de esta instalación, se descargó la versión 2.2 (figura 1). Comprende los siguientes complementos:

• Ruby 2.2.6
• Rails 5.0
• Bundler
• Git
• Sqlite
• TinyTDS
• SQL Server Support
• DevKit

Figura 1. Descarga de Ruby

Teniendo lista la descarga, es necesario descargar la consola de git desde la página oficial (https://git-scm.com/), esto con el objetivo de ejecutar de una manera práctica los comandos necesarios de Ruby. Es posible descargarla directamente desde aquí.

Paso 2: Instalación de los componentes:

Continuando con el proceso, es necesario ejecutar el instalador de ruby previamente descargado:

Figura 2. Inicio de instalación de Ruby

Se debe aceptar las licencias y presionar “siguiente”, en la siguiente ventana, será necesario que las opciones para instalar Git y añadir los ejecutables se encuentren marcados (Figura 3).

Figura 3. Se deben marcar ambas casillas

Figura 4. Proceso de instalación

Al terminar la instalación (Figura 5), es recomendable iniciar la configuración de la consola de git y ssh.

Figura 5. Seleccionar la configuración de git

Al configurar git, solicitará el nombre de usuario y un correo electrónico (figura 6).

Figura 6. Configurando git

Al finalizar el proceso, la consola proporcionará una clave de seguridad. Es altamente recomendable almacenarla en algún archivo para su posterior uso.

Este proceso instalará también git, por lo que no es necesario instalar el que se descargó. Esta indicación se dio en el caso de que la instalación fallara o se omitiera algún paso de los indicados.

Para verificar que la instalación se efectuó satisfactoriamente, se deberá abrir la consola de git y escribiendo el comando “Rails -v”, el cual retornará la versión de Ruby instalada en el sistema. Si muestra un mensaje similar al de la figura 7, entonces se ha concluido satisfactoriamente el proceso.

Figura 7. Comprobar la versión de Ruby

Paso 3: Generación del CRUD “Person”

Para este proceso, se tomará como base de datos MySQL y se utilizará la base de datos “persontest”. El código de creación es el siguiente:

CREATE DATABASE persontest /*!40100 COLLATE 'utf8_spanish_ci' */;

use persontest;

Habiendo creado la base de datos, es necesario abrir la cosola de git y situarse en el directorio “c/Sites”, el cual se crea por defecto cuando se instala Ruby.

Es necesario ejecutar el comando “rails new persontest”: esta instrucción generará todos los archivos necesarios para el proyecto (Figura 8).

Figura 8. Construir el proyecto

Al finalizar el proceso, debe aparecer una ventana similar a la de la figura 9.

Figura 9. Construcción del proyecto finalizada

El proyecto se ha generado en c:\Sites\persontest, esta carpeta se puede abrir con cualquier editor de texto, para este caso se utilizará sublime text 3.

Llegados a este paso, es necesario configurar la gema de MySQL junto con la opción de SQLite para testing, en el archivo “Gemfile” ubicado en raíz del proyecto (figura 10) y la conexión a la base de datos en el archivo “config/dabatase.yml” (figura 11).

Figura 10. Configuración de gema para MySQL

Figura 11. Configuración de conexión a MySQL

Es necesario, una vez hechas estas configuraciones, decirle a Rails que debe descargar e instalar las librerías que se le indicaron. Esto se logra ejecutando los comandos “bundle update” y “bundle install”. Al finalizar debe mostrarse algo similar a la figura 12.

Figura 12. Se ha ejecutado bundle update y bundle install

A continuación, se procederá a generar el “scaffold” (se le llama scaffold al proceso de construcción de código necesario para una funcionalidad simple) de la clase persona, con los atributos mencionados al principio (figura 13).

El comando a ejecutar es: rails generate scaffold person firstName:string lastName:string

Figura 13. Generación de Scaffold

Ejecutado el proceso anterior, es necesario llevar a cabo el proceso de “migrado”, es decir, indicarle a Rails que debe conectarse a la base de datos y construir el modelo indicado. Esto se logra con el comando: rails db:migrate (figura 14).

Figura 14. Ejecución del migrado

Lo anterior generará la tabla “people” en la base de datos (véase CoC Ruby para mayor entendimiento) y se mostrará algo similar a la figura 15.

Figura 15. Generación satisfactoria del modelo en la base de datos

Paso 4: Arrancar el servidor y ver el módulo en acción

Lo primero a seguir es arrancar el servidor, esto se logra ubicándose en la carpeta generada por ruby (C:\Sites\persontest) y ejecutando el comando “rails s”. Es recomendable otorgar los permisos de firewall (figura 16).

Figura 16. Arrancando el servidor y otorgando permisos del Firewall

Arrancado el servidor, es necesario abrir el navegador e ir a la dirección “localhost:3000”, y se mostrará una ventana similar a la figura 17. Esto indica que se ha efectuado el proceso de instalación satisfactoriamente, además de que la aplicación está lista para usarse.

Figura 17. Servidor de Rails arrancado y listo para usarse

Para verificar lo que se acaba de contruir, es necesario ir a la dirección http://localhost:3000/people, en donde se encuentra la funcionalidad recién implementada. Debiéndose ver una imagen similar a la que muestra la figura 18.

Figura 18. Scaffold de la clase persona

Nota:

Si se presenta un error similar al de la figura 19, entonces debe ir al archivo “C:\Sites\persontest\app\views\layouts\application.html.erb” y cambiar el parámetro “application” a “default”, en las líneas 7 y 8.

Figura 19. Error al mostrar la vista del proyecto

Espero te sea de utilidad ;)

Spring Framework

He estado fuera mucho tiempo, así que pensé para volver a escribir por acá; ¿con qué tema empezaré? Entonces tomé la decisión de hablar sobre uno de los frameworks mas populares en cuanto a Java se refiere. En esta primer entrada, definiré los conceptos de Spring, e iré abordando sobre los puntos específicos que se requieren para efectuar una aplicación sencilla que pueda ser funcional.

Sin mas, definamos: Spring es un framework para el desarrollo de aplicaciones y contenedor de inversión de control, de código abierto para la plataforma Java 2​.

Eso del "inversor de control" se refiere a la filosofía "no nos llames, nosotros te llamamos", y se refiere a que es Spring quien tiene el control de la aplicación, no los componentes.

Spring Framework comprende diversos módulos que proveen un rango de servicios:

• Contenedor de inversión de control: permite la configuración de los componentes de aplicación y la administración del ciclo de vida de los objetos Java, se lleva a cabo principalmente a través de la inyección de dependencias.
• Programación orientada a aspectos: habilita la implementación de rutinas transversales.
• Acceso a datos: se trabaja con RDBMS en la plataforma java, usando Java Database Connectivity y herramientas de Mapeo objeto relacional con bases de datos NoSQL.
• Gestión de transacciones: unifica distintas APIs de gestión y coordina las transacciones para los objetos Java.
• Modelo vista controlador: Un framework basado en HTTP y servlets, que provee herramientas para la extensión y personalización de aplicaciones web y servicios web REST.
• Framework de acceso remoto: Permite la importación y exportación estilo RPC, de objetos Java a través de redes que soporten RMI, CORBA y protocolos basados en HTTP incluyendo servicios web (SOAP).
• Convención sobre Configuración: el módulo Spring Roo ofrece una solución rápida para el desarrollo de aplicaciones basadas en Spring Framework, privilegiando la simplicidad sin perder flexibilidad.
• Procesamiento por lotes: un framework para procesamiento de mucho volumen que como características incluye funciones de registro/trazado, manejo de transacciones, estadísticas de procesamiento de tareas, reinicio de tareas, y manejo de recursos.
• Autenticación y Autorización: procesos de seguridad configurables que soportan un rango de estándares, protocolos, herramientas y prácticas a través del subproyecto Spring Security (antiguamente Acegi).
• Administración Remota: Configuración de visibilidad y gestión de objetos Java para la configuración local o remota vía JMX. 
• Mensajes: Registro configurable de objetos receptores de mensajes, para el consumo transparente desde la a través de JMS, una mejora del envío de mensajes sobre las API JMS estándar.
• Testing: Soporte de clases para desarrollo de unidades de prueba e integración.

A pesar de que tomé estas definiciones de la wikipedia, es mas cierto que las tomé de base e hice un mini-resumen de la parte que en verdad es importante.

Les dejo un enlace con un tutorial de MitoCode muy bueno sobre conceptos y definiciones. Ya que posteriormente estaré subiendo contenido de configuraciones.

Espero te sea de utilidad ;)