Comment utiliser IRIS à partir de Django - Exemples

Découvrir Django

Django est un framework web conçu pour développer des serveurs et des API, et pour traiter des bases de données de manière rapide, évolutive et sécurisée. Pour ce faire, Django fournit des outils permettant non seulement de créer le squelette du code, mais aussi de le mettre à jour sans souci. Il permet aux développeurs de voir les changements presque en direct, de corriger les erreurs avec l'outil de débogage et de traiter la sécurité avec facilité.

Pour comprendre le fonctionnement de Django, examinons l'image :

En résumé, le client envoie son requête avec une URL. Cette URL est adressée à une vue qui doit traiter cette requête de manière appropriée en récupérant les informations du modèle alimenté par la base de données. Une fois que le traitement est achevé, la réponse est renvoyée au client par l'intermédiaire d'un modèle. Django rend ce processus complexe moins problématique.

Découvrir Django-iris

Django utilise des backends personnalisables pour gérer n'importe quelle base de données dont le développeur pourrait avoir besoin. MySQL, Postgre, Oracle et d'autres ont déjà été implémentés et sont faciles à trouver sur GitHub. Django-iris est un backend permettant d'adapter le framework Django aux bases de données IRIS, de sorte que toutes les fonctionnalités des plates-formes d'InterSystems peuvent être utilisées en parallèle avec les outils Django.

Pratiquement, si nous reprenons l'illustration précédente, la BASE DE DONNÉES serait IRIS au lieu de PostgreSQL.

Le code source et des informations sur l'application et ses développeurs peuvent être trouvés sur django-iris par caretdev.  

Pour commencer

J'ai appris à Innovatium que lorsqu'il s'agit d'un nouveau langage de code ou d'un nouvel outil, la meilleure façon de commencer est de découvrir comment réaliser un système CRUD (abbréviation anglaise de "Create, Read, Update, and Delete", c'est-à-dire créer, lire, mettre à jour et supprimer) simple. Après cela, il sera plus facile de comprendre comment cela fonctionne et d'évoluer vers des tâches plus complexes et plus spécifiques que vous pourriez être amené à accomplir.

Compte tenu de ce qui précède, je vais d'abord vous montrer comment construire le CRUD le plus simple. Après avoir clarifié les choses, et lorsque vous commencerez à vous familiariser avec l'outil, je passerai à d'autres exemples où Django peut être utile. Enfin, si nous avons de la chance, je pourrai vous convaincre de l'utiliser.

Vous pouvez suivre ce tutoriel sur l'historique des commits du référentiel GitHub, en commençant par django-admin startproject irisCrud.

Conditions préalables

Vous devez avoir Python, Django, un bon outil de développement comme VSCode, et un accès à une instance d'IRIS. Voici un guide rapide :

Download VSCode (n'oubliez pas d'ajouter des extensions Python pour vous aider à développer)

Download Python

Tapez pip install django dans le terminal

Tapez pip install django-iris dans le terminal

Le coup d'envoi "Kick-off"

Créez un dossier pour votre projet, placez le répertoire de votre terminal dans ce nouveau dossier et tapez django-admin startproject PROJECTNAME .

Vous pouvez ignorer le point à la fin pour créer un dossier à l'intérieur du répertoire courant avec le nom PROJECTNAME.

Cela devrait créer les fichiers suivants, dans lesquels vous devez choisir "CRUD" comme PROJECTNAME : 

Vous pouvez maintenant effectuer votre première migration et lancer votre serveur en tapant les commandes suivantes dans le terminal. À ce stade, vous devriez remarquer que quelques fichiers supplémentaires ont été créés.

python manage.py migrate

python manage.py runserver

Si vous suivez le lien http://127.0.0.1:8000/, vous verrez la page d'accueil par défaut des projets Django.
La prochaine étape consistera à créer le superutilisateur avec python manage.py createsuperuser. Soyez prudent : lorsque vous saisissez le mot de passe, vous ne verrez aucun changement, mais rappelez-vous que le terminal lit déjà ce que vous tapez.  

Ajouter des exigences pour django-iris

Créez un fichier dans le dossier racine, nommez-le requirements.txt, et copiez-y ce qui suit :

# Django itself
django>=4.0.0
# InterSystems IRIS driver for Django
django-iris==0.2.2

Dans le terminal, tapez `pip install -r requirements.txt` et obtenez votre django-iris prêt à être utilisé dans votre projet.
Ouvrez maintenant settings.py et cherchez la configuration DATABASES. Modifiez-la pour obtenir quelque chose de similaire à ce qui suit :

DATABASES = {
    'default': {
        'ENGINE': 'django_iris',
        'NAME': 'USER',
        'USER': '_SYSTEM',
        'PASSWORD': 'SYS',
        'HOST': 'localhost',
        'PORT': 1972,
    }
}

Où

• ENGINE doit pointer sur 'django_iris' ;
• NAME doit indiquer l'espace de noms souhaité ;
• USER et PASSWORD doivent se référer à un utilisateur disposant de privilèges adéquats ;
• HOST et PORT doivent mener à votre instance. Vous pouvez le vérifier dans le gestionnaire de serveur InterSystems IRIS.

Création d'une application

Retournez dans le terminal et tapez python manage.py startapp NAMEOFTHEAPP.

Vous devriez obtenir un dossier similaire au dossier ci-dessous : 

Vous pouvez maintenant créer un modèle en modifiant models.py et en créant une classe avec le nom et les champs requis. Par exemple :

class Book(models.Model):
	title  = models.CharField(max_length=50)
	author = models.CharField(max_length=30)

Chaque champ doit être spécifié en tant que propriété "models". Vous pouvez consulter tous les champs disponibles ici. Vous pouvez également définir diverses options, telles que le traitement des valeurs nulles et vides ou la création d'alternatives possibles pour le champ.
Pour s'assurer que le programme reconnaîtra cette nouvelle application, il faut retourner à settings.py et ajoutez le nom de l'application à la liste INSTALLED_APPS :

INSTALLED_APPS: [
 …
‘books’,
]

Une fois l'étape précédente terminée, saisissez python manage.py makemigrations dans le terminal pour configurer les futures migrations. Vérifiez migrations/__pycache__/0001_initial.py Pour mieux comprendre ce le fonctionnement de cette commande. Ensuite, saisissez python manage.py migrate pour appliquer les changements.

Passez dans le portail de gestion IRIS > Explorateur de système > SQL, choisissez le même espace de noms que celui que vous avez défini dans les paramètres DATABASES et recherchez SQLUser. Vous verrez les nouvelles tableaux créés dans IRIS :

Si vous choisissez un schéma dans le tableau, vous pourrez voir son nom de classe qui peut être ouvert et modifié (à vos risques et périls) à partir du Studio ou de tout autre outil de développement. 

Un peu de front-end

Si vous ouvrez le fichier urls.py à partir du dossier du projet (CRUD), vous remarquerez un chemin préconstruit qui mène à admin. Si vous suivez http://127.0.0.1:8000/admin, il vous sera demandé d'entrer un nom d'utilisateur et un mot de passe. Vous pouvez utiliser celui que vous avez sélectionné lors de l'exécution de la commande createuperuser et jeter un coup d'œil à ce que Django a à offrir sur cette page.

Cependant, nous pourrions avoir plus de pages. Pour créer une URL personnalisée basée sur la nouvelle application, importez include de django.urls et ajoutez un nouveau chemin, pointant vers l'application :

from django.urls import path, include
urlpatterns = [
    path('admin/', admin.site.urls),
    path('books/', include('books.urls')),
]

Cette opération devrait vous rediriger vers le fichier books/urls.py (il vous faudra d'abord créer ce fichier), dans lequel nous allons ajouter un autre chemin nous permettant d'accéder à la vue. Le fichier devrait ressembler à ce qui suit :

from django.contrib import admin
from django.urls import path
from .views import home
urlpatterns = [
	path(‘’, home)
]

Il est temps de créer la vue vers laquelle nous sommes dirigés. Passez à books/views.py et ajoutez une définition avec la requête comme paramètre :

def home(request):
	return render(request, “index.html”)

Finalement, créez le fichier index.html. Il doit être ajouté au dossier books/templates. Consultez l'image ci-dessous à titre de référence : 

Si vous utilisez VSCode, vous pouvez taper !+ENTER dans le fichier. Je vais vous donner un squelette de la page HTML, de sorte que vous soyez en mesure d'ajouter "Hello World" au corps de la page ou quelque chose de similaire. Voici un exemple :

<!DOCTYPE html>
<html>
 <body> hello world! </body>
</html>

Saisissez python manage.py migrate pour appliquer les changements et rendez-vous sur http://127.0.0.1:8000/books. Il se peut que l'on vous demande de faire fonctionner le serveur avec python manage.py runserver une fois de plus. Après cela, le serveur devrait fonctionner sans problème. 

Ajouter des objets à partir de la page d'administration 

En revenant à la page d'administration, nous pouvons maintenant effectuer toutes les actions CRUD sur le modèle créé. Pour cela passez à books/admin.py, importez le modèle depuis .models, et enregistrez-le :

from .models import Book
admin.site.register(Book)

Si vous passez à http://127.0.0.1:8000/admin, vous devriez maintenant voir le tableau BOOKS avec des options CRUD. Je vous recommande d'ajouter quelques livres pour les étapes suivantes.

Vous pouvez éventuellement implémenter une fonction __str__ dans la classe du modèle pour obtenir une version plus lisible de l'objet. Par exemple, il pourrait s'agir de quelque chose d'aussi simple que ce qui suit :

def __str__(self):
	return self.title+” “+self.author

Si vous n'êtes pas familier avec cela, consultez n'importe quel article sur la POO (Programmation Orientée Objet) sur Python. Celui-ci en contient un exemple, surtout si vous voulez en savoir plus sur la méthode __str__.

Les images ci-dessous montrent le portail d'administration avant et après sa mise en œuvre :

Afficher les objets sur la page d'accueil - CRUD Read

Revenez au fichier views.py, où nous avons défini la fonction home. Importez votre modèle et ajoutez-le à la fonction. Cela vous permettra d'y accéder depuis le HTML :

from .models import Book
def home(request):
	books = Book.objects.all()
	return render(request, “index.html”, {“books”:books})

Maintenant, dans le fichier index.html vous pouvez accéder directement à tous les champs de votre modèle. Par exemple, j'ai décidé d'afficher une liste complète de tous les articles avec le code suivant :

<body>
…
  <ul>
    {% for book in books %}
    <li> {{book.id}} - {{book.title}} by {{book.author}} </li>
    {% endfor %}
  </ul>
</body>

Encore une fois, si vous n'êtes pas familier avec ce type de code, vous pouvez consulter en ligne toute documentation fiable sur les bases du HTML, et cliquer ici pour en savoir plus sur les balises {%%}. 

Reprenons l'image du début de cet article. Elle nous montre que le client envoie une requête (c'est-à-dire qu'il ouvre le site web) et que l'URL l'adresse à une vue (la fonction accueil), qui répond avec les modèles contenant les informations de la base de données. Cette réponse est renvoyée au client sous la forme d'un modèle (HTML).

Actuellement, il devrait ressembler à l'image ci-dessous :

Ajouter de nouveaux objets - CRUD Create

Tout d'abord, il faut décider de la manière dont nous prévoyons d'obtenir les informations pour le nouvel objet. J'ai choisi de construire un simple formulaire. Cependant, il faudra spécifier le token pour protéger notre serveur contre les interactions malveillantes. Pour en savoir plus sur la sécurité, cliquez ici.

<body>
  …
  <form action=”{% url ‘save’ %}” method=”POST”>
    {% csrf_token %}
    <input type=”text” name=”title”>
    <input type “text” name=”author”>
    <button type=”submit”>save</button>
  </form>
</body>

Une fois de plus, nous avons une requête du client (c'est-à-dire lorsque l'utilisateur remplit le formulaire), et nous avons besoin d'une URL l'adressant à une vue. L'action sur le formulaire peut spécifier cette URL, alors créons-la.

Dans books/urls.py nous allons importer save depuis les vues et ajouter un nouveau chemin :

from .views import home, save
urlpatterns = [
…
path(‘save/’, save, name=”save”),
]

Finalement, nous créons la vue :

def save(request):
	formsTitle = request.POST.get(“title”)
	formsAuthor = request.POST.get(“author”)
	Book.objects.create(title=formsTitle, author=formsAuthor)
	books = Book.objects.all()
	return render(request, “index.html”, {“books”: books})

Si nous rechargeons la page, nous verrons les entrées et le bouton. Vous pouvez également ajouter quelques objets supplémentaires pour vérifier le fonctionnement. En outre, vous pouvez ouvrir le portail SQL sur le portail de gestion IRIS pour voir comment le formulaire envoie les informations directement au tableau IRIS.

Modification d'objets existants - CRUD Update

Tout comme pour les opérations que nous avons créées précédemment, nous devons construire quelque chose pour envoyer la demande. Par exemple, nous pouvons ajouter un lien à chaque objet qui renvoie vers un formulaire analogue à celui que nous venons de construire.

Commençons par modifier le index.html:

<body>
  …
  <ul>
  {% for book in books %}
    <li>
      {{book.id}} - {{book.title}} by {{book.author}} 
      <a href=”{% url ‘edit’ book.id %}”>Edit</a>
    </li>
    {% endfor %}
  </ul>
  …
</body>

Maintenant, dans le fichier urls.py nous devons ajouter la nouvelle URL, avec le paramètre ID :

from .views import home, save, edit
urlpatterns = [
…
path(‘edit/<int:id>’, edit, name=”edit”),
]

Ensuite, nous pouvons créer la vue édition dans views.py:

def edit(request, id):
	book = Book.objects.get(id=id)
	return render(request, “update.html”, {“book”: book})

La vue édition va envoyer un nouveau modèle à l'utilisateur afin qu'il puisse saisir les informations nécessaires à la mise à jour de l'objet. Le fichier update.html doit être créé dans books/templates. Vous trouverez ci-dessous un exemple de modèle qui répond à nos besoins :

<!DOCTYPE html>
<html>
  <body>
    <form action=”{% url ‘update’ book.id %}” method=”POST”>
      {% csrf_token %}
	 <input type=”text” name=”title” value=”{{book.title}}”>
	 <input type=“text” name=”author” value=”{{book.author}}”>
	 <button type=”submit”>update</button>
    </form>
  </body>
</html>

Puisque nous avons une nouvelle URL, nous devons la créer dans urls.py et spécifier sa vue dans views.py:

# file books/urls.py
from .views import home, save, edit, update
urlpatterns = [
…
path(‘update/<int:id>’, update, name=”update”),
]

# file books/views.py
from django.shortcuts import redirect
def update(request, id):
	book = Book.objects.get(id=id)
	book.title = request.POST.get(“title”)
	book.author = request.POST.get(“author”)
	book.save()
	return redirect(home)

À présent, notre retour va se faire vers le modèle renvoyé par la vue d'accueil.

À ce stade, vous pouvez recharger le programme et tout tester, en vérifiant les informations correspondantes sur IRIS.

Suppression d'un objet - CRUD Delete

Nous devons faire en sorte que le client puisse interagir avec le serveur d'une manière qui permette à ce dernier de supprimer des informations. Il existe de nombreuses façons de rendre cela possible. Je vais simplement ajouter un autre lien qui contient une URL, qui adresse cette information à une vue, à la liste d'affichage.

Modifiez le fichier index.html comme indiqué ci-dessous :

<body>
  …
  <ul>
    {% for book in books %}
    <li>
      {{book.id}} - {{book.title}} by {{book.author}} 
      <a href=”{% url ‘edit’ book.id %}”>Edit</a>
      <a href = “{% url ‘delete’ book.id %}”>Delete</a>
    </li>
    {% endfor %}
  </ul>
  …
</body>

J'espère que vous avez appris suffisamment de choses sur ce processus pour deviner qu'à ce stade, nous devons créer un chemin sur urls.py:

from .views import home, save, edit, update, delete
urlpatterns = [
…
path(‘delete/<int:id>’, delete, name=”delete”),
]

Pour finir, créez la vue :

def delete(request, id):
	book = book.objects.get(id=id)
	book.delete()
	return redirect(home)

Rechargez la page. Votre nouveau lien est prêt à être testé :

Conclusion

Dans cet article, nous avons créé la base de presque tous les serveurs. Il devrait vous être facile d'imaginer comment faire évoluer ce que nous avons fait aujourd'hui vers un système d'enregistrement ou de facturation, ou peut-être même un blog, en ajoutant simplement quelques fonctions de sécurité (et, bien sûr, un tout petit peu de CSS).

Cependant, nous pouvons encore approfondir ce que nous avons appris ici pour créer des portails qui peuvent afficher toutes les informations que vous avez déjà sur votre instance IRIS, en faisant évoluer notre serveur vers un portail de gestion pour contrôler le flux de données, l'interaction avec l'utilisateur, l'affichage d'informations sur les journaux et même l'envoi de courriels. En outre, nous pouvons également utiliser Django pour créer un point final, tel qu'une page web facile à utiliser pour interagir avec les API que nous construisons à partir d'IRIS, y compris le traitement, la transformation et la surveillance des données que les plates-formes d'InterSystems fournissent.