CREATE TABLE IF NOT EXISTS `SlimProdutos`.`Categorias` (
`id` INT NOT NULL AUTO_INCREMENT ,
`nome` VARCHAR(100) NULL ,
PRIMARY KEY (`id`) )
ENGINE = InnoDB;

CREATE TABLE IF NOT EXISTS `SlimProdutos`.`Produtos` (
`id` INT NOT NULL AUTO_INCREMENT ,
`nome` VARCHAR(100) NULL ,
`preco` DECIMAL(10,2) NULL ,
`dataInclusao` DATE NULL ,
`idCategoria` INT NOT NULL ,
PRIMARY KEY (`id`) ,
INDEX `fk_Produtos_Categorias_idx` (`idCategoria` ASC) ,
CONSTRAINT `fk_Produtos_Categorias`
FOREIGN KEY (`idCategoria` )
REFERENCES `SlimProdutos`.`Categorias` (`id` )
ON DELETE NO ACTION
ON UPDATE NO ACTION)
ENGINE = InnoDB;

Crie a pasta SlimProdutos no seu WebRoot (c:\wamp\www) e certifique-se que ela esteja no mesmo nível da pasta Slim. Copie o arquivo .htaccess da pasta Slim para SlimProdutos e crie o arquivo index.php, inicialmente com o seguinte código:

<?php
require '../Slim/Slim/Slim.php';
\Slim\Slim::registerAutoloader();
$app = new \Slim\Slim();
$app->response()->header('Content-Type', 'application/json;charset=utf-8');

$app->get('/', function () {
echo "SlimProdutos";
});

$app->run();

Este é o esqueleto básico de uma aplicação RESTful com o framework Slim. Incluímos a biblioteca, instanciamos um objeto ($app) e mapeamos o “GET /” para exibir uma mensagem. Isso faz com que ao acessarmos http://localhost/SlimProdutos, a mensagem seja exibida.

Exibindo as categorias

Para exibirmos as categorias de um produto, teremos que alterar o código para que possamos mapear o “GET /categorias”, ler o banco de dados e exibir informações. Vamos supor que já foram adicionadas algumas categorias na tabela. Vamos criar uma função que retorna a conexão com o banco de dados e depois mapear pelo Slim o método para obter categorias:

<?php

require '../Slim/Slim/Slim.php';
\Slim\Slim::registerAutoloader();
$app = new \Slim\Slim();
$app->response()->header('Content-Type', 'application/json;charset=utf-8');

$app->get('/', function () {
echo "SlimProdutos ";
});

$app->get('/categorias','getCategorias');

$app->run();

function getConn()
{
return new PDO('mysql:host=localhost;dbname=SlimProdutos',
'root',
'',
array(PDO::MYSQL_ATTR_INIT_COMMAND => "SET NAMES utf8")
);

}

function getCategorias()
{
$stmt = getConn()->query("SELECT * FROM Categorias");
$categorias = $stmt->fetchAll(PDO::FETCH_OBJ);
echo "{categorias:".json_encode($categorias)."}";
}

As duas partes mais importantes deste código são:

1. O mapeamento get de /categorais: $app->get(‘/categorias’,’getCategorias’);
2. Na função getCategorias, o retorno json:   echo “{categorias:”.json_encode($categorias).”}”;

Ao testarmos o método, acessando http://localhost/SlimProdutos/categorias, poderemos ver a resposta. Algo do tipo:

{categorias:[{"id":"1","nome":"Eletr\u00f4nicos"},{"id":"2","nome":"Inform\u00e1tica"}]}

Incluindo produtos

Agora vamos incluir um produto. Após esta tarefa, conseguiremos executar duas operações básicas, que é consultar e inserir dados, sendo que as outras operações serão muito semelhantes. Começamos, então, mapeando a requisição no Slim, da seguinte forma:

$app->post('/produtos','addProduto');

Coloque este código abaixo do mapeamento “GET /categorias”. O novo mapeamento diz que se houver uma requisição “POST /produtos”, o método addProduto será chamado. Este método está descrito a seguir:

function addProduto()
{
$request = \Slim\Slim::getInstance()->request();
$produto = json_decode($request->getBody());
$sql = "INSERT INTO produtos (nome,preco,dataInclusao,idCategoria) values (:nome,:preco,:dataInclusao,:idCategoria) ";
$conn = getConn();
$stmt = $conn->prepare($sql);
$stmt->bindParam("nome",$produto->nome);
$stmt->bindParam("preco",$produto->preco);
$stmt->bindParam("dataInclusao",$produto->dataInclusao);
$stmt->bindParam("idCategoria",$produto->idCategoria);
$stmt->execute();
$produto->id = $conn->lastInsertId();
echo json_encode($produto);
}

Veja que o método é um pouco mais complexo que o primeiro, mas é de fácil compreensão. Inicialmente, obtemos a requisição POST para que possamos obter os dados que estão vindo do “formulário”. Colocamos formulário entre parêntesis porque, na verdade, a requisição não sabe de onde estes dados vieram, sabe apenas que existe um objeto JSON representando esse objeto e que este JSON está no corpo (“body”) da requisição.

Através do json_decode, nós pegamos o JSON do corpo da requisição ($request->getBody()) e o transformamos em um objeto armazenado na variável $produto. A partir da linha onde montamos o SQL, estamos preparando tudo para gerar o INSERT, utlizando PDO. Para finalizar, utilizamos o comando lastInsertId para retornar o último id gerado pelo INSERT, e retornamos novamente o objeto $produto, só que agora com o id preenchido.

Como testar se ainda não temos um cliente?

As aplicações RESTful são criadas de forma completamente separada da interface. Ainda não criamos uma. Sendo assim, como podemos testar a nossa aplicação se ainda não existe um “input”? Você pode usar uma ferramenta chamada curl para fazer a requisição ao servidor. No exemplo de inclusão de produtos, você poderia executar o seguinte comando:

curl -i -X POST -H 'Content-Type: application/json' -d '{"nome": "Produto 1", "idCategoria": "1"}' http://localhost/SlimProdutos/produtos

Para facilitar, recomendo utilizar uma app do Google Chrome chamada REST Console, muito útil para testes rápidos! Existem dezenas de aplicações com esta funcionalidade, fique a vontade em testá-las.

Obtendo um produto

Através do id de um produto, podemos obter suas informações. O mapeamento da api pode ser configurado pelo seguinte código:

$app->get('/produtos/:id','getProduto');

Repare que usamos uma variável :id que determina o campo id da tabela Produtos. Este :id será um parâmetro repassado para o método getProduto, conforme o código a seguir:

function getProduto($id)

{
$conn = getConn();
$sql = "SELECT * FROM produtos WHERE id=:id";
$stmt = $conn->prepare($sql);
$stmt->bindParam("id",$id);
$stmt->execute();
$produto = $stmt->fetchObject();

//categoria
$sql = "SELECT * FROM categorias WHERE id=:id";
$stmt = $conn->prepare($sql);
$stmt->bindParam("id",$produto->idCategoria);
$stmt->execute();
$produto->categoria = $stmt->fetchObject();

echo json_encode($produto);
}

Neste código, repassamos o :id do mapeamento para o parâmetro $id do método. Ele é usado no SQL de produtos para que se possa obter o registro da tabela. Veja que criamos a variável $produto como resultado da SQL e que depois realizamos uma segunda consulta ao banco de dados, para se obter a categoria do produto. O resultado final dessa consulta é um JSON semelhante ao exibido a seguir:

{
"id": "1",
"nome": "Produto1",
"preco": null,
"dataInclusao": null,
"idCategoria": "1",
"categoria": {
"id": "1",
"nome": "Eletr\u00f4nicos"
}
}

Editando o produto

De acordo com a API configurada, quando realizamos um POST repassando o id do produto, estamos salvando o objeto, ou seja, executando o comando update. O mapeamento Slim é o seguinte:

$app->post('/produtos/:id','saveProduto');

E o código:

function saveProduto($id)
{
$request = \Slim\Slim::getInstance()->request();
$produto = json_decode($request->getBody());
$sql = "UPDATE produtos SET nome=:nome,preco=:preco,dataInclusao=:dataInclusao,idCategoria=:idCategoria WHERE   id=:id";
$conn = getConn();
$stmt = $conn->prepare($sql);
$stmt->bindParam("nome",$produto->nome);
$stmt->bindParam("preco",$produto->preco);
$stmt->bindParam("dataInclusao",$produto->dataInclusao);
$stmt->bindParam("idCategoria",$produto->idCategoria);
$stmt->bindParam("id",$id);
$stmt->execute();

echo json_encode($produto);

}

Apagando o produto

Para apagar o produto, é enviado o método http DELETE, conforme o mapeamento:

$app->delete('/produtos/:id','deleteProduto');

E o código:

function deleteProduto($id)
{
$sql = "DELETE FROM produtos WHERE id=:id";
$conn = getConn();
$stmt = $conn->prepare($sql);
$stmt->bindParam("id",$id);
$stmt->execute();
echo "{'message':'Produto apagado'}";
}

$app->get('/produtos','getProdutos');