Aún no tienes acceso a esta clase

Crea una cuenta y continúa viendo este curso

Exponer datos a través de HTTP GET

6/19
Recursos

Aportes 62

Preguntas 23

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad? Crea una cuenta o inicia sesión.

Hola, como estan?
Por si tuvieron algun problema, dejo abajo el código de ejemplo con los comandos para ejecutar en la terminal.
Espero que les sea de ayuda.
Saludos,

<?php
// CLASE 06 - Exponer datos a traves de HTTP GET

// Definimos los recursos disponibles
$allowedResourceType = [
    'books',
    'authors',
    'genres',
];

// Validamos que el recurso este disponible
$resourceType = $_GET['resource_type'];

if ( !in_array($resourceType, $allowedResourceType)) {
    die;
}

// Defino los recursos
$books = [
    1 => [
        'titulo' => 'Lo que el viento se llevo',
        'id_autor' => 2,
        'id_genero' => 2,
    ],
    2 => [
        'titulo' => 'La Iliada',
        'id_autor' => 1,
        'id_genero' => 1,
    ],
    3 => [
        'titulo' => 'La Odisea',
        'id_autor' => 1,
        'id_genero' => 1,
    ],
];

// Se indica al cliente que lo que recibirá es un json
header('Content-Type: application/json');

// Generamos la respuesta asumiendo que el pedido es correcto
switch( strtoupper($_SERVER['REQUEST_METHOD'])) {
    case 'GET':
        echo json_encode($books);
        break;
    case 'POST':
        break;
    case 'PUT':
        break;
    case 'DELETE':
        break;
}


// Inicio el servidor en la terminal 1
// php -S localhost:8000 server.php

// Terminal 2 ejecutar 
// curl http://localhost:8000 -v
// curl http://localhost:8000/\?resource_type\=books
// curl http://localhost:8000/\?resource_type\=books | jq

Mi codigo en js

const express = require("express");
const bodyParser = require("body-parser");
const router = express.Router();
 
var app = express();
app.use(bodyParser.json());
 
app.use(router);

const books = [
    {
        titulo : 'Lo que el viento se llevo',
        id_autor : '2',
        id_genero : '2'
    },
    {
        titulo : 'La Iliada',
        id_autor : '1',
        id_genero : '1'
    },
    {
        titulo : 'La Odisea',
        id_autor : '1',
        id_genero : '1'
    }]

 
router.get("/", function(req, res) {
  console.log(req.query);
  console.log(req.body);
 
  res.json(books)
});
 
app.listen(3000);
 
console.log("La aplicacion esta escuchando en http://localhost:3000");```
 

El curso esta interesante, sin embargo lo que no me gusta es que es con PHP y al comienzo dice que no es indispensable pero cuando ya llevas 3 videos que es con codigo de PHP, te das cuenta que si es indispensable PHP, pero no estoy interesado en aprender PHP. Se debería crear un curso así para Python.
Gracias.

Hice el ejemplo de esta clase con Python y Flask.

![](

Saludos,

El curso me parece interesante para conocer el manejo de las API Rest pero al no contar con los conocimientos PHP no puedo sacar todo el jugo al curso pero se logra transmitir la idea sin problema. Sigamos!!

Curso de Buenas Prácticas para Escritura de Código:
https://platzi.com/clases/mejor-codigo/

Mi versión con Python y Flask

from flask import Flask, jsonify, make_response
from flask_restful import Resource, Api

app = Flask(__name__)
api = Api(app)

books = [
    {
        'isbn': '744586',
        'title': 'Cien años de soledad',
        'description': 'Lorem insup lol.',
        'autor': 'Gabriel Garcia Marquez'
    },
    {
        'isbn': '7894546',
        'title': 'De animales a dioses',
        'description': 'Lorem insup lol.',
        'autor': 'Yuval Noah Harari'
    }
]

class Books(Resource):
    def get(self):
        return make_response(jsonify({'books': books}), 200)

class Authors(Resource):
    pass

class Generes(Resource):
    pass

api.add_resource(Books, '/books')
api.add_resource(Authors, '/authors')
api.add_resource(Generes, '/generes')

if __name__ == '__main__':
    app.run(debug=True)

Hasta php estoy aprendiendo en este curso 😮

6 - Exponer datos a traves de HTTP GET

Desarrollar un servidor capaz de recibir peticiones por medio de http y devolver respuestas por medio http, el protocolo de http puede trabajar con cualquier formato de texto, puede ser json, xml. La idea es exponer los recursos disponible en servidor para que sean solicitado. Un recurso puede ser una colección o un elemento único.

Pasos para exponer datos

  1. Se define los tipos de recursos disponibles

$allowedResourceType = [
    'books',
    'authors',
    'genres',
];

  1. Se valida la petición, es decir que el tipo derecursos solicitado exista
$resourceType = $_GET['resource_type'];

if (!in_array($resourceType, $allowedResourceType)) {
    die;
}
  1. Se indica al cliente que lo que recibirá una respuesta es un json
header('Content-Type: application/json');
  1. Se define una estructura básica que interpreta que verbo se está usando en la petición para ello se utiliza un switch y se utilizará la siguiente variable para saber que método se está usando:
          $_SERVER['REQUEST_METHOD'];
switch (strtoupper($_SERVER['REQUEST_METHOD'])) {
    case 'GET':
        echo json_encode($books);
        break;
    case 'POST':
        break;
    case 'PUT':
        break;
    case 'DELETE':
        break;
}
  1. Luego se inicia el servidor web para hacer la prueba Se realiza la consulta por medio de curl, se debe posicionar en la carpeta donde se encuentra el archivo server.php

Terminal 1, ejecutar

# $ php -S localhost:8000 server.php

Terminal 2, ejecutar

 # $ curl "://localhost:8000" -v
 # $ curl "://localhost:8000/\?resource_type\=books"
 # $ curl "://localhost:8000/\?resource_type\=books" | jq
  1. para obtener solamente las cabeceras
# $ curl "://localhost:8000/\?resource_type\=books" -v > /dev/null

Levantar el servidor en php:
$ php -S localhost:8000 server.php
Realizar la consulta:
$ curl http://localhost:8000 -v
$ curl http://localhost:8000?resource_type=books

# Se importa la clase Flask para poder iniciar el sevidor
# Se importa el modulo jsonify para dar el formato JSON a nuestras estructuras de datos
# Se importa el modulo request para poder tener acceso a los verbos HTTP
from flask import Flask, jsonify, request


# Creamos una instancia de la clase Flask
app = Flask(__name__)
# Creamos una lista de diccionarios, que nos servira como BDD
libros = [
    {"titulo": "Cien años de soledad", 
    "autor": "Gabriel Garzia Marquez",
    "genero": "Novela"
    },
    {"titulo": "Harry Potter: La piedra filosofal",
    "autor": "J.K. Rowling",
    "genero": "Fantasia"
    }
]


# Creamos una ruta con la que cual se podra acceder al servidor a traves del metodo GET
@app.route("/libros", methods=["GET"])
def mostrar_libros():
    # Retornamos nuestra lista, con el formato JSON
    return jsonify({"libros": libros})


# Este es el punto de entrada de nuestra aplicacion, es buena practica colocarlo
if __name__ == "__main__":
    # Inciamos nuestro servidor, el parametro DEBUG permite que los cambios en nuestro codigo se actualicen en tiempo real
    # Con el parametro PORT establecemos el puerto de escucha de nuestro servidor
    app.run(debug=True, port=8000)```

¿qué es más recomendable? ¿establecer una conexión permanente con el servidor, o en cada petición, efectuar la conexión?

No se si sirva para después pero por si acaso aquí les dejo los arrays que construí con amor para jugar con las peticiones

<?php
//definimos los recursos disponibles
$allowedResourceTypes = [
    'books',
    'authors',
    'genders'
];
//validamos que el recurso este disponible
$resourceType = $_GET['resource_type'];
if(!in_array($resourceType, $allowedResourceTypes)){
    die;
}
//definos los recursos
$books = [
        0 => [
            'title'=>'Lo que el viento se llevo',
            'id_author' => 1,
            'id_gender'=>1
        ],
        1 => [
            'title'=>'La iliada',
            'id_author' => 0,
            'id_gender'=>0,
        ],
        2 => [
            'title'=>'La riqueza de las naciones',
            'id_author' => 2,
            'id_gender'=>2,
        ],
        3 => [
            'title'=>'El diario de Ana Frank',
            'id_author' => 3,
            'id_gender'=>3,
        ],
        4 => [
            'title'=>'La odisea',
            'id_author' => 0,
            'id_gender'=>0,
        ],
        5 => [
            'title'=>'Teoría de los sentimientos morales',
            'id_autor' => 2,
            'id_gender'=>2,
        ]
    ];

    $genders = [
        0 => [
            'id_genders' => 0,
            'genero' => 'poeseia/epopeya',

        ],
        1 => [
            'id_genders' => 1,
            'genero' => 'novela',
            
        ],
        2 => [
            'id_genders' => 2,
            'genero' => 'politica/naturaleza humana',
            
        ],
        3 => [
            'id_genders' => 3,
            'genero' => 'autobiografia',
            
        ]

        ];

    $authors =[
        0 => [
            'id_authors' => 0,
            'athors' => 'Homero',
        ],
        1 => [
            'id_authors' => 1,
            'athors' => 'Margaret Mitchell',
        ],
        2 => [
            'id_authors' => 2,
            'athors' => 'Adam Smith',
        ],
        3=>[
            'id_authors' => 3,
            'athors' => 'Ana frank',
        ],
    ];

    header('Content-Type:application/json');
    // Generamos la respuesta asumiendo que el pedido es correcto
    switch(strtoupper($_SERVER['REQUEST_METHOD'])){
        case 'GET':
            echo json_encode($books);
            break;
        case 'POST':
            break;
        case 'PUT':
            break;
        case 'DELETE':
            break;
    }```

**Apuntes: **
Para los que usan IIS y tienen algunas dudas:
Levantar un servidor: php -S tudominio.local.com:8000 nombreArchivo.formato
Para hacer consulta CURL: curl http://tudominio.local.com:80
Para hacer consulta CURL con más detalles: curl http://tudominio.local.com:80 -v
Consecuentemente, Definimos los recursos disponibles, declarando los parametros que van a pasar por el Query string, luego validamos que el recurso esté disponible, en caso de no estarlo podemos detener la ejecución del script, luego de esto definimos los recursos (En la vida real, los libros estarían disponibles en una DB) y finalmente validamos la respuesta asumiendo que el pedido es correcto.

Por si alguno le pasa que no hace match, si tienes zsh es probable que tu URL necesite (" ") si no, no funcionara.

Les comparto el link donde explica como descargar php para Ubuntu 18.04 / Ubuntu 16.04
https://computingforgeeks.com/how-to-install-php-7-3-on-ubuntu-18-04-ubuntu-16-04-debian/

Todo estuvo muy bien menos que haya utilizado PHP para este curso… La mayoría de gente se esta enfocando en Python, Go, Angular, .Net, javascript. etc. El instructor seleccionó el menos indicado. Estoy buscando mas cursos de Rest API en Platzi pero no hay mas. Eso si estuvo muy mal.

Les comparto el código que hice, me inspiré en las novelas de Julio Verne

  • Estructuré un poquito author y genre en arreglos para agregarles un id y name

  • Agregué los comentarios en inglés (para aquellos que no les gusta mesclar ambos idiomas)

<?php

// Defining allowed type resources
$alloweResourceTypes = [ 
    'books',
    'authors',
    'genres',
];

// Validating the availability of the resource
$resourceType = $_GET['resource_type'];

// in_array() funcion verifies that an element belongs to the array
if (!in_array( $resourceType, $alloweResourceTypes )) {
    die; //end script 
}

// Defining resources: book
$books = [
    1 => [
        'title' => 'A Journey to the Center of the Earth',
        'author' => [
            'id_autor' => 210,
            'name_author' => 'Jules Verne'
        ],
        'genre' => [
            'id_genre' => 1,
            'name_genre' => 'Science Fiction'
        ],
    ],
    2 => [
        'title' => 'From the Earth to the Moon',
        'author' => [
            'id_autor' => 210,
            'name_author' => 'Jules Verne'
        ],
        'genre' => [
            'id_genre' => 1,
            'name_genre' => 'Science Fiction'
        ],
    ],
    3 => [
        'title' => 'Twenty Thousand Leagues Under the Sea',
        'author' => [
            'id_autor' => 210,
            'name_author' => 'Jules Verne'
        ],
        'genre' => [
            'id_genre' => 1,
            'name_genre' => 'Science Fiction'
        ],
    ],
    4 => [
        'title' => 'The Mysterious Island',
        'author' => [
            'id_autor' => 210,
            'name_author' => 'Jules Verne'
        ],
        'genre' => [
            'id_genre' => 1,
            'name_genre' => 'Science Fiction'
        ],
    ],
];

header('Content-Type: application/json');

// Generating the response asumming that the request is correct
switch (strtoupper($_SERVER['REQUEST_METHOD']) ) {
    case 'GET':
        echo json_encode($books);
    break;

    case 'POST':
    break;

    case 'PUT':   
    break;

    case 'DELETE':
    break;                        
}

Que curiosa la sintaxis de PHP para declarar los diccionarios.

Buenas compas, para los que no os funcione el | jq es por que debeis instalar un paquete, os llevara un minuto. Iniciais una powerShell con permisos de administrador y ejecutais el comando “chocolatey install jq” os pedira una confirmacion, le poneis “y” y listo, paquete instalado y listo para usar.

Estoy trabajando en windos y me arrojó el error 500. Para solucionarlo hice lo siguiente:
1 - El profesor usa el VSC para crear el archivo server.php, yo hice lo mismo pero en mi terminal de ubuntu tuve que crear un archivo vim (server.php) y guardarlo. Ya que las cosas que creo en la pc (windows) no figuran en ubuntu. Hice lo mismo que el profe pero en un archivo nuevo y lo dejé guardado en el desktop de ubuntu.
2 - Ejecute los pasos que se especifican en el vídeo y cuando fui a la terminal PUM! chau error 500, no me lo hacía más y apliqué las demás instrucciones sin problemas. Que satisfacción que siento después de estar trabado por un par de horas.

Yo si decía que tenía un código PHP muy ordenado y es que da un curso de buenas prácticas. Excelente.

A mi me daba error, no se por que pero mi consola le metía los \ automáticamente y así si funciono

curl http://localhost:8000\?resource_type\=books  -v

hola, solo vengo a decirles que este curso es mas teorico por lo cual si tienen bases en algun lenguaje que no sea php , prueben hacer lo del curso en su lenguaje favorito , o si ya son cracks en esto de la programacion que lo hagan en un lenguaje que quieran aprender, asi aprenden mas sobre el concepto general

Pasos para usar en python

  1. Crear un ambiente virtual con: py -m venv .env
  2. Activar el ambiente: call / . e n v/scripts/activate
  3. Instalar Flask: pip3 install Flask
  4. Crear el archivo py con el nombre: a p p . p y
  5. Setear la app principal: set FLASK_APP=ap p . p y
  6. Ejecutar con: flask run

Importar con: from flask import Flask

Codigo:

from flask import Flask, request
import json

# define the app
app = Flask(__name__)

# Data base
books = [
# agregar los libros aqui
]

#formating the data base
dataBooks = jso n  . d umps(books)

# Main page
@ap p . r o ute('/')
def index():
    # getting the resource type
    resource = str(requ es t . a r g s . g et('resource_type'))

    #if requested books, then return that
    if (resource == 'books'):
        return dataBooks
    
    #else, return a main page
    else:
        return "<h1>Main page</h1>"

# run the app
if __name__ == '__main__':
    ap p .  r  un(debug=True)

me cuesta seguir el ritmo… será que tendré que aprender PHP para seguir con el curso,

Les dejo como lo hice en Python con Flask

Alguien tiene este caso hecho en JS?

Me parece muy bueno el curso, lo único que no me gusta mucho es la combinación del código en inglés y español

me comentaba un ing de la empresa que los primeros servicios fueron los curl despues los rest y luego los servicios soup, pero yo reo que lo que lleva de ganar en esta llevando la parada ahora son los microserviciós

¡Hasta que al fin salió!.

Creo que se puede llevar muy bien si usan servicios como Postman o el plugin Rest Client de VS Code… Es importante saber hacer las peticiones desde la consola, eso si. Pero creo que este tipo de herramientas optimizan y ayudan bastante el desarrollo de APIs

Resumen de descifrado y encriptado de json en php:
$json = ‘{“a”:1,“b”:2,“c”:3}’;
var_dump(json_decode($json)); //convierte json a arreglo

$array = [ “a” => 1, “b” => 2, “c” => 3];
echo json_encode($json_encode($json)); //convierte arreglo a json

Se que php todavia tiene bastante demanda pero admito que no tanto como antes. Aun asi vale la pena aprenderlo??

Buenas, que tal muchachos?
Los llamados a la API también los pueden hacer mediante herramientas como Postman, esta enfocada para desarrollo de APIs y es bastante completa, se las recomiendo!

Se me hace muy diificil llevar el hilo del curso con php 😕

Hasta ahora me ha parecido genial el curso, muy importante en este camino de desarrollo web

Mi código en javascript, NodeJS: (En un archivo index.js)

const express = require('express');
const app = express();
const bodyParser = require('body-parser');

app.use(bodyParser.urlencoded({ extended: false }));
app.use(bodyParser.json());

const allowedResources = [
  'books',
  'authors',
  'genres'
];

const books = [
  { title: 'Lo que el viento se llevo', id_autor: 2, id_genero: 2 },
  { title: 'La Iliada', id_autor: 1, id_genero: 1 },
  { title: 'La odisea', id_autor: 1, id_genero: 1 }
];

app.get('/', (req, res) => {
  const resourceType = req.body.resource_type;

  if(allowedResources.indexOf(resourceType) === -1) {
    return res.json({ message: 'Failed', error: 'missing "resource_type"' });    
  }
  res.json({ books });
});

app.listen(5000, () => {
  console.log('server on port 5000');
});

Antes de ejecutarlo, instalen las dependencias necesarias poniendo:

npm i express body-parser

Y ejecutarlo con:

node index.js

Accedes a esta API a traves de localhost:5000

al momento de usar el jq para ordenar el json en la consola me tira el siguiente error;

<parse error: Invalid numeric literal at line 3, column 11>

En Go:

package main

import (
	"encoding/json"
	"fmt"
	"net/http"
)

var AllowedResources = map[string]bool{
	"books":   true,
	"authors": true,
	"genres":  true,
}

type Book struct {
	Titulo    string `json:"titulo"`
	Id_Autor  int    `json:"id_autor"`
	Id_gereno int    `json:"id_gereno"`
}

var Books = []Book{
	{
		Titulo:    "Lo que el viento se llevo",
		Id_Autor:  2,
		Id_gereno: 2,
	},
	{
		Titulo:    "El señor de los anillos",
		Id_Autor:  1,
		Id_gereno: 1,
	},
	{
		Titulo:    "La Odisea",
		Id_Autor:  1,
		Id_gereno: 3,
	},
}

func main() {
	http.Handle("/", http.HandlerFunc(ExampleHandler))
	http.ListenAndServe(":8080", nil)
}

func ExampleHandler(w http.ResponseWriter, r *http.Request) {
	// Get the resource from the request
	params := r.URL.Query()
	resource := params.Get("resource_type")

	// Check if the resource is allowed
	if !AllowedResources[resource] {
		w.WriteHeader(http.StatusNotFound)
		fmt.Fprint(w, "<h1>Not Found</h1>")
		return
	}

	// Handle the request
	switch r.Method {
	case http.MethodGet:
		w.Header().Set("Content-Type", "application/json")
		switch resource {
		case "books":
			j, err := json.Marshal(Books)
			if err != nil {
				w.WriteHeader(http.StatusInternalServerError)
				fmt.Fprint(w, "<h1>Internal Server Error</h1>")
				return
			}

			fmt.Fprint(w, string(j))
		}
		//case "authors":

	case http.MethodPost:
		w.Write([]byte("POST"))
	case http.MethodPut:
		w.Write([]byte("PUT"))
	case http.MethodDelete:
		w.Write([]byte("DELETE"))
	default:
		w.Header().Set("Allow", "GET, POST, PUT, DELETE")
		w.Write([]byte("UNKNOWN METHOD"))
	}

}

Ejemplo básico en JS implementando GET, POST, PUT, DELETE utilizando express

Espero les sirva y se animen a los que no nos gusta mucho PHP

Crear proyecto y paquetes

npm init
npm install -g nodemon
npm i express

Crear un archivo index.js y copiar el siguiente codigo:

const express = require("express");
const router = express.Router();

// prepare server
var app = express();
app.use(express.json());
app.use(router);

// prepare Data
let books = 
[
    {
        id: 1,
        titulo : 'Lo que el viento se llevo',
        id_autor : '2',
        id_genero : '2'
    },
    {
        id: 2,
        titulo : 'La Iliada',
        id_autor : '1',
        id_genero : '1'
    },
    {
        id: 3,
        titulo : 'La Odisea',
        id_autor : '1',
        id_genero : '1'
    }
]

// methods

// GET
router.get("/", function(req, res) {
  res.status(200).json({
    data: books, 
    message: 'MOVIES LISTED'
})

});

router.get("/:idGet", async function(req, res) {

const { idGet } = req.params
const bookFound = books.find( book => book.id == idGet )

res.status(200).json({
    data: bookFound, 
    message: 'GET:Id SUCCESS'
})
});

  // POST

  router.post("/", async function(req, res) {

    const { body: dataBody } = req
    books.push(dataBody)

    res.status(201).json({
        data: dataBody, 
        message: 'POST SUCCESS'
    })
  });

  // PUT

  router.put("/:idPut", async function(req, res) {

    const { idPut } = req.params
    const { body: dataBody } = req

    const bookFound = books.find( book => book.id == idPut )

    bookFound.titulo = dataBody.titulo

    res.status(200).json({
        data: bookFound, 
        message: 'PUT SUCCESS'
    })
  });

  // DELETE

  router.delete("/:idDelete", async function(req, res) {

    const { idDelete } = req.params
    const bookFound = books.find( book => book.id == idDelete )

    books = books.filter( book => book.id != idDelete )

    res.status(200).json({
        data: bookFound, 
        message: 'DELETE SUCCESS'
    })
  });
 
const port = 3001
app.listen(port);
 
console.log("La aplicación esta escuchando en localhost:" + port); 

Ejecutar mediante la terminal:

nodemon index

Integración en Python con FastAPI

from fastapi import FastAPI
from pydantic import BaseModel


app = FastAPI()


class Book(BaseModel):
    isbn: int
    title: str
    id_author: int


books = [
    Book(isbn=123456,
         title='Lo que se llevo el viento',
         id_author=2),
    Book(isbn=345678,
         title='La Ilíada',
         id_author=1),
    Book(isbn=234567,
         title='La Odisea',
         id_author=1)
]


@app.get('/')
async def show_books():
    return books

La variable $_GET en php recibe un array de valores que son enviados atravez de la URL https://www.php.net/manual/es/reserved.variables.get.php
Aqui hay más información tambien de la $_SERVER

no se que es pero no entendi NA

Genial, sencillo y práctico, obviamente hacer una API profesional requiere de más cosas, por ejemplo, creo que Laravel hace un muy buen trabajo con ello ^^

En caso de que te este dando el error 500 Internal Server Error, verifica que tu terminal se encuentre en la carpeta donde tienes el archivo (que acabamos de escribir en clase). Recuerda que una cosa es que hayas escrito el documento en tu editor, y otra que el editor y la terminal se encuentren en la misma carpeta 😃

En mi caso, tuve que moverme a la carpeta que hice del curso, o sea:

cd 'Platzi/API REST'

A alguien le arrojó el error 500 cuando intentaron conectarse al server desde la segunda terminal?

$_SERVER[‘REQUEST_METHOD’];
php -S localhost:7000 exp-services.php
curl http://localhost:7000?resource_type=books -v

f ($_SERVER[‘REQUEST_METHOD’] == ‘GET’)
{
if (isset($_GET[‘idcliente’]))
{
//Mostrar un post
$sql = $dbConn->prepare(“SELECT * FROM tblcliente where idcliente=:idcliente”);
$sql->bindValue(’:idcliente’, $_GET[‘idcliente’]);
$sql->execute();
header(“HTTP/1.1 200 OK”);
echo json_encode( $sql->fetch(PDO::FETCH_ASSOC) );
exit();
}
else {
//Mostrar lista de post
$sql = $dbConn->prepare(“SELECT * FROM tblcliente”);
$sql->execute();
$sql->setFetchMode(PDO::FETCH_ASSOC);
header(“HTTP/1.1 200 OK”);
echo json_encode( $sql->fetchAll() );
exit();
}
}

// Crear un nuevo post
if ($_SERVER[‘REQUEST_METHOD’] == ‘POST’)
{
$input = $_POST;
$sql = “INSERT INTO tblcliente
(identidad, nombres, email, clave)
VALUES
(:identidad, :nombres, :email, :clave)”;
$statement = $dbConn->prepare($sql);
bindAllValues($statement, $input);
$statement->execute();
$postId = $dbConn->lastInsertId();
if($postId)
{
$input[‘idcliente’] = $postId;
header(“HTTP/1.1 200 OK”);
echo json_encode($input);
exit();
}
}

//Borrar
if ($_SERVER[‘REQUEST_METHOD’] == ‘DELETE’)
{
$identidad = $_GET[‘identidad’];
$statement = $dbConn->prepare(“DELETE FROM tblcliente where identidad=:identidad”);
$statement->bindValue(’:identidad’, $identidad);
$statement->execute();
header(“HTTP/1.1 200 OK”);
exit();
}

//Actualizar
if ($_SERVER[‘REQUEST_METHOD’] == ‘PUT’)
{
$input = $_GET;
$postId = $input[‘idcliente’];
$fields = getParams($input);

$sql = "
      UPDATE posts
      SET $fields
      WHERE idcliente='$postId'
       ";

$statement = $dbConn->prepare($sql);
bindAllValues($statement, $input);

$statement->execute();
header("HTTP/1.1 200 OK");
exit();

}

//En caso de que ninguna de las opciones anteriores se haya ejecutado
header(“HTTP/1.1 400 Bad Request”);

?>

Buenas,
¿por que tras hacer ejecutar el curl, en el switch ejecuta el bloque de ‘GET’ y no el de otra operación?¿Se toma ‘GET’ por defecto?.
Un saludo.

Que clase tan del carajo.!! Muy util

super 😃 thanks

profesor: podrias explicar como utilizar el visual code desde tu ubuntu de windows???

Un buen ejemplo para empezar es genial

de donde se puede buscar toda la documentacion de api rest que esta escribiendo??¿?

Como una buena práctica se podría estandarizar la respuesta, tanto si el recurso existe como si no existe, por ejemplo:

// En caso de que exista:
[
    "status": "SUCCESS",
     "code": 200,
    "message": "resource found successfully"
    "resources":   [
		{...},
		{...}
	]
]

// En caso que no exista
[
    "status": "FAILED",
     "code": 404,
    "message": "resource not valid"
]

Así al momento de integrar la API se puede tener una mejor interpretación de la misma

si quisiera levantar esto en un contenedor de ansible seria exactamente igual solo que cambiaría la IP? Gracias 😄

Mi primer servicio rest

Porque en la programacion de “Books” termina con “,” al final siendo que el el ultimo elemento???

como podría conectarlo con una base de datos?

Excelente, se entiende muy bien a pesar de no conocer php…

<h3>Exponer datos a través de HTTP GET</h3>

Producir tus propios servicios REST permitirá que otras aplicaciones puedan conectarse a la tuya para obtener datos que tienes en tu servidor o para incorporar nueva información.

De lo que se trata es de desarrollar un servidor que pueda interpretar peticiones HTTP y devolver respuestas HTTP. Usualmente estas respuestas se realizan a través de Json

Para poder saber que verbo se utilizo en una petición, vamos a utilizar una variable que nos provee PHP llamada $_SERVER donde le pasamos un valor ‘REQUEST_METHOD’ que nos dirá cuál es el método que se utilizó para realizar la petición

<?php

switch (strtoupper($_SERVER['REQUEST_METHOD'])) {
    case 'GET':
        # code...
        break;

    case 'POST':
        # code...
        break;

    case 'PUT':
        # code...
        break;
    
    case 'DELETE':
        # code...
        break;
}

Cuando queremos exponer nuestros recursos tenemos que definir cuáles son esos recursos que vamos a mostrar al exterior.

Para hacer una consulta al server que hemos creado escribimos en nuestra consola así:

curl http ://localhost:8000/\?resource_type\=books -v

El código de la clase es el siguiente:

// Definimos los recursos disponibles
$allowedResourceTypes = [
    'books',
    'authors',
    'genres',
];

// Validamos que el recurso este disponible
$resourceType = $_GET['resource_type'];

if (!in_array($resourceType, $allowedResourceTypes)) {    
    die;
}

// Defino los recursos (esto en la real-life los datos estan en DB)
$books = [
    1 => [
        'titulo' => 'Lo que el viento se llevo',
        'id_autor' => 2,
        'id_genero' => 2,
    ],
    2 => [
        'titulo' => 'La íliada',
        'id_autor' => 1,
        'id_genero' => 1,
    ],
    3 => [
        'titulo' => 'La odisea',
        'id_autor' => 1,
        'id_genero' => 1,
    ],
];

header( 'Content-Type: application/json' );

// Generamos la respuesta asumiendo que el pedido es correcto
switch (strtoupper($_SERVER['REQUEST_METHOD'])) {
    case 'GET':
        echo json_encode( $books );
        break;

    case 'POST':
        # code...
        break;

    case 'PUT':
        # code...
        break;
    
    case 'DELETE':
        # code...
        break;
}