Checking and validating phone numbers.

In applications sometimes is needed check and verify if a phone number is valid or possible if the number have all required digits to be valid for this purpose there are several options to tackle the problem like regular expressions for example to validate E.164 format, library like the Google libphonenumber and API like the Twillio Lookup for something more complete.

for this post i created a small app for test a demo purpose using the python port of the Google library

the app takes the country and the phone number then it validate and check against the python phonenumbers data.
check phone number app

In the form after select the country the calling code of the country is set and then with the number is, the number is formatted in E.164 and send as JSON in a request to a python micro-service running Python bottle and the library
Request:

{
  "phone_number":"+40721234567",
  "country_code":"RO"
}

Response:

{
  "possible_number": true,
  "number_data": "Country Code: 40 National Number: 721234567",
  "valid_number": true,
  "carrier_data": "Vodafone"
}

for the country data on the calling codes i found a excellent repository https://mledoze.github.io/countries/ with the data included in different formats very useful, for the country combo box i use react and semantic-ui.

the code for the form and the python micro-service are in github:

form and javascript: https://github.com/jms/check-phone-number

Python micro-service: https://github.com/jms/check-phone-number-service

The app was deployed on Openshift and can be tested on the following link: http://checkphonenumber-jms.rhcloud.com/

References:

http://bottlepy.org/docs/dev/index.html
https://github.com/googlei18n/libphonenumber
https://github.com/daviddrysdale/python-phonenumbers
http://en.wikipedia.org/wiki/E.164
https://www.twilio.com/help/faq/phone-numbers/how-do-i-format-phone-numbers-to-work-internationally
https://www.twilio.com/lookup

Git, my cheatsheet

Basic workflow

# setup the project
git clone github/project.git
git branch FeatureX
git co FeatureX

# make some changes
git st
git add .

# commit changes 
git ci -m 'commit message'

# push changes to branch
git push origin branch-name

# next pull request/merge with master on github or command line

Sometimes you don’t want to track some files(like local env configuration settings)

# no track file 
git update-index --assume-unchanged Gemfile .ruby-version 

# track file again
git update-index --no-assume-unchanged path/to/file.txt

About branch

# view hidden branch or detached 
git branch -a  

# track branch 
git branch branch_name origin/branch_name 

# sync a branch with master 

# update master
git checkout master
git pull 

# change to the branch 
git checkout branch
git merge origin/master 

# fix conflicts 
# commit changes
# branch is updated

Steps to merge pull request from branch, take it from Github

# Step 1: From your project repository, bring in the changes and test.

git fetch origin
git checkout -b branch-name origin/branch-name
git merge master

# Step 2: Merge the changes and update on GitHub.

git checkout master
git merge --no-ff branch
git push origin master

Alias for .gitconfig

[alias]
        co = checkout
        ci = commit
        st = status
        br = branch
        hist = log --pretty=format:\"%h %ad | %s%d [%an]\" --graph --date=short
        type = cat-file -t
        dump = cat-file -p
        tree = log --oneline --graph --decorate --all
        bra = branch -a 
        cbr = branch -l 

Some reference
https://help.github.com/articles/syncing-a-fork
https://help.github.com/articles/configuring-a-remote-for-a-fork

JIRA en Tomcat7 con Java7, PostgreSQL 9.2 y Nginx — parte 2

En el post anterior completamos la preparación del archivo WAR para hacer el deploy en el servidor de aplicaciones Tomcat 7 ahora configuraremos Tomcat 7 y nginx siguiendo los siguientes pasos:

Creamos un script para iniciar Tomcat como servicio creamos el archivo “tomcat” con el siguiente contenido:

#!/bin/bash
# description: Tomcat Start - Stop - Restart
# processname: tomcat
# chkconfig: 234 20 80
JAVA_HOME=/opt/tcjira/jdk1.7.0_21
export JAVA_HOME
PATH=$JAVA_HOME/bin:$PATH
export PATH
CATALINA_HOME=/opt/tcjira/tomcat7
source $CATALINA_HOME/bin/setenv.sh

case $1 in
start)
echo "Starting Tomcat"
/bin/su jira $CATALINA_HOME/bin/startup.sh
;;
stop)
echo "Stopping Tomcat"
/bin/su jira  $CATALINA_HOME/bin/shutdown.sh
;;
restart)
echo "Restarting Tomcat"
/bin/su jira  $CATALINA_HOME/bin/shutdown.sh
/bin/su jira  $CATALINA_HOME/bin/startup.sh
;;
*)
echo $"Usage: $0 {start|stop}"
exit 1
;;
esac
exit 0

agregamos el servicio al sistema, copiamos el script a /etc/init.d

cp tomcat /etc/init.d
chkconfig --add tomcat
chkconfig --level 3 tomcat on

# activamos el servicio postgresql para que inicie automatico
chkconfig postgresql-9.2 on

# verificamos los servicios
chkconfig --list | grep -i '3:on'

# iniciamos los servicios
service tomcat start
service postgresql-9.2 start 

# creamos el usuario y base de datos para jira
su - postgres
createuser -P jira
psql -d postgres

postgres=# CREATE DATABASE jiradb OWNER jira ENCODING 'UNICODE';

Por seguridad configuraremos Nginx como reverse proxy y usaremos un subdominio con el fin de acceder a la aplicacion web jira usando el puerto tcp 80 pasando por Nginx, en lugar de ir directo a Tomcat en el puerto tcp 8080.

server {
        listen  80;
        server_name     dev.h4v0k.com;
        
        access_log      off;

        location / {
                proxy_pass http://localhost:8080;
                proxy_read_timeout  10800s;
                proxy_set_header    Host            $host;
                proxy_set_header    X-Real-IP       $remote_addr;
                proxy_set_header    X-Forwarded-for $remote_addr;
                port_in_redirect off;
                proxy_redirect   http://dev.h4vok.com:8080/jira/  /;
                proxy_connect_timeout 300;
                add_header  X-Frame-Options SAMEORIGIN; 
        }

        error_page   500 502 503 504  /50x.html;
        location = /50x.html {
                root   /srv/www/htdocs;
        }

}

luego modificaremos la configuracion de tomcat en server.xml para definir el proxy.

<Connector port="8080" protocol="HTTP/1.1"
               connectionTimeout="20000"
               redirectPort="8443" URIEncoding="UTF-8"
               proxyName="dev.h4v0k.com"
               proxyPort="80" 
/>

Para hacer el deploy de la aplicación se requiere una configuración mas en el Tomcat antes de iniciar. En el directorio “/opt/tcjira/tomcat7/conf/Catalina/localhost” creamos un archivo llamado “jira.xml” con lo siguiente:

<?xml version='1.0' encoding='utf-8'?>

<Context path="/jira" debug="0" useHttpOnly="true">
 
  <Resource name="UserTransaction" auth="Container" type="javax.transaction.UserTransaction"
      factory="org.objectweb.jotm.UserTransactionFactory" jotm.timeout="60"/>
        <Manager pathname=""/>
         
</Context>

En este archivo se define el contexto para el deploy de la aplicacion java, el path “/jira” sera el que utilizaremos para llegar a la aplicacion por lo deberemos renombrar el archivo WAR creado previamente y moverlo al folder de aplicaciones de Tomcat.

cd /opt/tcjira/atlassian-jira-6.0.1/dist-tomcat
mv atlassian-jira-6.0.1.war /opt/tcjira/tomcat7/webapps/jira.war 

con todo configurado correctamente, podremos ver en el log la inicialización de la aplicación y continuar la configuración con el wizard desde el navegador, donde se configurara la licencia y los parametros de la BD.

logs de apache tomcat:

Jira startup

postgresql 9.2

Postgresql 9.2 JDBC

Atlassian Jira funcionando

Jira running

Referencia:

JIRA Installation and Upgrade Guide

Running+the+Setup+Wizard

Installing JIRA on Tomcat 6.0 or 7.0

JIRA en Tomcat7 con Java7, PostgreSQL 9.2 y Nginx — parte 1

JIRA es una excelente herramienta para el tracking de tareas, bugs y seguimiento de proyectos, cuando se combina con el complemento para seguimiento de proyectos GreenHopper presenta la herramienta mas versátil para la aplicación de metodologías ágiles (Scrum, Kanban).

JIRA es ofrecida en diferentes planes, en la nube o alojado en la infraestructura propia y diferentes precios segun el numero de usuarios. Posee un precio accesible para equipos de 10 usuarios cuando se aloja en infraestructura propia ($10).

Continue reading “JIRA en Tomcat7 con Java7, PostgreSQL 9.2 y Nginx — parte 1”

Explorando node y express – parte 1

En la actualidad las aplicaciones web están tomando un enfoque mas amplio al controlar desde el servidor web hasta el contenido final que es servido al usuario final, node la plataforma construida en el runtime javascript de chrome permite la rápida construcción de aplicaciones usando un modelo de no bloqueo en I/O y basado en eventos hacen de la plataforma ideal para aplicaciones web escalables, aplicaciones de redes y aplicaciones con cargas de datos intensivas en tiempo real haciendo uso de base de datos nosql como MongoDB, CouchDB, Riak.

Node.js es una plataforma en la cual se han desarrollado muchos componentes que en conjunto brindan toda la funcionalidad necesaria para construir aplicaciones web, como es connect un framework middleware para node, express framework para aplicaciones web, jade

Para este articulo lo primero sera instalar node y el framework express

node esta disponible para todas las plataformas Windows(instaladores para 32 y 64 bits), Linux, Solaris, FreeBSD, Darwin en codigo fuente para compilar e instalar.

Una vez instalado node tenemos acceso al gestor de modulos npm y podremos instalaremos express
express se puede configurar de 2 maneras.

la primera opcione es crear un directorio con un descriptor para la aplicación, un archivo
package.json y luego ejecutar la instalación del modulo express con npm

$ mkdir ndemo
$ cd ndemo
$ vim package.json
$ npm install 
$ npm ls

Descriptor de la aplicacion: package.json

// file: package.json
{
    "name":"ndemo",
    "version":"0.0.1",
    "private":true,
    "scripts":{
        "start":"node app"
    },
    "dependencies":{
        "express":"3.x",
        "jade":"*",
        "stylus":"*"
    }
}

la otra alternativa es instalar express de manera global usando npm y utilizar el comando express para crear la aplicación.

# requiere permisos de root
$ npm install -g express
$ express -s -c stylus ndemo

al final se tendrá el directorio de la aplicación con los módulos necesarios como se muestra en la imagen usando “npm ls” se pueden ver las dependencias de express en la aplicación

npm ls

Con la primera opción se debe crear el script de inicio y del servidor para arrancar la aplicación, con la segunda opción estos archivos son creados automáticamente.