El otro día un cliente me preguntó ¿Cual es la hora ideal para publicar contenidos en redes sociales? Por mi parte le compartí información que había leido con anterioridad, la mayoría de sitios extranjeros, casualmente ahora me acabo de encontrar un estudio bastante interesante que les comparto “Estudio de Medios y Dispositivos entre internautas mexicanos” de autoría IAB México ( Interactive Advertising Bureau). Aquí dejo datos bastante genéricos pero que les permitirá tener un panorama bastante amplio para la toma de decisiones referente a sus contenidos digitales, sobre todo pensando en redes sociales.

horario cuando los internautas ponen más atencion a contenidos digitales

horario cuando los internautas ponen más atencion a contenidos digitales.

 

Sigue leyendo


Java Gmail

Java Gmail

En el siguiente contenido consta de dos partes:

En la primera explicare como establecer una conexión con Gmail con el protocolo smpt y bajo la capa de conexión segura(SSL).

En la segunda voy a explicar acerca de una clase(Gmail.java)  que podemos re-utilizar para el envio de correos electronicos desde nuestros proyectos en Java.

Parte 1 – Proceso básico del envío de correos electrónicos:

Lo primero vamos a explicar cual es el procedimiento básico de envíos de correos electrónicos con SMTP con Java utilizando la API de: Javax.mail , el cual el proceso básico consiste en tres partes:

  1. Establecer las propiedades de la conexión.
  2. Autenticarse y establecer una sesión.
  3. Agregando atributos del email y envio.

Como se comento vamos a ocupar javax.mail la cual sera una dependencia de nuestro código, para resolver dicha dependencia podemos ocupar maven:

 <dependency>
        <groupId>javax.mail</groupId>
        <artifactId>mail</artifactId>
        <version>1.4</version>
    </dependency>

O bien lo puedes descargar el .jar desde:
http://www.oracle.com/technetwork/java/javasebusiness/downloads/java-archive-downloads-eeplat-419426.html#javamail-1.4.7-oth-JPR

1.- Estableciendo propiedades

Lo primero que tenemos que hacer es definir las propiedades de nuestra conexión para esto ocupamos el paquete java.util.Properties donde vamos a establecer el puerto 465 y activamos la autenticación con capa SSL.

// Paso 1 estableciendo las propiedades de conexión
java.util.Properties mailServerProperties;
mailServerProperties = System.getProperties();
mailServerProperties.put("mail.smtp.host", "smtp.gmail.com");
mailServerProperties.put("mail.smtp.socketFactory.port", "465");
mailServerProperties.put("mail.smtp.socketFactory.class", "javax.net.ssl.SSLSocketFactory");
mailServerProperties.put("mail.smtp.auth", "true");
mailServerProperties.put("mail.smtp.port", "465");

 

2.- Autenticandose

Vamos a identificarnos y establecer sesión para esto ocupamos el paquete javax.mail.Session, como se ve a continuación:

javax.mail.Session getMailSession = Session.getDefaultInstance(
       mailServerProperties,
       new javax.mail.Authenticator() {
	protected PasswordAuthentication getPasswordAuthentication() {
		return new PasswordAuthentication("mi.cuenta@gmail.com", "mi password");
	}
});

3.- Enviado el correo

Enviando el correo

javax.mail.internet.MimeMessage generateMailMessage;
generateMailMessage = new MimeMessage(getMailSession);
//Estableciendo el destino (TO)
generateMailMessage.addRecipient(Message.RecipientType.TO, new InternetAddress("destino@server.com"));

//Estableciendo el destino de la copia (CC)
generateMailMessage.addRecipient(Message.RecipientType.CC, new InternetAddress("con.copia@gmail.com"));

//Estableciendo el destino de la copia oculta (BCC)
generateMailMessage.addRecipient(Message.RecipientType.BCC, new InternetAddress("bcc@hotmail.com"));

//Estableciendo el titulo del mensaje (subject)
generateMailMessage.setSubject("titulo del mensaje a enviar");

// Estableciendo el contenido del correo electronico enriquesido(HTML)
String bodyEmail = "<h1>correo desde gmail</h1><p>Enviado de forma exitosa</p>";
generateMailMessage.setContent(bodyEmail, "text/html");

//Finalmente  enviamos el correo
javax.mail.Transport.send(generateMailMessage);

Parte 2 .- Clase Gmail Una clase lista para enviar desde Gmail

Vamos a crear una clase llamada Gmail en donde le vamos a agregar lo anterior explicado a la vez que la creamos de una forma que sea muy fácil de reutilizar, veamos como quedaría:

package com.mundosica.core.Utils;

import java.util.Properties;

import javax.mail.Message;
import javax.mail.MessagingException;
import javax.mail.PasswordAuthentication;
import javax.mail.Session;
import javax.mail.internet.AddressException;
import javax.mail.internet.InternetAddress;
import javax.mail.internet.MimeMessage;

public class Gmail {
    static Properties mailServerProperties;
    static Session getMailSession;
    static MimeMessage generateMailMessage;
    static String login = "username";
    static String password = "secret";
    static String to = null;
    static String cc = null;
    static String bcc = null;
    static String subject = null;
    static String body = null;
    
    public static void config(String... namesAndValues) {
        if (namesAndValues.length % 2 == 1) {
            throw new IllegalArgumentException("The number of arguments must be pair.");
        }
        String nameConfig = null, valueConfig = null;
        for (int i = 0; i < namesAndValues.length - 1; i += 2) {
            nameConfig = namesAndValues[i].trim().toLowerCase();
            valueConfig = namesAndValues[i +1];
            switch    (nameConfig) {
                case "username":
                case "login":
                    Gmail.login = valueConfig;
                    break;
                case "password":
                case "pass":
                    Gmail.password = valueConfig;
                    break;
                case "to":
                    Gmail.to = valueConfig;
                    break;
                case "cc":
                    Gmail.cc = valueConfig;
                    break;
                case "bcc":
                    Gmail.bcc = valueConfig;
                    break;
                case "title":
                case "subject":
                    Gmail.subject = valueConfig;
                    break;
                case "msg":
                case "body":
                    Gmail.body = valueConfig;
            }
        }
    }
    public static Boolean send(String... namesAndValues) {
        Gmail.config(namesAndValues);
        try {
            return Gmail.send();
        } catch (MessagingException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return false;
    }
    public static Boolean send() throws AddressException, MessagingException {
        Boolean success = false;
        // step 1 set connection properties
        mailServerProperties = System.getProperties();
        mailServerProperties.put("mail.smtp.host", "smtp.gmail.com");
        mailServerProperties.put("mail.smtp.socketFactory.port", "465");
        mailServerProperties.put("mail.smtp.socketFactory.class", "javax.net.ssl.SSLSocketFactory");
        mailServerProperties.put("mail.smtp.auth", "true");
        mailServerProperties.put("mail.smtp.port", "465");
        // step 2 Authentication
        if (Gmail.login == null || Gmail.password == null) {
                return success;
        }
        Session getMailSession = Session.getDefaultInstance(mailServerProperties,new javax.mail.Authenticator() {
            @Override
            protected PasswordAuthentication getPasswordAuthentication() {
            return new PasswordAuthentication(Gmail.login, Gmail.password);
            }
        });

        // step 3 sending Email
        generateMailMessage = new MimeMessage(getMailSession);
        if (Gmail.to != null) {
            generateMailMessage.addRecipient(Message.RecipientType.TO, new InternetAddress(Gmail.to));
        }
        if (Gmail.cc != null) {
            generateMailMessage.addRecipient(Message.RecipientType.CC, new InternetAddress(Gmail.cc));
        }
        if (Gmail.bcc != null) {
            generateMailMessage.addRecipient(Message.RecipientType.BCC, new InternetAddress(Gmail.bcc));
        }
        if (Gmail.subject == null) {
            Gmail.subject = "subject gmail object";
        }
        generateMailMessage.setSubject(Gmail.subject);
        if (Gmail.body == null) {
            Gmail.body = "<h1>body gmail object</h1><p>it's a simple test</p>";
        }
        generateMailMessage.setContent(Gmail.body, "text/html");
        javax.mail.Transport.send(generateMailMessage);
        return success;
    }

}

Test Haciendo una prueba

Haciendo una prueba con Junit, dejo dos ejemplos de como utilizar la clase Gmail:

import org.junit.Test;
public class GmailTest {

    @Test
    public void testSendDirecto() {
        Gmail.send(
                "login", "some.user@gmail.com",
                "password", "secret",
                "to", "edw_inkisidor@hotmail.com",
                "cc", "chanerec@gmail.com",
                "bcc", "eymard@gmail.com",
                "subject", "prueba de email",
                "body", "<h1>Esto es una prueba de envio de correos</h1><p>exitosa!!</p>"
        );
    }
    
    @Test
    public void testConfigYSend() {
        //Esto quizas en el archivo de configuracion
        Gmail.config(
                "username", "some.user@gmail.com", //alias de login
                "pass", "**secret**", //alias de password
                "to", "edw_inkisidor@hotmail.com",
                "cc", "chanerec@gmail.com",
                "bcc", "eymard@gmail.com"
        );
        //esto en donde se envia el correo previamente ya configurado los parametros
        Gmail.send(
                "title", "prueba de email",//alias de subject
                "msg", "<h1>Esto es una prueba de envio de correos</h1><p>exitosa!!</p>"
        );
    }
}

Código en github

Este código forma parte de un conjunto de clases que hemos desarrollado en mundosica.com, del cual extraje esta parte y lo dejo en github para quien lo guste usar:

Visitar proyecto


El presente post pretende responder a la pregunta ¿Cuales son los sitios 100 websites más visitados en México? No importa el origen del website lo importante es el volumen de visitas, Toda la información fue tomada de Alexa.com y en esta ocasión procuré hacer una comparación con un post que publiqué el año pasado.

Breve resumen:
Google.com.mx es el sitio más visitado y se mantiene en primer lugar en relación al año 2013, no así su competidor bing quien perdió posiciones pasando del lugar 31 al 45. Google mantiene su aplastante superioridad frente a sus competidores y conserva los lugares de yutube y google.com

Al parece a los mexicanos nos gustan las redes sociales ya que el segundo puesto lo mantiene Facebook a demás de las otras 6 redes sociales que aparecen entre los 100 sitios más visitados durante 2014. También śe incrementó el número de sitios de comercio electrónico seguido de los portales de noticias, comunidades web, Publicidad, instituciones financieras, buscadores, redes sociales, etc.

Se pueden sacar muchas conclusiones aquí algunas muy básicas.

*NetFlix perdió posiciones pero se mantiene como líder en video on demand

*Mercado Libre pierde posiciones pero sitios como Linio.com.mx pasó del lugar

* unam.mx gana 11 posiciones, un incremento bastante considerable

PayPal pierde posiciones pero aun se mantiene por encima de sites con servicios financieros como Banamex.com.mx

Aliexpress.com pasó del lugar 90 al 32 , sin duda los mexicanos ya no somos tan reacios a comprar en línea.

Organicé los 100 sitios en categorías muy básicas quedando de la siguiente forma:

Los 100 websites más visitados en México durante 2014

Sigue leyendo


El siguiente articulo es el primero de una serie de artículos en donde intentare expresar un conjunto de ideas de una arquitectura de aplicación que nos permita con el tiempo crear proyectos de software robustos. Para conseguir este objetivos tendremos que ver primero algunos tópicos avanzados en Java.

 

libreria_java

Accediendo a la información de la clase

El método getClass() se encuentra definido en Object como un método final, dicho método devuelve una representación en tiempo de ejecución de la clase del objeto sobre el cual podemos acceder a una serie de caracteristicas del objeto por ejemplo: el nombre de la clase, el nombre de su superclase y los nombres de los interfaces que implementa.

Mostrando el nombre de la clase

Observe el siguiente código de la clase PruebaNombre.java:

public class PruebaNombre {
	public String nombreClase() {
		return this.getClass().getSimpleName();
	}
	public static void main(String[] args) {
		PruebaNombre prueba = new PruebaNombre();
		System.out.print(prueba.nombreClase());
	}
}

Al ejecutar nos imprime PruebaNombre el cual es el nombre simple para la clase en cuestión, lo importante aquí es que accedemos a la clase por medio de this.getClass() y de ahí accedemos al nombre de la clase con el método getSimpleName, que es lo que devolvemos.

Accediendo a atributos

Ahora por medio de getClass vamos a crear un método para acceder a los atributos existentes en la clase para imprimir el nombre y valor de cada atributo:

import java.lang.reflect.Field;
public class PruebaAtributos {
	String atributo_1 = "valor 1";
	String atributo_2 = "valor 2";
	String valor_x = null;
	
	public void imprimirAtributos() {
		Field[] fields = this.getClass().getDeclaredFields();
		for(Field field : fields) {
                try {
                	String fieldName = field.getName();
                	Object fieldValue = field.get(this);
					System.out.println(fieldName + ":" + fieldValue);
				} catch (IllegalArgumentException | IllegalAccessException e) {
					e.printStackTrace();
				}
            }
	}
	public static void main(String[] args) {
		PruebaAtributos prueba = new PruebaAtributos();
		prueba.imprimirAtributos();
	}
}

En este caso el resultado del código es el siguiente:

atributo_1:valor 1
atributo_2:valor 2
valor_x:null

Accediendo al constructor, creando elementos dinámicos

Desde la instancia de clase también podemos acceder a los constructores de clase, para a partir de estos crear una nueva instancia dinámica del objeto en cuestión, observe el siguiente código:

import java.lang.reflect.InvocationTargetException;

public class PruebaNewInstance {
	public String atributo_1 = "valor default";
	/**
	 * Constructores normales
	 * 
	 * @param atributo_value
	 */
	public PruebaNewInstance(String atributo_value){
        this.atributo_1 = atributo_value;
    }
	public PruebaNewInstance(){}
	/**
	 * Devuelve una instancia de PruebaNewInstance dinamica a partir de un constructor con atributos
	 * @param atributo_value
	 * @return
	 */
	static public PruebaNewInstance constructor(String atributo_value) {
		try {
			return PruebaNewInstance.class.getConstructor(String.class).newInstance(atributo_value);
		} catch (InstantiationException | IllegalAccessException
				| IllegalArgumentException | InvocationTargetException
				| NoSuchMethodException | SecurityException e) {
			e.printStackTrace();
		}
		return null;
	}
	/**
	 * Devuelve una instancia de PruebaNewInstance dinamica a a patir del constructor vacio
	 * 
	 * @return
	 */
	static public PruebaNewInstance constructor() {
		try {
			return PruebaNewInstance.class.newInstance();
		} catch (InstantiationException | IllegalAccessException
				| IllegalArgumentException | SecurityException e) {
			e.printStackTrace();
		}
		return null;
	}

	public static void main(String[] args) {
		PruebaNewInstance prueba = new PruebaNewInstance("valor_atributo_1");
		System.out.println(prueba.atributo_1);
		// Creando un objeto desde un constructor dinamico
		PruebaNewInstance prueba2 = PruebaNewInstance.constructor("val_atrib_1 constructor Dinamico");
		System.out.println(prueba2.atributo_1);
		//
		PruebaNewInstance prueba3 = PruebaNewInstance.constructor();
		System.out.println(prueba3.atributo_1);
	}
}

El resultado del código anterior es:

valor_atributo_1
val_atrib_1 constructor Dinamico
valor default

Código completo

Dejo un enlace del código en cuestión: [ PruebaGetClass.java ]

Conclusiones

¿Se te ocurre algunas formas de utilizar estas características del lenguaje java?, bien esto lo podríamos utilizar para p.e. acceder a los nombres y atributos y a partir de esto realizar determinadas acciones.

¿Para donde vamos?

Podríamos crear un objeto abstracto Model el cual podría servir como un objeto persistencia del cual podríamos heredar en otros objetos p.e. PersonasModel debería de conectar a la tabla personas, también podríamos agregar atributos como prmary_key y a partir de estos valores realizar consultas SQL como INSERT, UPDATE, SELECT.


En ocasiones necesitamos ejecutar determinada tarea con permisos de usuario root p.e. arrancar determinado servicio como web o de base de datos. Desgraciadamente cuando agregamos un lanzador en nuestro escritorio este se ejecutara con los permisos del usuario que le haga clic en el lanzador en cuestión.

Crear un lanzador

Bien imaginemos que queremos ejecutar el siguiente script con permisos de usuario root:

/bin/mi_script.sh

Para esto vamos a crear un lanzador con el comento gnome-desktop-item-edit como vemos a continuación:

 #Creando lanzador en el escritorio
gnome-desktop-item-edit --create-new ~/Escritorio/

Esto nos debería de ejecutar una ventana similar a la que se muestra a continuación:

 

Creador de lanzadores

Credor de lanzadores

Este comando básicamente nos genera un lanzador el cual no es otra cosa que un archivo de texto que contiene la información de la aplicación a ejecutar cuando le damos clic, para mayor información del formato consulte:

https://developer.gnome.org/integration-guide/stable/desktop-files.html.es

Agregando login root al lanzador

Una vez que tengamos abierta la ventana de la configuración agregamos lo siguiente en el campo de comando:

gksudo bash /bin/mi_script.sh

Con esto estamos diciendo que el comando bash /bin/mi_script.sh sera ejecutado con permisos de usuario root por medio del comando gksudo el cual es una versión gráfica del comando sudo, a continuación se ilustra la imagen:

lanzador_con_gksudo

Notas:

  • El comando gksudo funciona para gnome para kde puedes ocupar el kdesudo.
  • Para tener disponible el comando gksudo debes de instalar previamente gnome-panel.

El 15 de enero de este año(2015) salio la versión Beta de firefox 36, veremos como instalar esta versión en nuestro sistema debian o derivados:

 

Pasos de instalación

1.- Agregando repositorio y actualizando la lista de paquetes

Lo primero que tenemos que hacer es agregar la fuente de firefox beta y posteriormente actualizamos la lista de paquetes disponibles, para esto ejecutamos las siguientes lineas:

#Agregando el nuevo repositorio
sudo apt-add-repository ppa:mozillateam/firefox-next

#Actualizando lista de paquetes
sudo apt-get update

2.- Actualizando firefox

#Actualizando el repositorio de firefox
sudo apt-get install --only-upgrade firefox

#instalando las traducciones adecuadas.
sudo apt-get install firefox-locale-es firefox-locale-es:i386

Finalmente probamos que todo funcione de forma correcta, para esto ejecutamos el lanzador de aplicaciones presionando Alt + F2 y escribimos firefox nos debería de abrir el firefox de ahí nos vamos a Help/About Mozilla firefox. Esto nos debería de aparecer que la versión es la 36


El protocolo ARP (Address Resolution Protocol) nos sirve para resolver direcciones físicas(MAC) a partir de las direcciones logicas(IP).

En ocasiones un nodo en la red necesita saber la dirección MAC de determinado equipo y sí solo conoce la dirección IP entonces realiza una solicitud ARP con esta dirección IP esperando que el equipo propietario de dicha dirección le responda con su dirección MAC.

Para que quede mas claro tratare de explicar esto con una imagen:

protocolo_arpComo podemos ver el nodo con IP 192.168.0.1 y MAC 10:16:F8:BA:19:57 Desea saber la dirección MAC del equipo con IP 192.168.0.9 por lo tanto envía una solicitud ARP a todos los equipos(broadcast) preguntando algo como:

Equipo 192.168.0.9 ¿me puedes enviar tu dirección MAC?

 

Esta “pregunta”(ARP – Request) les llega a todos los equipos a la red, pero solamente el equipo que tenga la dirección 192.168.0.9 será quien responda dicha pregunta(ARP-Reply) con algo como:

Equipo 192.168.0.1, yo soy 192.168.0.9 y mi dirección física es: 00:D1:16:19:34:01

Si nos percatamos en el ARP-Reply(respuesta) la respuesta la envia al equipo con MAC 10:16:F8:BA:19:57 por lo cual la solicitud no es enviada a todos los equipos como en el caso del ARP-Request(solicitud).

Tablas ARP

Todo este proceso de obtener la relaciones de direcciones IP y MACs puede provocar bastante trafico en la red sobre todo en el proceso de solicitud ya que como vimos se llena toda la red de paquetes.

Por esta razón los equipos van generando una tabla en donde almacenan esta información y con esto evitar la necesidad de realizar solicitudes ARPs. Dichas tablas son conocidas como Tablas ARPs.

Obteniendo las tablas ARPs:

Cuando configuramos una red es bastante común el ocupar las direcciones MAC y su relación con las direcciones IPs para determinadas configuraciones p.e. configurar una NAT, asignación de direcciones IPs especificas, bloqueo de equipos, etc…

La mayoría de los sistemas operativos cuentan con el comando arp el cual nos muestra dichas tablas veamos como obtenerlas en los sistemas operativos mas comunes:

#Linux, MAC y Windows
arp -a
#En Windows tmb se puede ocupar
arp -g

Tablas ARPs en Android.

En android no contamos con dicho comando sin embargo podemos acceder a un archivo (arp) ubicado en /proc/net/ (en esta carpeta están las configuraciones de red de android) en el cual se encuentran las tablas arp, sin mas veamos como visualizar dichas tablas.

cat /proc/net/arp

Nota: para acceder a la consola en android podemos ocupar la aplicación: “Terminal Emulator for Android”, la cual puedes acceder desde:

https://play.google.com/store/apps/details?id=jackpal.androidterm&hl=es

NOTA2: Los sistemas operativos Unix(Linux & MAC) cuentan tambien con el archivo /proc/net/arp

Para mayor info:


Muchas gracias a la Universidad Politécnica de Tlaxcala por invitarme a participar como conferencista en 3er Congreso de Tecnologías de la Información y el 7mo. Foro de Software Libre con “Tras la Chuleta con Software Libre” , espero que a los estudiantes les sea de utilidad la información recabada durante los 10 años de experiencia que tengo con mundosica.com empresa orientada a ofrecer soluciones basadas en Software Libre.

Es para mi un gusto haber convivido con los académicos Maestro Osvaldo Moreno Hernández, Maestro Augusto Melendez Teodoro y al Maestro Carlos David Moctezuma Ortíz quienes me invitaron a participar en el evento. De igual manera me dio mucho gusto vover a tener largas charlas con Alex Fusser, conocer a Martín García de Nettix Perú y Allan Gerardo Sandoval Cuevas quien andaba devielándose durante el evento.

Nuevamente muchas gracias a todos por la hospitalidad y todas las facilidades, espero haber respondido a las expectativas y será un gusto regresar cada vez que me inviten.

Foto cortesía 



Más allá de solo la presencia web es importante pensar en los objetivos que se desean conseguir con un web site. En algunos casos los clientes ya tienen website pero

¿su sitio se visualiza en dispositivos móviles?

¿Su sitio web solo se puede ver si tiene instalado flashplayer?

Muchos de los usuarios de dispositivos móviles no descargan flash solo para ver un solo sitio web. Nuestro trabajo es hacer fácil el de usted.