Hay una forma muy sencilla con la clase URI de CodeIgniter que nos permite convertir los segmentos de la URI en un array asociativo de clave/valor: $this->uri->uri_to_assoc();.

Teniendo, por ejemplo, una ruta que sea:

dominio.tld/buscar/categoria/zapatos/medida/m/marca/converse/x/y

Podemos usar:

Code block

$valores = $this->uri->uri_to_assoc(1);

Y obtendremos un array:

Code block

[array]
(
    'categoria' => 'zapatos'
    'medida' => 'm'
    'marca' => 'converse'
    'x' => 'y'
)

Si quisiéramos convertir un array a una URI asociativa simplemente llamaríamos $this->uri->uri_to_assoc(array());.

Esta es la revisión del tutorial que escribí hace más de un año. Es prácticamente lo mismo pero con todos los archivos que necesitas en un zip, a parte de ciertas modificaciones necesarias en el procesado de los datos.

Para esa gente que esta buscando un sistema de usuarios funcional con registro, tengo que decir que no tengo tiempo para programarlo todo por mi mismo para este manual. De este modo, como he hecho desde que comencé en CodeIgniter, usaremos una aplicación de terceros: un sistema completo de usuarios. Lo he basado en el trabajo de Popcorn, llamado ‘Redux Authentication’ (v2 beta).
Lo primero que necesitamos es descargar la librería de Redux. Accedemos al proyecto en Google Code y lo descargamos aquí. Puedes ir a la entrada oficial en el foro de CodeIgniter para preguntar sobre la misma.
Cuando descargues la librería, verás que dentro existe una carpeta llamada ‘Example Application’. Usaremos esta aplicación pero necesitamos actualizarla a la ultima versión de CodeIgniter, sino no nos funcionará. Ten en cuenta, que en el pack final ya esta actualizado pero es mucho mejor si lo haces por tu propio pie, aprenderás más.
Es muy fácil actualizarlo: descargas CodeIgniter y lo descomprimes. Ve a ‘Example Application’, renombra la carpeta a ajaxlogin (usaré este nombre en los ejemplos). Entra en la misma y seguidamente a /system. Borra todas las carpetas excepto application, donde esta la aplicación. Accede a la versión descarga de CodeIgniter y copia todas las carpetas que has eliminado (todas menos application). Puedes encontrar la guía oficial de CodeIgniter para la actualización aquí.
Entonces, instala la base de datos y configurala. Lo primero que tienes que hacer es añadir un grupo llamado ‘members’ en la tabla de grupos:

Code block

INSERT INTO groups (`id`, `name`, `description`) VALUES (NULL, 'member', 'Members')

En el archivo config/redux_auth.php verás que hay una opción para configurar el grupo por defecto. En la base de datos no tenemos datos de modo que necesitamos añadir un grupo por defecto y modificar el archivo de configuración para que lo detecte. Otra recomendación para este mismo archivo es cambiar la configuración de activación a FALSE porque no funciona del todo. Hay otras variables que puedes cambiar, como el método de entrada (username, email…). He elegido el e-mail, que es el que viene por defecto.  Cambiar para que sea el usuario no es difícil. Probarlo.

Code block

$config['email_activation'] = FALSE;

Code block

<script type="text/javascript" src="<?php echo base_url().'assets/js/jquery-1.3.2.min.js'; ?>"></script>
<script type="text/javascript" src=<?php echo base_url().'assets/js/ajaxlogin.js'; ?>"></script>

En este caso, la diferencia con el otro script, es que usaremos la función de Redux para el login y esto optimizará nuestro código ya que esta mucho más depurado. En el controller welcome añadiremos dos funciones:

Code block

function _check_login($email)
{
    return $this->redux_auth->login($email, $this->password);
}

function ajaxLogin()
{
    $this->load->library('validation');
    $this->password = $this->input->post('password');
    $this->loginemail = $this->input->post('email');

    $this->form_validation->set_rules('email', 'Email Address', 'trim|required|callback__check_login');
    $this->form_validation->set_rules('password', 'Password', 'trim|required');

    if ($this->form_validation->run() == false)
    {
        $data = array(    'success' =>    'no',
                'message' =>    'The email or password you provided are wrong.');

        $output = json_encode($data);
    }

    else
    {
        $data = array(    'success' =>    'yes',
                'welcome' =>    'Welcome '.$this->loginemail.'!');

        $output = json_encode($data);
    }

    $output = str_replace("\r", "", $output);
    $output = str_replace("\n", "", $output);

    echo $output;
}

Para entender el código: la primera función, _check_login(), usa el modelo redux_auth_model.php para validar el correo y la contraseña que hemos seleccionado. Para más información mira el modelo en la carpeta models. Si la información procesada es correcta devuelve TRUE, sino FALSE. En caso de que devuelva TRUE, la aplicación crea la sesión con nuestro e-mail. Si necesitas alguna cosa más, edita el modelo.

La segunda función es un mix de la función de login de Redux y mi función de AJAX. Toma los dos inputs y los valida. El primero, correo electrónico, usa la función callback a la función _check_login(). Si la información no es correcta, o sucede algún problema, devuelve FALSE. Entonces pasaremos la información a la función AJAX y la codificaremos con JSON. La información codificada se muestra tal que así: { “success”: “no”, “message”: “The email or password you provided are wrong.” }.

Hay que tener en cuenta que uso $this->password y $this->loginemail. Estas variables tienen que ser definidas en el inicio el controlador, así:

Code block

class Welcome extends Controller {

    private $password     = NULL;
    private $loginemail    = NULL;

    /**
     * index
     *
     * @return void
     * @author Mathew
    **/

    function index()
    {
        redirect('welcome/status');
...

Perfecto! Ahora modificaremos el login. Como sabes, la mejor manera de crear un formulario en CodeIgniter es accediendo a su user guide. De este modo, abre /views/login.php. Cuando tenemos un tenemos un formulario de login normalmente solo lo mostramos cuando el usuario no esta identificado. En el ejemplo de la librería Redux esto no pasa y tenemos que modificarlo. La manera es comprobar si existe el item ‘identity’ en la session. Añade al principio del archivo:

Code block

<?php
    if($this->session->userdata($this->config->item('identity')))
    {
        echo "<h1>You're aready logged in!</h1>";
    }

    else {
?>

        <h1>Login</h1>

Esto comprobará si existe. Al final del archivo, añade:

Code block

<?php
    }
?>

Compruébalo. Accede y vuelve al formulario de identificación. Mostrará You’re already logged in.
Tenemos que añadir algunas lineas más al archivo login.php. Cambia el form_open() y añade un id, añade un id a la tabla y añade un id a las divs extras que usaremos para mostrar los errores o sucesos de la aplicación AJAX. Es necesario que jQuery los identifique y eso lo hacemos con los ids.

Code block

<?php echo form_open('welcome/login',array('id' => 'userlogin')); ?>

<table id="loginform">

<div id="logged"><div>

<div id="loginerror"></div>

He añadido estas dos últimas <div>’ despues del form_close().

A parte, haz estos cambios:

Code block

<td><?php echo form_input('email', set_value('email')); ?></td>

Por:

Code block

<td><input type="text" name="email" value="<?php set_value('email'); ?>" id="email" /></td>

Y:

Code block

<td><?php echo form_password('password'); ?></td>

Por:

Code block

<td><input type="password" name="password" value="" id="password" /></td>

Ahora es tiempo del archivo javascript. Recuerda que antes hemos añadido la librería de jQuery. Crea un archivo que se llame ajaxlogin.js en /assets/js/. Para usar el ajaxForm necesitas un plugin. Lo puedes descargar aquí. Lo añadimos igual que hemos hecho los dos del principio, en /views/template.php:

Code block

<script type="text/javascript" src="<?php echo base_url().'assets/js/jquery.form.js'; ?>"></script>

Ahora, escribe en ajaxlogin.js:

Code block

$(document).ready(function(){

    $("#userlogin").ajaxForm({
        type: "POST",
        url: "http://localhost/ajaxlogin/index.php/welcome/ajaxLogin",
        dataType: "json",
        data: "email="+$("#email").val()+"&amp;password;="+$("#password").val(),
        success: updateLogin
    });

});

Ten en cuenta que es posible que tengas que cambiar la URL.  Yo lo uso en mi localhost y con el alias ajaxlogin. Mismamente, uso el index.php y el controlador welcome. Debes modificarlo si es necesario.
Ahora mismo, el script funcionaria pero debemos añadirle un complemento… la función que llama ajaxForm cuando se ejecuta:

Code block

function updateLogin(data) {

    $('#logged').html('');
    $('#logged').hide();

    $("#loginform").fadeOut("slow",
        function() {

            if (data.success == 'yes') {
                $('#logged').html(data.welcome).fadeIn("slow");

            }
            if (data.success == 'no') {
                $('#loginerror').html(data.message).fadeIn("slow").fadeOut("slow",
                    function() {
                        $("#loginform").fadeIn("slow");
                    }
                );
            }
        }
    );
}

Esto creará nuestra animación y hará desaparecer el form. Igualmente escribirá los datos JSON a la <div> que hemos especificado.

Puedes descargar los archivos de este ejemplo funcionando aquí: ipalaus-ajaxlogin-v0.2.rar.

¡Gracias a todos! ¡Espero que funcione!

Después de mucho tiempo sin escribir, y habiendo salido ya la versión 1.6.2 de CodeIgniter, escribo para presentar una mejora a un helper de CodeIgniter. Concretamente se trata del HTML Helper, el cual incluye funcione para la ayuda en el HTML.

¿Qué hace? ¿Por qué? La última versión del framework añadía la posibilidad de crear tags <link /> con lo que podíamos añadir facilmente archivos CSS, shorcuts.ico u otros similares. Esto se hace mediante:

Code block

link_tag('archivo.css);

Y… ¿porqué no para incluir archivos JavaScript? Así que me decidí a hacer mi primer aportación al core de CodeIgniter (y espero que la añadan, claro). Esto consiste en la función script_tag(); para añadir tags <script />.

Y… ¿Cómo se usa? Simplemente es una extensión del helper existente así que debemos colocar el archivo dentro de la carpeta helpers dentro de application con el nombre MY_html_helper.php teniendo en cuenta que el prefijo para las extensiones es “MY_” ($config['subclass_prefix'] = ‘MY_’; en config.php).

El código en cuestión es el siguiente:

Code block

<?php  if ( ! defined('BASEPATH')) exit('No direct script access allowed');

/**
* Script
*
* Generates a script inclusion of a JavaScript file
* Based on the CodeIgniters original Link Tag.
*
* Author(s): Isern Palaus <ipalaus@ipalaus.es>, Viktor Rutberg <wishie@gmail.com>
*
* @access    public
* @param    mixed    javascript sources or an array
* @param    string    language
* @param    string    type
* @param    boolean    should index_page be added to the javascript path
* @return    string
*/    

if ( ! function_exists('script_tag'))
{
    function script_tag($src = '', $language = 'javascript', $type = 'text/javascript', $index_page = FALSE)
    {
        $CI =& get_instance();

        $script = '<script ';

        if(is_array($src))
        {
            foreach($src as $v)
            {
                if ($k == 'src' AND strpos($v, '://') === FALSE)
                {
                    if ($index_page === TRUE)
                    {
                        $script .= ' src="'.$CI->config->site_url($v).'"';
                    }
                    else
                    {
                        $script .= ' src="'.$CI->config->slash_item('base_url').$v.'"';
                    }
                }
                else
                {
                    $script .= "$k=\"$v\"";
                }
            }

            $script .= ">\n";
        }
        else
        {
            if ( strpos($src, '://') !== FALSE)
            {
                $script .= ' src="'.$src.'" ';
            }
            elseif ($index_page === TRUE)
            {
                $script .= ' src="'.$CI->config->site_url($src).'" ';
            }
            else
            {
                $script .= ' src="'.$CI->config->slash_item('base_url').$src.'" ';
            }

            $script .= 'language="'.$language.'" type="'.$type.'"';

            $script .= '>'."\n";
        }

        $script .= '</script>';

        return $script;
    }
}

En cuanto su uso es sencillo:

Code block

script_tag('archivo.js);

Pronto os presentaré también otra modificación del helper URL Helper. Hasta pronto.

Para empezar será necesario saber si estamos usando mod_rewrite en Apache. Lo más fácil es, directamente, ir al archivo de configuración (el archivo http.conf) y buscar: mod_rewrite.so. Deberíamos encontrar la siguiente línea:

[code]LoadModule rewrite_module modules/mod_rewrite.so[/code]

Sin embargo, si esta contiene un símbolo de almohadilla (#) es que no esta activado. Si lo contiene al principio, lo borramos, guardamos y reiniciamos el servidor. Así, mod_rewrite se iniciará cada vez al iniciar Apache.

Ahora es el momento de crear nuestro archivo de configuración especifico en el directorio donde este nuestro index.php. A este archivo le pondremos de nombre .htaccess y contendrá lo siguiente:

Code block

RewriteEngine On
RewriteBase /
RewriteCond %{REQUEST_FILENAME} !-f
RewriteCond %{REQUEST_FILENAME} !-d
RewriteRule ^(.*)$ index.php/$1 [L]

# If we don't have mod_rewrite installed, all 404's
# can be sent to index.php, and everything works as normal.
# Submitted by: ElliotHaughin
ErrorDocument 404 /index.php

Bien, con esto ya nos ocupamos de cuando se acceda a nuestra web automáticamente, lo que hace el servidor web, es catalogar como si accediéramos a la misma pero con index.php/ al principio. Solo nos queda una cosa, que CodeIgniter nos construya los enlaces sin el index.php/. De este modo, accedemos al archivo config.php y cambiaremos la variable $config['index_page']:
De:

Code block

$config['index_page'] = "index.php";

A:

Code block

$config['index_page'] = "";

Para solucionar este problema deberemos hacer solo dos cosas:

1. En nuestro config.php modificaremos el $config['uri_protocolo'] dejándolo similar a este:
   [code lang="php"]
   $config['uri_protocol'] = "PATH_INFO";
   [/code]
2. En nuestros controladores usaremos la siguiente función para reconstruir el array $_GET:
   [code lang="php"]
   parse_str($_SERVER['QUERY_STRING'],$_GET);
   [/code]

Con esto, debería funcionar perfectamente. Pronto, más trucos, programas y ejemplos sobre CodeIgniter.

CodeIgniter, a parte, nos da la posibilidad de trabajar con más de una base de datos a la vez, configurando y conectando específicamente a una u otra dependiendo de las necesidades. Sin embargo, no es el objeto de esta explicación.

Supongamos que queremos hacer una consulta parecida a la siguiente:
SELECT * FROM entradas

Lo normal en PHP sería usar un mysql_query(“SELECT * FROM entradas”);, sin embargo en CodeIgniter (y usando librería específica) lo usaríamos de la siguiente forma:
[code lang="php"]
$this->db->query("SELECT * FROM entradas");
[/code]

GET

Conclusión, podemos usarlo de la misma manera. Luego si quisiéramos estructurar los resultados podríamos usar la función foreach de PHP. Sin embargo, hay una manera mucho más fácil en CodeIgniter de tratar las consultas. Ellos lo llaman el Active Record Class y se emplearía, para el ejemplo de antes, así:
[code lang="php"]
$query = $this->db->get("entradas");

// Genera: SELECT * FROM entradas;
[/code]

También en $this->db->get(); es posible usar un segundo parámetro para especificar un LIMIT:
[code lang="php"]
$query = $this->db->get("entradas", 10, 20);

// Genera: SELECT * FROM entradas LIMIT 20,10
[/code]

SELECT

También podemos especificar el SELECT con $this->db->select(); tipo:
[code lang="php"]
$query = $this->db->select("id,title,body");
$query = $this->db->get("entradas");

// Genera: SELECT id,title,body FROM entradas
[/code]

Existen algunas funciones de MySQL que tienen una propiedad de SELECT específica en CodeIgniter, sin embargo, solo los listaré ya que no los usaremos en aplicaciones básicas:

• $this->db->select_max();
• $this->db->select_min();
• $this->db->select_avg();
• $this->db->select_sum();

JOIN

Esto nos permite unir dos tablas tal que así:
[code lang="php"]
$query = $this->db->join("comentarios", "comentarios.id = entradas.id");
$query = $this->db->get("entradas");

// Genera: SELECT * FROM entradas JOIN comentarios ON comentarios.id = entradas.id
[/code]

WHERE

[code lang="php"]
$query = $this->db->where("id","38");
$query = $this->db->get("entradas");

// Genera: SELECT * FROM entradas WHERE id = '38'
[/code]

Si quisiéramos podríamos unir varios WHERE, simplemente añadiendo otras condiciones:
[code lang="php"]
$query = $this->db->where("id","38");
$query = $this->db->where("name","Isern");
$query = $this->db->where("surname","Palaus");
$query = $this->db->get("entradas");

// Genera: SELECT * FROM entradas WHERE id = '38' AND name = 'Isern' AND surname = 'Palaus'
[/code]

Pero claro, no todo son igualdades. Quizás queremos buscar una cosa que sea más pequeña que, o diferente, o mayor, etcétera. La forma es especificar en el primer campo, si no hay nada se tomará = por defecto:
[code lang="php"]
$query = $this->db->where("id >","38");
$query = $this->db->where("name !=","Isern");
$query = $this->db->where("surname","Palaus");
$query = $this->db->get("entradas");

// Genera: SELECT * FROM entradas WHERE id > '38' AND name != 'Isern' AND surname = 'Palaus'
[/code]

Al igual que SELECT, hay muchas más propiedades:

• $this->db->or_where();
• $this->db->where_in();
• $this->db->or_where_in();
• $this->db->where_not_in();
• $this->db->or_where_not_in();

LIKE

[code lang="php"]
$query = $this->db->like("body","sentencia");
$query = $this->db->get("entradas");

// Genera: SELECT * FROM entras LIKE body = '%sentencia%'
[/code]

Sin embargo, podría ser que no quisiéramos que las dos partes fueran aleatorias… De modo que podemos especificar en un tercer campo el % donde debe estar. Puede ser: before, both y after.
[code lang="php"]
$query = $this->db->like("body","sentencia1","before");
$query = $this->db->like("title","sentencia2","both");
$query = $this->db->like("slug","sentencia3","after");
$query = $this->db->get("entradas");

// Genera: SELECT * FROM entradas LIKE body = '%sentencia1' AND title = '%sentencia2%' AND slug = 'sentencia3%'
[/code]

Otros tipos de LIKE que podemos usar son:

• $this->db->not_like();
• $this->db->or_not_like();
• $this->db->group_by();

GROUP BY

En otras versiones se conocia como $this->db->groupby(); pero ha sido eliminado.
[code lang="php"]
$query = $this->db->group_by("title");
$query = $this->db->get("entradas");

// Genera: SELECT * FROM entradas GROUP BY title
[/code]

DISTINCT

Para añadir DISTINCT a la consulta:
[code lang="php"]
$query = $this->db->distinct();
$query = $this->db->get("entradas");

// Genera: SELECT DISTINCT * FROM entradas
[/code]

HAVING

[code lang="php"]
$query = $this->db->having("uid = 32");
$query = $this->db->get("entradas");

// Genera: SELECT * FROM entradas HAVING uid = 32
[/code]

También es posible usar $this->db->or_having();

ORDER BY

$this->db->order_by(); permite ordenar un resultado en una dirección especifica. En el primer parámetro especificamos el nombre de la columna y en el segundo la dirección. Las posibilidades del segundo parámetro son: ASC, DESC y RANDOM.
[code lang="php"]
$query = $this->db->order_by("id","DESC");
$query = $this->db->get("entradas");

// Genera: SELECT * FROM entradas ORDER BYid DESC
[/code]

LIMIT

Permite especificar el limite de resultados que quieres que devuelva:
[code lang="php"]
$query = $this->db->limit(30);
$query = $this->db->get("entradas");

// Genera: SELECT * FROM entradas LIMIT 10
[/code]

COUNT ALL

Permite contar el numero de entradas que hay en una tabla:
[code lang="php"]
$num = $this->db->count_all("entradas");

// Genera: un numero que lo podemos tratar como una variable o escribirlo
[/code]

COUNT ALL RESULTS

A diferencia de COUNT ALL, nos permite contar el numero de resultados en la actual consulta:
[code lang="php"]
$query = $this->db->where("name","Isern");
$query = $this->db->get("entradas");

$num = $this->db->count_all_results();

// Genera: un numero
[/code]

INSERT

Para insertar datos usando el Active Record de CodeIgniter debemos usar un array luego insertar:
[code lang="php"]
$insert = array("title" => "Test",
"body" => "Test",
"name" => "Isern",
"surname" => "Palaus");

$this->db->insert("entradas",$insert);

// Genera: INSERT INTO entradas (title, body, name, surname) VALUES ('Test', 'Test', 'Isern', 'Palaus')
[/code]

UPDATE

Al igual que INSERT usaremos un array para insertar, sin embargo si queremos actualizar, por ejemplo, una entrada deberemos especificar un where:
[code lang="php"]
$update = array("title" => "Test",
"body" => "Test",
"name" => "Isern",
"surname" => "Palaus");

$this->db->where("id","3");
$this->db->update("entradas",$update);

// Genera: UPDATE entradas SET title = 'Test', body = 'Test', name = 'Isern', surname = 'Palaus' WHERE id = 3
[/code]

DELETE

Al igual que UPDATE usaremos un ID para especificar cual es la que queremos borrar:
[code lang="php"]
$this->db->where("id","3");
$this->db->delete("entradas");

// Genera: DELETE FROM entradas WHERE id = 3
[/code]

Y esto es más o menos todo lo que nos ofrece CodeIgniter para tratar nuestras bases de datos. Espero que haya servido de ayuda a más de uno ya que muchas visitas recibidas buscaban como usar MySQL en CodeIgniter. ]]> http://blog.ipalaus.es/consultas-mysql-en-codeigniter/feed 18 http://blog.ipalaus.es/codeigniter-paginar-resultados http://blog.ipalaus.es/codeigniter-paginar-resultados#comments Wed, 12 Mar 2008 15:50:19 +0000 Isern Palaus http://blog.ipalaus.es/codeigniter-paginar-resultados Más >]]> CodeIgniter, como buen framework que es, tiene una librería para poder paginar nuestros resultados. En cuanto a paginar me refiero a tener la posibilidad de crear paginas entre resultados, por ejemplo, cada 10 resultados 1 pagina. Nosotros vamos a usar el código del blog que creamos en el artículo CodeIgniter: Aplicación Básica (I), Creación de un Blog.

Para empezar vamos a recuperar el código que nos muestra las entradas del blog:

Archivo: /application/controllers/blog.php
[code lang="php"]
function index()
{
$query = $this->db->orderby("id","desc");
$query = $this->db->;get("posts");

$this->load->helper("date");
$datestring = "%d-%m-%Y";

foreach ($query->result() as $row) {
$data["posts"][$row->id]["title"] = $row->title;
$data["posts"][$row->id]["url"] = $row->url_title;
$data["posts"][$row->id]["body"] = $row->body;
$data["posts"][$row->id]["date"] = mdate($datestring,$row->created_on);
}

$this->load->view("blog_front",$data);
}
[/code]

Para no complicar mucho la cosa con rutas y .htaccess vamos a cambiar los enlaces permanentes a nuestras entradas a localhost/blog/goto/enlace-permamente. Lo primero que tenemos que hacer en nuestro controlador es cargar la librería de pagination:

Archivo: /application/controllers/blog.php, Línea: 15
[code lang="php"]
$this->load->library("pagination");
[/code]

Justo antes de $this->load->helper(“date”);. Para usar esta librería tenemos que configurar varias cosas como: la URL base, el total de entradas que tenemos en la base de datos y el total por entrada. Una vez configurado, lo cargamos:

Archivo: /application/controllers/blog.php
[code lang="php"]
$this->load->library("pagination");

$config["base_url"] = base_url().index_page();
$config["total_rows"] = $this->db->count_all("posts");
$config["per_page"] = "4";

$this->pagination->initialize($config);
[/code]

También tenemos que especificar en que posición en la URL se va a especificar la pagina. Esto lo haremos con $this->uri->segment(); como usamos en el artículo anterior.

[code lang="php"]
$num = $this->uri->segment(1);
[/code]

Y lo más importante: como hacer las consultas a la base de datos. Para hacerlo mucho más fácil, vamos a usar un modelo. Es decir, en el controlador solo gestionaremos los datos y mandaremos al modelo hacer las consultas. Sin embargo vamos a usar un pequeño truco para pasar esta la información:

[code lang="php"]
if($num === "all"){
$data["posts"] = $this->blog_model->getPaginated("posts",$config["per_page"]);
} else {
if(!isset($num) OR !is_numeric($num)) $num = 0;
$data["posts"] = $this->blog_model->getPaginated("posts",$config["per_page"],$num);
}
[/code]

Primero comprobamos si $num es igual a all, si es así, mostramos las primeras entradas (las más recientes) limitando al numero que hemos configurado por pagina. Si esto no se cumple comprobamos si $num esta especificado (recordar que lo recupera de la URI) o si es realmente un número, sino atribuye el valor de la variable a 0. A partir de aquí, busca también a partir de $num valores los siguientes siendo estos especificados por pagina. Si veis como es el modelo lo veréis más claro:

Archivo: /application/models/blog_model.php
[code lang="php"]
class Blog_model extends Model
{

function __construct ()
{
parent::__construct();
}

function getPaginated($table,$num=-1,$offset=-1)
{
$sql = "SELECT * from ".$table." order by id desc";
if($num != -1)
$sql .= " limit ";
if($num != -1 AND $offset != -1)
$sql .= "$offset,";
if($num != -1)
$sql .= "$num";

$query = $this->db->query($sql);

$this->load->helper("date");
$datestring = "%d-%m-%Y";

foreach ($query->result() as $row) {
$data["posts"][$row->id]["title"] = $row->title;
$data["posts"][$row->id]["url"] = $row->url_title;
$data["posts"][$row->id]["body"] = $row->body;
$data["posts"][$row->id]["date"] = mdate($datestring,$row->created_on);
}

return $data["posts"];
}

}
?>
[/code]

Como podéis comprobar gran parte del código es el que ya usábamos en el controlador. Es importante que se guarde este fichero con el nombre de blog_model.php y lo carguemos luego en el controlador con $this->load->model(“blog_model”);.

Bien, nuestro controlador blog.php debería ser algo así:

Archivo: /application/controllers/blog.php
[code lang="php"]
function show()
{
$url_title = $this->uri->segment(2, 0);

if($url_title) {
$this->load->helper("date");
$datestring = "%d-%m-%Y";

$query = $this->db->where("url_title",$url_title);
$query = $this->db->get("posts");

foreach ($query->result() as $row) {
$data["post"]["id"] = $row->id;
$data["post"]["title"] = $row->title;
$data["post"]["url"] = $row->url_title;
$data["post"]["body"] = $row->body;
$data["post"]["date"] = mdate($datestring,$row->created_on);
}

$this->load->view("blog_single",$data);
} else {
redirect();
}
}
[/code]

Y también tenemos que editar el routes.php:

[code lang="php"]
$route['default_controller'] = "blog";
$route['scaffolding_trigger'] = "";

$route["blog"] = "blog";
$route["add"] = "blog/add";

$route["goto/:any"] = "blog/show";

$route[":any"] = "blog";
[/code]

Esto implica cambiar en blog_front.php y blog_single.php los enlaces permanentes por: /goto/enlace-permanente.

[code lang="php"]
anchor("goto/".$post["url"],"Enlace Permanente").
[/code]

Y para finalizar solo nos queda añadir los enlaces para crear las paginas. Esto lo hacemos con una función de la librería de pagination $this->pagination->create_links();, yo lo he añadido tal que así:

Archivo: /application/views/blog_front.php
[code lang="php"]

foreach ($posts as $id => $post) {

echo "

".anchor("goto/".$post["url"],"#".$id)." ".$post["title"]."

";
echo "

".$post["body"]."

";
echo "".anchor("goto/".$post["url"],"Enlace Permanente")." - ".$post["date"]."";

}
?>

Page rendered in {elapsed_time} seconds

[/code]

Conclusión

Con todo esto ya tenemos nuestras entradas al blog paginadas correctamente. Solo me queda decir que la idea me ha venido de una búsqueda que he visto en Google Analytics, así que espero que quien lo buscase pueda volver a encontrarlo otra vez.

Descargar el ejemplo del blog y la su contenido paginado: ipalaus-CodeIgniter_BlogExample_Pagination_v1.rar

Lo primero que vamos a necesitar es CodeIgniter, podéis recurrir a la web oficial para descargarlo o usar la pre-configuración del artículo CodeIgniter: Iniciación y Configuración (concretamente este). Una vez descomprimido vamos a renombrar algunos ficheros y configurar algunos.

Accedemos a /application/controllers/ y cambiamos el nombre de welcome.php a blog.php. Blog.php será la base de nuestra aplicación, el controlador principal. Lo abrimos y veremos como es, por defecto, un controlador de CodeIgniter. En este primer ejemplo no vamos a usar modelos para no complicar las cosas, en un futuro, lo haremos. Editamos nuestro archivo blog.php para que quede tal que así:

Archivo: /application/controllers/blog.php
[code lang="php"]

class Blog extends Controller {

function Blog()
{
parent::Controller();
}

function index()
{

}
}
?>
[/code]

Es sumamente importante que sea class Blog y no class blog, al igual que function Blog() y no function blog().

Ahora vamos a configurar CodeIgniter para que su controlador principal sea blog.php de modo que cuando accedamos a la pagina web sin establecer controlador alguno, sea blog.php el controlador por defecto. Para hacer esto necesitamos configurar el archivo routes.php y podemos encontrarlo en /application/config. Routes.php se ocupa de las rutas de nuestra URI, se usa habitualmente para redirigir cosas a los controladores. Si por ejemplo queremos que una dirección tipo /producto/id/123 vaya a productos.php y /producto/nombre/abc también vaya a productos.php podríamos usar algo similar a esto:

[code lang="php"]
$route['/producto/id/:num'] = "productos/productById";
$route['/producto/name/:any'] = "productos/productByName";
[/code]

Siendo productById y productByName dos funciones dentro del controlador productos.php. Bien, pero eso no es lo que necesitamos nosotros ahora mismo. El archivo routes.php también se usa para establecer el controlador por defecto y por defecto hay el welcome, nosotros lo cambiaremos por blog:

Archivo: /application/config/routes.php, Línea: 43
[code lang="php"]
$route['default_controller'] = "blog";
[/code]

También será necesario usar autoload.php, también en /application/config/ para cargar automáticamente una librería (database) y un helper (url):

Archivo: /application/config/autoload.php, Línea: 42
[code lang="php"]
$autoload['libraries'] = array("database");
[/code]

Archivo: /application/config/autoload.php, Línea: 54
[code lang="php"]
$autoload['helper'] = array("url");
[/code]

Al añadir database al array de librerías, se cargar cada vez que accedamos a cualquier controlador. Como nuestra aplicación estará basada en la base de datos, y la usaremos todo el rato, ya nos va bien cargarla al principio. El helper url lo vamos a usar para

Base de Datos

Ahora realmente empezamos a trabajar con la aplicación, lo primero que necesitaremos será una base de datos MySQL. Para configurar los datos de la base de datos deberemos acceder a /application/config/database.php como ya expliqué en el artículo CodeIgniter: Iniciación y Configuración. Una vez configurado, crearemos nuestra tabla. El esquema sería el siguiente:

[code]
CREATE TABLE `posts` (
`id` int(5) NOT NULL auto_increment,
`title` varchar(64) NOT NULL,
`url_title` varchar(64) NOT NULL,
`body` text NOT NULL,
`created_on` varchar(10) default NULL,
PRIMARY KEY (`id`)
) ENGINE=MyISAM DEFAULT CHARSET=latin1;
[/code]

El único campo que puede confundir un poco es el campo url_title, este campo lo usaremos para crear URI tipo: blog.iplauas.es/este-seria-el-url-title.

Controlador y vistas

Vamos a crear nuestro controlador. Los controladores los podemos dividir mediante funciones, nosotros vamos a usar la función index() para mostrar las entradas, show() para ver una entrada en particular (enlace permanente) y add() para añadirlas.

Lo primero que haremos en nuestra función index() va a ser la consulta a MySQL. En esta consulta, pondremos en un array() todas las entradas que tengamos en nuestra tabla MySQL. Debería ser algo así:

Archivo: /application/controllers/blog.php
[code lang="php"]
function index()
{
$query = $this->db->orderby("id","desc");
$query = $this->db->get("posts");

foreach ($query->result() as $row) {
$data["posts"][$row->id]["title"] = $row->title;
$data["posts"][$row->id]["url"] = $row->url_title;
$data["posts"][$row->id]["body"] = $row->body;
$data["posts"][$row->id]["date"] = $row->created_on
}
}
[/code]

Como podéis comprobar, lo primero que hacemos es ordenarlos por ID y luego almacenamos en el array $data["posts"] el contenido de las entradas. Sin embargo, tengo planteado guardar la fecha en timestamp de modo que necesitaremos convertirla a una fecha humana. Para esto usaremos el helper date de CodeIgniter. Para cargar un helper debemos usar la expresión: $this->load->helper();. En nuestro caso, crearemos un patrón para las fechas que lo almacenaremos en una variable:

Archivo: /application/controllers/blog.php
[code lang="php"]
function index()
{
$query = $this->db->orderby("id","desc");
$query = $this->db->get("posts");

foreach ($query->result() as $row) {
$data["posts"][$row->id]["title"] = $row->title;
$data["posts"][$row->id]["url"] = $row->url_title;
$data["posts"][$row->id]["body"] = $row->body;
$data["posts"][$row->id]["date"] = $row->created_on
}
}
[/code]

De este modo la fecha se mostrará DD-MM-AAAA. Con esto tenemos nuestro controlador index() listo. Solo nos falta añadir la salida, lo que llamaremos view y podemos encontrar en /application/views/. Si accedemos al directorio veremos el archivo welcome_message.php, le cambiaremos el nombre a blog_front.php. Lo abrimos con nuestro editor de textos y veremos que hay establecidos unos estilos (CSS), vamos a usar los mismos.

Lo primero que necesitamos saber es como cargar la vista desde nuestro controlador, para cargar la vista lo haremos con $this->load->view();. Otro tema de las vistas es añadirle nuestro contenido dinámico, para pasar el contenido tendremos que añadir una variable. Veamos como lo haríamos en nuestro ejemplo, siendo nuestro contenido el array $data.

Archivo: /application/controllers/blog.php
[code lang="php"]
function index()
{
$query = $this->db->orderby("id","desc");
$query = $this->db->get("posts");

$this->load->helper('date');
$datestring = "%d-%m-%Y";

foreach ($query->result() as $row) {
$data["posts"][$row->id]["title"] = $row->title;
$data["posts"][$row->id]["url"] = $row->url_title;
$data["posts"][$row->id]["body"] = $row->body;
$data["posts"][$row->id]["date"] = date($datestring,$row->created_on);
}

$this->load->view("blog_front",$data);
}
[/code]

Si ejecutáis este código, funcionará al 100%. Sin embargo, en nuestra vista, no vamos a ver más que el mensaje estático del welcome_message.php que hemos renombrado. Ahora es el momento de empezar a crear como se verá. Vamos a hacerlo muy sencillo para que veáis como trabajar con las variables que hemos pasado. Entre las dos etiquetas body del archivo blog_front.php, vamos a poner este código:

[code lang="php"]
foreach ($posts as $id => $post) {

echo "

".anchor($post["url"],"#".$id)." ".$post["title"]."

";
echo "

".$post["body"]."

";
echo "".anchor($post["url"],"Enlace Permanente")." - ".$post["date"]."";

}
?>

Pagina generada en {elapsed_time} segundos

[/code]

Como podéis recordar, nosotros teníamos una variable $data["posts"], que realmente es un array $posts dentro del array $data. Dentro del array $posts tenemos un array para cada ID de entrada. Para eso usamos la función foreach, para “dividir” estos arrays y generar el contenido para cada ID. En cuanto al contenido dentro del ID podéis fijaros en la siguiente expresión:

[code lang="php"]
anchor($post["url"],"#".$id)
[/code]

anchor() es una función que forma parte del helper url que hemos usado en autoload.php. En el primer termino de la función especificamos la dirección a donde debe apuntar el enlace y, en la segunda, el texto a mostrar.

Con esto que tenemos ya podemos mostrar las entradas correctamente, ahora vamos a crear la función show() en blog.php para ver una específica. Para empezar, clonaremos el blog_front.php y lo nombraremos blog_single.php. De momento lo dejaremos así. Volveremos al controlador blog.php y añadiremos el siguiente código:

[code lang="php"]
function show()
{
$url_title = $this->uri->segment(1, 0);

if($url_title) {
$this->load->helper('date');
$datestring = "%d-%m-%Y";

$query = $this->db->where("url_title",$url_title);
$query = $this->db->get('posts');

foreach ($query->result() as $row) {
$data["post"]["id"] = $row->id;
$data["post"]["title"] = $row->title;
$data["post"]["url"] = $row->url_title;
$data["post"]["body"] = $row->body;
$data["post"]["date"] = mdate($datestring,$row->created_on);
}

$this->load->view('blog_single',$data);
} else {
redirect();
}
}
[/code]

Podemos ver que el código es prácticamente igual al de la función index(), pero este tiene una particularidad: muestra solo una entrada. Como podéis ver, al principio del código establecemos el $url_title con $this->uri->segment(1, 0);. Esto nos permite recibir un segmento determinado de la URI, en nuestro caso, el primero. Acto seguido comprobamos si existe algo establecido y si existe empezamos a montar la estructura. Hemos añadido una cosa en la sentencia $query, hemos usado $this->db->where(“url_title”,$url_title); para establecer que el campo url_title de la base de datos sea igual al $url_title.

Si todo esto no se cumpliera, hay un redirect() que los envía al principio de la aplicación.

También tenemos que cambiar el código de nuestra vista, ya que solo hemos duplicado el archivo. Entre las etiquetas y debería haber algo así:

Archivo: /application/views/blog_single.php
[code lang="php"]

-

Page rendered in {elapsed_time} seconds

[/code]

Solo nos falta un truco que hemos usado en archivo routes.php que hemos hablado antes:

Archivo: /application/config/routes.php, Línea: 46-49
[code lang="php"]
$route["blog"] = "blog";
$route["add"] = "blog/add";

$route[":any"] = "blog/show";
[/code]

Añadir entradas

Esta es la última parte de nuestra aplicación básica, como añadir una entrada a la base de datos. Es muy sencillo. Para empezar esta vez crearemos primero la vista. Copiamos uno de las vistas y cambiamos el nombre por blog_add.php. Vamos a usar otra de helpers de CodeIgniter para crear el campo de formulario, form. Entre las etiquetas y debería quedar algo tal que así:

Archivo: /application/view/blog_add.php
[code lang="php"]

Añadir entrada

Título:

Contenido

Contraseña

validation->error_string; ?>

Page rendered in {elapsed_time} seconds

[/code]

Lo único que os puede despistar aquí es el $this->validation->error_string;, forma parte de una de las librerías de CodeIgniter que vamos a usar en nuestro controlador para validar los campos. Se usa para que, si al validar el formulario hay un error, mostrar en el mismo archivo el error. Para poder añadir la entrada a nuestro controlador blog.php vamos a añadirle el siguiente código:

[code lang="php"]
function add()
{
$this->load->library("validation");
$this->load->helper("form");

$admin_password = "prueba";

$rules["title"] = "trim|required|min_length[3]|max_length[64]";
$rules["body"] = "trim|required|min_lenght[50]";
$rules["password"] = "trim|required";
$this->validation->set_rules($rules);

$fields["title"] = "título";
$fields["body"] = "contenido";
$fields["password"] = "contraseña";
$this->validation->set_fields($fields);

if ($this->validation->run() && $this->input->post("password") == $admin_password) {

$this->load->helper("date");

$insert = array(
"title" => $this->input->post("title"),
"url_title" => url_title($this->input->post("title")),
"body" => $this->input->post("body"),
"created_on" => now()
);

$this->db->insert("posts", $insert);

redirect("");
}

$this->load->view("blog_add");
}
[/code]

Como podéis ver, al principio del código, lo primero que hacemos es cargar la librería validation que hemos comentado antes. También cargamos el helper form para crear el formulario. El sistema de “protección” es algo cutre, pero no era la misión de este artículo precisamente. Hemos establecido una contraseña que se validará cuando enviemos la entrada. Seguidamente establecemos, gracias a la librería validation, que es lo que los campos deben cumplir. Acto seguido, por si algo falla, establecemos unos nombres “humanos” a los campos.

Si todo lo anterior valida, y la contraseña que hemos puesto en el formulario es igual a la establecida en el campo $admin_password, podremos montar el array $insert que luego usaremos para añadir el contenido a la base de datos. Como podéis ver en el campo “url_title” usamos la función url_title() para crear unos vínculos más accesibles y no un simple id. Una vez hemos añadido el contenido redirigimos a la pagina principal. Si esto falla volvemos a cargar la vista blog_add.php.

Conclusión

Con todo esto ya podéis crear vuestra primera aplicación en CodeIgniter usando bases de datos, varias vistas y usando routes.php para redirigir las URI. Es una base bastante fuerte para empezar a desarrollar algo encima. Próximamente enseñaré como hacer un sistema de usuarios bastante para evitar que la gente vea nuestra administración.

Descargar el ejemplo “Aplicación Básica (I), Creación de un Blog”: ipalaus-CodeIgniter_BlogExample_v1.rar

En el desarrollo de software, un framework es una estructura de soporte definida en la cual otro proyecto de software puede ser organizado y desarrollado. Típicamente, un framework puede incluir soporte de programas, bibliotecas y un lenguaje interpretado entre otros software para ayudar a desarrollar y unir los diferentes componentes de un proyecto.

Lo primero que necesitamos es descargar la última versión de CodeIgniter, nosotros trabajaremos con la versión 1.6.1 que es la última hoy en día. Una vez descargada descomprimimos el archivo .rar y veremos una estructura tal que así:

[code]
/system/
/user_guide/
/index.php
/license.txt
[/code]

En la carpeta system hay todo el contenido del framework: helpers, librerías, plugins… Y lo más importante, la carpeta application que es realmente donde nuestra aplicación va a estar. Acto seguido tenemos el directorio user_guide, es la misma Guía del Usuario (en inglés) que hay en la web de CodeIgniter. A mi me parece una de las mejores guías que he leído nunca. El index.php gestiona la aplicación y el liecense.txt es la licencia, seria interesante que la leyerais.

Requisitos

• Servidor
  • PHP 4.3.2 o superior
  • Una base de datos es lo más común en este tipo de aplicaciones, hay soporte para: MySQL (4.1+), MySQLi, MS SQL, Postgre, Oracle, SQLite y ODBC.

Instalación

La instalación de este framework es muy sencilla, y más si dejamos la configuración del mismo para otro apartado. Solo deberíamos subir los archivos a nuestro servidor (configurados) y ya estaría lista pero por motivos de seguridad, nosotros vamos a cambiar la jerarquía de los directorios. De un amigo, Víctor Román, aprendí que el acceso a la aplicación solo debería tenerla el servidor por lo que los directorios como application y system no deberían ser públicos. Para realizar esto usaremos un truco que, obviamente, podéis saltar si no os interesa o vuestro hosting no os lo permite.

Para empezar, necesitamos saber si podemos hacer una redirección de un dominio o subdominio, por ejemplo blog.ipalaus.es, a /ipalaus_es/subdominios/blog/public_html. Esto nos permitirá tener nuestros archivos del blog en un mismo directorio pero los públicos solo estarán en la carpeta public_html. Para empezar crearemos el directorio public_html en nuestra versión local y moveremos a esa misma carpeta el archivo index.php que teníamos en la raíz. Otra manía personal es poner los directorios application y system separados, porque podríamos, por ejemplo, usar siempre el mismo system para 3 o 4 aplicaciones y solo actualizar uno en vez de tener que hacerlo para cada uno… Así que movemos el application fuera de system. Debería quedarnos una jerarquía tal que así:

[code]
/application/
/public_html/
/public_html/index.php
/system/
[/code]
(El license.txt y la carpeta user_guide han sido borrados)

Ahora accedemos a editar el /public_html/index.php con cualquier editor de texto. Y editamos las siguientes lineas:

Archivo: /public_html/index.php, Línea: 26
[code lang="php"]
$system_folder = "../system";
[/code]

Archivo: /public_html/index.php, Línea: 43
[code lang="php"]
$application_folder = "../application";
[/code]

Y con esto ya tenemos configurada nuestra jerarquía. Ahora toca hacer una configuración básica del sistema.

Configuración

La configuración básica de nuestra aplicación se basará en la configuración de los archivos config.php y database.php, ambos en /application/config/. Para empezar, el config.php, lo abrimos con nuestro editor de textos favorito. Hay algunas cosas que simplemente las paso por alto, variables que no nos hacen falta para nada en una configuración básica.

Archivo: /application/config/config.php, Línea: 14
[code lang="php"]
$config['base_url'] = "http://blog.ipalaus.es/";
[/code]

La variable $config['base_url'] corresponde a la dirección que CodeIgniter interpretará como base cuando tenga que incluir ficheros o similar. Es muy importante que sea correcta. Otros ejemplos podrían ser: http://localhost/blog, http://www.ipalaus.es/…

Archivo: /application/config/config.php, Línea: 26
[code lang="php"]
$config['index_page'] = "index.php";
[/code]

Esta variable la usaremos en caso de que hayamos renombrado nuestro archivo index.php (en /public_html), cosa que dudo… De todos modos, si queremos usar mod_rewrite de Apache tendremos que dejar en blanco. En otra entrada explicaré como usar mod_rewrite en CodeIgniter.

Archivo: /application/config/config.php, Línea: 57
[code lang="php"]
$config['url_suffix'] = "";
[/code]

Hay gente que tiene la “manía” de ponerle sufijos a las direcciones web… Quizá para ocultar que realmente es PHP o poner una extensión significativa. Si pusiéramos algo tipo $config['url_suffix'] = “html”;, todas las direcciones nos saldrían tipo: http://blog.ipalaus.es/entradas/codeigniter-configuracion-basica.html, siendo este archivo, PHP.

Archivo: /application/config/config.php, Línea: 69
[code lang="php"]
$config['language'] = "spanish";
[/code]

Desde la web de uno de los creadores de CodeIgniter, Derek Allard, podemos descargar el archivo de idioma spanish. Su instalación es tan sencilla como, descomprimir el fichero y mover su contenido a /application/language/spanish/. Dentro del directorio spanish deben estar los archivos .php y no ningún directorio más. Este archivo de lenguaje es, generalmente, para errores y mensajes relacionados con las librerías del framework.

Archivo: /application/config/config.php, Línea: 234-241
[code lang="php"]
$config['sess_cookie_name'] = 'blogipalaus_session';
$config['sess_expiration'] = 7200;
$config['sess_encrypt_cookie'] = FALSE;
$config['sess_use_database'] = FALSE;
$config['sess_table_name'] = 'ci_sessions';
$config['sess_match_ip'] = FALSE;
$config['sess_match_useragent'] = TRUE;
$config['sess_time_to_update'] = 300;
[/code]

Esta parte es usada solo si usamos sesiones en nuestras aplicaciones… Aunque si vamos a usar PHP para programar nuestro sitio web, lo más probable es que las usemos. Lo más característico de esta parte es poder usar la base de datos para gestionar las sesiones. Si lo quisiéramos, deberíamos cambiar la variable $config['sess_use_database'] a TRUE.

Archivo: /application/config/config.php, Línea: 266
[code lang="php"]
$config['global_xss_filtering'] = TRUE;
[/code]

Activaremos el filtro de XSS por si las moscas… Nunca se sabe .

Ahora ya hemos terminado con el config.php y pasamos a la configuración de database.php que, obviamente, es más sencilla. En CodeIgniter es posible usar varios perfiles de base de datos, por si tenemos una base de datos de desarrollo y una de producción o miles de configuraciones más.

Archivo: /application/config/config.php, Línea: 40-51
[code lang="php"]
$db['default']['hostname'] = "localhost";
$db['default']['username'] = "ipalaus";
$db['default']['password'] = "ejemplo";
$db['default']['database'] = "blog";
$db['default']['dbdriver'] = "mysql";
$db['default']['dbprefix'] = "";
$db['default']['pconnect'] = TRUE;
$db['default']['db_debug'] = TRUE;
$db['default']['cache_on'] = FALSE;
$db['default']['cachedir'] = "";
$db['default']['char_set'] = "utf8";
$db['default']['dbcollat'] = "utf8_general_ci";
[/code]

Como podéis comprobar es bien sencillo. Colocar el nombre de usuario, la base de datos, el host de la misma… Si quisiéramos usar una base de datos diferente a MySQL deberíamos cambiar el $db['default']['dbdriver'] por el deseado. A parte, es posible usar cache para las consultas MySQL… pero es algo bastante avanzado y que a usuarios de a pié no es muy necesario.

Conclusión

Espero que esta pequeña introducción a CodeIgniter, a nivel muy básico, sirva a alguien para animarse a programar usando este framework. Pretendo continuar añadiendo configuraciones y pequeños programas y ejemplos para que podáis incrementar vuestro nivel de conocimiento en CodeIgniter.

Descarga CodeIgniter en Español y semiconfigurado: CodeIgniter_1.6.1-spanish.rar

Uno de los principales problemas a la hora de empezar a programar es que muchos usuarios necesitamos donde mirar por tal de tener una base para empezar nuestro programa. No es lo mejor a la larga porque siempre terminamos basando nuestro trabajo en otros proyectos, pero es una buena forma de empezar a programar. En este caso explicaré como hacer un sistema que valide a lo usuarios mediante un formulario AJAX y el framework PHP Code Igniter.

Lo primero que necesitamos en este caso es jQuery que podemos descargarlo desde la web oficial. jQuery es una librería de JavaScript que nos facilita muchísimo las cosas a la hora de programar. Obviamente también necesitaremos Code Igniter y me reservo el derecho en publicar una entrada futura sobre el mismo.

Para empezar lo haremos con una cosa sencilla, la base de datos que vamos a usar. Es bien simple: id, usuario, contraseña, correo y hora de “registro”.

[code lang="mysql"]
CREATE TABLE `users` (
`uid` int(10) NOT NULL auto_increment,
`username` varchar(16) NOT NULL,
`password` varchar(32) NOT NULL,
`email` varchar(128) NOT NULL,
`time` int(10) NOT NULL,
PRIMARY KEY (`uid`)
) ENGINE=InnoDB DEFAULT CHARSET=latin1;

[/code]

Ahora es hora del controlador que llamaré user.php, este user.php se ocupará de las funciones básicas como son: comprobar el usuario y la desconexión del mismo.

[code lang="php"]
load->model("user_model");
$this->load->model("dalia_model");

$this->load->helper("security");
$this->load->helper("form");
}

/* Checks if the password that the user gives is equal at the DB ones */
function _check_login($username) {
$password = md5($this->validation->password);

if(!$this->user_model->checkUserLogin($username,$password,"users"))
return FALSE;

return TRUE;
}

function index() {
$this->load->view("userLogin");
}

function checkLogin()
{
$this->load->library('validation');
$rules['username'] = 'trim|required|callback__check_login';
$rules['password'] = 'trim|required';
$this->validation->set_rules($rules);

$fields['username'] = 'username';
$fields['password'] = 'password';
$this->validation->set_fields($fields);

if ($this->validation->run()) {
$username = $this->validation->username;
$uid = $this->user_model->getUserId($username,"users");

$this->session->set_userdata("logged_in",$uid);

$output = '{ "success": "yes", "welcome": "Welcome" }';
} else {
$output = '{ "success": "no", "message": "This is not working" }';
}

$output = str_replace("\r", "", $output);
$output = str_replace("\n", "", $output);

echo $output;
}

function logout()
{
$this->session->sess_destroy();
redirect("");
}

}

?>
[/code]

Para el login en AJAX vamos a tener que usar una comprobación en PHP que la llamaremos mediante jQuery. Es tan simple como saber si el usuario que intentamos acceder es válido o no lo es. Esta función de comprobar el usuario es checkLogin() y la analizamos desde el principio. En primer termino nos encontramos con:

[code lang="php"]
$rules['username'] = 'trim|required|callback__check_login';
[/code]

Que hace una llamada a la función _check_login(). Es la función que realmente comprueba en al base de datos si el usuario existe o no en la misma:

[code lang="php"]
function _check_login($username) {
$password = md5($this->validation->password);

if(!$this->user_model->checkUserLogin($username,$password,"users"))
return FALSE;

return TRUE;
}
[/code]

Lo primero que hacemos es obtener la contraseña y codificarla en md5, ya que es como reside en la base de datos. Mediante el modelo user_model, que analizaremos más adelante, comprobamos con el nombre de usuario y contraseña que el usuario ha ingresado si coinciden con los que corresponden. Si esto es verdad, y coinciden, devolveremos un TRUE… del contrario, FALSE.

El modelo que usamos para comprobar el usuario, llamado user_model.php, es muy sencillo. El código es el siguiente:

[code lang="php"]
db->where("username",$username);
$query = $this->db->where("password",$password);
$query = $this->db->limit(1,0);
$query = $this->db->get($table);

if ($query->num_rows() == 0) {
return NULL;
}

return TRUE;
}
}
?>
[/code]

Simplemente devuelve TRUE o FALSE dependiendo de si son válidos los datos que pasamos a la función.

Una vez tenemos casi todo el código, es hora de la View donde mostraremos el formulario en AJAX. Tengo las vistas separadas de modo que pueda cargar un header, el contenido y un footer. Mi formulario irá al header pero podría funcionar en cualquier otro sitio.

[code lang="php"]

session->userdata('logged_in')) {
?>

Welcome, you're already logged In.

'userlogin'));?>
Username:

Password:

[/code]

Como comprobaciones en medio de la vista nos podemos dar cuenta de la siguiente:

[code lang="php"]
if($this->session->userdata('logged_in')) {
[/code]

Simplemente lo usamos para comprobar si es un usuario que ya ha logeado o si es un nuevo usuario. Si es nuevo, esta comprobación fallará y nos mostrará el nuevo formulario de login. No tiene ningún tipo de complicación. Lo que más puede generar dudas es el código de jQuery, que también es muy simple y son pocas lineas:

[code lang="javascript"]
$(document).ready(
function(){

$("#userlogin").ajaxForm({
type: "POST",
url: "/user/checkLogin",
dataType: "json",
data: "username="+$("#username").val()+"&password;="+$("#password").val(),
success: updateLogin
});

}
)
[/code]

Para usar este tipo de llamada (ajaxForm) vamos a necesitar el plugin jQuery Form que podemos descargar desde la página del autor. Como curiosidad destacar el success: updateLogin que se encargará de actualizar nuestro formulario sin necesidad de cargar de nuevo la página. Esta es otra función a parte que llama una vez ha ejecutado el script. El código es el siguiente:

[code lang="javascript"]
function updateLogin(data) {
$('#logged').html('');
$('#logged').hide();

$("#loginform").fadeOut("slow",
function() {
if (data.success == 'yes') {
$('#logged').html(data.welcome).fadeIn("slow");
}

if (data.success == 'no') {
$('#loginerror').html(data.message).fadeIn("slow").fadeOut("slow",
function() {
$("#loginform").fadeIn("slow");
}
);
}
}
);

}
[/code]

Dependiendo de si el script PHP ha devuelto success == yes o success == no, ejecutará y actualizará de un modo o de otro. Los data.welcome o data.message son los mensajes que hemos enviado usando JSON a la hora de validar el script en el controlador user.php.

Bien, espero que con esto puedan crear su primer login en AJAX usando jQuery y PHP. Pronto, más sobre AJAX, PHP y CodeIgniter!