Muchos webmaster tienen redes de sitios clasificados por tema o rubro, de los cuales obtienen consultas, potenciales clientes, etc. Luego utilizan estos datos para cobrar comisiones, hacer un seguimiento de las ventas y monitorear la actividad. Centralizar estas consultas en un solo correo es una solución que suele ser práctica para casos de poco volumen o bien cuando los sitios los gestionamos solo nosotros.
Para los casos en que tenemos muchos sitios y queremos que terceros puedan ver la información, a modo de control, es necesario contar con una planilla en la cual se carguen los mensajes en forma automatica. Lo ideal es que los campos de información de los formularios completen las columnas del excel online para hacer facil el seguimiento. Eso es lo que vamos a hacer, guardar todos los emails en un Google Doc que podemos compartir y mantener actualizado al momento.
Gracias a rakisuy por este artículo!
Rakisuy:
Lo primero que debemos de hacer es ir a nuestro Google Docs, alli creamos una nueva Hoja del tipo formulario. La podemos editar, creamos los campos que tendrá nuestro formulario de Cforms.
Hacemos click arriba a la derecha en More actions y seleccionamos Embed. Esto nos abrira un popup con un codigo HTML, el cual es un iframe, para insertar nuestro formulario en donde deseemos, pero eso no lo haremos!
Tomamos la URL del iframe y la abrimos en el navegador, alli nos abrira nuestro formulario.
Lo importante ahora es que veamos el action en el codigo HTML de nuestro form, el cual es por ej.:
Aqui lo que nos importa es el formkey, el theme no nos interesa, por lo que lo borramos junto con todo lo demas dejando asi:
https://docs.google.com/spreadsheet/formResponse?formkey=dddddddddddddddddddddddddd
El nombre de nuestros campos es entry.0.single para nuestro primer campo, entry.1.single para el segundo, y asi sucecivamente, vemos que cambia el indice el campo, se le suma uno y comienza en 0
Lo importante es hacer un post a nuestro action, y pasando el valor de nuestros campos, pero tenemos que tener cuidado, ya que Google Docs usa HTTPS, protocolo seguro, por lo que el codigo PHP necesario para hacer un envio POST aqui es:
$Url = ‘https://docs.google.com/spreadsheet/formResponse?formkey=dddddddddddddddddddddddddd’;
$strRequest = «entry.0.single=valor campo uno&entry.1.single=valro del campo 2&entry.2.single=valor del campo 3»;
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $Url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_POST, 1) ;
curl_setopt($ch, CURLOPT_POSTFIELDS, $strRequest);
curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, 0);
curl_setopt($ch, CURLOPT_SSL_VERIFYHOST, 0);
$result = curl_exec($ch);
curl_close($ch);
La variable $Url es nuestro action, pero recuerda que sin pasar el theme, ni los otros parametros, solo el action!
Nuestros valores lo pasamos en la variable $strRequest, y lo hacemos como string, poniendo el nombre de nuestro campo = $nuestrovalor y los unimos con «&».
Con este codigo y hasta ahora podemos insertar datos en nuestra planilla de Docs, pero nos falta la integración con nuestro Cforms, para eso utilizaremos el archivo my-functions.php e iremos a la linea 154, la cual es:
function my_cforms_action($cformsdata) {
Notemos que todo el archivo esta comentado, lo que haremos sera descomentar esta funcion para poder utilizarla.
Lo siguiente que haremos sera obtener el valor ingresado en nuestro formulario de Cforms, lo hacemos de la siguiente manera:
$micampo = $form[‘El nombre de mi campo’];
En donde dice ‘El nombre de mi campo’ es el nombre del campo que le dimos en nuestro panel de Administración de WordPress en nuestro Cforms. y asi podemos obtener el valor de todos los campos, por lo que nos quedaria algo asi:
De esta manera, las consultas que nos llegan al mail tambien quedaran en una hoja de Google Docs, sumamente util en caso de recibir varias consultas que pueden atender varias personas, permite una importante organización.
Algo bueno de esto tambien es que Google automaticamente nos agrega una columna Timestamp, de cuando se insertaron los datos, sabiendo asi el momento exacto de la consulta.
Una forma simple de agregar marcas de agua a las imagenes de nuestro sitio en wordpress no consiste en usar plugins, podemos hacerlo con un archivo .htaccess, un archivo php y la imagen a incrustar.
Lo que tenemos que hacer es crear el archivo watermark.php en la raiz del ftp (junto al archivo wp-config.php), con el siguiente contenido:
<?php
$src = $_GET[‘src’];
header(‘Content-type: image/jpeg’);
//this will prevent the watermark from showing up in the thumbnail images
if (eregi(«150×150», $src)) {
$watermark = imagecreatefrompng(‘empty.png’);
} else {
$watermark = imagecreatefrompng(‘watermark.png’);
}
Luego agregamos un archivo watermark.jpg en la raiz, junto al archivo php.
Por ultimo modificamos el arcvhio .htaccess con la siguiente línea, de forma que cada pedido de una imagen en tamaño completo tenga la marca de agua incrustada.
En el artículo anterior Como proteger un directorio en un sitio web con contraseña vimos como agregar un password a un directorio. Una aplicación útil de esto es proteger el directorio admin de nuestro wordpress con usuario y contraseña para agregar un nivel extra de seguridad.
Los pasos a seguir son los mismos que en el caso anterior, creamos el archivo .htpasswd, lo colocamos en un directorio no accesible desde la web y luego el archivo .htaccess en el directorio wp-admin de forma que el sitio público no quede bloqueado pero si el admin.
El problema que puede surgir en muchos casos con esta solución es que no podemos acceder al archivo admin-ajax.php, que es utilizado por ejemplo por algunos plugins para cargar contenidos.
Una solución es agregar en nuestro archivo .htaccess una directiva para que este archivo sea accesible para todo el público sin pedido de contraseña, esto lo logramos con un archivo como el que sigue:
Posted: febrero 19th, 2011 | Author:admin | Filed under:PHP, Recursos Web | Tags:Google Translate, PHP | Comentarios desactivados en Traducción en tiempo real mediante Google Translate con PHP
La traducción de textos en tiempo real es posible utilizando PHP y la API de Google Translate. En forma rápida y sencilla podemos realizar traducciones en los idiomas soportados por el servicio de Google.
En dos líneas podemos realizar el pedido de traducción y procesar la información de respuesta que llega en JSON:
Los parámetros a utilizar son tres. El primero indica la versión de API que estamos utilizando, en la actualidad la 2.0 está en desarrollo por lo que haremos uso de la 1.0.
El parámetro q indica el texto a traducir. Luego indicamos los idiomas de origen y destino. En este caso es que indica español y en que indica english. Debemos hacer uso de las siglas utilizadas por Google Translate para indicar los idiomas.
Al procesar el JSON con json_decode obtenemos un array con un campo «responseStatus» que indica si la traducción se realizó con éxito. En dicho caso devuelve el valor «200».
El texto está contenido en [«responseData»][«translatedText»], por lo cual podemos responder en un AJAX para realizar traducciones instantáneas y en forma sencilla.
Enviar mails con PHP suele ser sencillo, utilizando la funcion mail() podemos hacerlo aunque no tenemos prácticamente fleixbilidad ni opciones. Casos típicos son cuando queremos enviar mails por smtp, utilizando una cuenta en particular, o nuestro servidor no tiene configurado un servidor local para PHP, o necesitamos una conexion SSL, etc.
Para estos casos podemos usar la clase phpmailer, que nos da todas estas opciones y más. La clase la pueden descargar de: phpmailer.codeworxtech.com
Lo único que necesitamos hacer luego de tener la clase descargada y colocada nuestro sitio, es incluir el archivo de la misma e instancia la clase:
require(«phpmailer/class.phpmailer.php»);
$mail = new PHPMailer();
Hecho esto pasamos a definir mail de origen, destino, nombre, etc.:
$mail->From = $mailfrom; // Mail de origen
$mail->FromName = $name; // Nombre del que envia
$mail->AddAddress($para); // Mail destino, podemos agregar muchas direcciones
$mail->AddReplyTo($mailfrom); // Mail de respuesta
Luego definimos el contenido del mail:
$mail->WordWrap = 50; // Largo de las lineas
$mail->IsHTML(true); // Podemos incluir tags html
$mail->Subject = «Consulta formulario Web: $name»;
$mail->Body = «Nombre: $name \n<br />».
«Email: $mailfrom \n<br />».
«Tel: $tel \n<br />».
«Mensaje: $info \n<br />»;
$mail->AltBody = strip_tags($mail->Body); // Este es el contenido alternativo sin html
Podemos adjuntar archivos simplemente agregando los mismos de la siguiente forma:
$mail->AddAttachment(«nombredearchivo.txt»); // Ingresamos la ruta del archivo
Y ahora viene la parte divertida (no solo me pica el…errr), definimos el servidor que enviara el mail, podemos definir tipo de servidor, autenticacion, usuario, contraseña, etc. Vemos ejemplo de las posibilidades que tenemos.
Si vamos a enviar mail desde el servidor local sin configuración especial podemos usar:
$mail->Host = ‘localhost’;
Si necesitamos utilizar una casilla de correo smtp, con user y pass:
$mail->IsSMTP(); // vamos a conectarnos a un servidor SMTP
$mail->Host = «mail.servidor.com»; // direccion del servidor
$mail->SMTPAuth = true; // usaremos autenticacion
$mail->Username = «info@servidor.com»; // usuario
$mail->Password = «pass»; // contraseña
Si necesitamos una conexion con SSL, por ejemplo para enviar un mail desde PHP con gmail:
Como ven esta clase es muy flexible y nos olvidamos de tener que manejar nosotros mismos conexiones complejas o con cabeceras especiales. Podemos simplificarnos mucho la vida utilizando phpmailer para enviar mails.
Ya para enviar el correo, simplemente utilizamos la siguiente linea:
$mail->Send();
Podemos poner esa llinea dentro de un if para saber si quedo todo bien configurado y se pudo enviar el email, de la siguiente forma:
if ($mail->Send())
echo «Enviado»;
else
echo «Error en el envio de mail»;
Uno de los grandes problemas de usabilidad en Internet es la interacción con el usuario cuando enviamos archivos. Por lo general al hacer descargas tenemos la barra de progreso del navegador que nos indica el estado/velocidad de la transferencia, pero qué sucede cuando enviamos un archivo? Especialmente en el caso de archivos grandes y cuando tenemos conexiones relativamente lentas, tenemos el problema de no saber qué pasa con el envío… Si se detuvo, si sigue funcionando, solo nos queda esperar a ver que pasa.
Aunque hay muchas soluciones parciales a este problema, por ejemplo con animaciones flash o javascript que muestran una barra de progreso simulado, queremos una solución real, que muestre si realmente hay transferencia.
Las soluciones más básicas de envío de archivo suelen funcionar con un formulario html que envía el o los archivos a un script para procesar, un código como este es algo típico:
Claro que este tipo de transferencia no nos da ninguna interacción avanzada que indique al usuario el progreso de la transferencia. Para esto vamos a necesitar un script del lado del servidor que se encargue de recibir el archivo. A pesar de que con PHP se pueden hacer unas cuntas cosas, no tenemos la capacidad de acceder directamente al sistema de archivos y ver el progreso del mismo, por lo cual queda descartado el uso del mismo por lo menos para monitorear el progreso de la carga. Sí podemos utilizar PHP para el resto del proceso, como sea insertar en una base de datos, enviar mensajes etc.
El intermediario para esta solución será un script en Perl, llamado Uber-Uploader. Este script requiere de que el servidor soporte scripts Perl, trabajando con también con PHP y Javascript. El sitio de origen de este script lo pueden encontrar aquí: http://uber-uploader.sourceforge.net/. De todas formas ya que al día de hoy no está actualizado a la última versión disponible adjunto un zip con los archivos necesarios.
Una gran ventaja de este script es que no necesitamos modificar mas que la configuración del mismo, sin tener que meternos con el código en Perl.
Volviendo al script, tenemos los siguiente archivos dentro del zip en cgi-bin:
uu_default_config.pm
uu_ini_status.pl
uu_lib.pm
uu_upload.pl
Estos son los archivos de Perl que deben incluirse en el directorio cgi-bin o donde nuestro servidor ejecute los archivos cgi (si este directorio no existe se puede probar con la raíz del sitio). Es muy importante que los permisos de ejecución esten correctamente configurados para que Apache pueda ejecutar el script. Seteando los permisos en 755 para todos los archivos de cgi-bin no deberíamos tener problema.
El archivo que más nos interesa en este caso es uu_default_config.pm que contiene la configuración general de directorios y filtros. Las opciones más importantes son:
config_file_name
Nombre del archivo de configuración, en la segunda parte veremos que podemos tener varias configuraciones.
temp_dir
Archivo temporal de carga para el script.
upload_dir
Donde quedarán guardados los archivos al ser cargados.
max_upload
Tamaño máximo de los archivos.
redirect_url
Dirección a donde nos llevará el script al terminar de cargar, donde podremos realizar tareas post carga como interacción con bases de datos etc.
disallow_extensions
Extensiones no permitidas de archivo.
Con esto tenemos la configuración del script Perl, ahora veamos la otra parte, PHP y Javascript. En este caso tenemos los siguientes archivos (los que aparecen fuera de cgu-bin en el zip):
upload.php
uu_conlib.php
uu_file_upload.js
uu_finished.php
uu_finished_lib.php
uu_get_status.php
Empecemos por uu_conlib.php, el cual es el archivo de configuración del lado de PHP. Las variables que más nos interesan son:
$path_to_upload_script
Define la ruta donde está el script Perl, noten que si el mismo no esta dentro de cgi-bin deberemos modificar la ruta.
$path_to_ini_status_script
Lo mismo que para la variable anterior.
$default_config_file
Archivo de configuración que utilizará este PHP, útil en caso de usar varias configuraciones.
$max_upload_slots
Cantidad máxima de slots de carga, sí, podemos cargar muchos archivos en cola =).
$progress_bar_width
Largo de la barra de progreso, más que nada un tema de diseño.
Pasemos al archivo upload.php, archivo que contiene el formulario html y archivo donde se «muestra» el uploader. Aquí podemos agregar variables al formulario las cuales recibiremos al finalizar la carga de los archivos, por ejemplo id de usuarios, campos con descripciones, etc.
Por último tenemos el archivo uu_finished.php, archivo a donde llegamos al terminar la carga. El script procesa la información de los archivos, datos como nombre, tamaño, etc de cada archivo cargado es accesible en este archivo. Por ejemplo para obtener el nombre del primer archivo cargado podemos hacerlo de la siguiente forma:
$_FILE_DATA[0]->getFileInfo(‘name’)
Y en caso de tener varios archivos cargados podemos hacer lo siguiente:
Ahora tenemos un panorama general del uso de este script, en la segunda parte veremos como tener varios archivos de configuración, como personalizar el formulario de contacto y los errores más comunes que debemos verificar.
Hacemos click arriba a la derecha en More actions y seleccionamos Embed. Esto nos abrira un popup con un codigo HTML, el cual es un iframe, para insertar nuestro formulario en donde deseemos, pero eso no lo haremos!
