One place for hosting & domains

      API

      Building a REST API With Django REST Framework


      How to Join

      This Tech Talk is free and open to everyone. Register below to get a link to join the live stream or receive the video recording after it airs.

      Date Time RSVP
      April 28, 2021 11:00–12:00 p.m. ET / 3:00–4:00 p.m. GMT

      About the Talk

      The Django REST Framework is a powerful toolkit for building RESTful APIs on top of the popular Python framework Django. With its browsable API, robust authentication policies, and object serialization, it offers an amazing experience for rapidly creating REST APIs. Let’s get our hands dirty and build some APIs with DRF!

      What You’ll Learn

      • How to install the Django REST Framework
      • How to authenticate against the DRF
      • How to quickly create a CRUD based REST API

      This Talk Is Designed For

      Developers who want to build robust RESTful APIs using Python.

      Prerequisites

      A basic understanding of the Python programming language.

      Resources

      Django REST framework quickstart

      To join the live Tech Talk, register here.



      Source link

      Cómo usar la API Fetch de JavaScript para obtener datos


      Introducción

      Hubo un tiempo en el que se utilizaba XMLHttpRequest para realizar solicitudes de API. No incluía promesas y no permitía un código JavaScript limpio. Al usar jQuery, se utilizó la sintaxis más limpia con jQuery.ajax().

      Ahora, JavaScript tiene su propia forma integrada de hacer solicitudes de API. Esta es la API Fetch, un nuevo estándar para realizar solicitudes de servidor con promesas, pero incluye muchas otras funciones.

      En este tutorial, creará solicitudes GET y POST usando la API Fetch.

      Requisitos previos

      Para completar este tutorial, necesitará lo siguiente:

      Paso 1: Introducción a la sintaxis de la API Fetch

      Para usar la API Fetch, invoque el método fetch, que acepta la URL de la API como parámetro:

      fetch(url)
      

      Después del método fetch(), incluya el método de promesa then():

      .then(function() {
      
      })
      

      Con el método fetch() se obtiene una promesa. Si la promesa devuelta es resolve, se ejecuta la función dentro del método then(). Esa función contiene el código para gestionar los datos recibidos de la API.

      Debajo del método then(), incluya el método catch():

      .catch(function() {
      
      });
      

      La API que invocó mediante fetch() puede estar inactiva o pueden producirse otros errores. Si esto sucede, se mostrará la promesa de reject. El método catch se usa para gestionar reject. El código dentro de catch() se ejecutará si se produce un error al invocar la API de su elección.

      Para resumir, usar la API Fetch se verá así:

      fetch(url)
      .then(function() {
      
      })
      .catch(function() {
      
      });
      

      Con un conocimiento sobre la sintaxis para usar la API Fetch, ahora puede continuar usando fetch() en una API verdadera.

      Paso 2: Usar Fetch para obtener datos de una API

      Las siguientes muestras de código se basarán en la API de Random User. Al usar la API, obtendrá diez usuarios y se mostrarán en la página usando Vanilla JavaScript.

      La idea es obtener todos los datos de la API de Random User y mostrarlos en los elementos de la lista dentro de la lista del autor. Primero cree un archivo HTML y añada un encabezado y una lista desordenada con la id de authors:

      <h1>Authors</h1>
      <ul id="authors"></ul>
      

      Ahora, añada las etiquetas script a la parte inferior de su archivo HTML y utilice un selector DOM para capturar la ul. Use getElementById con authors como argumento. Recuerde que authors es el id para la ul creada anteriormente:

      <script>
      
          const ul = document.getElementById('authors');
      
      </script>
      

      Cree una variable constante llamada url que albergará la URL de la API que mostrará diez usuarios al azar:

      const url="https://randomuser.me/api/?results=10";
      

      Habiendo ya establecido ul y url, es momento de crear las funciones que se utilizarán para crear los elementos de la lista. Cree una función llamada createNode que tome un parámetro llamado element:

      function createNode(element) {
      
      }
      

      Más tarde, cuando se invoque createNode, deberá pasar el nombre de un elemento HTML real para crear.

      Dentro de la función, añada la instrucción return que devuelve el elemento usando document.createElement():

      function createNode(element) {
          return document.createElement(element);
      }
      

      También necesitará crear una función llamada append que tome dos parámetros: parent y el:

      function append(parent, el) {
      
      }
      

      Esta función añadirá el a parent usando document.createElement:

      function append(parent, el) {
          return parent.appendChild(el);
      }
      

      Tanto CreateNode como append están listos para funcionar. Ahora usando la API Fetch, invoque la API de Random User usando fetch() con url como argumento:

      fetch(url)
      
      fetch(url)
        .then(function(data) {
      
          })
        })
        .catch(function(error) {
      
        });
      

      En el código anterior, está invocando la API Fetch y pasando la URL a la API de Random User. Luego, se recibe una respuesta. Sin embargo, la respuesta que se obtiene no es JSON, sino un objeto con una serie de métodos que pueden usarse dependiendo de lo que se quiera hacer con la información. Para convertir el objeto devuelto en JSON, utilice el método json().

      Añada el método then() que contendrá una función con un parámetro llamado resp:

      fetch(url)
      .then((resp) => )
      

      El parámetro resp toma el valor del objeto devuelto de fetch(url). Utilice el método json() para convertir resp en datos JSON:

      fetch(url)
      .then((resp) => resp.json())
      

      Aún se deben procesar los datos JSON. Añada otra instrucción then() con una función que tiene un argumento llamado data:

      .then(function(data) {
      
          })
      })
      

      Dentro de esta función, cree una variable llamada authors que se establece igual a data.results:

      .then(function(data) {
          let authors = data.results;
      

      Para cada autor en authors, le convendrá crear un elemento de lista que muestre una imagen de ellos y muestre su nombre. El método map() funciona muy bien para esto:

      let authors = data.results;
      return authors.map(function(author) {
      
      })
      

      Con su función de map, cree una variable llamada li que se establecerá igual a createNode con li (el elemento HTML) como argumento:

      return authors.map(function(author) {
          let li = createNode('li');
      })
      

      Repita esto para crear un elemento span y un elemento img:

      let li = createNode('li');
      let img = createNode('img');
      let span = createNode('span');
      

      La API ofrece un nombre para el autor y una imagen que acompaña al nombre. Establezca img.src en la imagen del autor:

      let img = createNode('img');
      let span = createNode('span');
      
      img.src = author.picture.medium;
      

      El elemento span debe contener el primer nombre y el apellido del author. La propiedad innerHTML y la interpolación de cadenas le permitirán hacer esto:

      img.src = author.picture.medium;
      span.innerHTML = `${author.name.first} ${author.name.last}`;
      

      Con la imagen y el elemento de lista ya creados junto con el elemento span, puede usar la función append que se creó anteriormente para mostrar estos elementos en la página:

      append(li, img);
      append(li, span);
      append(ul, li);
      

      Una vez que se completan ambas funciones then(), puede añadir la función catch(). Esta función registrará el posible error en la consola:

      .catch(function(error) {
        console.log(error);
      });
      

      Este es el código completo de la solicitud que creó:

      function createNode(element) {
          return document.createElement(element);
      }
      
      function append(parent, el) {
        return parent.appendChild(el);
      }
      
      const ul = document.getElementById('authors');
      const url="https://randomuser.me/api/?results=10";
      
      fetch(url)
      .then((resp) => resp.json())
      .then(function(data) {
        let authors = data.results;
        return authors.map(function(author) {
          let li = createNode('li');
          let img = createNode('img');
          let span = createNode('span');
          img.src = author.picture.medium;
          span.innerHTML = `${author.name.first} ${author.name.last}`;
          append(li, img);
          append(li, span);
          append(ul, li);
        })
      })
      .catch(function(error) {
        console.log(error);
      });
      

      Acaba de realizar con éxito una solicitud GET usando la API de Random User y la API Fetch. En el siguiente paso, aprenderá a hacer solicitudes POST.

      Paso 3: Gestionar solicitudes POST

      Fetch se ajusta de manera determinada a las solicitudes GET, pero puede usar todos los demás tipos de solicitudes, cambiar los encabezados y enviar datos. Para ello, debe establecer su objeto y pasarlo como el segundo argumento de la función fetch.

      Antes de crear una solicitud POST, cree los datos que desea enviar a la API. Este será un objeto llamado data con la clave name y el valor Sammy (o su nombre):

      const url="https://randomuser.me/api";
      
      let data = {
        name: 'Sammy'
      }
      

      Asegúrese de incluir una variable constante que contenga el enlace de la API de Random User.

      Dado que se trata de una solicitud POST, deberá indicarlo de forma explícita. Cree un objeto llamado fetchData:

      let fetchData = {
      
      }
      

      Este objeto debe incluir tres claves: method, body y headers. La clave method debe tener el valor 'POST'. body debe establecerse igual al objeto data que acaba de crear. headers debe tener el valor de new Headers():

      let fetchData = {
        method: 'POST',
        body: data,
        headers: new Headers()
      }
      

      La interfaz Headers es una propiedad de la API Fetch, que le permite realizar varias acciones en los encabezados de las solicitudes y respuestas HTTP. Si desea obtener más información sobre esto, este artículo llamado Cómo definir rutas y métodos de solicitud HTTP en Express puede proporcionarle más información.

      Una vez establecido este código, se puede realizar la solicitud POST usando la API Fetch. Incluirá url y fetchData como argumentos para su solicitud POST fetch:

      fetch(url, fetchData)
      

      La función then() incluirá el código que maneja la respuesta recibida del servidor de API de Random User:

      fetch(url, fetchData)
      .then(function() {
          // Handle response you get from the server
      });
      

      Para crear un objeto y usar la función fetch(), también hay otra opción. En vez de crear un objeto como fetchData, puede usar el constructor de solicitudes para crear su objeto de solicitud. Para ello, cree una variable llamada request:

      const url="https://randomuser.me/api";
      
      let data = {
        name: 'Sara'
      }
      
      var request =
      

      La variable request debe establecerse igual a new Request. La construcción new Request incluye dos argumentos: la url de la API (url) y un objeto. El objeto también debe incluir las claves method, body y headers, así como fetchData:

      var request = new Request(url, {
          method: 'POST',
          body: data,
          headers: new Headers()
      });
      

      Ahora, request puede usarse como el único argumento para fetch(), ya que también incluye la URL de API:

      fetch(request)
      .then(function() {
          // Handle response we get from the API
      })
      

      En su totalidad, su código se verá así:

      const url="https://randomuser.me/api";
      
      let data = {
        name: 'Sara'
      }
      
      var request = new Request(url, {
          method: 'POST',
          body: data,
          headers: new Headers()
      });
      
      fetch(request)
      .then(function() {
          // Handle response we get from the API
      })
      

      Ahora conoce dos métodos para crear y ejecutar solicitudes POST con la API Fetch.

      Conclusión

      Aunque la API Fetch aún no es compatible con todos los navegadores, es una excelente alternativa a XMLHttpRequest. Si desea aprender a invocar las API web usando React, consulte este artículo sobre ese mismo tema.



      Source link

      Como usar a Fetch API do JavaScript para buscar dados


      Introdução

      Houve um tempo em que o XMLHttpRequest era usado para fazer solicitações de API. Ele não incluía promessas e não gerava um código JavaScript organizado. Ao usar o jQuery, usava-se a sintaxe mais organizada com o jQuery.ajax().

      Agora, o JavaScript tem sua própria maneira integrada de fazer solicitações de API. Isso é feito pela Fetch API, um novo padrão para fazer solicitações de servidor com promessas, que inclui também muitas outras funcionalidades.

      Neste tutorial, você criará solicitações GET e POST usando a Fetch API.

      Pré-requisitos

      Para concluir este tutorial, você precisará do seguinte:

      Para usar a Fetch API, chame o método fetch, que aceita a URL da API como um parâmetro:

      fetch(url)
      

      Após o método fetch(), inclua o método de promessa then():

      .then(function() {
      
      })
      

      O método fetch() retorna uma promessa. Se a promessa retornada for resolve, a função dentro do método then() é executada. Essa função contém o código para lidar com os dados recebidos da API.

      Abaixo do método then(), inclua o método catch():

      .catch(function() {
      
      });
      

      A API chamada usando fetch() pode estar inoperante ou outros erros podem ocorrer. Se isso acontecer, a promessa reject será retornada. O método catch é usado para lidar com reject. O código dentro de catch() será executado se um erro ocorrer ao chamar a API escolhida.

      Resumindo, usar a Fetch API será parecido com isto:

      fetch(url)
      .then(function() {
      
      })
      .catch(function() {
      
      });
      

      Com uma compreensão da sintaxe para usar a Fetch API, agora siga em frente para usar fetch() em uma API real.

      Passo 2 — Usando Fetch para buscar dados de uma API

      As amostras de código a seguir baseiam-se na Random User API. Usando a API, você irá buscar dez usuários e os exibirá na página usando o JavaScript puro.

      A ideia é obter todos os dados da Random User API e exibí-los em itens de lista dentro da lista de autores. Comece criando um arquivo HTML e adicionando um cabeçalho e uma lista não ordenada com o id de authors:

      <h1>Authors</h1>
      <ul id="authors"></ul>
      

      Agora, adicione identificadores script no final do seu arquivo HTML e use um seletor DOM para pegar o ul. Utilize getElementById com authors como o argumento. Lembre-se, authors é o id para o ul criado anteriormente:

      <script>
      
          const ul = document.getElementById('authors');
      
      </script>
      

      Crie uma variável constante chamada url que armazenará o URL da API que irá retornar dez usuários aleatórios:

      const url="https://randomuser.me/api/?results=10";
      

      Com ul e url instalados, é hora de criar as funções que serão usadas para criar os itens de lista. Crie uma função chamada createNode que recebe um parâmetro chamado element:

      function createNode(element) {
      
      }
      

      Mais tarde, quando o createNode for chamado, será necessário passar o nome de um elemento HTML real a ser criado.

      Dentro da função, adicione uma instrução return que retorna o element usando document.createElement():

      function createNode(element) {
          return document.createElement(element);
      }
      

      Também será necessário criar uma função chamada append que recebe dois parâmetros: parent e el:

      function append(parent, el) {
      
      }
      

      Essa função irá acrescentar el ao parent usando o document.createElement:

      function append(parent, el) {
          return parent.appendChild(el);
      }
      

      Tanto o createNode quanto o append estão prontos para o uso. Agora, com a Fetch API, chame a Random User API usando fetch() com url como o argumento:

      fetch(url)
      
      fetch(url)
        .then(function(data) {
      
          })
        })
        .catch(function(error) {
      
        });
      

      No código acima, você está chamando a Fetch API e passando o URL para a Random User API. Então, uma resposta é recebida. No entanto, a resposta recebida não é JSON, mas um objeto com uma série de métodos que podem ser usados dependendo do que você quer fazer com as informações. Para converter o objeto retornado em JSON, use o método json().

      Adicione o método then(), que irá conter uma função com um parâmetro chamado resp:

      fetch(url)
      .then((resp) => )
      

      O parâmetro resp recebe o valor do objeto retornado de fetch(url). Use o método json() para converter resp em dados JSON:

      fetch(url)
      .then((resp) => resp.json())
      

      Os dados JSON ainda precisam ser processados. Adicione outra instrução then() com uma função que tem um argumento chamado data:

      .then(function(data) {
      
          })
      })
      

      Dentro dessa função, crie uma variável chamada authors que seja definida igual à data.results:

      .then(function(data) {
          let authors = data.results;
      

      Para cada autor em authors, será criado um item de lista que exibe uma figura o nome deles. O método map() é ótimo para isso:

      let authors = data.results;
      return authors.map(function(author) {
      
      })
      

      Dentro de sua função map, crie uma variável chamada li que será definida igual a createNode com li (o elemento HTML) como o argumento:

      return authors.map(function(author) {
          let li = createNode('li');
      })
      

      Repita isso para criar um elemento span e um elemento img:

      let li = createNode('li');
      let img = createNode('img');
      let span = createNode('span');
      

      A API oferece um nome para o author e uma imagem que acompanha o nome. Defina img.src para a imagem do autor:

      let img = createNode('img');
      let span = createNode('span');
      
      img.src = author.picture.medium;
      

      O elemento span deve conter o primeiro e último nome de author. A propriedade innerHTML e a interpolação de strings permitirão fazer isso:

      img.src = author.picture.medium;
      span.innerHTML = `${author.name.first} ${author.name.last}`;
      

      Com a imagem e o elemento de lista criados juntamente com o elemento span, use a função append criada anteriormente para exibir esses elementos na página:

      append(li, img);
      append(li, span);
      append(ul, li);
      

      Com ambas as funções then() concluídas, adicione agora a função catch(). Essa função irá registrar o erro em potencial no console:

      .catch(function(error) {
        console.log(error);
      });
      

      Este é o código completo da solicitação que você criou:

      function createNode(element) {
          return document.createElement(element);
      }
      
      function append(parent, el) {
        return parent.appendChild(el);
      }
      
      const ul = document.getElementById('authors');
      const url="https://randomuser.me/api/?results=10";
      
      fetch(url)
      .then((resp) => resp.json())
      .then(function(data) {
        let authors = data.results;
        return authors.map(function(author) {
          let li = createNode('li');
          let img = createNode('img');
          let span = createNode('span');
          img.src = author.picture.medium;
          span.innerHTML = `${author.name.first} ${author.name.last}`;
          append(li, img);
          append(li, span);
          append(ul, li);
        })
      })
      .catch(function(error) {
        console.log(error);
      });
      

      Você acabou de realizar uma solicitação GET com sucesso usando a Random User API e a Fetch API. No próximo passo, irá aprender como realizar solicitações POST.

      Passo 3 — Lidando com solicitações POST

      A Fetch usa por padrão solicitações GET, mas é possível usar qualquer outro tipo de solicitação, alterar os cabeçalhos e enviar os dados. Para fazer isso, é necessário definir seu objeto e passá-lo como o segundo argumento da função fetch.

      Antes de criar uma solicitação POST, crie os dados que gostaria de enviar à API. Este será um objeto chamado data com a chave name e o valor Sammy (ou seu nome):

      const url="https://randomuser.me/api";
      
      let data = {
        name: 'Sammy'
      }
      

      Certifique-se de incluir uma variável constante que contém o link da Random User API.

      Como esta é uma solicitação POST, será necessário declarar isso explicitamente. Crie um objeto chamado fetchData:

      let fetchData = {
      
      }
      

      Esse objeto precisa incluir três chaves: method, body e headers. A chave method deve conter o valor 'POST'. body deve ser definido igual ao objeto data que acabou de ser criado. headers deve conter o valor de new Headers():

      let fetchData = {
        method: 'POST',
        body: data,
        headers: new Headers()
      }
      

      A interface Headers, que é uma propriedade da Fetch API, permite realizar várias ações em cabeçalhos de solicitação HTTP e de resposta. Se quiser aprender mais sobre isso, este artigo chamado Como definir rotas e métodos de solicitação HTTP no Express pode oferecer-lhe mais informações.

      Com esse código no lugar, a solicitação POST pode ser feita usando a Fetch API. Você incluirá url e fetchData como argumentos para sua solicitação POST fetch:

      fetch(url, fetchData)
      

      A função then() irá incluir o código que lida com a resposta recebida do servidor da Random User API:

      fetch(url, fetchData)
      .then(function() {
          // Handle response you get from the server
      });
      

      Para criar um objeto e usar a função fetch(), há também outra opção. Ao invés de criar um objeto como o fetchData, é possível usar o construtor de solicitações para criar seu objeto de solicitação. Para fazer isso, crie uma variável chamada request:

      const url="https://randomuser.me/api";
      
      let data = {
        name: 'Sara'
      }
      
      var request =
      

      A variável request deve ser definida igual a new Request. O constructo new Request recebe dois argumentos: a url da API (url) e um objeto. O objeto também deve incluir as chaves method, body e headers assim como o fetchData:

      var request = new Request(url, {
          method: 'POST',
          body: data,
          headers: new Headers()
      });
      

      Agora, request pode ser usado como o argumento único para o fetch(), uma vez que ele também inclui a url da API:

      fetch(request)
      .then(function() {
          // Handle response we get from the API
      })
      

      No conjunto, seu código ficará semelhante a este:

      const url="https://randomuser.me/api";
      
      let data = {
        name: 'Sara'
      }
      
      var request = new Request(url, {
          method: 'POST',
          body: data,
          headers: new Headers()
      });
      
      fetch(request)
      .then(function() {
          // Handle response we get from the API
      })
      

      Agora, você conhece dois métodos para criar e executar solicitações POST com a Fetch API.

      Conclusão

      Embora a Fetch API ainda não seja suportada por todos os navegadores, é uma ótima alternativa ao XMLHttpRequest. Se quiser aprender como chamar APIs da Web usando o React, confira este artigo sobre este tópico.



      Source link