• GET: Utilizaremos 2 consultas get para obtener información de la base de datos sobre los usuarios registrados, la primera para obtener un arreglo de todos los usuarios, y la segunda con un identificador obtendremos un arreglo de datos de un único usuario.
• POST: Con este método insertaremos usuarios a nuestro sistema o base de datos.
• PUT: Si tenemos el identificador de un usuario podemos hacer modificaciones a la base de datos, por lo que usaremos este método para poder hacerlo.
• DELETE: Por último utilizaremos este método para eliminar un usuario con su identificador.

Lo primero que necesitamos hacer es crear la base de datos, en este caso la haremos en SQL, asumiendo que sea desde consola, ingresando el siguiente código:

CREATE DATABASE restslim;
USE restslim;
CREATE TABLE usuarios (
  id int(11) NOT NULL AUTO_INCREMENT,
  username varchar(100) NOT NULL,
  password varchar(100) NOT NULL,
  description text,
  PRIMARY KEY (id)
) ENGINE=InnoDB  DEFAULT CHARSET=utf8;

Una vez creada la base de datos y la tabla usuarios, el segundo paso es preparar la conexión a mysql, en php existen varios métodos para realizarlo como pueden ser funciones mysql (obsoleto desde la versión 5 de php), mysqli que recomienda el sitio oficial de php, y por último con un objeto de clases php PDO, aunque las 3 formas son válidas, utilizare la ultima opcion ya que a mi parecer es más fácil de utilizar y el uso de consulta preparas es muy simple.

Abrimos nuestro archivo index.php que configuramos anteriormente (ver de nuevo), de preferencia borramos el código innecesario y dejamos solo lo siguiente:

require 'Slim/Slim.php';
\Slim\Slim::registerAutoloader();
$app = new \Slim\Slim();

En la siguiente linea agregamos la función para poder realizar la conexión a la base de datos:

/*
 *conexiónon a base de datos
 */
function PDOconnection()
{
	try{
		$connection = new PDO("mysql:host=localhost;Mibase=prueba_slim", "usuario", "password");
		$connection->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
	}
	catch(PDOException $error)
	{
		echo "Error PDOconnection: " . $error->getMessage();
	}
	return $connection;
}

Reemplaza el texto “mibase” por tu nombre de base de datos de igual manera el texto “usuario” y la “contraseña” por tu configuracion, y de esta manera ya tendremos la conexión a la base de datos, el siguiente paso es registrar las rutas en el objeto $app creado inicialmente.

En este punto comenzaremos a utilizar los métodos HTTP para obtener la lista de usuarios y los datos de un usuario en específico utilizando su id, en este caso haremos uso del método GET, para registrar una ruta en slim tipo GET, se utiliza el método con el mismo nombre quedando de la siguiente manera:

$app->get("/usuarios/", function() use($app)
{
	try{
		$connection = PDOconnection();
		$consulta = $connection->prepare("SELECT * FROM usuarios");
                $consulta->execute();
		$usuarios = $consulta->fetchAll();
		$connection = null;
		$app->response->headers->set("Content-type", "application/json");
		$app->response->status(200);
		$app->response->body(json_encode($usuarios));
	}
	catch(PDOException $error)
	{
		echo "Error PDOconnection: " . $error->getMessage();
	}
});

En el método se agrega el primer parámetro “nombre de la ruta” y luego se agrega una función o clase a utilizar en este caso utilizamos una función anónima que puede ser declarada como parámetro, como puedes darte cuenta creamos la conexión a la base de datos, y con la sentencia SQL realizamos la consulta de manera rápida, siempre debes de realizar la consulta dentro de un try/catch para evitar errores en ejecución. Por último recogemos los datos y los mostramos en formato json con la función json_encode().

Para obtener los datos de un usuario en especifico solo necesitamos tener el identificador de la base de datos y podremos realizar la consulta, en este caso pasamos el parámetro id a través de la ruta “/usuario/:id”, el texto “:id” slim lo reconoce como variable y lo podremos utilizar dentro de la función como se ve a continuación:

$app->get("/usuario/:id", function($id) use($app)
{
	try{
		$connection = PDOconnection();
		$consulta = $connection->prepare("SELECT * FROM usuarios WHERE id = ?");
                $consulta->bindParam(1, $id);
                $consulta->execute();
		$usuarios = $consulta->fetch();
		$connection = null;
		$app->response->headers->set("Content-type", "application/json");
		$app->response->status(200);
		$app->response->body(json_encode($usuarios));
	}
	catch(PDOException $error)
	{
		echo "Error PDOconnection: " . $error->getMessage();
	}
});

Para utilizar el parámetro ”:id” declarado en la ruta, debemos incluir dentro de la función el parámetro con el mismo nombre. En la sentencia SQL utilizamos el signo ? para referirnos a un parámetro variable que desconocemos, esto se conoce como sentencias preparadas, puedes utilizar este signo para referirte a los parámetros que desees solo debes respetar el orden al ingresarlos, y con el método “bindParam(1, $id)” reemplazamos el signo por la variable.

Para insertar usuarios hacemos uso del método POST que es utilizado para enviar información de manera más discreta, el código a utilizar seria asi:

$app->post("/usuarios/", function() use($app)
{
	$usuario = $app->request->post("username");
	$password = $app->request->post("password");
	$description = $app->request->post("description");

	try{
		$connection = PDOconnection();
		$db = $connection->prepare("INSERT INTO usuarios VALUES(null, ?, ?, ?)");
		$db->bindParam(1, $usuario);
		$db->bindParam(2, $password);
		$db->bindParam(3, $description);
		$db->execute();
		$lastid = $connection->lastInsertId();
		$connection = null;
		$app->response->headers->set("Content-type", "application/json");
		$app->response->status(200);
		$app->response->body(json_encode($lastid));
	}
	catch(PDOException $error)
	{
		echo "Error PDOconnection: " . $error->getMessage();
	}
});

Como puedes notar, con el método request->post(“nombre_de_lparametro”) obtenemos el valor de cada variable, y utilizando sentencias preparadas insertamos cada valor en nuestra base de datos, y como respuesta mostramos un 1 en caso de haberse agregado los datos con éxito.

Para actualizar los datos de un usuario existente en la base de datos, solo es necesarios el id, utilizamos el método PUT realizamos las modificaciones, el código necesarios es el siguiente:

$app->put("/usuarios/", function() use($app)
{
	$usuario = $app->request->put("username");
	$password = $app->request->put("password");
	$description = $app->request->put("description");
        $id = $app->request->put("id");

	try{
		$connection = PDOconnection();
		$db = $connection->prepare("UPDATE usuarios SET username = ?, password = ?, description = ? WHERE id = ?");
		$db->bindParam(1, $usuario);
		$db->bindParam(2, $password);
		$db->bindParam(3, $description);
		$db->bindParam(4, $id);
		$db->execute();
		$connection = null;
		$app->response->headers->set("Content-type", "application/json");
		$app->response->status(200);
		$app->response->body(json_encode(array("update" => 1)));
	}
	catch(PDOException $error)
	{
		echo "Error PDOconnection: " . $error->getMessage();
	}
});

El código es similar al método POST la diferencia es básicamente la consulta SQL que ahora es “update” en lugar de “insert”.

Si necesitamos eliminar un usuarios, utilizamos el método DELETE utilizando el id del usuarios para referirnos a él en la base de datos, de igual forma que en el método GET también pasamos el id a través de la url, el codigo quedaria de esta manera:

$app->delete("/usuarios/:id", function($id) use($app)
{
	try{
		$connection = PDOconnection();
		$db = $connection->prepare("DELETE FROM usuarios WHERE id = ?");
		$db->bindParam(1, $id);
		$db->execute();
		$connection = null;
		$app->response->headers->set("Content-type", "application/json");
		$app->response->status(200);
		$app->response->body(json_encode(array("delete" => 1)));
	}
	catch(PDOException $error)
	{
		echo "Error PDOconnection: " . $error->getMessage();
	}
});

Si todo salio bien, mostramos un 1 como confirmación, y por último agregamos la linea “$app->run();” para poner a correr la aplicación.

Una vez finalizado la configuración en slim debemos probar si todo esta funcionado correctamente, lo cual explicaré en la próxima entrada para no hacer muy largo el artículo.

La entrada Rest ful api con slim php – rutas y mysql aparece primero en Cronicas de un geek.

las ventajas de utilizar un servicio RESTful es que podemos utilizar un formato ligero de objetos Javascript llamado JSON, el cual nos permite tener diferentes aplicaciones en distintos lenguajes que pueden interactuar entre sí, gracias a la flexibilidad del protocolo, y con el aumento de aplicaciones móviles es común que las bases de datos y en algunos casos la capacidad de procesamiento la realiza un servidor en la nube y no el teléfono, un ejemplo podría ser el de crear una aplicación en Android para un blog en WordPress, si queremos mostrar una lista de nuestros últimos artículos de manera personalizada, lo ideal sería recoger los datos del servidor y mostrarlos en una lista o en secciones, incluso el plugin jetpack permite el acceso de tu blog a través de su api json sin crearla nosotros lo que lo hace aún mas fácil, mas adelante haré un tutorial de como hacerlo pero por ahora supongamos que no tenemos la api y tenemos que hacerla de forma manual.

Se puede crear un api RESTful en varios lenguajes, en Ruby, PHP o Java por ejemplo, lo que nos da más opciones para escoger, en este caso por flexibilidad y facilidad de uso utilizaremos php y el micro framework slim el cual nos agiliza el tiempo de desarrollo y entre sus ventajas podemos mencionar:

1. Manejo de métodos HTTP estándar y personalizados
2. Configuración sencilla
3. Manejo de rutas
4. Manejo de plantillas para vistas
5. Es software libre.

Métodos HTTP utilizados en RESTful

HTTP es un protocolo de transferencias usado en Internet, la mayoría de navegadores sólo utilizan los métodos GET y POST para realizar transferencias dejando de lado los otros métodos (para ver todos lo métodos y su explicación da click aqui ). CRUD es el acrónimo utilizado para referirse a las funciones de Crear, Obtener, Actualizar y Borrar (Create, Read, Update, Delete en inglés), es lo que básicamente haremos con slim utilizando los métodos http para hacerlo, la función de cada método es la siguiente:

• GET: utilizado para obtener información (visibles en la url en el navegador).
• POST: utilizado para insertar información.
• PUT: utilizado para para actualizar datos.
• DELETE: utilizado para eliminar datos.

Existen otros métodos en el protocolo http que no usaremos aquí y cabe mencionar que esta es la utilización conocida como RESTful.

Instalación de slim

Primero debes descargar el código, existen dos formas y la más recomendada es por medio de composer lo único que necesitas para hacerlo es agregar en el archivo composer.json.

{
"require": {
"slim/slim": "2.*"
}
}

y ejecutamos php composer.phar install desde la consola (también agregare a la lista un tutorial de composer), y la segunda opción es de manera manual que simplemente bajas la última versión del código que puedes descargar aquí, una vez descargado el código, dentro de la carpeta creas un archivo llamado index.php en el caso de haber hecho la descarga a través de composer agrega el siguiente código:

require 'vendor/autoload.php';

si lo descargaste manual solo necesitas incluir la carpeta slim y en el archivo index.php agregamos el siguiente código:

require 'Slim/Slim.php';
\Slim\Slim::registerAutoloader();

Para iniciar la clase utilizamos lo siguiente:

$app = new \Slim\Slim();

y de esta manera ya tenemos todo listo para comenzar a agregar nuestras funciones, como prueba de que todo esta funcionando podemos agregar el siguiente ejemplo:

require 'Slim/Slim.php';
\Slim\Slim::registerAutoloader();
// GET route
$app->get(
    '/',
    function () {
        $template = <<<EOT
<!DOCTYPE html>
    <html>
        <head>
            <meta charset="utf-8"/>
            <title>Test de funcionamiento</title>
        </head>
        <body>
            <h1>Slim funciona perfectamente</h1>
        </body>
    </html>
EOT;
        echo $template;
    }
);
$app->run();

Si vemos en pantalla el mensaje “Slim funciona perfectamente” es porque todo esta funcionado bien. Para no hacer mas largo el tutorial dejaré hasta aquí este primer artículo, en la próxima entrada hablaré sobre las rutas y conexión a mysql, lo cual nos será de utilidad en muchas formas, si te gusto el articulo no olvides en comentar.

La entrada Cómo crear un api RESTful con slim php – introducción aparece primero en Cronicas de un geek.