PHP, CodeIgniter y jQuery
Entradas etiquetadas con mysql
Consultas MySQL en CodeIgniter
17 Mar
Aunque pueda parecer difícil, hacer consultas en MySQL en CodeIgniter es la cosa más fácil del mundo. Y no solo con MySQL sino con todos los protocolos soportados por el framework. Es importante, sobretodo, que tengamos nuestro CodeIgniter correctamente configurado. Podéis echarle una ojeada al artículo de configuración y iniciación para ver como configuramos los datos de MySQL.
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.
AJAX Login con jQuery y Code Igniter (PHP)
7 Mar
Nueva versión del tutorial: AJAX Login con jQuery y CodeIgniter – v2 + archivos
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"]
;?>content/img/logo.png){kind=logo}
session->userdata('logged_in')) {
?>
?>
Welcome, you're already logged In.
'userlogin'));?>
[/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!
