introduction

Dans cet article, nous allons créer un projet Django, afficher l'écran d'accueil, l'écran de création de compte et l'écran de connexion. La plupart sont des notes personnelles, mais j'espère que vous les trouverez utiles. Le fonctionnement ne peut pas être garanti.

L'authentification utilise django-allauth. L'édition et le test de l'écran avec django-allauth sont décrits dans Créer un écran de connexion avec Django allauth.

Installation / enregistrement

Installer python
Inscrivez-vous avec stripe Vous n'êtes pas obligé de l'utiliser si vous ne l'utilisez pas.

Démarrer un projet

Créez l'emplacement du projet django avec la commande suivante.

mkdir ec-django

Créez un environnement virtuel pour python et installez les packages requis.

cd ec-django/

python -m venv venv

//Entrez dans l'environnement virtuel
source venv/bin/activate

//Installation du package dans un environnement virtuel
pip install Django==2.2
pip install django-allauth==0.39.1 //Fonctions d'authentification telles que la fonction de connexion
pip install django-environ==0.4.5 //Variables d'environnement.Pour lire à partir du fichier env
pip install mysqlclient==1.4.4 //Pour la base de données Mysql
//pip install stripe==2.35.0 //Fonction de paiement par bande

Créez un projet.


django-admin startproject config .

Créez une application (principale) qui gère les utilisateurs.


./manage.py  startapp main

Créez d'autres répertoires nécessaires.

//Répertoire des fichiers python pour un traitement facile
mkdir script
touch ./script/__init__.py

//fichier de modèles(.html etc.)Répertoire à mettre
mkdir templates

//Répertoire pour placer les fichiers statiques
mkdir static

Définition des variables d'environnement avec le fichier env

Créer un fichier .env


touch .env

Les variables d'environnement sont ajoutées au fichier .env suivant chaque fois qu'une fonction est ajoutée. Si vous le publiez sur le net comme git, veillez à ne pas le télécharger.

`.env`


DEBUG=Ture

SECRET_KEY=<django-secret-key> //./config/setting.clé secrète py

//Voici les paramètres liés à la base de données. (Correspondance avec le DB défini dans la seconde moitié de l'article.)
DB_NAME=databese-name
DB_USER=user-name
DB_PASS=password

Créez un programme qui lit les variables d'environnement. Le programme suivant lit également les informations de la base de données et le chemin d'accès au répertoire de base du projet Django, qui sera défini plus loin dans cet article.

import environ
import os
from config.settings.base import BASE_DIR #Régler après

import logging
logger = logging.getLogger(__file__)

def get_env_dict(env_path):
    env = {}
    try:
        read_env = environ.Env()
        environ.Env.read_env(env_path)

        #moins que,.Écrivez sur les paramètres à lire à partir du fichier env.
        if read_env('DEBUG') == 'True' or True:
            env['DEBUG'] = True
        elif read_env('DEBUG') == 'False' or False:
            env['DEBUG'] = False
    
        #secret keys
        env['SECRET_KEY'] = read_env('SECRET_KEY')

        #DB setting
        env['DB_NAME'] = read_env('DB_NAME')
        env['DB_USER'] = read_env('DB_USER')
        env['DB_PASS'] = read_env('DB_PASS')

    except environ.ImproperlyConfigured as e:
        logger.info('Une clé qui n'a pas été définie est définie: {}'.format(e))
        
    except Exception as e:
        logger.info('Erreur de réglage de la variable d'environnement: {e}'.format(e))
    
    return env
        

env_path = os.path.join(BASE_DIR, '.env')
env = get_env_dict(env_path)

Configurer la base de données MySQL

J'ai évoqué ce qui suit. Paramètres de base de données de Django que je fais toujours lorsque j'utilise MySQL (utf8mb4) avec Django Configuration MySQL sur Mac

brew install mysql 
//mysql --version
//mysql  Ver 14.14 Distrib 5.7.25, for osx10.14 (x86_64) using  EditLine wrapper

mysql.server start

mysql -u root -p

//Base de données de noms de base de données-name,Nom d'utilisateur utilisateur-name,Mot de passe mot de passe

mysql> CREATE DATABASE database-name;
mysql> CREATE USER 'username'@'localhost' IDENTIFIED BY 'password';
mysql> GRANT ALL PRIVILEGES ON database-name.* TO 'user-name'@'localhost';
mysql> FLUSH PRIVILEGES;

//Si vous exécutez le test dans Django
mysql> GRANT ALL PRIVILEGES ON test_django_test.* TO 'mysiteuser'@'localhost';

Paramètres des paramètres Django

Créez un fichier de configuration. Le fichier de configuration est. Bien qu'il s'agisse de ./config/settings.py, créez un fichier de paramètres pour le développement comme suit.

mkdir ./config/settings
touch ./config/settings/__init__.py
touch ./config/settings/base.py
touch ./config/settings/development.py

Définir les paramètres de base

`python:./config/settings/base.py`


import os

###############
# Build paths #
###############

BASE_DIR = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) #Corrigé par changement de fichier
PROJECT_NAME = os.path.basename(BASE_DIR)


############
# Security #
############

DEBUG = False

ALLOWED_HOSTS = []

#################
# Core settings #
#################

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

    #django-allauth
    'allauth',
    'allauth.account',
    'allauth.socialaccount',

    #application principale
    'main.apps.MainConfig',
]

MIDDLEWARE = [
    'django.middleware.security.SecurityMiddleware',
    'django.contrib.sessions.middleware.SessionMiddleware',
    'django.middleware.common.CommonMiddleware',
    'django.middleware.csrf.CsrfViewMiddleware',
    'django.contrib.auth.middleware.AuthenticationMiddleware',
    'django.contrib.messages.middleware.MessageMiddleware',
    'django.middleware.clickjacking.XFrameOptionsMiddleware',
]
ROOT_URLCONF = 'config.urls'

TEMPLATES = [
    {
        'BACKEND': 'django.template.backends.django.DjangoTemplates',
        'DIRS': [
            os.path.join(BASE_DIR, 'templates', 'allauth'), #Endroit pour mettre le modèle de connexion, etc.
            os.path.join(BASE_DIR, 'templates'), #Où mettre le modèle
        ],
        'APP_DIRS': True,
        'OPTIONS': {
            'context_processors': [
                'django.template.context_processors.debug',
                'django.template.context_processors.request',
                'django.contrib.auth.context_processors.auth',
                'django.contrib.messages.context_processors.messages',
            ],
        },
    },
]


WSGI_APPLICATION = 'config.wsgi.application'

##################
# Authentication #
##################

AUTH_USER_MODEL = "main.User" #main/model.Pour utiliser le modèle utilisateur à définir dans py pour l'authentification

#URL de transition après le traitement de la connexion
LOGIN_REDIRECT_URL = 'home'

#URL de transition après le traitement de la déconnexion
ACCOUNT_LOGOUT_REDIRECT_URL = 'home'

AUTHENTICATION_BACKENDS = (
    'django.contrib.auth.backends.ModelBackend',
    'allauth.account.auth_backends.AuthenticationBackend', #Les paramètres de messagerie sont définis dans Utilisateur personnalisé, des paramètres sont donc requis
)

#Définissez la méthode d'authentification sur une adresse e-mail
ACCOUNT_AUTHENTICATION_METHOD = 'email' 

#Demander une adresse e-mail lors de la création d'un compte
ACCOUNT_EMAIL_REQUIRED = True 

#Ne pas envoyer d'e-mail de confirmation d'inscription utilisateur:Lors de l'envoi'option'
ACCOUTN_EMAIL_VERIFICATION = 'none'

#N'utilisez pas le nom de l'utilisateur (puisque ce qui suit est commenté, ce projet l'exige lors de la création d'un compte: par défaut)
#ACCOUNT_USERNAME_REQUIRED = False 

#Avec le bouton de déconnexion, vous pouvez immédiatement passer à la destination de la redirection sans passer à l'écran de déconnexion.
ACCOUNT_LOGOUT_ON_GET = True 

#all-authentification utilisée pour déterminer le site
SITE_ID = 1

############
# Database #
############

DATABASES = {}


############
# Messages #
############

MESSAGE_STORAGE = 'django.contrib.messages.storage.session.SessionStorage'

###########
# Logging #
###########

LOGGING = {}

#######################
# Password validation #
#######################

AUTH_PASSWORD_VALIDATORS = [
    {
        'NAME': 'django.contrib.auth.password_validation.UserAttributeSimilarityValidator',
    },
    {
        'NAME': 'django.contrib.auth.password_validation.MinimumLengthValidator',
    },
    {
        'NAME': 'django.contrib.auth.password_validation.CommonPasswordValidator',
    },
    {
        'NAME': 'django.contrib.auth.password_validation.NumericPasswordValidator',
    },
]


########################
# Internationalization #
########################

LANGUAGE_CODE = 'ja' #Set pour le Japon

TIME_ZONE = 'Asia/Tokyo' #Set pour le Japon

USE_I18N = True

USE_L10N = True

USE_TZ = True


################
# Static files #
################

#Définir où placer les fichiers statiques
STATIC_URL = '/static/'
STATICFILES_DIRS = [os.path.join(BASE_DIR, 'static')]
STATIC_ROOT = '/var/www/{}/static'.format(PROJECT_NAME)

#Définissez l'emplacement pour placer le fichier multimédia
MEDIA_URL = '/media/'
MEDIA_ROOT = '/var/www/{}/media'.format(PROJECT_NAME)

Définir les paramètres de développement

`python:./config/settings/development.py`


from .base import *
from script.get_env_dict import env 

#####################
# Security settings #
#####################

DEBUG = True

SECRET_KEY = env['SECRET_KEY']

ALLOWED_HOSTS = ['*']


############
# Database #
############

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.mysql',
        'NAME': env['DB_NAME'], #Nom de la base de données créée
        'USER': env['DB_USER'], #Nom d'utilisateur connexion
        'PASSWORD': env['DB_PASS'],
        'HOST': 'localhost',
        'PORT': '3306',
        'ATOMIC_REQUESTS': True, #transaction
        'OPTIONS': {
            'charset': 'utf8mb4',
            'sql_mode': 'TRADITIONAL,NO_AUTO_VALUE_ON_ZERO,ONLY_FULL_GROUP_BY',
        },
        "TEST": {
            'NAME' : 'test_django_test'
        }
    }
}

###########
# Logging #
###########

LOGGING = {
    #La version est fixée à "1"
    'version': 1,
    #Ne pas invalider les paramètres de journal existants
    'disable_existing_loggers': False,
    #Format du journal
    'formatters': {
        #Pour le developpement
        'develop': {
            'format': '%(asctime)s [%(levelname)s] %(pathname)s:%(lineno)d ' '%(message)s'
        },
    },
    #gestionnaire
    'handlers': {
        #Gestionnaire pour la sortie de la console
        'console': {
            'level': 'DEBUG',
            'class': 'logging.StreamHandler',
            'formatter': 'develop',
        },
    },
    #Enregistreur
    'loggers': {
        #Un enregistreur qui récupère les journaux pour toutes vos propres applications
        '': {
            'handlers': ['console'],
            'level': 'DEBUG',
            'propagate': False,
        },
        #Un enregistreur qui récupère tous les journaux de Django lui-même
        'django-test': {
            'handlers': ['console'],
            'level': 'INFO',
            'propagate': False,
        },
    },
}

################
# Static files #
################

STATIC_ROOT = os.path.join(BASE_DIR, 'static-root')
MEDIA_ROOT = os.path.join(BASE_DIR, 'media')

##################
# Email settings #
##################

EMAIL_BACKEND = 'django.core.mail.backends.console.EmailBackend'

Modifiez ./manage.py afin que development.py soit sélectionné lorsque DEBUG dans le fichier .env a la valeur True.

`python:./manage.py`



#!/usr/bin/env python
"""Django's command-line utility for administrative tasks."""
import os
import sys
from script.get_env_dict import env

def main():
#.Développement lorsque DEBUG du fichier env est True.Charger py
    if env['DEBUG'] == True:
        os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'config.settings.development')
        
    elif env['DEBUG'] == False:
        os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'config.settings.development') ## TODO :Les paramètres liés à l'environnement de production sont décrits séparément.

        
    from django.db.backends.mysql.schema import DatabaseSchemaEditor
    DatabaseSchemaEditor.sql_create_table += " ROW_FORMAT=DYNAMIC"

    try:
        from django.core.management import execute_from_command_line
    except ImportError as exc:
        raise ImportError(
            "Couldn't import Django. Are you sure it's installed and "
            "available on your PYTHONPATH environment variable? Did you "
            "forget to activate a virtual environment?"
        ) from exc
    execute_from_command_line(sys.argv)


if __name__ == '__main__':
    main()

Essayez d'afficher la page d'accueil !!

Créer un routage d'URL

Ici, définissez le modèle d'URL sur l'écran de gestion de projet, l'écran tel que la connexion dans django-allauth et l'écran lié à main / urls.py.

`python:./config/urls.py`


from django.contrib import admin
from django.urls import path, include
from script.get_env_dict import env
from django.conf import settings
from django.conf.urls.static import static

urlpatterns = [
    path('admin/', admin.site.urls), #Écran de gestion de projet
    path('accounts/', include('allauth.urls')), #Fonctions de gestion de compte telles que la connexion
    path('', include('main.urls')), #Chose sur l'application principale telle que l'écran d'accueil
]+ static(settings.MEDIA_URL, document_root=settings.MEDIA_ROOT)

Définissez l'URL d'écran de l'application principale.

./main Puisque urls.py n'est pas inclus dans l'application, créez urls.py

Lors de l'enregistrement d'un nom d'utilisateur, une restriction par expression régulière (username_regex) et une restriction sur le nombre minimum de caractères (MinLengthValidator) sont ajoutées comme fonctions de validation.

touch ./main/urls.py

Définissez le chemin d'accès à l'écran d'accueil.

`urls.py`


from django.contrib import admin
from django.views.generic import TemplateView
from django.urls import path, include
from main import views

urlpatterns = [
    path('', TemplateView.as_view(template_name="main/home.html"), name='home'),
]

Créer un modèle utilisateur pour la fonction de connexion

En tant que modèle d'utilisateur, le nom d'utilisateur et l'adresse e-mail requis pour la création de compte sont définis. Ici, les caractères pouvant être utilisés pour le nom d'utilisateur sont limités.

`python:./main/models.py`


from django.db import models
from django.contrib.auth.models import AbstractUser
from django.contrib.auth.validators import UnicodeUsernameValidator
from django.core.validators import MinLengthValidator, RegexValidator
from django.utils.translation import gettext_lazy as _ #Pour l'internationalisation telle que la fonction de traduction


class User(AbstractUser):
    """Custom user to perform authentication by email """
    username_validator = UnicodeUsernameValidator()
    username_regex = RegexValidator(regex=r'^[a-zA-Z0-9][a-zA-Z0-9\-]+', message="Les caractères qui ne peuvent pas être utilisés dans le nom d'utilisateur sont spécifiés.")
    username = models.CharField(_('username'), max_length=150, unique=True,
        help_text=_('Required. 150 characters or fewer. Letters, digits and @/./+/-/_ only.'),
        validators=[username_validator, username_regex, MinLengthValidator(5)],
        error_messages={
            'unique': _("A user with that username already exists."),
        },
    )
    email = models.EmailField('emial address', unique=True)

Migration de base de données

Étant donné que le modèle utilisateur est défini dans models.py, la migration est effectuée.


//Démarrage de la base de données
mysql.server start

//Créer un fichier de migration
./manage.py makemigrations

//Migrer vers DB
./manage.py migrate

Si vous faites une erreur dans le modèle et migrez à nouveau la base de données, et si vous pouvez supprimer la base de données pendant le développement, vous pouvez l'initialiser avec la commande suivante.


//Supprimer le fichier de migration
find . -path "*/migrations/0*.py" -delete
find . -path "*/migrations/__pycache__/0*.pyc" -delete

//Supprimer / réinitialiser la base de données
mysql -u root -p

mysql> drop database database-name;
mysql>create database database-name;
mysql>exit;

mysql.server restart

Créer un modèle de maison

Créez le jeu main / home.html dans ./main/urls.py.

mkdir ./templates/main
touch ./templates/main/home.html

<!DOCTYPE html>
<html lang="js">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>Document</title>
</head>
<body>
    <h1>Hello djanog !!</h1>
</body>
</html>

Afficher la page d'accueil

Démarrez le serveur avec la commande suivante

./manage.py runserver

Si vous accédez à http: // localhost: 8000 / dans votre navigateur, vous devriez voir un écran qui dit Hello djanog !!. De plus, si vous accédez à http: // localhost: 8000 / accounts / signup /, l'écran de création de compte s'affiche. De plus, si vous accédez à http: // localhost: 8000 / accounts / login /, l'écran de connexion s'affiche.

Par exemple, l'écran suivant s'affiche. スクリーンショット 2019-08-16 23.41.31.png

Les références

Pour de nombreuses parties de cet article, j'ai fait référence aux manuels suivants. Peut-être que cet article seul ne suffit pas à compléter, alors achetez les livres suivants !! C'est un très bon livre.

[Manuels Django utilisables sur le terrain << Basics >>](https://www.amazon.co.jp/%E7%8F%BE%E5%A0%B4%E3%81%A7%E4%BD % BF% E3% 81% 88% E3% 82% 8B-Django-% E3% 81% AE% E6% 95% 99% E7% A7% 91% E6% 9B% B8% E3% 80% 8A% E5% 9F% BA% E7% A4% 8E% E7% B7% A8% E3% 80% 8B-% E6% A8% AA% E7% 80% AC-% E6% 98% 8E% E4% BB% 81 / dp / 4802094744)

Démarrer un projet Django