Obtener los días de un mes dinámicamente en MySQL – Stored Procedure

Comparto un Stored Procedure en MySQL para obtener todos los días de un mes a partir de una fecha.

Por el momento no tengo algún plugin para wordpress para compatir código y que se muestre de una manera bonita :D, así que les comparto una imagen del Stored Procedure y más abajo el código del Stored Procedure en sí.

dias_del_mes_dinamico

La lógica del procedure es sencilla, el stored espera recibir un parametro fecha de inicio del mes como entrada con formato ‘2000-02-01’. Tomando en cuenta el parametro de entrada debemos saber cual es el ultimo día de ese mes, para lo cual utilizamos la función LAST_DAY('2000-02-01') que nos retorna ‘2000-02-28’. Sabiendo cual es el día Inicial y el día Final podemos recorrer todas las fechas ese mes y guardarlas en una tabla temporar, ¿Por qué una tabla temporal? pues por que YOLO :D.

Aquí el código del Stored :D


#-----------------------------INICIO-------------------------------------------------
CREATE DEFINER=`root`@`localhost` PROCEDURE `dias_mes_dinamico`(IN `dia_entrada` DATE)
LANGUAGE SQL
NOT DETERMINISTIC
CONTAINS SQL
SQL SECURITY DEFINER
COMMENT ''
BEGIN
/*
Author: Rafael Vázquez García
Date: 2015-08-01
Description: Procedure to get every day of the month
*/

#Declaration of variables
DECLARE var_inicio, var_final INT DEFAULT 0;
DECLARE fecha_Inicial,fecha_Final, fecha_incremento DATE;

#AVariable initializations
SET fecha_Inicial = dia_entrada;
SET fecha_Final= LAST_DAY(fecha_Inicial);
SET var_inicio = EXTRACT(DAY FROM fecha_Inicial);
SET var_final = EXTRACT(DAY FROM fecha_Final);
SET fecha_incremento = fecha_Inicial;

#Create a temporaty table to store every day of a month
CREATE TEMPORARY TABLE examen.tmp_dias_mes(
id INT,
dia_mes DATE
);

#Get every day of the month
WHILE var_inicio <= var_final DO
INSERT INTO examen.tmp_dias_mes (id,dia_mes) values(var_inicio, fecha_incremento);
SET fecha_incremento = DATE_ADD(fecha_incremento, INTERVAL 1 DAY);
SET var_inicio = var_inicio + 1;
END WHILE;

#Show the temporary table
SELECT * FROM examen.tmp_dias_mes;

#Drop the temporary table
DROP TABLE examen.tmp_dias_mes;
END
#—————————–FIN————————————————-

Bueno, pues todavía se puede optimizar más este Procedimiento, ya que podriamos validar que sea una fecha valida y que no explote el mundo cuando le pasemos un 30 de Febrero :D y cachar cualquier excepción.

Espero que sea de utilidad. Saludos.

P.D. Linux Rules!

Playing with Yowsup-cli 2.0 – Receive messages and do stuff

Hello geek people that  read these post, I bring a super post compared to Pandora’s box, well the truth that comparison with the Pandora’s box is just to give drama. But this post veeeeery be useful.

First of all, Yowsup is a Python library that allows developing applications to use the services and benefits of WhatsApp. If clone the github repo Repo Yowsup and install all its dependencies you can use a customer WhatsApp for Cli pretty good in his shows include the option of sending messages, Echo messages and other things.

Had already previously worked with Yowsup , but stop using it because of the change of architecture Whatsapp thank God included End to End encryption. A few days ago I have the task of performing a system for notifications and then WhatsApp uses worldwide, at least here in Mexico all cellular companies offer it free or by buying credit per month, so I felt good choice Whatsapp used as a means to send alerts and use Yowsup. You can also do with Pushbullet , but that’s another story and another post in the future.

Well, get to work, first of all we have to clone the repo Yowsup

git clone https://github.com/tgalal/yowsup.git

We supply a few depencias and packages necessary to correctly start Yowsup.

sudo apt-get update
sudo apt-get upgrade
sudo apt-get install python-dateutil
sudo apt-get install python-setuptools
sudo apt-get install python-dev
sudo apt-get install libevent-dev
sudo apt-get install ncurses-dev

We must have a cell phone number available to register it in WhatsApp, and remember that we can not use WhatsApp on different devices -.- ‘.

Inside the directory where we have downloaded Yowsup we must run the following command to install yowsup.

sudo python setup.py install

With this we will have yowsup-cli as one command more linux, located in /usr/local/bin/yowsup-cli. Proceed to register our number on Whatsapp.

yowsup-cli registration –requestcode sms –phone 521xxxxxxxxxx –cc 52 –mcc 334 –mnc 030
yowsup-cli registration –register xxx-xxx –phone 521xxxxxxxxxx –cc 52

With this we will have Whatsapp for our mobile number password. We can save our data configuration in a file like the following example and name it as we want.

#############

cc=52
phone=521
password=

#######

And we can try sending a message to a number of Whatsapp with the following command

yowsup-cli demos –config yowsup/whatsapp_config.txt –send 5219999999999 “Your Butt”

Until this part all well, we can make a maaaaaany of things like notificaiones, alerts etc, buuuuutt putting hand python really will have a range of possibilities :D

Whatsapp client to receive and execute Linux commands

If we are curious can see that Yowsup comes with several demos and one very important is the EchoClient, which when we run it, we can send a message to Whatsapp to the number that we are using with Yowsup. We will create a new folder inside the folder demos and call readclient.

folder

Well the code that we will make our client will be used in the demo EchoClient but we will modify it a little.

ReadClient-Yowsup

The code is as follows:


import os
from yowsup.layers.interface import YowInterfaceLayer, ProtocolEntityCallback

class ReadEchoLayer(YowInterfaceLayer):

@ProtocolEntityCallback(“message”)
def onMessage(self, messageProtocolEntity):

if messageProtocolEntity.getType() == ‘text’:
self.onTextMessage(messageProtocolEntity)
elif messageProtocolEntity.getType() == ‘media’:
self.onMediaMessage(messageProtocolEntity)

self.toLower(messageProtocolEntity.ack())
self.toLower(messageProtocolEntity.ack(True))

@ProtocolEntityCallback(“receipt”)
def onReceipt(self, entity):
self.toLower(entity.ack())

def onTextMessage(self,messageProtocolEntity):
# just print info
print(“Llego el mensaje %s” % (messageProtocolEntity.getBody()))
os.system(“notify-send ‘Mensaje de Whatsapp’ ‘{mensje}'”.format(mensje=messageProtocolEntity.getBody()))
os.system(“espeak -ves ‘%s'” % (messageProtocolEntity.getBody()))

def onMediaMessage(self, messageProtocolEntity):
# just print info
if messageProtocolEntity.getMediaType() == “image”:
print(“Echoing image %s to %s” % (messageProtocolEntity.url, messageProtocolEntity.getFrom(False)))

elif messageProtocolEntity.getMediaType() == “location”:
print(“Echoing location (%s, %s) to %s” % (messageProtocolEntity.getLatitude(), messageProtocolEntity.getLongitude(), messageProtocolEntity.getFrom(False)))

elif messageProtocolEntity.getMediaType() == “vcard”:
print(“Echoing vcard (%s, %s) to %s” % (messageProtocolEntity.getName(), messageProtocolEntity.getCardData(), messageProtocolEntity.getFrom(False)))

As shown in the code do an import os to run linux commands from python:D. In the original example of EchoClient contains the line

self.toLower(messageProtocolEntity.forward(messageProtocolEntity.getFrom()))

For purposes of our client we will erase that line, since this is the order forwardar to the message he received the customer.

Modify the onTextMessage function and it will be in the following way

onTestMessage

Where the first line prints the screen a message rimmed the contents of the message that came, in the second line, run the function os.system () and we have to pass the linux command to execute, in this case notify-send to launch a notification on your desktop.

TestMensaje

The third line also runs the function os.system () which for a command as a parameter so the console talk, a type loquendo, but we passed the content that I get Whatsapp message so that the system reads it, a Jarvis type;).

It’s alive alive !!!!!

Vídeo demo.

Well, this can be many things, a brilliant implementation would be tcp over Whatsapp to have a proxy anywhere :D. I hope you make it useful :D.

 

Jugando con Yowsup-cli 2.0 – Recibir mensajes y hacer cosas

Hola raza ñoña que lee estos post, hoy traigo un super post comparado con la caja de pandora, bueno la verdad que la comparación con la caja de pandora solo es para darle dramatismo. Pero este post será de muuucha utilidad.

Primero que nada, Yowsup es una librería en Python que permite desarrollar aplicaciones para usar los servicios y bondades de Whatsapp. Si clonan el repo de github Repo de Yowsup e instalan todas sus dependencias podrá utilizar un cliente de Whatsapp para Cli bastante bueno, entre sus demostraciones incluyen la opción de envio de mensajes, Echo de mensajes y otras cosas.

Anteriormente ya había trabajado con Yowsup, pero deje de usarlo debido al cambio de arquitectura de Whatsapp que gracias a Dios incluyeron cifrado End to End. Desde unos días atras tengo la encomienda de realizar un sistema para notificaciones y pues Whatsapp lo usa todo el mundo, al menos aquí en México todas las compañías de celular lo ofrecen gratuito o por una recarga de saldo al mes, así que me pareció buena opción usar Whatsapp como medio para enviar alertas y usar Yowsup. Que también se puede hacer con Pushbullet, pero eso es harina de otro costal y otro post en el futuro.

Bueno, manos a la obra, primero que nada tenemos que clonar el repo de Yowsup

git clone https://github.com/tgalal/yowsup.git

Debemos suplir unas cuantas depencias y paquetes necesarios para echar a andar correctamente Yowsup.

 

sudo apt-get update
sudo apt-get upgrade
sudo apt-get install python-dateutil
sudo apt-get install python-setuptools
sudo apt-get install python-dev
sudo apt-get install libevent-dev
sudo apt-get install ncurses-dev

Debemos tener un número de celular disponible para darlo de alta en Whatsapp, ya que recordemos que no podemos usar Whatsapp en dispositivos diferentes -.-‘.

Dentro del directorio donde tenemos descargado Yowsup debemos correr el siguiente comando para instalar yowsup.

sudo python setup.py install

Con esto tendremos yowsup-cli como un comando más el linux, ubicado en /usr/local/bin/yowsup-cli. Procedemos a registrar nuestro número en Whatsapp.

yowsup-cli registration –requestcode sms –phone 521xxxxxxxxxx –cc 52 –mcc 334 –mnc 030
yowsup-cli registration –register xxx-xxx –phone 521xxxxxxxxxx –cc 52

Con esto tendremos la contraseña de Whatsapp para nuestro número de celular.

Podemos guardar nuestros datos de configutación en un archivo como el siguiente ejemplo y nombrarlo como querramos.

#############

cc=52
phone=521
password=

#######

Y podemos probar enviando un mensaje a un número de Whatsapp con el siguiente comando

yowsup-cli demos –config yowsup/whatsapp_config.txt –send 5219999999999 “Tu Cola”

Y a nuestro contacto debe llegarle el mensaje  que mandamos :D.

Hasta esta parte todo bien, podemos hacer un choooooooorro de cosas como notificaiones, alertas etc, peeeeero metiendole mano python realmente se habré un abanico de posibilidades :D

Cliente de Whatsapp para recibir mensajes y ejecutar comandos de Linux

Si somos curiosos podemos ver que Yowsup viene con varas demos y uno muy importante es el EchoClient, el cual cuando lo ejecutamos, podemos enviar un mensaje a de Whatsapp hacia el número que estamos usando con Yowsup. Pues crearemos una nueva carpeta dentro de la carpeta demos y se llamara readclient.

folder

Bueno el código con el que haremos nuestro cliente será el que se usa en el demo EchoClient pero lo modificaremos un poco, quedando así

ReadClient-Yowsup

El código es el siguiente:


import os
from yowsup.layers.interface import YowInterfaceLayer, ProtocolEntityCallback

class ReadEchoLayer(YowInterfaceLayer):

@ProtocolEntityCallback(“message”)
def onMessage(self, messageProtocolEntity):

if messageProtocolEntity.getType() == ‘text’:
self.onTextMessage(messageProtocolEntity)
elif messageProtocolEntity.getType() == ‘media’:
self.onMediaMessage(messageProtocolEntity)

self.toLower(messageProtocolEntity.ack())
self.toLower(messageProtocolEntity.ack(True))

@ProtocolEntityCallback(“receipt”)
def onReceipt(self, entity):
self.toLower(entity.ack())

def onTextMessage(self,messageProtocolEntity):
# just print info
print(“Llego el mensaje %s” % (messageProtocolEntity.getBody()))
os.system(“notify-send ‘Mensaje de Whatsapp’ ‘{mensje}'”.format(mensje=messageProtocolEntity.getBody()))
os.system(“espeak -ves ‘%s'” % (messageProtocolEntity.getBody()))

def onMediaMessage(self, messageProtocolEntity):
# just print info
if messageProtocolEntity.getMediaType() == “image”:
print(“Echoing image %s to %s” % (messageProtocolEntity.url, messageProtocolEntity.getFrom(False)))

elif messageProtocolEntity.getMediaType() == “location”:
print(“Echoing location (%s, %s) to %s” % (messageProtocolEntity.getLatitude(), messageProtocolEntity.getLongitude(), messageProtocolEntity.getFrom(False)))

elif messageProtocolEntity.getMediaType() == “vcard”:
print(“Echoing vcard (%s, %s) to %s” % (messageProtocolEntity.getName(), messageProtocolEntity.getCardData(), messageProtocolEntity.getFrom(False)))

Como se muestra en el código hacemos un import os para poder ejecutar los comandos de linux desde python :D. En el ejemplo original de EchoClient contiene la linea

self.toLower(messageProtocolEntity.forward(messageProtocolEntity.getFrom()))

Para efectos de nuestro cliente borraremos esa linea, ya que esta es la que se encargar de forwardar el mensaje que recibio el cliente.

Modificaremos la función onTextMessage y quedará de la siguiente manera

onTestMessage

Donde la Primera línea imprime el pantall un mensaje mostando el contenido del mensaje que llegó, en la segunda línea ejecutamos la funcion os.system() y le pasamos el comando de linux a ejecutar, en este caso notify-send para lanzar una notificación en el escritorio.

TestMensaje

La tercera línea tambien ejecuta la función os.system() el cual para como parametro un comando para que la consla hable, un tipo loquendo, pero le pasamos el contenido que llego de el mensaje Whatsapp para que el sistema lo lea, un tipo Jarvis ;).

Está vivo, vivooooo !!!

Vídeo demo.

Bueno, con esto se puede realizar unnnnnn chorro de cosas, una implementación genial sería tcp over Whatsapp para tener un proxy en todos lados :D, pero bueno eso es más elavodaro. Espero que les sea util :D.

 

Get every day in a month dynamically MySQL – Stored Procedure

I share one MySQL Stored Procedure for every day of a month from a date.

At the moment I dont have a wordpress plugin for compatir code and is displayed in a nice way: D, so I share a picture of the Stored Procedure and below the Stored Procedure code itself.

dias_del_mes_dinamico

The logic is simple procedure, the stored parameter expects a start date month entry ‘2000-02-01’ format. Considering the input parameter must know what is the last day of that month, for which we use the function LAST_DAY('2000-02-01') returns us to ‘2000-02-28’. Knowing what the initial day and the final day we can go all dates that month and store in a temporär table, why a temporary table? Because YOLO: D.

Stored code here: D


#-----------------------------INICIO-------------------------------------------------
CREATE DEFINER=`root`@`localhost` PROCEDURE `dias_mes_dinamico`(IN `dia_entrada` DATE)
LANGUAGE SQL
NOT DETERMINISTIC
CONTAINS SQL
SQL SECURITY DEFINER
COMMENT ''
BEGIN
/*
Author: Rafael Vázquez García
Date: 2015-08-01
Description: Procedure to get every day of the month
*/

#Declaration of variables
DECLARE var_inicio, var_final INT DEFAULT 0;
DECLARE fecha_Inicial,fecha_Final, fecha_incremento DATE;

#AVariable initializations
SET fecha_Inicial = dia_entrada;
SET fecha_Final= LAST_DAY(fecha_Inicial);
SET var_inicio = EXTRACT(DAY FROM fecha_Inicial);
SET var_final = EXTRACT(DAY FROM fecha_Final);
SET fecha_incremento = fecha_Inicial;

#Create a temporaty table to store every day of a month
CREATE TEMPORARY TABLE examen.tmp_dias_mes(
id INT,
dia_mes DATE
);

#Get every day of the month
WHILE var_inicio <= var_final DO
INSERT INTO examen.tmp_dias_mes (id,dia_mes) values(var_inicio, fecha_incremento);
SET fecha_incremento = DATE_ADD(fecha_incremento, INTERVAL 1 DAY);
SET var_inicio = var_inicio + 1;
END WHILE;

#Show the temporary table
SELECT * FROM examen.tmp_dias_mes;

#Drop the temporary table
DROP TABLE examen.tmp_dias_mes;
END
#—————————–FIN————————————————-

Well, you can still optimize this process, and we could validate that a date is valid and not to exploit the world when we pass February 30th: D and catch any exception.

I hope you find it useful. Regards.

P.D. Linux Rules!

Recordatorio para tomar Pastillas con bash y notify-send

Hola gente.

El motivo de la entrada es cuando tienes que tomarte una partilla a cierta hora del día y hoy les voy a compatir una entrada para crear notificaciones que funcionen como recordatorios con notify-send en Ubuntu Mate 15.04.

ScreenshotRecordatorio

Primero que nada notify-send como lo dice “man” es un programa notificaciones de escritorio :D y esta es la manera como debe usarse

man_notify

 

Una de la opciones que nos permite usar notify-send es usar un icono para la notificación, en este caso yo quise personalizarlo un poco más descargando un png de un capsula de 32×32 pixeles y colocandola con los demás iconos de mi sistema. En mi caso yo lo descargue en la ruta ‘/usr/share/icons/gnome/32×32/status/’

$ sudo wget http://www.icon2s.com/wp-content/uploads/2013/09/medical-icon-Equipment-Capsule-Red.png

Una vez descargado el icono podemos probrar la notificación con el siguiente comando

$ notify-send -i /ruta/al/icono/medical-icon-Equipment-Capsule-Red.png Recordatorio "Tomar Pastilla"

Ahora prodemos crear un script en bash para que ejecute el comando

script_notificacion

Adjunto el script

#!/bin/bash

DISPLAY=:0.0 /usr/bin/notify-send -i /usr/share/icons/gnome/32×32/status/medical-icon-Equipment-Capsule-Red.png Recordatorio “Tomar Pastilla”

Es muy importante recalcar que se agrega la línea DISPLAY=:0.0 antes de la orden para ejecutar la notificación, ya que con eso estamos diciendole que sobre ese display que es nuestro escritorio debemos lanzar la notificación, ya que si no lo indicamos, cuando el script sea ejecutado por un cron no podrá visualizarse.

Al final debemos dar permisos de ejecución al script “chmod +x pastilla.sh"

Y agregamos el script al crontab para que se ejecute en los periodos de tiempo que programemos

$ contrab -e

Abrimos el crontab con nuestro editor favorito y agregamos la siguiente línea

 

0 10 * * * /bin/bash /home/usuario/scripts/notifications/pastilla.sh >/dev/null 2>&1

En este caso el script de notificación de ejecutará todos los días a las 10 a.m.

Espero que les sea útil. Saludos.
 

Netstat – Mostrar puertos abiertos y que servicios ocupan esos puertos

netstat_windows_nao

Ha pasado un rato sin escribir una entrada, pero aquí ando de nuevo.

En mi trabajo me ha tocado averiguar puertos de TCP o UDP ocupan ciertas aplicaciones o servicio y por eso me hice de la ayuda de la herramienta netstat. 

El comando debe ejecutado con permisos de sudo para poder observar el PID y el nombre del programa que corre sobre cierto puerto. El comando es el siguiente:

netstat -tupna

Donde cada parámetro que se le pasan netstat son:

-t: Lista todos los puertos TCP

-u: Lista todos los puertos UDP

-p: muestra el PID y nombre del programa al que pertenece cada socket

-n: Muestra direcciones numéricas en lugar de nombres de host.

-a: muestra el PID y nombre del programa al que pertenece cada socket

La salida del comando es la siguiente:

netstat

Podemos observar que hay un proceso de Java corriendo en el puerto tcp 25565 en estado “Listen” y sabiendo el PID podemos ejecutar un kill para tenerlo o buscar como dar de baja correctamente el servicio.

En el caso de Windows contamos con la herramienta netstat en cmd, pero los parametros cambian un poco.

El comando debe ser ejecutado en un cmd con permisos de Administrador. El comando es el siguiente.

netstat -naob > app_port.txt

Adicionalmente damos salida del comando hacia un archivo de texto para poder identificar el puerto o proceso más facilmente.

Donde cada parametro significa:

-n: muestra las direcciones y puertos de forma numérica

-a: Muestra todas las conexiones y puertos que se encuentran escuchando peticiones

-o: Muestra el ID del proceso asociado a la conexion

-b: Muestra el nombre del proceso.

La salida del comando es el siguiente

netstat_windows

Como se aprecia en la imagen, es la salida del comando en un archivo de texto y podemos hacer búsquedas fácilmente. También podemos ejecutar el comando si el parámetro “b” y la salida del comando sería la siguiente.

netstat_windows_nao

Sabiendo el PID del proceso podemos ejecutar “taskkill /PID <número de PID>” desde un cmd para terminal algún proceso.

Por el momento es todo,  espero que les pueda ser útil.

Calcular un Dirección de Red en base a una Dirección IP y la Mascara de Red

El día de ayer me encontraba repasando algunos conceptos básicos sobre direccionamiento IP, y me tope con el caso de calcular una dirección de red en base a una dirección IP y una mascara de red.

La operación es bastante sencilla, solo basta con convertir la dirección ip y la mascara a binario y comenzar a realizar un ‘AND’ bit por bit y convertir el resultado de binario a decimal y ta, tan !! Sabremos la dirección de red. :D

calculo de id de Red

 

La imagen superior muestra la operación de la dirección de red o id de la red.

En un principio usaba lápiz y papel, con el tiempo se adquiere destreza y puede realizarse como un calculo mental. Ha pasado un poco de tiempo se ha empolvado un poco esa destreza, pero me he hecho de otras habilidades bastante útiles. Así que mientras  desempolvaba esos conocimientos me dije a mi mismo, mi mismo hay que hacerlo con JavaScript. :D

En un principio comencé por declarar variables en javascript y asignar la dirección ip y la mascara, hacer un Split, convertir posición del arreglo en binario, completar ceros a la izquierda y realizar ‘AND’ bit por bit. Tengo que admitir que ese código era un chulada.

Me detuve a leer este post sobre Operadores sobre bits, lo cual me facilito muuuuuuucho la vida.

A continuación comparto el código:

Calculo Dirección de Red

var ip = '192.168.1.241';
var mask = '255.255.255.0';
var ipSplit = ip.split('.');
var maskSplit = mask.split('.');

/**
* La funcion determina la dirección de red en base a una direccion ip y una mascara de red
*
**/
function networkAddress(ipSplit, maskSplit){
var netAddress = new Array;
for(var i = 0 ;i < 4; i++){
netAddress.push(parseInt(ipSplit[i]) & parseInt(maskSplit[i]));
}
return netAddress;
};

networkAddress(ipSplit, maskSplit);

Basta cambiar las direcciones y ejecutarlo directamente sobre la consola de JavaScript de Chrome o su Browser favorito y ta, tan.

Resultado :D

Mi plan es hacer una extensión de Chrome y una función personalizada para Spreadsheet con GoogleAppScript que inicialmente calcule las direcciones de red y en un futuro pueda realizar direccionamiento VLSM, pero por cuestiones de sueño y trabajo no  pude hacerlo. Cuando este lista la subiré a la Chrome Web Store.

Espero que les sea de utilidad. Saludos.

Happy Hacking !