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

Consumir web services SOAP facil con Python Suds

Suds es un tremendo cliente SOAP para consumir web services es basado en Python a diferencia de los clientes en Java no hay generación de clases, y el API es tipo orientado a objetos. Y lo mejor es el poco código que se debe escribir para consumir un servicio web y para muestra un ejemplo sencillo:

Lo primero instalar el cliente ya sea descargándolo del sitio o instalando el paquetes si nuestra distribución de linux lo incluye en sus repositorios.

# fedora 15
yum -y install python-suds
# tarball
wget https://fedorahosted.org/releases/s/u/suds/python-suds-0.4.tar.gz
tar xzvf python-suds-0.4.tar.gz
cd python-suds-0.4
python setup.py install

Para el ejemplo utilizaremos uno de los webservices del sitio webservicesx.net

#!/usr/bin/env python

from suds.client import Client
url = 'http://www.webservicex.net/globalweather.asmx?WSDL'
client = Client(url)
print client

si todo esta correcto la salida del script mostrara esto:

web service output

Suds ( https://fedorahosted.org/suds/ )  version: 0.3.9 GA  build: R659-20100219

Service ( GlobalWeather ) tns="http://www.webserviceX.NET"
   Prefixes (0)
   Ports (2):
      (GlobalWeatherSoap)
         Methods (2):
            GetCitiesByCountry(xs:string CountryName, )
            GetWeather(xs:string CityName, xs:string CountryName, )
         Types (0):
      (GlobalWeatherSoap12)
         Methods (2):
            GetCitiesByCountry(xs:string CountryName, )
            GetWeather(xs:string CityName, xs:string CountryName, )
         Types (0):

El servicio web tiene 2 metodos los cuales podemos invocar de la siguiente manera:

#!/usr/bin/env python

from suds.client import Client
url = 'http://www.webservicex.net/globalweather.asmx?WSDL'
client = Client(url)
#print client
weather =  client.service.GetWeather('Managua', 'Nicaragua')
print weather

esto generara un string conteniendo el xml para que luego pueda ser procesado según se requiera .

<?xml version="1.0" encoding="utf-16"?>
<CurrentWeather>
  <Location>Managua A. C. Sandino, Nicaragua (MNMG) 12-09N 086-10W 56M</Location>
  <Time>Jul 18, 2011 - 12:00 AM EDT / 2011.07.18 0400 UTC</Time>
  <Wind> from the ESE (110 degrees) at 5 MPH (4 KT):0</Wind>
  <Visibility> greater than 7 mile(s):0</Visibility>
  <SkyConditions> partly cloudy</SkyConditions>
  <Temperature> 77 F (25 C)</Temperature>
  <DewPoint> 73 F (23 C)</DewPoint>
  <RelativeHumidity> 88%</RelativeHumidity>
  <Pressure> 29.88 in. Hg (1011 hPa)</Pressure>
  <Status>Success</Status>
</CurrentWeather>

Referencias:

Python Suds

Android SDK en Fedora 14 x86-64

El SDK de Android esta hecho para 32bits para ponerlo a funcionar en Fedora 14 x86-64(64 bits) y correr el emulador usando el JDK de 64 bits requiere instalar librerias de 32 bits; accediendo como usuario root instalamos lo siguiente:

su -
yum install ncurses-libs.i686 libstdc++.i686 glibc.i686 libX11-devel.i686  \
glibc.i686 SDL.i686 libX11.i686 libXext.i686 libao.i686  alsa-lib.i686 -y

Descargamos el SDK del sitio de Android http://developer.android.com/sdk/index.html

Linux (i386) |  android-sdk_r10-linux_x86.tgz |  26981997 bytes |  c022dda3a56c8a67698e6a39b0b1a4e0

descomprimimos el archivos, desde la terminal ejecutamos

cd android-sdk-linux_x86/tools
./android

descargamos el SDK con la version del API que vayamos a utilizar y listo solo queda configurar el dispositivo y probarlo.

El dispositivo puede crearse desde la consola o desde la aplicacion grafica.

# creando el dispositivo desde la consola
cd android-sdk-linux_x86/tools
./android  create avd -c 256M -t 1 -n android_223 -a -s WQVGA400 --force

al igual el emulador se puede arrancar desde la consola o la aplicacion.

# ejecutando el emulador
cd android-sdk-linux_x86/tools
./emulator -cpu-delay 0 -no-boot-anim -cache ./cache  -verbose -avd android_223

las opciones -cpu-delay 0 -no-boot-anim -cache ./cache, mejora un poco el rendimiento haciendo mas responsivo el emulador.

android on fedora 14 x86-64
android on fedora 14 x86-64

referencia:

Android Developers

Detección y redirección de móviles con Apache mod_rewrite.

Cuando se desarrollan aplicaciones web o versiones móviles de sitios una aspecto fundamental es la detección del móvil y sus capacidades existen 2 opciones para realizar esta tarea ambas utilizan base de datos formatos XML con las características de los móviles una es opensource WURFL y la otra es Device Atlas la cual funciona en base a licencias, gratuita para evaluación con la data de ambas es posible implementar la detección del móvil y sus capacidades.

Ahora bien como dice el titulo de este articulo detección y redirección con Apache mod_rewrite , si no se requiere una solucion compleja lo mas sencillo y rápido si se esta trabajando con Apache es usar su modulo de re-escritura de url ( mod-rewrite ) y eso es mediante unas cuantas reglas en un archivo .htaccess en el directorio como estas:

RewriteEngine On

RewriteCond %{HTTP_USER_AGENT} ^(Android|BlackBerry) [NC,OR]
RewriteCond %{HTTP_USER_AGENT} ^(Motorolla|Nokia|Samsung|SonyEricsson) [NC,OR]
RewriteCond %{HTTP_USER_AGENT} iP(hone|od) [NC,OR]
RewriteCond %{HTTP_USER_AGENT} .*Mobile.*Safari

RewriteRule ^$ http://movil.midominio.com  [R=301,L]

La deteccion es proporcionada por las expresiones regulares evaluadas de la variable “HTTP_USER_AGENT” y la redireccion por la expresion “RewriteRule ^$ http://movil.midominio.com [R=301,L]” en este caso por ejemplo tenemos un sitio en “midominio.com” y una version movil en “movil.midominio.com” el htaccess redireccionara cada peticion que sea movil al subdominio automaticamente.