Cet article vous montrera comment créer une application à partir du cloud à l'aide du ** Django Web Framework ** pour aider les développeurs Web à relever les défis auxquels ils sont confrontés aujourd'hui.
Avant de parler de Django, laissez-moi vous dire ce qu'est une application Web. Une application Web est un ensemble de code écrit dans un langage de programmation qui est rendu sur un navigateur et résout généralement des problèmes bien définis. Par exemple, un article de blog (comme celui-ci!), Un site Web de commerce électronique ou un réseau social.
Eh bien, c'est assez simple, mais qu'est-ce qu'un framework Web? Un framework Web est un ensemble de composants réutilisables qui gèrent de manière intégrée de nombreuses tâches courantes et répétitives du développement d'applications Web. Au lieu d'avoir à obtenir une bibliothèque de codes différents et à trouver un moyen de les faire fonctionner ensemble, le framework Web fournit tous les composants dont vous avez besoin dans un seul package et s'occupe de l'intégration. ..
Maintenant que vous connaissez le concept d'applications et de frameworks Web, parlons de Django. Django est l'un des derniers frameworks Web visant à simplifier la création d'applications Web. Django fournit un ensemble d'outils pour vous aider à développer rapidement des applications Web réutilisables, évolutives, propres et hautement dynamiques.
Django est construit sur le paradigme DRY (Don't Repeat Yourself), et vous devez écrire moins de code que le code moyen requis en utilisant d'autres frameworks à chaque étape du processus de développement. Cela signifie ne pas être.
Cette série de tutoriels vous guidera à travers le développement de plusieurs applications, comment les différents composants et applications fournis avec Django vous aideront à écrire moins de code à chaque étape du processus de développement. Voici comment faire tout cela dans le cloud. Cette fois, nous exécuterons l'application Web sur une instance Alibaba Cloud Elastic Compute Service (ECS). La procédure de configuration de Django sur ECS n'est pas décrite. Au lieu de cela, reportez-vous aux deux didacticiels suivants.
1、https://www.alibabacloud.com/getting-started/projects/how-to-deploy-django-application-on-alibaba-cloud 2、http://www.alibabacloud.com/blog/how-to-deploy-a-django-application-with-docker_581157
Le projet que nous essayons de construire est une application Web de commerce électronique qui permet aux gens d'acheter et de vendre des biens. Pour plus de flexibilité et de maintenabilité, le projet est divisé en trois applications indépendantes: l'application principale, l'application panier et l'application de paiement.
Comme mentionné précédemment, l'application principale gère tout ce qui concerne le produit que vous souhaitez vendre (ajouts, modifications, suppressions). L'application principale vise à gérer l'ensemble du processus d'achat.
1, utilisateur (acheteur / vendeur et administrateur) 2, informations sur le produit 3, catégorie de produit
L'application de panier est utilisée pour gérer le processus d'achat et de vente. Les éléments spécifiques gérés ici sont les suivants.
1, options d'achat et de vente 2, le panier du client et les articles du panier 3, ajouter / supprimer des articles au panier
L'application de paiement vous donne accès à la passerelle de paiement et vous permet de recevoir l'argent transmis par le client. Cliquez ici pour plus de détails:
1, passerelle de paiement 2, méthode de paiement 3, intégration de l'API de paiement
Installez python 3 et pip
$ python --version
# sudo apt-get install python3
# sudo apt-get install python-pip
Installation de la base de données PostgreSQL
# sudo apt-get update
# sudo apt-get install python-dev libpq-dev postgresql postgresql-contrib
Installation de virtualenv
# sudo pip install virtualenv
Installation d'oreillers En utilisant cette bibliothèque, vous pourrez imprimer des profils et des images de produits sur des modèles.
(venv)$ pip install pillow
Cette commande crée un environnement virtuel dans le dossier venv qui fait de python3 l'interpréteur python par défaut.
$ virtualenv venv --python=python3
$ cd venv
Cette commande active cet environnement virtuel.
$ source bin/activate
(venv)$ cd venv
(venv)$ pip install django==2.1
(venv)$ django-admin startproject buyandsell
Après avoir terminé avec succès chacune des étapes ci-dessus, le dossier de projet résultant devrait ressembler à ceci:
buyandsell/
buyandsell/
__init__.py
settings.py
urls.py
wsgi.py
db.sqlite3
manage.py
Voici quelques-uns des fichiers affichés dans ce dossier.
1, ** settings.py **: ce fichier est utilisé pour définir la configuration principale de l'application, comme les paramètres d'accès à la base de données et les définitions de service de fichiers statiques. 2, ** urls.py **: Ce fichier est utilisé pour créer une racine URL qui fournit le contenu stocké par l'application. 3, ** wsgi.py **: ce fichier définit les paramètres par défaut utilisés par le serveur Web dans les paramètres de déploiement. 4, ** manage.py **: Le script principal de gestion du projet Django et de ses applications (migration de base de données, exécution de test, exécution de serveur de développement). 5, ** db.sqlite3 **: Il s'agit du préréglage de base de données par défaut dans Django. Utilisez-le pour le développement uniquement, mais lors du déploiement, changez-le en une base de données PostgreSQL qui sera utilisée en conjonction avec l'application Django. 6, ** admin.py **: Utilisé pour générer une application d'interface d'administration. 7, ** tests.py **: définit les tests à exécuter lors du test de l'application. 8, ** app.py **: ce fichier contient les paramètres par défaut de l'application.
Après avoir créé le projet, vous devez créer des tables de base telles que User, Session, etc. pour fournir le comportement par défaut de Django.
(venv)$ cd buyandsell
(venv)$ python manage.py migrate
Le superutilisateur Django est l'utilisateur root de Linux, et cet utilisateur a tous les droits sur les données stockées dans la base de données Django. Cet utilisateur a tous accès à l'interface d'administration.
(venv)$ cd buyandsell
(venv)$ python manage.py createsuperuser admin
Remarque: veuillez saisir un mot de passe à 8 caractères qui est un mélange de chiffres majuscules et minuscules et de caractères spéciaux.
Vous pouvez le tester en exécutant une commande dans le dossier racine «acheter et vendre».
(venv)$ python manage.py runserver SERVER_IP:SERVER_PORT
SERVER_IP est l'adresse IP publique de l'instance de machine virtuelle et SERVER_PORT est le port externe configuré sur le serveur.
Toutes les applications développées dans ce didacticiel suivent le processus ci-dessous.
(venv)$ cd buyandsell
(venv)$ django-admin startapp core
Après l'initialisation de l'application principale, le dossier du projet doit avoir un nouveau dossier avec la structure suivante:
core/
__init__.py
admin.py
apps.py
migrations/
__init__.py
models.py
tests.py
views.py
Pour que Django considère l'application principale dans le cadre du projet d'achat et de vente, vous devez ajouter les paramètres suivants à votre fichier settings.py:
….
INSTALLED_APPS = [
'core',
…
]
….
Comme mentionné ci-dessus, cette application gère les modèles suivants.
1, profil utilisateur 2, produit 3, catégorie de produit Et voici le code source correspondant.
from django.db import models
from django.urls import reverse
from django.contrib.auth.models import User
from django.conf import settings
from datetime import datetime
class UserProfile(models.Model):
user = models.OneToOneField(User, on_delete=models.CASCADE)
photo = models.ImageField(upload_to='profile_images', blank=True)
phone = models.CharField(max_length=20)
def __str__(self):
return self.user + "profile"
def get_absolute_url(self):
return reverse("profile_detail", kwargs={"pk": self.pk})
class Product(models.Model):
""" This the default Product class """
name = models.CharField(max_length=50)
description = models.TextField(max_length=100)
photo = models.ImageField(upload_to='product_images', blank=True)
price_ht = models.FloatField()
category = models.ForeignKey("core.Category", on_delete=models.CASCADE)
created_at = models.DateTimeField(default=datetime.now)
created_by = models.ForeignKey(User, on_delete=models.CASCADE)
TVA_AMOUNT = 19.25
def price_ttc(self):
return self.price_ht + self.TVA_AMOUNT
def __str__(self):
return self.name
def get_absolute_url(self):
return reverse("product_detail", kwargs={"pk": self.pk})
class Category(models.Model):
name = models.CharField(max_length=50)
description = models.TextField(max_length=100)
photo = models.ImageField(upload_to='category_images', blank=True)
def __str__(self):
return self.name
def get_absolute_url(self):
return reverse("category_detail", kwargs={"pk": self.pk})
Après avoir défini le modèle, vous devez enregistrer ces structures dans la base de données à l'aide de la commande suivante:
(venv)$ python manage.py makemigrations
(venv)$ python manage.py migrate
Vous devez définir des vues et des fichiers modèles afin que les utilisateurs finaux puissent accéder à votre application à partir de votre navigateur.
Créez des vues et des fichiers de modèle pour gérer la création, les mises à jour, les suppressions, les listes et les détails du modèle.
Le contenu du fichier views.py est indiqué ci-dessous.
from django.shortcuts import render
from django.views.generic import DetailView, ListView, CreateView, UpdateView, DeleteView
from .models import Product, Category, UserProfile
# Product views
class ProductDetailView(DetailView):
model = Product
template_name = "core/product_detail.html"
class ProductListView(ListView):
model = Product
template_name = "core/product_list.html"
class ProductCreateView(CreateView):
model = Product
template_name = "core/product_create.html"
def form_valid(self, form):
form.instance.created_by = self.request.user
return super().form_valid(form)
class ProductUpdateView(UpdateView):
model = Product
template_name = "core/product_update.html"
class ProductDeleteView(DeleteView):
model = Product
template_name = "core/product_delete.html"
Ici, nous allons présenter le modèle Html utilisé pour afficher le formulaire de création de produit.
{% extends 'base.html' %}
{% block title %} Creation of a product {% endblock %}
{% block menu_bar %}
{{ block.super }}
<li class="active" ><a href="{% url 'product-list' %}">products</a></li>
{% endblock menu_bar %}
{% block content %}
<h3>Creation of a product</h3>
<form action="" method="post" enctype="multipart/form-data" >
{% csrf_token %}
{{ form.as_p }}
<input type="submit" value="Create">
<button class="button"><a href="{% url 'product-list' %}">Cancel</a></button>
</form>
{% endblock %}
Le fichier de modèle Html se trouve dans le répertoire templates / core dans le dossier racine de l'application principale.
Pour plus d'informations sur l'utilisation des fichiers de modèle Django, voir: django-website / templates
UrlConf est une structure qui définit la manière dont la navigation est effectuée sur votre application. Il est défini dans le fichier views.py.
Vous trouverez ci-dessous le contenu de ce fichier.
# Product Urls
urlpatterns = [
path('products/', views.ProductListView.as_view(), name='product-list'),
path('product/<int:pk>/', views.ProductDetailView.as_view(), name='product-detail'),
path('product/create/', views.ProductCreateView.as_view(), name='product-create'),
path('product/<int:pk>/update/', views.ProductUpdateView.as_view(), name='product-update'),
path('product/<int:pk>/delete/', views.ProductDeleteView.as_view(), name='product-delete'),
]
Les itinéraires définis jusqu'à présent servent de points d'entrée pour accéder aux fichiers modèles définis dans la section vue. Ce fichier crée une liaison entre le chemin de l'URL et la vue associée à cette URL.
En général, lorsque vous créez une application Web pour répondre aux besoins professionnels de votre client, vous créez également une application d'administrateur qui gère les données, les autorisations, les autorisations et les rôles stockés dans la base de données. Django simplifie la vie des développeurs web car cela se fait déjà par défaut.
Pour configurer l'interface d'administration, vous devez modifier admin.py et le configurer pour utiliser le modèle.
Les réglages sont effectués de cette manière.
from core.models import Product
class ProductAdmin(admin.ModelAdmin):
pass
admin.site.register(Product, ProductAdmin)
Vous pouvez également annoter la classe ProductAdmin.
@admin.register(Product)
class ProductAdmin(admin.ModelAdmin):
pass
Après avoir répété ces étapes pour tous les modèles, utilisez le code suivant dans le fichier admin.py.
from django.contrib import admin
from core.models import Product, Category, UserProfile
@admin.register(Product)
class ProductAdmin(admin.ModelAdmin):
pass
@admin.register(Category)
class CategoryAdmin(admin.ModelAdmin):
pass
@admin.register(UserProfile)
class UserProfileAdmin(admin.ModelAdmin):
pass
Une fois que cela est fait, vous pouvez ouvrir votre navigateur à l'adresse suivante pour voir l'écran d'administration.
127.0.0.1:8000/admin/
Vous vous êtes connecté avec le compte de super utilisateur créé dans ce didacticiel.
Maintenant que nous avons une application fonctionnelle, nous essayons d'ajouter des styles pour la rendre plus visible. Utilisez donc Bootstrap 3 et la bibliothèque Jquery pour ajouter des styles à votre application.
Il existe un processus pour le faire.
Téléchargez le fichier source correspondant.
1、bootstrap.css 2、bootstrap.js 3、jquery.js
Créez un sous-dossier appelé static dans le dossier principal et créez un autre dossier nommé core à l'intérieur. De cette façon, placez les fichiers statiques de l'application principale dans ces dossiers.
Définissez les paramètres STATIC_ROOT et STATIC_URL pour accéder à ces fichiers depuis votre navigateur
STATIC_URL = '/static/'
STATIC_ROOT = os.path.join(BASE_DIR, '/static/')
Consolidez les fichiers statiques dans le fichier base.html et mettez les modèles hérités à la disposition de ces bibliothèques.
Tout d'abord, chargez toutes les bibliothèques statiques.
{% load static %}
Vous pouvez désormais utiliser cette balise pour utiliser des ressources statiques dans des dossiers statiques, comme illustré ci-dessous.
{% static 'core/css/bootstrap.css' %}
Vous trouverez ci-dessous le fichier base.html qui résulte de l'importation réussie de toutes les ressources statiques.
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1">
<meta name="description" content="">
<meta name="author" content="">
<link rel="icon" href="../../favicon.ico">
<title>{% block title %} Welcome to the core app !! {% endblock %}</title>
<link rel="stylesheet" type="text/css" href="{% static 'core/css/bootstrap.css' %}">
<link rel="stylesheet" type="text/css" href="{% static 'core/css/main.css' %}">
</head>
<body>
<script src="{% static 'core/js/jquery.js' %}"></script>
<script src="{% static 'core/js/bootstrap.js' %}"></script>
</body>
</html>
À la fin de ce didacticiel, vous verrez comment créer une application à l'aide du framework Web Django. Plus précisément, nous avons appris quels sont les modèles, vues et modèles de Django.
Le code source de l'application utilisée dans ce didacticiel se trouve sur GitHub.
https://github.com/binel01/buyandsell/tree/master/core