¿Usted necesita añadir una firma pre-definida a sus correos electrónicos?
1.- Solo debe ingresar a su cuenta de e-mail con usuario y contraseña.
2.- Preferencias de Webmail —> Preferencias de la cuenta —>  Firma
3- Añadir los datos que usted necesita y finalmente guardar.

Así de sencillo.

Para añadir una imagen a la firma solo debe dar click en el ícono de imagen y añadir la URL.

Imagen-a-firma


Con el siguiente tutorial usted podrá re-enviar sus correos electrónicos a cuentas que ya administra

1.- En la esquina superior derecha elegir “Configuración d la cuenta

2.- Reenvió de correos y seleccionar “Configurar reenvío

3.- Usted escribirá un correo electrónico existente donde llegarán los correos electrónicos

4.- Finalmente seleccionará “Agregar reenvió

Eso es todo, ahora los correos que le envien a su cuenta personalizada le llegará al correo que acaba de añadir.

redireccionar-correo

Para cualquier suerencia o comentario puede llamarnos al (951)205 43 51 o escribir a contacto@mundosica.com


El presente tutorial le permitirá cambiar la contraseña de su cuenta de e-mail.

Usted deberá acceder a  su dominio/webmail: ejemplo www.su-dominio.com/webmail

1.- En la esquina superior derecha encontrará Configuración de cuenta de correo

2.- Luego seleccione Cambiar contraseña

3.- Deberá establecer una contraseña con mayúsculas, minúsculas y números

4.- Finalmente deberá dar click en “Cambiar Contraseña”

cambiar-contraseña

 

 

 

 

Así de fácil.

Cualquier duda o comentario puede llamarnos al (951)205 43 51 o escribir a contacto@mundosica.com


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.