One place for hosting & domains

      DreamHost’s Ultimate Small Business Resource Guide


      We see you, small business owners! You bring character and diversity to your hometowns and spice to your niche on the internet. You create jobs. You build local economies and provide unique products and services with a personal touch big corporations can only try to replicate. Plus, you are living your dream: turning your passion into a money-making venture that improves the world and gives you the chance to be your own boss.

      We know how hard you work to make this dream a reality. It’s never easy to run your own business, but the current COVID-19 global pandemic has been a particular plague on small businesses. Governments around the world have social distancing guidelines to stop the spread of this coronavirus, bringing global economies to their knees.

      With people stuck at home, non-essential businesses closed, and millions out of work, the customers you rely on to stay afloat either can’t come to your shop or are short on cash for anything outside living expenses. None of this is your fault, and it is happening despite your diligent work and vision for your business.

      Even National Small Business Week — an annual springtime celebration of your essential place in the U.S. economy scheduled for this week — has been postponed thanks to COVID-19. But we are going to celebrate you anyway! Here at DreamHost, we believe in small business, and we are proud to provide a platform and digital home for so many of you.

      The pandemic will let up eventually, and we are still rooting for you. To help you get some ideas for how to build and boost your business, we’ve collected our best advice for small business owners — all in one place.

      Read on to find essential tips about:

      Feel free to use the links above to jump around to the most pertinent articles for you and your business — or read straight on through for an overview of all the advice we have to offer.

      You Can Build a Website

      Whether you want to start a blog or run a small business, DreamHost makes it easy to begin your online journey. Our shared hosting plans give you everything you need to thrive online at an affordable price.

      Building a Small Business Website

      In the small-business world, your website is everything. It’s your homestead on the frontier of the web. It declares your brand to the world and is often the first impression potential customers have of your business.

      For many of you, your website is your business.

      Even if your business is a brick-and-mortar operation — such as a restaurant or antique store — your company’s website needs to be helpful, optimized, and updated and maintained regularly. Your website provides valuable info, including where to find you and when, and drives customers off their couches and into your stores.

      The internet is where your customers spend most of their time, especially right now. Use these resources to learn how to get going on WordPress, build a beautiful website from the ground up, and tailor it to fit your own business.

      Building an Online Store

      If you have an online business — or if you want to start selling your products online in addition to your physical store — a reliable and attractive online shop is what you need. Your customers want to browse, find the products they want, and check out without a glitch. To make that happen, you need to build an online store with a trusted platform in addition to your business’s WordPress website.

      It’s surprisingly easy to get an online shop up and keep it going — you just need the right tools and tips. We love WooCommerce and Shopify, and you’ll learn about both, plus more tips and tricks for selling online, in the helpful guides below.

      Small Business Advice

      You small business owners are a scrappy bunch, and much of what you know you learned through good, old fashioned experience. There’s no education like the one that comes from getting out there and making your own mistakes.

      As valuable as mistakes and failures are, we want to set you up as much as possible for success and triumph. In this section, you’ll find a roundup of our best advice for entrepreneurs — learn how to manage everything from your stress to your small business website and beyond.

      Small-Biz Tools and Resources

      You want your small business to reach its full potential — and so do we! No person is an island, and the same goes for businesses. We all need a little help and support sometimes, and when we use available tools, we can get more done in less time.

      There are so many tools out there to help you manage and grow your business, and to optimize the whole enterprise for success. Stop doing things the hard way. Here you’ll find all of our favorite tools, apps, plugins, and more for making the work of running your business a little easier.

      Ways to Make Money Online

      Thanks to the internet, there’s never been a better time to start a side hustle. Money-making opportunities abound online, from blogging to affiliate marketing.

      Whether you want to build up an extra income source on top of your full-time gig or are looking for ideas to build up your business, we got you. Let’s walk through our favorite — not to mention lucrative and legitimate — ways to make money online.

      Small-Biz Marketing Tips

      There are more than 1.5 billion (and counting) websites on the internet today. So how does your humble food blog or photography portfolio get noticed, by the right people, amid all the noise?

      One word: marketing.

      “If you build it, they will come” is an adage that doesn’t hold up so well when it comes to your business’s presence online. Merely having a website just isn’t enough; you need to draw people to it for it to do any good. You need some smart strategies to bump your website up to the top of search results, find and engage social media followers, and encourage positive reviews.

      Do you want your brand to get noticed? Find your target market. Drive traffic to your website. Do some smart social media and email marketing. Create killer content and optimize your site for top search engine results. How? We thought you’d never ask: Learn or brush up on these skills with our handy dandy guides to marketing your small business.

      Want More Small-Biz Hacks?

      Whether you need marketing advice or a heads-up on the latest web design trends, we’ve got content for that! Subscribe to our monthly newsletter so you never miss an article.

      You’ve Got This

      There you have it — everything we’ve ever written to guide, inform, and inspire small business owners in one handy guide. We know that you’ve got what it takes to make it through this crisis, and we hope these resources can help you get there.

      Now, we have a question for you: How can we help? What small-biz related questions are keeping you up at night? Holler at us over on Twitter to let us know which additional topics and resources you’d like us to cover for small business owners.

      Are you wondering where to get started? You can easily build an online presence for your small business with shared hosting. Our plans, which start at just $2.59 per month, offer all the tools you need to build your business and reach your customers.





      Source link

      How to Install Node.js and NGINX on Debian 10


      Updated by Linode Written by Linode

      Node.js is an open-source JavaScript runtime environment that can serve dynamic and responsive content and is often used to create and serve web applications. When serving Node.js applications, NGINX is commonly used to create a reverse proxy that points at a running Node.js server. In this guide, you will install and configure NGINX on a Debian 10 Linode. NGINX will handle requests to static files, like index.html and also, create a reverse proxy to a Node.js server. You will then create a test JavaScript file in order to test your running Node.js server.

      Before You Begin

      1. If you want to use a custom domain name for your site, purchase a domain name from a trusted registrar and use Linode’s DNS Manager to add the domain and create a domain record for it.

      2. Set up your Linode using the Getting Started and Securing your Server guides.

        Note

        Note

        This guide is written for a non-root user. Commands that require elevated privileges are prefixed with sudo. If you’re not familiar with the sudo command, visit our Users and Groups guide.

        All configuration files should be edited with elevated privileges. Remember to include sudo before running your text editor.

      Install and Configure NGINX

      1. Install NGINX and the screen utility. You will use screen in the Create Your the Node.js Web Server File.

        sudo apt-get install nginx screen
        
      2. Start NGINX and enable it to start automatically on reboots.

        sudo systemctl start nginx
        sudo systemctl enable nginx
        
      3. Using your preferred text editor, create a new NGINX site configuration file located in the /etc/nginx/sites-available/ directory. Replace the example file name and any instances of example.com with your own domain name or IP address.

        /etc/nginx/sites-available/example.com
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
        14
        15
        16
        17
        18
        
        #Names a server and declares the listening port
        server {
            listen 80;
            server_name example.com www.example.com;
        
            #Configures the publicly served root directory
            #Configures the index file to be served
            root /var/www/example.com;
            index index.html index.htm;
        
            #These lines create a bypass for certain pathnames
            #www.example.com/test.js is now routed to port 3000
            #instead of port 80
            location ~* .(js)$ {
                proxy_pass http://localhost:3000;
                proxy_set_header Host $host;
            }
        }
      4. Create a symlink from your NGINX configuration file in the sites-available directory to the sites-enabled directory.

        sudo ln -s /etc/nginx/sites-available/example.com /etc/nginx/sites-enabled/example.com
        
      5. Remove the symlink from NGINX’s default site configuration file.

        sudo rm /etc/nginx/sites-enabled/default
        
      6. Verify that there are no syntax errors in your site’s configuration file.

        sudo nginx -t
        

        Your output should resemble the following:

          
        nginx: the configuration file /etc/nginx/nginx.conf syntax is ok
        nginx: configuration file /etc/nginx/nginx.conf test is successful
            
        
      7. Restart NGINX to load your site’s configuration.

        sudo systemctl restart nginx
        

      Create Your Site’s Index File

      Note

      Ensure you replace example.com with your own site’s name or IP address in all commands and examples in this section.

      1. Create your site’s root directory, which will store the index.html file you will create in the next step. The directory’s location should be the one you designated in your site’s NGINX configuration file for the root configuration.

        sudo mkdir -p /var/www/example.com
        
      2. Using the text editor of your choice, create your site’s index file in the root directory using the example below.

        /var/www/example.com/index.html
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
        14
        15
        
        <!DOCTYPE html>
        <html>
        <body>
        
        <p><strong>If you have not finished the <a href="https://linode.com//docs/development/nodejs/how-to-install-nodejs-and-nginx-on-debian-10/">guide</a>, the button below will not work.</strong></p>
        
        <p>The button links to test.js. The test.js request is passed through NGINX and then handled by the Node.js server.</p>
        
        <a href="test.js">
        <button type="button">Go to test.js</button>
        </a>
        
        </body>
        </html>
            

      Create Your Node.js Web Server

      Install Node.js

      1. Install the Node Version Manager (NVM) for Node.js. This program helps you manage different Node.js versions on a single system.

        sudo wget -qO- https://raw.githubusercontent.com/creationix/nvm/v0.35.3/install.sh | bash
        
      2. Load NVM in your current terminal session.

        export NVM_DIR="$([ -z "${XDG_CONFIG_HOME-}" ] && printf %s "${HOME}/.nvm" || printf %s "${XDG_CONFIG_HOME}/nvm")"
        [ -s "$NVM_DIR/nvm.sh" ] && . "$NVM_DIR/nvm.sh"
        

        Verify that you have access to NVM by printing its current version.

        nvm --version
        

        You should see a similar output:

          
        0.35.3
            
        
      3. Install Node.js.

        Note

        As of writing this guide, the latest LTS version of Node.js is v12.16.2. Update this command with the version of Node.js you would like to install.
        nvm install 12.16.2
        
      4. Use NVM to run your preferred version of Node.js.

        nvm use 12.16.2
        

        Your output will resemble the following

          
        Now using node v12.16.2 (npm v6.14.4)
            
        

      Create a Test JavaScript File

      In the Install and Configure NGINX section you configured NGINX to listen on port 80 to serve its static content. You also configured a reverse proxy to your Linode’s localhost:3000 when a request for the /test.js file is made. In this section you will create the test.js file to be able to test your Node.js web server that you will create in the next section.

      Note

      Ensure you replace example.com with your own site’s name or IP address in all commands and examples in this section.

      1. Create the test.js file in your site’s root directory.

        /var/www/example.com/test.js
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
        14
        15
        16
        17
        
        <!DOCTYPE html>
        <html>
        <body>
        
        <h2>
        Your Node.JS server is working.
        </h2>
        
        <p>
        The below button is technically dynamic. You are now using Javascript on both the client-side and the server-side.</p>
        
        <button type="button" onclick="document.getElementById('sample').innerHTML = Date()"> Display the date and time.</button>
        <p id="sample"></p>
        
        </body>
        </html>
            

      Create the Node.js Web Server File

      In this section, you will create a file named server.js that will use Node.js modules to help you write a simple web server that can handle client requests and return responses to them.

      1. In your site’s root directory, create the server.js file with the following content.

        /var/www/example.com/server.js
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
        14
        15
        16
        17
        18
        19
        20
        21
        22
        23
        24
        
        //nodejs.org/api for API docs
        //Node.js web server
        var http = require("http"),                           //Import Node.js modules
            url = require("url"),
            path = require("path"),
            fs = require("fs");
        
        http.createServer(function(request, response) {       //Create server
        var name = url.parse(request.url).pathname;           //Parse URL
        var filename = path.join(process.cwd(), name);        //Create filename
        fs.readFile(filename, "binary", function(err, file) { //Read file
            if(err) {                                         //Tracking Errors
                response.writeHead(500, {"Content-Type": "text/plain"});
                response.write(err + "n");
                response.end();
                return;
            }
            response.writeHead(200);                          //Header request response
            response.write(file, "binary");                   //Sends body response
            response.end();                                   //Signals to server that
         });                                                  //header and body sent
        }).listen(3000);                                      //Listening port
        console.log("Server is listening on port 3000.")      //Terminal output
                
      2. Run a new screen session.

        screen
        

        Press return when prompted.

      3. Navigate to your root directory where your test.js file is located.

        cd /var/www/example.com
        
      4. Run your Node.js web server. Appending & to the end of a command will keep the web server’s process running in the background.

        node server.js &
        

        You should see your terminal return a process ID after issuing the previous command. Return to your command prompt by entering CTRL+C.

      5. Exit your screen session by pressing Ctrl+A then d.

      6. Open a browser and navigate to your site’s domain or IP address. You should see your site’s index.html page load.

      7. Click on the page’s Go to test.js button to load the test.js page whose content will be served dynamically with your Node.js web server.

      8. Click on the test page’s Display the date and time button to dynamically display the current date and time.

      You have now completed the basic configurations to proxy requests to the Node.js server you wrote. As a next step, you may consider looking into further NGINX configurations to better handle serving static content and dynamic content from a reverse proxy.

      There are many frameworks to help you continue to develop web apps using JavaScript. You may consider using Express.js, Ember.js, or Vue.js.

      More Information

      You may wish to consult the following resources for additional information on this topic. While these are provided in the hope that they will be useful, please note that we cannot vouch for the accuracy or timeliness of externally hosted materials.

      This guide is published under a CC BY-ND 4.0 license.



      Source link

      Comment créer un raccourci d’URL avec Django et GraphQL


      L’auteur a sélectionné Girls Who Code pour recevoir un don dans le cadre de l’initiative Écrire pour des donations. 

      Introduction

      GraphQL est une norme d’API créée et mise à disposition par Facebook comme alternative à API REST. Contrairement aux API REST, GraphQL utilise un système typé pour définir sa structure de données où toutes les informations envoyées et reçues doivent être conformes à un schéma prédéfini. Il expose également un point d’accès unique pour toutes les communications au lieu de multiples URL pour différentes ressources et résout le problème épineux en renvoyant uniquement les données demandées par le client, ce qui génère des réponses plus petites et plus concises.

      Dans ce tutoriel, vous allez créer un backend pour un raccourcisseur d’URL-un service qui prend n’importe quelle URL et génère une version plus courte et plus lisible- tout en plongeant dans les concepts de GraphQL, comme les interrogations et les mutations et les outils, comme l’interface GraphiQL. Vous avez peut-être déjà utilisé de tels services auparavant comme bit.ly.

      Comme GraphQL est une technologie non basée sur le langage, elle est appliquée en plus de langages et cadres divers. Ici, vous utiliserez le langage de programmation général Python, le cadre web Django et la bibliothèque Graphene-Django comme implémentation Python GraphQL avec des intégrations spécifiques pour Django.

      Conditions préalables

      Étape 1 – Mise en place du projet Django

      Dans cette étape, vous installerez tous les outils nécessaires à l’application et à la mise en place de votre projet Django.

      Une fois que vous avez créé le répertoire de votre projet et lancé votre environnement virtuel comme prévu dans les conditions préalables, installez les paquets nécessaires en utilisant piple gestionnaire de paquets Python. Ce tutoriel permet d’installer la version 2.1.7 de Django et la version 2.2.0 ou supérieure de Graphene-Django :

      • pip install "django==2.1.7" "graphene-django>==2.2.0"

      Vous avez maintenant tous les outils nécessaires dans votre ceinture à outils. Ensuite, vous allez créer un projet Django en utilisant la commande django-admin. Un projet est la plaque tournante par défaut de Django – un ensemble de dossiers et de fichiers avec tout le nécessaire pour démarrer le développement d’une application web. Dans ce cas, vous appellerez votre projet shorty et le créerez au sein de votre dossier actuel en spécifiant le . à la fin.

      • django-admin startproject shorty .

      Après avoir créé votre projet, vous dirigerez les migrations de Django. Ces fichiers contiennent du code Python généré par Django et sont chargés de modifier la structure de l’application selon les modèles de Django. Les changements peuvent comprendre la création d’une table, par exemple. Par défaut, Django est livré avec son propre ensemble de migrations responsables de sous-systèmes comme Django Authentification. Il est donc nécessaire de les exécuter avec la commande suivante : 

      Cette commande utilise l’interpréteur Python pour invoquer un script Django appelé manage.py, chargé de gérer différents aspects de votre projet, comme la création d’applications ou l’exécution de migrations.

      Cela donnera un résultat similaire à ce qui suit :

      Output

      Operations to perform: Apply all migrations: admin, auth, contenttypes, sessions Running migrations: Applying contenttypes.0001_initial... OK Applying auth.0001_initial... OK Applying admin.0001_initial... OK Applying admin.0002_logentry_remove_auto_add... OK Applying admin.0003_logentry_add_action_flag_choices... OK Applying contenttypes.0002_remove_content_type_name... OK Applying auth.0002_alter_permission_name_max_length... OK Applying auth.0003_alter_user_email_max_length... OK Applying auth.0004_alter_user_username_opts... OK Applying auth.0005_alter_user_last_login_null... OK Applying auth.0006_require_contenttypes_0002... OK Applying auth.0007_alter_validators_add_error_messages... OK Applying auth.0008_alter_user_username_max_length... OK Applying auth.0009_alter_user_last_name_max_length... OK Applying sessions.0001_initial... OK

      Une fois que la base de données de Django est prête à fonctionner, démarrez son serveur de développement local :

      • python manage.py runserver

      Il en résultera :

      Output

      Performing system checks... System check identified no issues (0 silenced). March 18, 2020 - 15:46:15 Django version 2.1.7, using settings 'shorty.settings' Starting development server at http://127.0.0.1:8000/ Quit the server with CONTROL-C.

      Cette commande supprime l’invite dans votre terminal et démarre le serveur.

      Visitez http://127.0.0.1:8000 dans votre navigateur local. Vous verrez cette page :

      Première page du serveur local de Django 

      Pour arrêter le serveur et revenir à votre terminal, appuyez sur CTRL+C. Chaque fois que vous devez accéder au navigateur, assurez-vous que la commande précédente est exécutée.

      Ensuite, vous terminerez cette étape en activant la bibliothèque Django-Graphene dans le projet. Django a le concept d’app, une application web avec une responsabilité spécifique. Un projet est composé d’une ou plusieurs applications. Pour l’instant, ouvrez le fichiershorty/settings.py dans l’éditeur de texte de votre choix. Ce tutoriel utilisera vim : 

      Le fichier settings.py gère tous les paramètres de votre projet. A l’intérieur, cherchez le INSTALLED_APPS et ajoutez l'entrée « graphene_django » : 

      shorty/shorty/settings.py

      ...
      INSTALLED_APPS = [
          'django.contrib.admin',
          'django.contrib.auth',
          'django.contrib.contenttypes',
          'django.contrib.sessions',
          'django.contrib.messages',
          'django.contrib.staticfiles',
          'graphene_django',
      ]
      ...
      

      Cet ajout indique à Django que vous utiliserez une application appelée graphene_django que vous avez installée à l’étape 1. 

      Au bas du fichier, ajoutez la variable suivante :

      shorty/shorty/settings.py

      ...
      GRAPHENE = {
          'SCHEMA': 'shorty.schema.schema',
      }
      

      Cette dernière variable indique votre schéma principal, que vous créerez plus tard. Dans GraphQL, un schéma contient tous les types d’objets, tels que les ressources, les requêtes et les mutations. Considérez qu’il s’agit d’une documentation représentant toutes les données et fonctionnalités disponibles dans votre système.

      Après les modifications, enregistrez et fermez le fichier.

      Vous avez maintenant configuré le projet Django. Dans l’étape suivante, vous allez créer une application Django et ses modèles.

      Étape 2 – Mise en place d’une application Django et de modèles

      Une plateforme Django est généralement composée d’un projet et de nombreuses applications ou apps. Une app ou application décrit un ensemble de fonctionnalités à l’intérieur d’un projet, et, si elle est bien conçue, elle peut être réutilisée à travers les projets Django.

      Dans cette étape, vous allez créer une application appelée shortenerresponsable de la fonction de raccourcissement des URL. Pour créer son squelette de base, tapez la commande suivante dans votre terminal :

      • python manage.py startapp shortener

      Ici, vous avez utilisé les paramètres startapp app_name, en donnant des instructions à manage.py de créer une application appelée shortener. 

      Pour terminer la création de l’application, ouvrez le fichier shorty/settings.py

      Ajouter le nom de l’application à la même entrée INSTALLED_APPS que vous avez modifiée auparavant :

      shorty/shorty/settings.py

      ...
      INSTALLED_APPS = [
          'django.contrib.admin',
          'django.contrib.auth',
          'django.contrib.contenttypes',
          'django.contrib.sessions',
          'django.contrib.messages',
          'django.contrib.staticfiles',
          'graphene_django'
          'shortener',
      ]
      ...
      

      Enregistrez et fermez le fichier.

      Avec votre raccourcisseur ajouté à shorty/settings.py, vous pouvez passer à la création des modèles pour votre projet. Les modèles sont l’un des éléments clés de Django. Ils sont utilisés pour représenter une base de données sous forme « Python », ce qui permet de gérer, d’interroger et de stocker des données à l’aide de code Python.

      Avant d’ouvrir le fichier models.py pour les modifications, ce tutoriel donne un aperçu des modifications que vous allez apporter.

      Votre fichier de modèle, models.py, contiendra le contenu suivant une fois que vous aurez remplacé le code existant :

      shorty/shortener/models.py

      from hashlib import md5
      
      from django.db import models
      

      Ici, vous importerez les paquets nécessaires à votre code. Vous ajouterez la ligne de hashlib import md5 en haut pour importer la bibliothèque standard Python qui sera utilisée pour créer un hachage de l’URL. La ligne de modèlesfrom django.db est une aide de Django pour la création de modèles. 

      Avertissement : Ce tutoriel fait référence au hachage comme le résultat d’une fonction qui prend une entrée et renvoie toujours la même sortie. Ce tutoriel utilisera la fonction de hachage MD5 à des fins de démonstration. 

      Notez que le MD5 présente des problèmes de collision et doit être évité en production.

      Ensuite, vous ajouterez un modèle nommé URL avec les champs suivants :

      • full_url : l’URL à raccourcir.
      • url_hash : un court hachage représentant l’URL complète.
      • clics : nombre de fois que l’URL courte a été consultée.
      • created_at : la date et l’heure auxquelles l’URL a été créée.

      shorty/shortener/models.py

      ...
      
      class URL(models.Model):
          full_url = models.URLField(unique=True)
          url_hash = models.URLField(unique=True)
          clicks = models.IntegerField(default=0)
          created_at = models.DateTimeField(auto_now_add=True)
      

      Vous allez générer l’url_hash en appliquant l’algorithme de hachage MD5 au champ de saisie full_url et en utilisant uniquement les 10 premiers caractères renvoyés lors de la méthode save() du modèle, exécutée à chaque fois que Django enregistre une entrée dans la base de données. En outre, les raccourcisseurs d’URL suivent généralement le nombre de fois qu’un lien a été cliqué. Vous y parviendrez en appelant la méthode clicked() lorsque l’URL est visitée par un utilisateur.

      Les opérations mentionnées seront ajoutées à l’intérieur de votre Modèle d’URL avec ce code :

      shorty/shortener/models.py

      ...
      
          def clicked(self):
              self.clicks += 1
              self.save()
      
          def save(self, *args, **kwargs):
              if not self.id:
                  self.url_hash = md5(self.full_url.encode()).hexdigest()[:10]
      
              return super().save(*args, **kwargs)
      

      Maintenant que vous avez examiné le code, ouvrez le fichier shortener/models.py :

      Remplacez le code par le contenu suivant :

      shorty/shortener/models.py

      from hashlib import md5
      
      from django.db import models
      
      
      class URL(models.Model):
          full_url = models.URLField(unique=True)
          url_hash = models.URLField(unique=True)
          clicks = models.IntegerField(default=0)
          created_at = models.DateTimeField(auto_now_add=True)
      
          def clicked(self):
              self.clicks += 1
              self.save()
      
          def save(self, *args, **kwargs):
              if not self.id:
                  self.url_hash = md5(self.full_url.encode()).hexdigest()[:10]
      
              return super().save(*args, **kwargs)
      

      Veillez à enregistrer et à fermer le fichier.

      Pour appliquer ces changements dans la base de données, vous devrez créer les migrations en exécutant la commande suivante :

      • python manage.py makemigrations

      Cela donnera la sortie suivante :

      Output

      Migrations for 'shortener': shortener/migrations/0001_initial.py - Create model URL

      Ensuite, exécutez les migrations :

      Vous verrez la sortie suivante dans votre terminal :

      Output

      Operations to perform: Apply all migrations: admin, auth, contenttypes, sessions, shortener Running migrations: Applying shortener.0001_initial... OK

      Maintenant que vous avez mis en place les modèles, l’étape suivante consiste à créer le point final GraphQL et une requête.

      Étape 3 – Création de requêtes

      L’architecture REST expose différentes ressources dans différents points finaux, chacun contenant une structure de données bien définie. Par exemple, vous pouvez obtenir une liste d’utilisateurs à l’adresse /api/usersqui s’attendent toujours aux mêmes domaines. GraphQL, en revanche, a un point final unique pour toutes les interactions, et utilise des Queries ou requêtes d’accès aux données. La différence principale – et la plus importante – est que vous pouvez utiliser une requête pour retrouver tous vos utilisateurs en une seule fois. 

      Commencez par créer une requête pour récupérer toutes les URL. Vous aurez besoin de plusieurs choses :

      • Un type d’URL, lié à votre modèle préalablement défini.
      • Une déclaration de requête nommée urls. 
      • Une méthode pour résoudre votre requête, c’est-à-dire récupérer toutes les URL de la base de données et les renvoyer au client.

      Créez un nouveau fichier appelé shortener/schema.py: 

      Commencez par ajouter les déclarations d’import Python :

      shorty/shortener/schema.py

      import graphene
      from graphene_django import DjangoObjectType
      
      from .models import URL
      

      La première ligne importe la principale bibliothèque de graphene qui contient les types de base de GraphQL, comme List. Le DjangoObjectType est une aide pour créer une définition de schéma à partir de n’importe quel modèle Django, et la troisième ligne importe votre modèle URL créé préalablement.

      Ensuite, créez un nouveau type de GraphQL pour le modèle d’URL en ajoutant les lignes suivantes : 

      shorty/shortener/schema.py

      ...
      class URLType(DjangoObjectType):
          class Meta:
              model = URL
      

      Enfin, ajoutez ces lignes pour créer un type de requête pour le modèle d’URL : 

      shorty/shortener/schema.py

      ...
      class Query(graphene.ObjectType):
          urls = graphene.List(URLType)
      
          def resolve_urls(self, info, **kwargs):
              return URL.objects.all()
      

      Ce code crée une classe de Query avec un champ nommé urls qui est une liste du URLType défini précédemment. Lors de la résolution de la requête à l’aide des resolve_urlsvous renvoyez toutes les URL stockées dans la base de données. 

      Le fichier complet shortener/schema.py est présenté ici :

      shorty/shortener/schema.py

      import graphene
      from graphene_django import DjangoObjectType
      
      from .models import URL
      
      
      class URLType(DjangoObjectType):
          class Meta:
              model = URL
      
      
      class Query(graphene.ObjectType):
          urls = graphene.List(URLType)
      
          def resolve_urls(self, info, **kwargs):
              return URL.objects.all()
      

      Enregistrez et fermez le fichier.

      Toutes les requêtes doivent maintenant être ajoutées au schéma principal. Considérez-le comme le détenteur de toutes vos ressources.

      Créez un nouveau dossier dans le shorty/schema.py et ouvrez-le avec votre éditeur : 

      Importez les paquets Python suivants en ajoutant les lignes suivantes. Le premier, comme déjà mentionné, contient les types GraphQL de base. La deuxième ligne importe le fichier Schema précédemment créé.

      shorty/shorty/schema.py

      import graphene
      
      import shortener.schema
      

      Ensuite, ajoutez la principale classe de Query. Elle conservera, par héritage, toutes les requêtes et les futures opérations créées :

      shorty/shorty/schema.py

      ...
      class Query(shortener.schema.Query, graphene.ObjectType):
          pass
      

      Enfin, créez la variable schema : 

      shorty/shorty/schema.py

      ...
      schema = graphene.Schema(query=Query)
      

      Le paramètre SCHEMA que vous avez défini à l’étape 2 renvoie à la variable schéma que vous venez de créer.

      Le shorty/schema.py est affiché ici en entier : 

      shorty/shorty/schema.py

      import graphene
      
      import shortener.schema
      
      
      class Query(shortener.schema.Query, graphene.ObjectType):
          pass
      
      schema = graphene.Schema(query=Query)
      

      Enregistrez et fermez le fichier.

      Ensuite, activez le point final GraphQL et l’interface GraphiQLqui est une interface graphique web utilisée pour interagir avec le système GraphQL. 

      Ouvrez le fichiershorty/urls.py : 

      Pour les besoins de ce tutoriel, supprimez le contenu du fichier et enregistrez-le, afin de pouvoir recommencer à zéro.

      Les premières lignes que vous ajouterez sont des déclarations d’importation en Python :

      shorty/shorty/urls.py

      from django.urls import path
      from django.views.decorators.csrf import csrf_exempt
      
      from graphene_django.views import GraphQLView
      

      La fonction path est utilisée par Django pour créer une URL accessible pour l’interface GraphiQL. Après, vous importez le csrf_exempt qui permet aux clients d’envoyer des données au serveur. Une explication complète se trouve dans la documentation du Graphene. À la dernière ligne, vous avez importé le code réel responsable de l’interface via GraphQLView.

      Ensuite, créez une variable nommée urlpatterns. 

      shorty/shorty/urls.py

      ...
      urlpatterns = [
          path('graphql/', csrf_exempt(GraphQLView.as_view(graphiql=True))),
      ]
      

      Cela permettra d’assembler tout le code nécessaire pour rendre l’interface GraphiQL disponible dans le chemin graphql/ :

      L’ensemble shortener/urls.py est affiché ici : 

      shorty/shorty/urls.py

      from django.urls import path
      from django.views.decorators.csrf import csrf_exempt
      
      from graphene_django.views import GraphQLView
      
      urlpatterns = [
          path('graphql/', csrf_exempt(GraphQLView.as_view(graphiql=True))),
      ]
      

      Enregistrez le dossier et fermez-le.

      De retour dans le terminal, lancez la commande python manage.py runserver (si elle n’est pas déjà en cours d’exécution) :

      • python manage.py runserver

      Ouvrez votre navigateur web à l’adresse suivante http://localhost:8000/graphql l’adresse. Cet écran s’affichera :

      Interface GraphiQL 

      GraphiQL est une interface dans laquelle vous pouvez exécuter des instructions GraphQL et voir les résultats. L’une des caractéristiques est la section « Docs » en haut à droite. Comme tout dans GraphQL est typé, vous obtenez une documentation gratuite sur tous vos types, requêtes, mutations, etc.

      Après avoir exploré la page, insérez votre première requête dans la zone de texte principale :

      query {
        urls {
          id
          fullUrl
          urlHash
          clicks
          createdAt
        }
      }
      

      Ce contenu montre comment une query GraphQL est structurée : tout d’abord, vous utilisez le mot-clé pour indiquer au serveur que vous ne voulez récupérer que certaines données. Ensuite, vous utilisez le champ urls défini dans le fichier shortener/schema.py à l’intérieur de la classe Query. A partir de là, vous demandez explicitement tous les champs définis dans le modèle d’URL en CamelCase qui est la valeur par défaut pour GraphQL. 

      Maintenant, cliquez sur le bouton flèche de lecture en haut à gauche. 

      Vous recevrez la réponse suivante, indiquant que vous n’avez toujours pas d’URLs :

      Output

      { "data": { "urls": [] } }

      Cela montre que GraphQL fonctionne. Dans votre terminal, appuyez sur CTRL+C pour arrêter votre serveur. 

      Vous avez accompli beaucoup de choses dans cette étape, en créant le point final GraphQL, en effectuant une requête pour récupérer toutes les URL et en activant l’interface GraphiQL. Maintenant, vous allez créer des mutations pour modifier la base de données.

      Étape 4 – Créer des mutations

      La majorité des applications permettent de modifier l’état de la base de données en ajoutant, mettant à jour ou supprimant des données. Dans GraphQL, ces opérations sont appelées « Mutations ». Elles ressemblent à des requêtes mais utilisent des arguments pour envoyer des données au serveur.

      Pour créer votre première Mutation, ouvrez shortener/schema.py: 

      A la fin du fichier, commencez par ajouter une nouvelle classe nommée CreateURL: 

      shorty/shortener/schema.py

      ...
      class CreateURL(graphene.Mutation):
          url = graphene.Field(URLType)
      

      Cette classe hérite de l’aide graphène.Mutation pour avoir les capacités d’une mutation GraphQL. Elle a également un nom de propriété url qui définit le contenu renvoyé par le serveur une fois la mutation terminée. Dans ce cas, ce sera la structure de données URLType.

      Ensuite, ajoutez une sous-classe nommée Arguments à la classe déjà définie : 

      shorty/shortener/schema.py

      ...
          class Arguments:
              full_url = graphene.String()
      

      Cela définit les données qui seront acceptées par le serveur. Ici, vous attendez un paramètre nommé full_url avec un contenu String :

      Ajoutez maintenant les lignes suivantes pour créer la méthode mutate :

      shorty/shortener/schema.py

      ...
      
          def mutate(self, info, full_url):
              url = URL(full_url=full_url)
              url.save()
      

      Cette méthode mutate fait une grande partie du travail en recevant les données du client et en les enregistrant dans la base de données. À la fin, elle renvoie la classe elle-même contenant l’élément nouvellement créé.

      Enfin, créez une Mutation qui contiendra toutes les Mutations de votre app, en ajoutant ces lignes : 

      shorty/shortener/schema.py

      ...
      
      class Mutation(graphene.ObjectType):
          create_url = CreateURL.Field()
      

      Jusqu’à présent, vous n’aurez qu’une seule mutation nommée create_url. 

      Le fichier complet shortener/schema.py est présenté ici :

      shorty/shortener/schema.py

      import graphene
      from graphene_django import DjangoObjectType
      
      from .models import URL
      
      
      class URLType(DjangoObjectType):
          class Meta:
              model = URL
      
      
      class Query(graphene.ObjectType):
          urls = graphene.List(URLType)
      
          def resolve_urls(self, info, **kwargs):
              return URL.objects.all()
      
      
      class CreateURL(graphene.Mutation):
          url = graphene.Field(URLType)
      
          class Arguments:
              full_url = graphene.String()
      
          def mutate(self, info, full_url):
              url = URL(full_url=full_url)
              url.save()
      
              return CreateURL(url=url)
      
      
      class Mutation(graphene.ObjectType):
          create_url = CreateURL.Field()
      

      Fermez et enregistrez le fichier.

      Pour terminer l’ajout de la mutation, modifiez le fichiershorty/schema.py : 

      Modifiez le fichier pour y inclure le code surligné suivant :

      shorty/shorty/schema.py

      
      import graphene
      
      import shortener.schema
      
      
      class Query(shortener.schema.Query, graphene.ObjectType):
          pass
      
      
      class Mutation(shortener.schema.Mutation, graphene.ObjectType):
          pass
      
      
      schema = graphene.Schema(query=Query, mutation=Mutation)
      

      Enregistrez et fermez le fichier. Si vous n’utilisez pas le serveur local, démarrez-le :

      • python manage.py runserver

      Naviguez vers http://localhost:8000/graphql dans votre navigateur web. Exécutez votre première Mutation dans l’interface web GraphiQL en exécutant la déclaration suivante :

      mutation {
        createUrl(fullUrl:"https://www.digitalocean.com/community") {
          url {
            id
            fullUrl
            urlHash
            clicks
            createdAt
          }
        }
      }
      

      Vous avez composé la Mutation avec le nom createURL, l’argument fullUrl, et les données que vous souhaitez voir figurer dans la réponse définie à l’intérieur du champ de l’url. 

      La sortie contiendra les informations URL que vous venez de créer dans les données GraphQL comme indiqué ici : 

      Output

      { "data": { "createUrl": { "url": { "id": "1", "fullUrl": "https://www.digitalocean.com/community", "urlHash": "077880af78", "clicks": 0, "createdAt": "2020-01-30T19:15:10.820062+00:00" } } } }

      Avec cela, une URL a été ajoutée à la base de données avec sa version hachée, comme vous pouvez le voir dans le champ urlHash. Essayez d’exécuter la requête que vous avez créée dans la dernière étape pour voir son résultat :

      query {
        urls {
          id
          fullUrl
          urlHash
          clicks
          createdAt
        }
      }
      

      La sortie affichera l’URL enregistrée :

      Output

      { "data": { "urls": [ { "id": "1", "fullUrl": "https://www.digitalocean.com/community", "urlHash": "077880af78", "clicks": 0, "createdAt": "2020-03-18T21:03:24.664934+00:00" } ] } }

      Vous pouvez également essayer d’exécuter la même requête, mais en ne demandant que les champs que vous voulez.

      Ensuite, essayez-le encore une fois avec une autre URL :

      mutation {
        createUrl(fullUrl:"https://www.digitalocean.com/write-for-donations/") {
          url {
            id
            fullUrl
            urlHash
            clicks
            createdAt
          }
        }
      }
      

      Le résultat sera :

      Output

      { "data": { "createUrl": { "url": { "id": "2", "fullUrl": "https://www.digitalocean.com/write-for-donations/", "urlHash": "703562669b", "clicks": 0, "createdAt": "2020-01-30T19:31:10.820062+00:00" } } } }

      Le système est maintenant capable de créer des URL courtes et de les répertorier. Dans l’étape suivante, vous permettrez aux utilisateurs d’accéder à une URL par sa version courte en les redirigeant vers la bonne page.

      Étape 5 – Créer le point final d’accès

      Dans cette étape, vous utiliserez Django Views-une méthode qui prend une demande et renvoie une réponse – pour rediriger toute personne accédant à la http://localhost:8000/url_hash à son URL complète. 

      Ouvrez le shortener/views.py avec votre éditeur : 

      Pour commencer, importez deux paquets en remplaçant le contenu par les lignes suivantes :

      shorty/shortener/views.py

      from django.shortcuts import get_object_or_404, redirect
      
      from .models import URL
      

      Celles-ci seront expliquées plus en détail ultérieurement.

      Ensuite, vous allez créer une Django View nommée root (racine). Ajoutez ce bout de code responsable de la View à la fin de votre fichier :

      shorty/shortener/views.py

      ...
      
      def root(request, url_hash):
          url = get_object_or_404(URL, url_hash=url_hash)
          url.clicked()
      
          return redirect(url.full_url)
      

      Il reçoit un argument appelé url_hash à partir de l’URL demandée par un utilisateur. Dans la fonction, la première ligne essaie de récupérer l’URL de la base de données en utilisant l’argument url_hash. Si elle n’est pas trouvée, elle renvoie l’erreur HTTP 404 au client, ce qui signifie que la ressource est manquante. Ensuite,elle augmente le la propriété cliquée de l’entrée de l’URL, en veillant à suivre le nombre de fois où l’URL est consultée. A la fin, elle redirige le client vers l’URL demandée.

      L’ensemble shortener/views.py est affiché ici : 

      shorty/shortener/views.py

      from django.shortcuts import get_object_or_404, redirect
      
      from .models import URL
      
      
      def root(request, url_hash):
          url = get_object_or_404(URL, url_hash=url_hash)
          url.clicked()
      
          return redirect(url.full_url)
      

      Enregistrez et fermez le fichier.

      Ensuite, ouvrez shorty/urls.py :

      Ajoutez le code surligné suivant pour activer la View racine.

      shorty/shorty/urls.py

      
      from django.urls import path
      from django.views.decorators.csrf import csrf_exempt
      
      from graphene_django.views import GraphQLView
      
      from shortener.views import root
      
      
      urlpatterns = [
          path('graphql/', csrf_exempt(GraphQLView.as_view(graphiql=True))),
          path('<str:url_hash>/', root, name='root'),
      ]
      

      La View racine sera accessible dans le /path de votre serveur, en acceptant un url_hash comme paramètre de chaîne.

      Enregistrez et fermez le fichier. Si vous n’utilisez pas le serveur local, démarrez-le en exécutant la commande python manage.py runserver.

      Pour tester votre nouvel ajout, ouvrez votre navigateur web et accédez à l’URL http://localhost:8000/077880af78.  Notez que la dernière partie de l’URL est le hachage créé par la mutation de l’étape 5. Vous serez redirigé vers la page URL du hachage, dans ce cas, le site web de la communauté DigitalOcean.

      Maintenant que la redirection URL fonctionne, vous rendrez l’application plus sûre en mettant en œuvre un traitement des erreurs lors de l’exécution de la mutation.

      Étape 6 – Mise en œuvre du traitement des erreurs

      Le traitement des erreurs est une bonne habitude à avoir dans toutes les applications, car les développeurs ne contrôlent généralement pas ce qui sera envoyé au serveur. Dans ce cas, vous pouvez essayer de prévoir les défaillances et de minimiser leurs impacts. Dans un système complexe tel que GraphQL, beaucoup de choses peuvent mal tourner, du client qui demande des données erronées jusqu’au serveur qui perd l’accès à la base de données.

      En tant que système typographique , GraphQL peut vérifier tout ce que le client demande et reçoit dans une opération appelée Schema Validation (Validation du schéma). Vous pouvez le voir en action en effectuant une Query ou (Requête) avec un champ non existant.

      Naviguez vers http://localhost:8000/graphql dans votre navigateur, et exécutez la requête suivante dans l’interface GraphiQL avec le champ iDontExist : 

      query {
        urls {
          id
          fullUrl
          urlHash
          clicks
          createdAt
          iDontExist
        }
      }
      

      Comme il n’y a pas de iDontExist défini dans votre requête, GraphQL renvoie un message d’erreur :

      Output

      { "errors": [ { "message": "Cannot query field "iDontExist" on type "URLType".", "locations": [ { "line": 8, "column": 5 } ] } ] }

      Ceci est important car, dans le système typographique GraphQL, l’objectif est d’envoyer et de recevoir uniquement les informations déjà définies dans le schéma.

      La présente demande accepte tout type de chaîne arbitraire dans le champ full_url. Le problème est que si quelqu’un envoyait une URL mal construite, vous redirigeriez l’utilisateur vers nulle part en essayant les informations stockées. Dans ce cas, vous devez vérifier si le full_url est bien formaté avant de l’enregistrer dans la base de données, et, en cas d’erreur, lever l’exception GraphQLError avec un message personnalisé.

      Mettons en place cette fonctionnalité en deux étapes. Tout d’abord, ouvrez le fichier raccourcis/modèles.py : 

      Ajoutez les lignes surlignées dans la section d’importation :

      shorty/shortener/models.py

      from hashlib import md5
      
      from django.db import models
      from django.core.validators import URLValidator
      from django.core.exceptions import ValidationError
      
      from graphql import GraphQLError
      ...
      

      L’URLValidator est une aide de Django pour valider une chaîne d’URL et l'erreur GraphQLE est utilisée par Graphene pour lever des exceptions avec un message personnalisé.

      Ensuite, assurez-vous de valider l’URL reçue par l’utilisateur avant de l’enregistrer dans la base de données. Activez cette opération en ajoutant le code mis en évidence dans le fichier raccourcis/modèles.py :

      shorty/shortener/models.py

      class URL(models.Model):
          full_url = models.URLField(unique=True)
          url_hash = models.URLField(unique=True)
          clicks = models.IntegerField(default=0)
          created_at = models.DateTimeField(auto_now_add=True)
      
          def clicked(self):
              self.clicks += 1
              self.save()
      
          def save(self, *args, **kwargs):
              if not self.id:
                  self.url_hash = md5(self.full_url.encode()).hexdigest()[:10]
      
              validate = URLValidator()
              try:
                  validate(self.full_url)
              except ValidationError as e:
                  raise GraphQLError('invalid url')
      
              return super().save(*args, **kwargs)
      

      Premièrement, ce code instancie l’URLValidator dans la variable validate. A l’intérieur du bloc try/except, vous validez() l’URL reçue et faites apparaître une erreur GraphQLE avec le message personnalisé d'url invalide si quelque chose s’est mal passé. 

      Le fichier complet shortener/models.py est affiché ici :

      shorty/shortener/models.py

      from hashlib import md5
      
      from django.db import models
      from django.core.validators import URLValidator
      from django.core.exceptions import ValidationError
      
      from graphql import GraphQLError
      
      
      class URL(models.Model):
          full_url = models.URLField(unique=True)
          url_hash = models.URLField(unique=True)
          clicks = models.IntegerField(default=0)
          created_at = models.DateTimeField(auto_now_add=True)
      
          def clicked(self):
              self.clicks += 1
              self.save()
      
          def save(self, *args, **kwargs):
              if not self.id:
                  self.url_hash = md5(self.full_url.encode()).hexdigest()[:10]
      
              validate = URLValidator()
              try:
                  validate(self.full_url)
              except ValidationError as e:
                  raise GraphQLError('invalid url')
      
              return super().save(*args, **kwargs)
      

      Enregistrez et fermez le fichier. Si vous n’utilisez pas le serveur local, démarrez-le avec la commande python manage.py runserver. 

      Ensuite, testez votre nouveau traitement des erreurs sur http://localhost:8000/graphql. Essayez de créer une nouvelle URL avec un full_url non valide dans l’interface GraphiQL :

      mutation {
        createUrl(fullUrl:"not_valid_url"){
          url {
            id
            fullUrl
            urlHash
            clicks
            createdAt
          }
        }
      }
      

      Lorsque vous envoyez une URL non valide, votre exception sera signalée par le message personnalisé :

      Output

      { "errors": [ { "message": "invalid url", "locations": [ { "line": 2, "column": 3 } ], "path": [ "createUrl" ] } ], "data": { "createUrl": null } }

      Si vous regardez dans votre terminal où lacommande python manage.py runserver est en cours d’exécution, une erreur apparaîtra : 

      Output

      ... graphql.error.located_error.GraphQLLocatedError: invalid url [30/Jan/2020 19:46:32] "POST /graphql/ HTTP/1.1" 200 121

      Un terminal GraphQL échouera toujours avec un code d’état HTTP 200, ce qui signifie généralement un succès. Rappelez-vous que, même si GraphQL est construit au-dessus de HTTP, il n’utilise pas les concepts de codes d’état HTTP ou de méthodes HTTP comme le fait REST.

      Grâce à la mise en place du traitement des erreurs, vous pouvez maintenant mettre en place un mécanisme pour filtrer vos requêtes en minimisant les informations renvoyées par le serveur.

      Étape 7 – Mise en place des filtres

      Imaginez que vous avez commencé à utiliser le raccourcisseur d’URL pour ajouter vos propres liens. Au bout d’un certain temps, il y aura tellement d’entrées qu’il sera difficile de trouver la bonne. Vous pouvez résoudre ce problème en utilisant des filtres.

      Le filtrage est un concept courant dans les API REST, où généralement un Paramètre d’interrogation avec un champ et une valeur est ajouté à l’URL. Par exemple, pour filtrer tous les utilisateurs nommés jojo, vous pouvez utiliser GET /api/users?name=jojo. 

      Dans GraphQL, vous utiliserez les Query Arguments (Arguments de requête) comme filtres. Ils créent une interface agréable et propre.

      Vous pouvez résoudre le problème des « URL difficiles à trouver » en permettant au client de filtrer les URL par leur nom en utilisant le champ full_url. Pour ce faire, il faut ouvrir le fichiershortener/schema.py dans votre éditeur préféré. 

      Tout d’abord, importez la méthode Q dans la ligne surlignée :

      shorty/shortener/schema.py

      import graphene
      from graphene_django import DjangoObjectType
      from django.db.models import Q
      
      from .models import URL
      ...
      

      Elle sera utilisée pour filtrer votre recherche dans la base de données.

      Ensuite, réécrivez l’ensemble classe de recherche avec le contenu suivant : 

      shorty/shortener/schema.py

      ...
      class Query(graphene.ObjectType):
          urls = graphene.List(URLType, url=graphene.String())
      
          def resolve_urls(self, info, url=None, **kwargs):
              queryset = URL.objects.all()
      
              if url:
                  _filter = Q(full_url__icontains=url)
                  queryset = queryset.filter(_filter)
      
              return queryset
      ...
      

      Les modifications que vous apportez sont :

      • Ajouter le paramètre de filtre d'url à l’intérieur de la variable urls et laméthode resolve_url. 
      • A l’intérieur des resolve_urls,si un paramètre nommé est donné, filtrer les résultats de la base de données aboutit à renvoyer les URL qui contiennent la valeur donnée en utilisant la méthode Q (full_url__icontains=url) méthode. 

      Le fichier complet shortener/schema.py est présenté ici :

      shorty/shortener/schema.py

      import graphene
      from graphene_django import DjangoObjectType
      from django.db.models import Q
      
      from .models import URL
      
      
      class URLType(DjangoObjectType):
          class Meta:
              model = URL
      
      
      class Query(graphene.ObjectType):
          urls = graphene.List(URLType, url=graphene.String())
      
          def resolve_urls(self, info, url=None, **kwargs):
              queryset = URL.objects.all()
      
              if url:
                  _filter = Q(full_url__icontains=url)
                  queryset = queryset.filter(_filter)
      
              return queryset
      
      
      class CreateURL(graphene.Mutation):
          url = graphene.Field(URLType)
      
          class Arguments:
              full_url = graphene.String()
      
          def mutate(self, info, full_url)
              url = URL(full_url=full_url)
              url.save()
      
              return CreateURL(url=url)
      
      
      class Mutation(graphene.ObjectType):
          create_url = CreateURL.Field()
      

      Enregistrez et fermez le fichier. Si vous n’utilisez pas le serveur local, commencez par python manage.py runserver. 

      Testez vos derniers changements sur http://localhost:8000/graphql. Dans l’interface GraphiQL, écrivez la déclaration suivante. Il filtrera toutes les URL avec le mot communauté :

      query {
        urls(url:"community") {
          id
          fullUrl
          urlHash
          clicks
          createdAt
        }
      }
      

      Le résultat n’est qu’une seule entrée puisque vous venez d’ajouter une URL avec la chaîne communautaire dedans. Si vous avez ajouté d’autres URL auparavant, votre résultat peut varier.

      Output

      { "data": { "urls": [ { "id": "1", "fullUrl": "https://www.digitalocean.com/community", "urlHash": "077880af78", "clicks": 1, "createdAt": "2020-01-30T19:27:36.243900+00:00" } ] } }

      Vous avez maintenant la possibilité d’effectuer des recherches par le biais de vos URL. Cependant, avec trop de liens, vos clients pourraient se plaindre que la liste d’URL renvoie plus de données que leurs applications ne peuvent traiter. Pour résoudre ce problème, vous allez mettre en place la pagination.

      Les clients qui utilisent votre backend peuvent se plaindre que le temps de réponse est trop long ou que sa taille est trop importante s’il y a trop d’entrées d’URL. Même votre base de données peut avoir du mal à rassembler un grand nombre d’informations. Pour résoudre ce problème, vous pouvez permettre au client de préciser le nombre d’éléments qu’il souhaite dans chaque demande en utilisant une technique appelée la pagination.

      Il n’y a pas de moyen par défaut de mettre en œuvre cette fonctionnalité. Même dans les API REST, vous pouvez le voir dans les en-têtes HTTP ou les paramètres de requête, avec des noms et des comportements différents.

      Dans cette application, vous implémenterez la pagination en activant deux arguments supplémentaires à la requête d’URL : first et skip. first sélectionnera le premier nombre variable d’éléments et skip spécifiera combien d’éléments doivent être sautés depuis le début. Par exemple, en utilisant d'abord == 10 et en sautant == 5, on obtient les 10 premières URL, mais on en saute 5, ce qui ne renvoie que les 5 restantes.

      La mise en œuvre de cette solution est similaire à l’ajout d’un filtre.

      Ouvrez le fichier shortener/schema.py :

      Dans le dossier, modifiez la classe de recherche en ajoutant les deux nouveaux paramètres dans la variable urls et la méthode resolve_urls, mise en évidence dans le code suivant :

      shorty/shortener/schema.py

      import graphene
      from graphene_django import DjangoObjectType
      from django.db.models import Q
      
      from .models import URL
      
      
      class Query(graphene.ObjectType):
          urls = graphene.List(URLType, url=graphene.String(), first=graphene.Int(), skip=graphene.Int())
      
          def resolve_urls(self, info, url=None, first=None, skip=None, **kwargs):
              queryset = URL.objects.all()
      
              if url:
                  _filter = Q(full_url__icontains=url)
                  queryset = queryset.filter(_filter)
      
              if first:
                  queryset = queryset[:first]
      
              if skip:
                  queryset = queryset[skip:]
      
              return queryset
      ...
      

      Ce code utilise les premiers paramètres nouvellement créés et saute les paramètres à l’intérieur de la méthode resolve_urls pour filtrer la requête de la base de données.

      Enregistrez et fermez le fichier. Si vous n’utilisez pas le serveur local, commencez par python manage.py runserver. 

      Pour tester la pagination, lancez la requête suivante dans l’interface GraphiQL à http://localhost:8000/graphql: 

      query {
        urls(first: 2, skip: 1) {
          id
          fullUrl
          urlHash
          clicks
          createdAt
        }
      }
      

      Votre raccourcisseur d’URL renvoie la deuxième URL créée dans votre base de données :

      Output

      { "data": { "urls": [ { "id": "2", "fullUrl": "https://www.digitalocean.com/write-for-donations/", "urlHash": "703562669b", "clicks": 0, "createdAt": "2020-01-30T19:31:10.820062+00:00" } ] } }

      Cela montre que la fonction de pagination fonctionne. N’hésitez pas à vous amuser en ajoutant d’autres URL et en testant différentes séries de first et skip.

      Conclusion

      L’ensemble de l’écosystème GraphQL se développe chaque jour avec une communauté active derrière lui. Des entreprises comme GitHub et Facebook ont prouvé qu’il était prêt au lancement, et vous pouvez maintenant appliquer cette technologie à vos propres projets.

      Dans ce tutoriel, vous avez créé un service de raccourcissement d’URL à l’aide de GraphQL, Python et Django en utilisant des concepts comme les requêtes et les mutations. Mais plus que cela, vous comprenez maintenant comment s’appuyer sur ces technologies pour construire des applications web en utilisant le framework web Django.

      Vous pouvez en savoir plus sur GraphQL et les outils utilisés ici dans le site web de GraphQL et les sites web de documentation consacrés à Graphene. De plus, DigitalOcean propose des tutoriels supplémentaires pour Python et Django que vous pouvez utiliser si vous souhaitez en savoir plus sur l’un ou l’autre. 



      Source link