znBlog v4.0 - PHP

Serendipity Atom Bug

nospam@example.com (th1nk3r) — Sat, 23 Feb 2008 16:46:16 -0500

Parece ser que el creador de feeds Atom del serendipity tiene unos cuantos bugs. Tengo que mirarlo más en profundidad, pero si podéis procurad usar el RSS2.0 en vez del ATOM, por lo que he comprobado funciona mejor y da menos problemas.

Serendipity plugin bug

nospam@example.com (th1nk3r) — Fri, 22 Feb 2008 04:42:17 -0500

Como algún lector perspicaz habrá visto en las últimas horas, el blog ha salido con un bug. No se mostraban correctamente los enlaces para ver la entrada anterior y la siguiente.

Para los que no conozcan serendipity, les diré que casi todo en este CMS funciona mediante plugins. Es una de las cosas que me gusta de él, ya que a diferencia de otros CMSs más prepotentes y caprichosos, no toma decisiones por ti. Si quieres un editor WYSIWYG puedes elegir entre 3 o 4, y si no quieres uno de esos bichos, pues lo descartas.

La funcionalidad para mostrar el link que te permite pasar a la entrada anterior y la siguiente también es un plugin, en este caso: serendipity_event_entrypaging. El bug que impedía pasar al post siguiente venía de la consulta a la base de datos y la diferencia horaria con el servidor (+9 horas). En lugar de sumar 9 horas a la hora del servidor, las restaba.

Si usáis serendipity y sufrís el mismo problema, revisad el fichero serendipity_event_entrypaging.php, buscad la definición de la función timeOffset y quitad el true de la llamada a la función serendipity_serverOffsetHour. Ese valor booleano define si se debe aplicar un offset negativo o no al tiempo. No se porque extraño motivo los creadores del plugin querían aplicar un tiempo negativo al offset, ya que con configurar la variable a "-9" el cambio estaría hecho.

La nueva función quedará de esta forma.

function timeOffset($timestamp) {
if (function_exists('serendipity_serverOffsetHour')) {
return serendipity_serverOffsetHour($timestamp);
}

return $timestamp;
}

firma.php v2.0

nospam@example.com (th1nk3r) — Wed, 24 Aug 2005 02:58:00 -0400

Esta tarde, en 15 minutillos que tenía aburridos, me he puesto a rehacer mi script de firma para foros
Creo que ya comenté hace algún tiempo lo de este script, es muy sencillo. Recoge información del sistema, y la monta junto con una imagen aleatoria, lo mete en un JPG y lo envía al solicitante.

Hasta ahora solo mostraba la versión del kernel, el uptime, el número de usuarios en el sistema y la cantidad de ram y swap libres. Me he cansado un poco de toda esa información, y he decidido cambiar lo que se muestra. Ahora aparece la versión del kernel de mi servidor, el uptime y la ram libre, y como extra la última canción escuchada (información sacada de audioscrobber ).
Aun me falta darle algunos retoques a ese script, de momento es bastante cutre, pero hace muy bien su función. Mi principal problema es que la mayoría de canciones tienen o el title o el autor en caracteres asiáticos (japoneses, chinos o coreanos), así que no se muestran bien. A petición de Kebrantador, pongo parte del código, aunque no esperéis demasiado.

// $rs es un objeto que uso para acceder a la base de datos
// en este caso ya he leido los datos. Cada firma tiene
// un formato diferente, por eso guardo la info en una tabla.
// Entre la info estan las coordenadas donde va a ir el texto
// el color, la fuente, el nivel de compresion de la imagen, etc

$image = $rs->fields['image'];
$compress = $rs->fields['compress'];
$fotn_name = $rs->fields['text_font'];
$acolor = explode(':', $rs->fields['text_color'];
$x_pos = $rs->fields['text_x'];
$y_pos = $rs->fields['text_y'];
$altura = $rs->fields['altura'];
$special = $rs->fields['special'];
$imagedir = '/dir/dir/dir/imagenes/firmas/';
$imagepath = $imagedir . $image;
$attr = getimagesize($imagepath);
if($attr[2] > 3)
die();
switch($attr[2])
{
case 1:
$image = imagecreatefromgif($imagepath);
break;
case 2:
$image = imagecreatefromjpeg($imagepath);
break;
case 3:
$image = imagecreatefrompng($imagepath);
break;
}

// Color del texto
$color = imagecolorallocate($image, $acolor[0], $acolor[1], $acolor[2]);
// Seleccionar fuente
$font = imageloadfont($imagedir . 'fonts/' . $font_name);

// Version
// En el cron he indicado que a los 5 minutos
// de reiniciar se ejecute:
// /usr/bin/uname -r > /dir/dir/firma_kernel.txt
$version = file_get_contents('/firma_kernel.txt');
$text = 'Gentoo GNU/Linux ' . $version;
if($special=='center')
$x = $x_pos + 40;
else
$x = $x_pos;
imagestring($image, $font, $x, $y_pos + (0 <strong> $altura, $text, $color);

// RAM y Uptime
// Se obtienen de forma muy parecida, los omito

// lastsong played
// Mediante un script shell que se ejecuta cada minuto
// en el crontab, descargo el ficherito:
// http://ws.audioscrobbler.com/txt/recent/th1nk3r
// y lo renombro como "firma_audio.txt"
$trackData = @file('/dir/dir/firma_audio.txt');
if($trackData != null)
{
$trackData[0] = trim($trackData[0]);
// Comprobamos si se esta escuchando ahora, aunque es
// una tonteria con el lag tan tremendo que hay entre
// que audioscrobbler publica los cambios y el script los
// descarga...
if($trackData[0] != '')
$track = '[' . $trackData[0] . ']';
else
$track = '[' . $trackData[1] . ']';
$track = html_entity_decode($track);
$track = trim($track);
}
else
$track = 'Audioscrobbler data error'
// Este error se produce cuando se esta actualizando
// el fichero firma_audio.txt...
if($special=='center')
$x = $x_pos + 25;
else
$x = $x_pos>;
imagestring($image, $font, $x, $y_pos + (2 </strong> $altura, $track, $color);
// Enviamos la imagen
header('Content-Type: image/jpeg');
$newimage = imagecreatetruecolor(500,150);
imagecopyresampled($newimage, $image, 0, 0, 0, 0, 500, 150, $attr[0], $attr[1]);
imageinterlace($newimage, 1);
imagejpeg($newimage, '', $compress);
imagedestroy($image);
imagedestroy($newimage);

Este código forma parte del script que genera las imágenes. Los directorios y alguna otra info es inventada, pero cambiando esos datos debería funcionar. Como ya he dicho, son firmas dinámicas y algunos foros no las admiten. Sin embargo, es fácil saltarse esa protección, lo dejo a vuestra imaginación.

Transparencias con GD

nospam@example.com (th1nk3r) — Sat, 16 Jul 2005 21:09:00 -0400

Me he pasado el día peleando con las librerías GD de PHP. ¿Cual es el problema?
Tengo un script que comprueba la dirección IP del referer cada vez que se solicita una imagen, para evitar el robo de estas. También me permite manipular imágenes, re-dimensionarlas, re-comprimirlas, etc, sin tener que tener varias versiones guardadas a la vez.

El script lo tenía terminado, pero me di cuenta de un bug muy grabe, terrible. Al re-dimensionar las imágenes no se conservan las transparencias ni en GIF ni en PNG. Es posible, que tampoco se pillen bien los GIFs animados (tengo que comprobarlo aun ), ya veremos...
Después de mucho leer y probar he conseguido solucionar el problema. Os copio la función que he creado y que permite re-dimensionar imágenes GIF, PNG y JPG, re-comprimiendolas y usando transparencias (y por supuesto, sin hacer uso de programas externos tipo imagemagick ). Me ha costado, pero al fin he solucionado el bug (la batalla con los gifs animados lo doy por perdida ). Disfrutad la función.

/**
$imagepath = ruta y nombre de la imagen
$compress = nivel de compresion para la img resultado
$x = anchura deseada para la img resultado
$y = altura deseada para la img resultado

Anteriormente ya se ha calculado la anchura y altura
para esa imagen en concreto (de forma que se mantengan
las proporciones).
*/
function readImg($imagepath, $compress, $x, $y)
{
$attr = getimagesize($imagepath);
switch ($attr[2])
{
case 1: // GIF
$image = imagecreatefromgif($imagepath);
header('Content-Type: image/gif');
header('Content-transfer-encoding: binary');
// Pixels esquina
$tr_color = imagecolorat($image, 0, 0);
$tl_color = imagecolorat($image, $attr[0]-1, 0);
$br_color = imagecolorat($image, 0, $attr[1]-1);
$bl_color = imagecolorat($image, $attr[0]-1, $attr[1]-1);
$newimage = imagecreate($x, $y);
// pixel con color negro
imagepalettecopy($newimage, $image);
imagecopyresampled($newimage, $image, 0, 0, 0, 0,
$x, $y, $attr[0], $attr[1]);
$ptr_over_black = imagecolorat($newimage, 0, 0);
$ptl_over_black = imagecolorat($newimage, $x-1, 0);
$pbr_over_black = imagecolorat($newimage, 0, $y-1);
$pbl_over_black = imagecolorat($newimage, $x-1, $y-1);
// pixel con color blanco
$bg = imagecolorallocate($newimage, 255, 255, 255);
imagefilledrectangle($newimage, 0, 0, $x, $y, $bg);
imagecopyresampled($newimage, $image, 0, 0, 0, 0,
$x, $y, $attr[0], $attr[1]);
$ptr_over_white = imagecolorat($newimage, 0, 0);
$ptl_over_white = imagecolorat($newimage, $x-1, 0);
$pbr_over_white = imagecolorat($newimage, 0, $y-1);
$pbl_over_white = imagecolorat($newimage, $x-1, $y-1);
if($ptr_over_black != $ptr_over_white)
{
imagefilledrectangle($newimage, 0, 0, $x, $y, $tr_color);
imagecopyresampled($newimage, $image, 0, 0, 0, 0,
$x, $y, $attr[0], $attr[1]);
imagecolortransparent($newimage, $tr_color);
}
elseif($ptl_over_black != $ptl_over_white)
{
imagefilledrectangle($newimage, 0, 0, $x, $y, $tl_color);
imagecopyresampled($newimage, $image, 0, 0, 0, 0,
$x, $y, $attr[0], $attr[1]);
imagecolortransparent($newimage, $tl_color);
}
elseif($pbr_over_black != $pbr_over_white)
{
imagefilledrectangle($newimage, 0, 0, $x, $y, $br_color);
imagecopyresampled($newimage, $image, 0, 0, 0, 0,
$x, $y, $attr[0], $attr[1]);
imagecolortransparent($newimage, $br_color);
}
elseif($pbl_over_black != $pbl_over_white)
{
imagefilledrectangle($newimage, 0, 0, $x, $y, $bl_color);
imagecopyresampled($newimage, $image, 0, 0, 0, 0,
$x, $y, $attr[0], $attr[1]);
imagecolortransparent($newimage, $bl_color);
}

imageinterlace($newimage,1);
imagegif($newimage);
break;
case 2: // JPEG
$image = imagecreatefromjpeg($imagepath);
header('Content-Type: image/jpeg');
header('Content-transfer-encoding: binary');
$newimage = imagecreatetruecolor($x,$y);
imagecopyresampled($newimage, $image, 0, 0, 0, 0,
$x, $y, $attr[0], $attr[1]);
imageinterlace($newimage,1);
imagejpeg($newimage,'', $compress);
break;
case 3: // PNG
$image = imagecreatefrompng($imagepath);
header('Content-Type: image/png');
header('Content-transfer-encoding: binary');
$newimage = imagecreatetruecolor($x,$y);
imageAlphaBlending($newimage, false);
imagecopyresampled($newimage, $image, 0, 0, 0, 0,
$x, $y, $attr[0], $attr[1]);
imageinterlace($newimage,1);
imagesavealpha($newimage,true);
imagepng($newimage);
break;
}
imagedestroy($image);
imagedestroy($newimage);
}

Árbol de categorías

nospam@example.com (th1nk3r) — Sun, 26 Jun 2005 19:53:00 -0400

Ademas de estudiar y jugar al Dynasty Warriors 5, me he vuelto a poner con la programación del nuevo CMS. Aun estoy esperando que Ally termine con los diseños de su weblog y el mio, pero yo ya estoy a saco con la programación de la sección de administración. Aun falta para que este todo listo, pero espero tenerlo todo para la Euskal. Últimamente he codificado las categorías de los posts. Ahora ya no habrá unas categorías fijas guardadas en el código php, sino que serán accesibles a través de un complejo árbol extensible (categorías y sub-categorías infinitas) dentro de una tabla de mysql.
Para complacer un poco a BenKo voy a explicar un poco como he creado todo el tema del árbol. No es fácil, así que cuidado con perderse.
La tabla en la base de datos solo tiene 6 campos:

id -> Identificador
parent -> Nodo padre (categoria de la que depende)
title -> Nombre de la categoria
lft -> lo explicare luego
rgt -> tambien lo explicare luego xD
active -> 1 para categoria activa, 0 para inactiva

Los datos fundamentales son el id, el id del padre, y lft/rgt. ¿Pero qué demonios son lft y rgt? Vamos a verlo con un ejemplo:
En la imagen podéis ver un árbol de ejemplo, con sus valores lft en rojo y rgt en verde. lft y rgt son índices que nos ayudan a comprender la estructura del árbol y a mostrarlo con una sola consulta a la base de datos. Si solo guardáramos el valor de pid y pid padre, tendríamos que recorrer todo el árbol con llamadas recursivas, lo que sería una perdida absoluta de recursos y tiempo.

¿Qué sub-categorías pertenecen a Informática? Fácil, ¿no?. Solo hay que preguntarle a la base de datos que categorías tienen su lft entre 10 y 21, es decir:

SELECT id FROM nombretabla WHERE lft BETWEEN 10 AND 21 ORDER BY lft ASC;

Sencillo, ¿verdad? Con esos IDs devueltos podemos borrar, buscar o hacer lo que necesitemos. Voy a explicar algunas operaciones:

Imprimir arbol a partir del nodo xxx

function print_tree($root=1)
{
// Obtenemos de la BD el valor lft y rgt del nodo $root
$sql = "SELECT lft, rgt FROM `tabla_categ` WHERE id='$root' ";
$result = mysql_query($sql);
$row = mysql_fetch_array($result);
$lft = $row['lft'];
$rgt = $row['rgt'];
$right = array();
// obtenemos todos los hijos del nodo $root
$sql = "SELECT id, title, lft, rgt, active FROM `tabla_categ` WHERE `lft` BETWEEN $lft AND $rgt ORDER BY lft ASC";
$result = mysql_query($sql);
while ($row = mysql_fetch_array($result))
{
// solo comprobar el vector $right si existe)
if (count($right)>0)
{
while ($right[count($right)-1]<$row['rgt'])
{
array_pop($right);
}
}
if($row['lft']==$lft)
$str = str_repeat('',count($right));
else
$str = str_repeat('     ',count($right)-1).'|--> ';
echo $str .$row['title']." ";
if(!$row['active'])
echo " (Inactiva)";
echo "\n";
$right[] = $row['rgt'];
}
}

Reconstruir valores rgt

Muy útil porque después de mover valores, tendremos los lft correctos, pero no los rgt. Esta función recursiva reescribirá los valores rgt (una gran ayuda )

function rebuild_tree($parent, $left)
{
if(!is_numeric($parent) || !is_numeric($left))
die();

// el valor rgt de un nodo final es lft+1
$right = $left + 1;
// obtener todos los hijos de ese nodo
$sql = "SELECT id, title FROM `tabla_categ` WHERE parent='$parent' ORDER BY title ASC";
$result = mysql_query($sql);
while ($row = mysql_fetch_array($result))
{
// Viva la recursividad!!! xD
$right = rebuild_tree($row['id'],$right);
}
$sql = "UPDATE `tabla_categ` SET `lft` = '$left', `rgt` = '$right' WHERE `id`='$parent'";
$result = mysql_query($sql);
// devolver right+1
return $right+1;
}

Mover un nodo

// $idOrigen -> El nodo a mover
// $idDentroDe -> Dentro de que nodo (=nodo padre)
// queremos moverlo

function moveNode($idOrigen, $idDentroDe)
{
// obtenemos lft y rgt del elemento a mover
$sql = "SELECT `lft`,`rgt` FROM `tabla_categ` WHERE `id`='$idOrigen'";
$result = mysql_query($sql);
$row = mysql_fetch_array($result);
$lftorigen = $row['lft'];
$rgtorigen = $row['rgt'];
// obtenemos lft del padre destino
$sql = "SELECT `lft` FROM `tabla_categ` WHERE `id`='$idDentroDe'";
$result = mysql_query($sql);
$row = mysql_fetch_array($result);
// el nodo movido terminara teniendo lft
// igual a la del padre + 1
$lftdestino = $row['lft']+1;
// $distancia a mover
$distancia = $lftdestino - $lftorigen;
// amplitud del intervalo a mover
// (el nodo a mover puede tener hijos!)
$amplitud = ($rgtorigen - $lftorigen) +1;
(if($distancia > 0)
{
// desplazamos nodos para dejar hueco en destino
$sql = "UPDATE `tabla_categ` SET `lft`= 'lft+$amplitud', `rgt`= 'rgt+$amplitud' WHERE `lft` >=$lftdestino";
$result = mysql_query($sql);
// cambiamos lft y rgt a los del destino
$sql = "UPDATE `tabla_categ` SET `lft`= 'lft+$distancia', `rgt`= 'rgt+$distancia' WHERE `lft` BETWEEN $lftorigen AND $rgtorigen";
$result = mysql_query($sql);
// quitamos el hueco dejado en el origen
// tras el desplazamiento
$sql = "UPDATE `tabla_categ` SET `lft`= 'lft-$amplitud', `rgt`= 'rgt-$amplitud' WHERE `lft` >$rgtorigen";
$result = mysql_query($sql);
}
elseif($distancia<0)
{
// desplazamos nodos para dejar hueco en destino
$sql = "UPDATE `tabla_categ` SET `lft`= 'lft+$amplitud', `rgt`= 'rgt+$amplitud' WHERE `lft` >=$lftdestino";
$result = mysql_query($sql);
// cambiamos lft yrgt a los del destino
// NOTA: en este caso los lft y rgt han sido
// desplazados por el UPDATE anterior
$sql = "UPDATE `tabla_categ` SET `lft`= 'lft-".($distancia+$amplitud)."', `rgt`= 'rgt-".($distancia+$amplitud)."' WHERE `lft` BETWEEN ".($lftorigen+$amplitud)." AND ".($rgtorigen+$amplitud);
$result = mysql_query($sql);
// quitamos el hueco dejado en el origen
// tras el desplazamiento
$sql = "UPDATE `tabla_categ` SET `lft`= 'lft-$amplitud', `rgt`= 'rgt-$amplitud' WHERE `lft` >".($rgtorigen+$amplitud);
$result = mysql_query($sql);
}
$sql = "UPDATE `tabla_categ` SET `parent`='$idDentroDe' WHERE `id`=".$idOrigen;
$result = mysql_query($sql);
// ¡¡IMPORTANTE!!
rebuild_tree(1,1);
}

¿Como lo enlazamos con los mensajes? Bien, dependiendo de la base de datos, y de como guardemos los mensajes, cada uno de estos tendrá asociado un id de categoría. Si estamos dispuestos a hacer uso de otra tabla, podemos guardar en otra tabla:

id -> Índice único de la tabla (no nos interesa)
id_msg -> Identificador de la entrada del weblog
id_categ -> Identificador de categoría

¿Qué conseguimos con esto? Pues que con una consulta sencilla podamos obtener todas las posibles categorías a las que pertenezca un mensaje. Un poco complicado, ¿no? Imaginad este trozo de tabla:

|----------------------|
| id | id_msg | id_cat |
|----------------------|
| 1 | 100 | 6 |
| 2 | 100 | 2 |
| 3 | 101 | 4 |
| 4 | 102 | 2 |
|----------------------|

Es fácil hacer una consulta que nos diga a que categorías pertenece el mensaje 100, ¿verdad? Gracias a esta estructura de árbol, también sabemos que todos los mensajes de KDE pertenecen también a Linux y a su vez a Informática, por lo que al realizar la búsqueda en la base de datos de un mensaje con categoría informática, podríamos buscar (una consulta compleja pero posible) todos los mensajes que tengan una categoría cuyo valor lft este entre 10 y 21 (el lft y el rgt de Informática).

El mayor problema con el que me he encontrado es a la hora de borrar categorías. ¿Que pasa con los mensajes huérfanos (=sin categoría)? No me apetece comerme la cabeza con este asunto de poca importancia, así que lo que he decidido es que no se pueden borrar categorías. Se les puede cambiar el nombre, mover y se pueden desactivar (al desactivar un nodo, se desactiva también toda la rama que cuelga de el), pero no se pueden borrar (para evitar un caos con los IDs). Si nos sobra una categoría podemos cambiarle el nombre, el padre y la posición y emplearla para otra cosa (habrá que cambiar las categorías de los mensajes que dependan de esa categoría, pero es un problema menor).Creo que me ha quedado un tutorial un poco complicado... espero que alguien pueda entender algo. Voy a rehacerlo unas cuantas veces para ver si queda mas útil....