Problema al actualizar PHP 5.3 – XCache requires Zend Engine API version

Al actualizar PHP desde una reposición, por ejemplo de la 5.2.* a la 5.3.*, la extensión de XCache queda desactualizada.

Para verificarlo simplemente tienes que hacer.

php -v
#Obtenemos de vuelta
XCache requires Zend Engine API version 220060519.
The Zend Engine API version 220090626 which is installed, is newer.
Contact mOo at http://xcache.lighttpd.net for a later version of XCache.

Para solucionarlo vamos a recompilar XCache.

#Nos movemos al directorio
cd /usr/local/src
#Obtenemos la última versión XCache 1.3.2
wget http://xcache.lighttpd.net/pub/Releases/1.3.2/xcache-1.3.2.tar.gz
#Descomprimimos
tar -zxf xcache*.tar.gz
#Nos movemos al source
cd xcache*
#Verificamos
phpize
#Creamos y nos movemos a otro directorio para compilar
mkdir ../xcache-build
cd ../xcache-build
#Configuramos
../xcache-1*/configure -enable-xcache
#Compilamos
make
#Instalamos
make install
#Verificamos
php -v
#Reiniciamos apache 
service httpd restart

Share



Crear servicio de aviso por SMS con google calendar y PHP

Voy a explicar como crear un servicio de avisos por SMS con la renovada api de google calendar (la han actualizado hace poco) y PHP.
En el ejemplo explico la creación de una función PHP que nos añade eventos en google calendar con notificación SMS para recibirlos en nuestro móvil vía SMS .

Lo primero es crear una cuenta o loguearnos en google calendar (si tienes una cuenta google para otro servicio también nos sirve).

Una vez dentro clickamos sobre Configuración/Cofiguración de Calendar y luego en la pestaña Configuración para móviles. Una vez verifiquemos nuestro móvil (nos envían un mensaje con un código) ya no tendremos que hacer nada más en google calendar.
*Puedes hacer pruebas en google calendar añadiendo eventos con aviso de notificación por móvil. Te llegará un mensaje con el título del evento, el lugar y la hora 😀

Ahora vamos a utilizar el potencial de google calendar para enviar desde nuestro servidor avisos por SMS.
Por ejemplo cuando deja de hacer ping nuestro servidor, cuando falla el backup, cuando nos hacen un pedido … como ves tiene multitud de aplicaciones.

Tenemos que tener en nuestro servidor instalado Zend Gdata. (link de descarga al final)
Si no quieres cargar los módulos siempre desde PHP.ini puedes hacerlo manualmente cuando te haga falta simplemente incluyendo la ruta donde se encuentra la librería (tal y como explico en el siguiente código)

<?php
// Carga manual de librerías Zend_Gdata
ini_set('include_path', '/ruta hasta las librerías/ZendGdata-1.11.0/library');
require_once ('/ruta hasta las librerías/ZendGdata-1.11.0/library/Zend/Loader.php');
// Declaramos las clases
Zend_Loader::loadClass('Zend_Gdata');
Zend_Loader::loadClass('Zend_Gdata_ClientLogin');
Zend_Loader::loadClass('Zend_Gdata_Calendar');
Zend_Loader::loadClass('Zend_Http_Client');
Zend_Loader::loadClass('Zend_Gdata_Extension_When');

// Función para crear evento SMS en Google Calendar
//Título indica el título del SMS; Texto indica parte del cuerpo del SMS;
//Minutos indica la demora del aviso; Email indica el login de la cuenta
//Password indica la contraseña de la cuenta
function crearEventoSMS ($titulo, $texto='', $minutos=5, $email='micuenta@gmail.com', $password='micontraseña') {
        // Nombre del servicio de Google Calendar
	$service = Zend_Gdata_Calendar::AUTH_SERVICE_NAME;
	$client = Zend_Gdata_ClientLogin::getHttpClient($email,$password,$service);

	$gdataCal = new Zend_Gdata_Calendar($client);
	$event = $gdataCal->newEventEntry();
	$event->title = $gdataCal->newTitle($titulo);
        // Añadimos texto
	if($texto!=''){
		$event->where = array($gdataCal->newWhere($texto));
		$event->content = $gdataCal->newContent("$texto");
	}
	// Calculamos la hora de creación del evento con la demora incluida para que nos avise
	$time=time()+$minutos*60;
        // Hora en formato RFC 3339
	$endDate = $startDate = date("Y-m-d", $time);
	$endTime = $startTime = date("H:i", $time);
	$tzOffset = "+01";

	$when = $gdataCal->newWhen();
	$when->startTime = "{$startDate}T{$startTime}:00.000{$tzOffset}:00";
	$when->endTime = "{$endDate}T{$endTime}:00.000{$tzOffset}:00";

	// Añadimos el recordatorio SMS
       $reminder = $gdataCal->newReminder();
       $reminder->method = "sms";
       // Tiempo de adelanto (no tiene sentido en el ejemplo actual)
       $reminder->minutes = 0;

	// Aplicamos
        $when->reminders = array($reminder);
        $event->when = array($when);

        // Añadimos el evento a google calendar
        $newEvent = $gdataCal->insertEvent($event);
}
?>

Para añadir notificaciones ya solamente tenemos que llamar a la función (por supuesto debemos incluirla en nuestro código)

<?php
     // Requerimos el archivo de la función
     require_once('ruta_hasta_nuestra_funcion.php');
     // La llamamos
     crearEventoSMS('SinPing');
     // Otra llamada para dentro de 2 horas
     crearEventoSMS('ComprobarPago', 'Tenemos que comprobar pago XXX', 120);
     // Otra llamada para otra cuenta que no es la default
     crearEventoSMS('EncargoOnline', 'El cliente tal tiene avería.', 10, 'fontanero@gmail.com', 'chirigota');     
?>

Espero que les sirva de utilidad 😀

– Descargar Zend Gdata

– Google Calendar

– Documentación Api Google Calendar

Share



Librería ADOdb Date Time para manejar fechas sin límites

Las funciones de PHP para trabajo con fechas utilizan timestamps y están restringidas a fechas entre 1901 y 2038 en sistemas operativos Unix y a 1970 y 2038 en sistemas operativos Windows, debido al desbordamiento del tipo de dato integer.

ado_date_time

Con ADOdb Date Time eliminamos dichas limitaciones ya que reemplaza las funciones de fecha con variables en coma flotante permitiendo utilizar fechas desde 100 dC hasta +3.000 dC.

Siempre viene bien ir pensando en el futuro 😀

Fuente : http://phplens.com/

Share



Recopilatorio 2008 de PHP Senior

El blog de php senior siempre me ha gustado por las conclusiones sacadas directamente de la experiencia de su autor 😀

Hace tiempo descubrí un pequeño índice/recopilatorio que sintetiza de alguna forma todo lo que nos falta a los desarrolladores PHP para poder empezar a considerarnos “Seniors”.

Esto es lo que el autor ha aprendido con los años y ha intentado compartir, tratando de lograr conciencia de nuestras carencias y que no podemos quedarnos solo con aprender la sintaxis particular de un lenguaje. Tenemos que romper con el modelo clásico de “programador” (“dominio del lenguaje”) y pasar a “desarrollador” (“dominio del sistema”).

Los artículos fundamentales hasta julio 2008

  1. Los desarrolladores debemos profesionalizarnos
  2. Buenas Prácticas de Desarrollo en PHP
  3. Code Smell – ¿A qué huele tu código?”
  4. Principios de Diseño Orientado a Objetos
  5. Programación Orientada a la Interface
  6. Herencia de clases y el “Principio de Liskov”
  7. Diseño en 3 capas
  8. Separar el código de la capa de presentación
  9. NO es necesaria la herencia múltiple
  10. NO es necesario crear un nuevo framework
  11. Capas de Abstracción
  12. Diferencias entre Lenguajes y Plataformas
  13. Estándares o muerte… para PHP
  14. Cómo traducir de UML a PHP5
  15. Los métodos “getter / setter”
  16. Standard PHP Library
  17. Patrones de Diseño
  18. Patrón Singleton en un entorno web con PHP
  19. Es fundamental contar con namespaces
  20. Migrar definitivamente a PHP5
  21. PHP Coding Standard (draft)
  22. Seven Steps to Better PHP code – part 1
  23. Seven Steps to Better PHP code – part 2

Pueden visitar el recopilatorio directamente desde Guías que debe seguir un ‘PHP Senior’

Fuente : phpsenior.blogspot.com

Share



Transformar direcciones web en enlaces web

La siguiente función php transforma las direcciones web de un texto por enlaces web que se abren en otra ventana.
Es un ejemplo bastante básico que fácilmente se puede adaptar a nuestras necesidades.

A la función se le puede pasar cualquier texto que ella se encarga de transformar los links.

//transforma las direcciones web de un texto que comiencen por http:// en links
function transforma_links($texto){
   if (ereg("[\"|'][[:alpha:]]+://",$texto) == false){
     $texto = ereg_replace('([[:alpha:]]+://[^<>[:space:]]+[[:alnum:]/])', '<a href="\\1" target="\"_new\"">\\1</a>', $texto);
   }
   return($texto);
}

Fuente: http://es.php.net/

Share



Validar urls con php

Me he topado con una función que permite validar urls de diferentes tipos:

https://usuario:contraseña@www.cualquiersitio.com:8080/login.php?do=login&style=%23#pagetop
http://usuario@www.cualquiersitio.com/#pagetop
https://cualquiersitio.com/index.html
ftp://usuario:****@cualquiersitio.com:21/
http://cualquiersitio.com/index.html/


//se le envía una cadena y devuelve true si es uan url válida o false en caso contrario
function url_valida($url){
  static $urlregex = "^(https?|ftp)\:\/\/([a-z0-9+!*(),;?&=\$_.-]+(\:[a-z0-9+!*(),;?&=\$_.-]+)?@)?[a-z0-9+\$_-]+(\.[a-z0-9+\$_-]+)*(\:[0-9]{2,5})?(\/([a-z0-9+\$_-]\.?)+)*\/?(\?[a-z+&\$_.-][a-z0-9;:@/&%=+\$_.-]*)?(#[a-z_.-][a-z0-9+\$_.-]*)?\$";

return eregi($urlregex, $url);

}

Explicación paso a paso:

function url_valida($url){
//TIPO DE CONEXIÓN
$urlregex = "^(https?|ftp)\:\/\/";

//USUARIO Y CONTRASEÑA (opcional)
$urlregex .= "([a-z0-9+!*(),;?&=\$_.-]+(\:[a-z0-9+!*(),;?&=\$_.-]+)?@)?";

//EL NOMBRE DE LA WEB O LA IP
$urlregex .= "[a-z0-9+\$_-]+(\.[a-z0-9+\$_-]+)*"; // http://x = allowed (ejemplo. http://localhost, http://routerlogin)
//$urlregex .= "[a-z0-9+\$_-]+(\.[a-z0-9+\$_-]+)+"; // http://x.x = minimum
//$urlregex .= "([a-z0-9+\$_-]+\.)*[a-z0-9+\$_-]{2,3}"; // http://x.xx(x) = minimum

//PUERTO (opcional)
$urlregex .= "(\:[0-9]{2,5})?";

//RUTA (opcional)
$urlregex .= "(\/([a-z0-9+\$_-]\.?)+)*\/?";

//GET de la ruta (opcional)
$urlregex .= "(\?[a-z+&\$_.-][a-z0-9;:@/&%=+\$_.-]*)?";

//ANCLA de la ruta (opcional)
$urlregex .= "(#[a-z_.-][a-z0-9+\$_.-]*)?\$";

//COMPROBAMOS
return eregi($urlregex, $url);
}

Share



Clase PHP para convertir un array en un objeto

Clase para convertir un array a objeto.
Muchas veces resulta mucho más intuitivo/eficiente manejar objetos que arrays.

/*
  Autor: Roberto Herrero (http://www.indomita.org)
  Asunto: Convertir un array a objeto  
*/

  class array_a_objeto{
    //constructor (se le envía el array a convertir)
    function array_a_objeto($array_objecto) {
      reset($array_objecto);
      while (list($key, $value) = each($array_objecto)) {
        $this->$key = tep_db_prepare_input($value);
      }
    }
  }
?>

Pongo un ejemplo 😀

//convertir el array de datos POST a objeto
$mi_var = new array_a_objeto($HTTP_POST_VARS);
//ahora en vez de llamar a los datos mediante 
echo $HTTP_POST_VARS["campo_texto_1"];
//podemos hacerlo así
echo $mi_var->campo_texto_1;

Share



Crear un select html desde php dinámicamente

Hoy voy a mostrar como generar un listado dinámico del control select, el combo desplegable, mediante PHP a partir de los datos devueltos por una consulta MySql.

Requisitos previos:
* Conocer como crear el conector $link.
Te dejo el tutorial por si te interesa: Tutorial Conexión a MySql desde PHP


//texto encabezado

echo "<h1>Selecciona una fruta</h1>";

//abrimos el select

//(el size indica el ancho del select)

echo '<select name="frutas" size="5">';

//realizamos la conexión

mysql_conecta($link);

//realizamos la consulta

$respuesta=mysql_query("select fruta_id, fruta_nombre from frutas", $link);

//recorremos los datos

while($fila=mysql_fetch_array($respuesta)){

 echo '<option value="'.$fila&#91;"fruta_id"&#93;.'"> 

      '.$fila["fruta_nombre"].'></option>';

}

//cerramos el select

echo '</select>';

Share



Realizar backup a MySql desde PHP

Voy a explicar como realizar un backup o copia de seguridad de tu base de datos MySql desde PHP.

//servidor MySql
$C_SERVER='tu_servidor';
//base de datos
$C_BASE_DATOS='tu_base_de_datos';
//usuario y contraseña de la base de datos mysql
$C_USUARIO='tu_usuario';
$C_CONTRASENA='tu_contraseña';
//ruta archivo de salida 
//(el nombre lo componemos con Y_m_d_H_i_s para que sea diferente en cada backup)
$C_RUTA_ARCHIVO = '/ruta_hasta/backups/backup_'.date("Y_m_d_H_i_s").'.sql';
//si vamos a comprimirlo
$C_COMPRIMIR_MYSQL='true';


//comando
$command = "mysqldump --opt -h ".$C_SERVER." ".$C_BASE_DATOS." -u ".$C_USUARIO." -p".$C_CONTRASENA.
     " -r \"".$C_RUTA_ARCHIVO."\" 2>&1"; 
 
//ejecutamos
system($command);

//comprimimos
if ($C_COMPRIMIR_MYSQL == 'true') {
 system('bzip2 "'.$C_RUTA_ARCHIVO.'"');
}


*Supongo que el tutorial es aplicable a cualquier tipo de base de datos siempre y cuando tenga una consola y comandos correspondientes, sería cuestión de adaptar el código.

Share



Mantenimiento MySql en PHP aplicable a otras bases de datos

Bueno, una manera bastante sencilla de realizar un mantenimiento de una base de datos MySql básico sería algo así :

* Conocer como crear el conector $link.
Te dejo el tutorial por si te interesa: Tutorial Conexión a MySql desde PHP

//conectamos
mysql_conecta($link);
//listamos tablas
$tablas=mysql_query("SHOW TABLES FROM box",$link);
//recorremos todas las tablas
while($ft=mysql_fetch_array($tablas)){
//optimizamos las tablas
mysql_query("OPTIMIZE TABLE ".$ft[0],$link);
//otras tareas ...
}

Share