Einführung

In diesem Artikel erstellen wir ein Django-Projekt, zeigen den Startbildschirm, den Kontoerstellungsbildschirm und den Anmeldebildschirm an. Die meisten von ihnen sind persönliche Notizen, aber ich hoffe, Sie finden sie hilfreich. Der Betrieb kann nicht garantiert werden.

Die Authentifizierung verwendet django-allauth. Das Bearbeiten und Testen des Bildschirms mit django-allauth wird unter Erstellen eines Anmeldebildschirms mit Django allauth beschrieben.

Installation / Registrierung

Python installieren
Mit Streifen registrieren Sie müssen es nicht verwenden, wenn Sie es nicht verwenden.

Starten Sie ein Projekt

Erstellen Sie den Speicherort des Django-Projekts mit dem folgenden Befehl.

mkdir ec-django

Erstellen Sie eine virtuelle Umgebung für Python und installieren Sie die erforderlichen Pakete.

cd ec-django/

python -m venv venv

//Betreten Sie die virtuelle Umgebung
source venv/bin/activate

//Paketinstallation in einer virtuellen Umgebung
pip install Django==2.2
pip install django-allauth==0.39.1 //Authentifizierungsfunktionen wie die Anmeldefunktion
pip install django-environ==0.4.5 //Umgebungsvariablen.Aus der env-Datei lesen
pip install mysqlclient==1.4.4 //Für MySQL-Datenbank
//pip install stripe==2.35.0 //Zahlungsfunktion per Streifen

Erstellen Sie ein Projekt.


django-admin startproject config .

Erstellen Sie eine App (main), die Benutzer verwaltet.


./manage.py  startapp main

Erstellen Sie andere erforderliche Verzeichnisse.

//Verzeichnis der Python-Dateien zur einfachen Verarbeitung
mkdir script
touch ./script/__init__.py

//Vorlagendatei(.HTML usw.)Verzeichnis zu setzen
mkdir templates

//Verzeichnis zum Ablegen statischer Dateien
mkdir static

Umgebungsvariablen mit env-Datei festlegen

Erstellen einer .env-Datei


touch .env

Umgebungsvariablen werden der folgenden .env-Datei jedes Mal hinzugefügt, wenn eine Funktion hinzugefügt wird. Wenn Sie es im Internet wie git veröffentlichen, achten Sie darauf, es nicht hochzuladen.

`.env`


DEBUG=Ture

SECRET_KEY=<django-secret-key> //./config/setting.py geheimer Schlüssel

//Im Folgenden sind die Einstellungen für die Datenbank aufgeführt. (Entspricht der in der zweiten Hälfte des Artikels festgelegten Datenbank.)
DB_NAME=databese-name
DB_USER=user-name
DB_PASS=password

Erstellen Sie ein Programm, das Umgebungsvariablen liest. Das folgende Programm liest auch die DB-Informationen und den Pfad zum Basisverzeichnis des Django-Projekts, das später in diesem Artikel festgelegt wird.

import environ
import os
from config.settings.base import BASE_DIR #Später eingestellt

import logging
logger = logging.getLogger(__file__)

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

        #weniger als,.Schreiben Sie über die Parameter, die aus der env-Datei gelesen werden sollen.
        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('Ein Schlüssel, der nicht gesetzt wurde, wird gesetzt: {}'.format(e))
        
    except Exception as e:
        logger.info('Fehler beim Einstellen der Umgebungsvariablen: {e}'.format(e))
    
    return env
        

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

Richten Sie die MySQL-Datenbank ein

Ich bezog mich auf Folgendes. Djangos DATABASE-Einstellungen, die ich immer mache, wenn ich MySQL (utf8mb4) mit Django verwende MySQL-Setup auf 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

//Datenbank mit DB-Namen-name,Benutzername Benutzer-name,Passwort Passwort

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;

//Wenn Sie den Test in Django ausführen
mysql> GRANT ALL PRIVILEGES ON test_django_test.* TO 'mysiteuser'@'localhost';

Django-Parametereinstellungen

Erstellen Sie eine Konfigurationsdatei. Die Einstellungsdatei ist. Obwohl es sich um ./config/settings.py handelt, erstellen Sie eine Einstellungsdatei für die Entwicklung wie folgt.

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

Grundparameter einstellen

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


import os

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

BASE_DIR = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) #Durch Dateiänderung behoben
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',

    #Haupt-App
    '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'), #Platz zum Einfügen der Anmeldevorlage usw.
            os.path.join(BASE_DIR, 'templates'), #Wo soll die Vorlage abgelegt werden?
        ],
        '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.So verwenden Sie das Benutzermodell, das für die Authentifizierung in py festgelegt wird

#URL zum Übergang nach der Anmeldeverarbeitung
LOGIN_REDIRECT_URL = 'home'

#URL zum Übergang nach der Abmeldeverarbeitung
ACCOUNT_LOGOUT_REDIRECT_URL = 'home'

AUTHENTICATION_BACKENDS = (
    'django.contrib.auth.backends.ModelBackend',
    'allauth.account.auth_backends.AuthenticationBackend', #E-Mail-Einstellungen werden im benutzerdefinierten Benutzer vorgenommen, daher sind Einstellungen erforderlich
)

#Stellen Sie die Authentifizierungsmethode auf eine E-Mail-Adresse ein
ACCOUNT_AUTHENTICATION_METHOD = 'email' 

#Fordern Sie beim Erstellen eines Kontos eine E-Mail-Adresse an
ACCOUNT_EMAIL_REQUIRED = True 

#Senden Sie keine Bestätigungs-E-Mail zur Benutzerregistrierung:Wenn du sendest'option'
ACCOUTN_EMAIL_VERIFICATION = 'none'

#Verwenden Sie keinen USER-Namen (Da Folgendes auskommentiert ist, erfordert dieses Projekt dies beim Erstellen eines Kontos: Standard)
#ACCOUNT_USERNAME_REQUIRED = False 

#Mit der Schaltfläche Abmelden können Sie sofort zum Umleitungsziel wechseln, ohne zum Abmeldebildschirm zu wechseln.
ACCOUNT_LOGOUT_ON_GET = True 

#all-auth wird verwendet, um die Site zu bestimmen
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 für Japan

TIME_ZONE = 'Asia/Tokyo' #Set für Japan

USE_I18N = True

USE_L10N = True

USE_TZ = True


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

#Legen Sie fest, wo statische Dateien abgelegt werden sollen
STATIC_URL = '/static/'
STATICFILES_DIRS = [os.path.join(BASE_DIR, 'static')]
STATIC_ROOT = '/var/www/{}/static'.format(PROJECT_NAME)

#Legen Sie den Speicherort für die Mediendatei fest
MEDIA_URL = '/media/'
MEDIA_ROOT = '/var/www/{}/media'.format(PROJECT_NAME)

Parameter für die Entwicklung einstellen

`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'], #Datenbankname erstellt
        'USER': env['DB_USER'], #Login Benutzername
        'PASSWORD': env['DB_PASS'],
        'HOST': 'localhost',
        'PORT': '3306',
        'ATOMIC_REQUESTS': True, #Transaktion
        'OPTIONS': {
            'charset': 'utf8mb4',
            'sql_mode': 'TRADITIONAL,NO_AUTO_VALUE_ON_ZERO,ONLY_FULL_GROUP_BY',
        },
        "TEST": {
            'NAME' : 'test_django_test'
        }
    }
}

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

LOGGING = {
    #Die Version ist auf "1" festgelegt.
    'version': 1,
    #Machen Sie vorhandene Protokolleinstellungen nicht ungültig
    'disable_existing_loggers': False,
    #Protokollformat
    'formatters': {
        #Zur Entwicklung
        'develop': {
            'format': '%(asctime)s [%(levelname)s] %(pathname)s:%(lineno)d ' '%(message)s'
        },
    },
    #Handler
    'handlers': {
        #Handler für die Konsolenausgabe
        'console': {
            'level': 'DEBUG',
            'class': 'logging.StreamHandler',
            'formatter': 'develop',
        },
    },
    #Logger
    'loggers': {
        #Ein Logger, der Protokolle für alle Ihre eigenen Anwendungen aufnimmt
        '': {
            'handlers': ['console'],
            'level': 'DEBUG',
            'propagate': False,
        },
        #Ein Logger, der alle Logs von Django selbst aufnimmt
        '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'

Ändern Sie ./manage.py so, dass development.py ausgewählt wird, wenn DEBUG in der .env-Datei True ist.

`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():
#.Entwicklung, wenn DEBUG der env-Datei True ist.Laden Sie 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 :Einstellungen in Bezug auf die Produktionsumgebung werden separat beschrieben.

        
    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()

Versuchen Sie die Homepage anzuzeigen !!

URL-Routing erstellen

Stellen Sie hier das URL-Muster auf den Projektverwaltungsbildschirm, den Bildschirm wie Anmelden in django-allauth und den Bildschirm für main / urls.py ein.

`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), #Projektmanagement-Bildschirm
    path('accounts/', include('allauth.urls')), #Kontoverwaltungsfunktionen wie Login
    path('', include('main.urls')), #Sache über Hauptanwendung wie Startbildschirm
]+ static(settings.MEDIA_URL, document_root=settings.MEDIA_ROOT)

Stellen Sie die Bildschirm-URL für die Haupt-App ein.

./main Da urls.py nicht in der App enthalten ist, erstellen Sie urls.py

Bei der Registrierung eines Benutzernamens werden eine Einschränkung durch reguläre Ausdrücke (username_regex) und eine Einschränkung der Mindestanzahl von Zeichen (MinLengthValidator) als Validierungsfunktionen hinzugefügt.

touch ./main/urls.py

Stellen Sie den Pfad zum Startbildschirm ein.

`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'),
]

Erstellen Sie ein Benutzermodell für die Anmeldefunktion

Als Benutzermodell werden Benutzername und E-Mail-Adresse festgelegt, die für die Kontoerstellung erforderlich sind. Hier sind die Zeichen, die für den Benutzernamen verwendet werden können, eingeschränkt.

`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 _ #Zur Internationalisierung wie Übersetzungsfunktion


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="Zeichen, die im Benutzernamen nicht verwendet werden können, werden angegeben.")
    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)

Datenbankmigration

Da das Benutzermodell in models.py festgelegt ist, wird die Migration durchgeführt.


//DB-Start
mysql.server start

//Erstellen einer Migrationsdatei
./manage.py makemigrations

//In DB migrieren
./manage.py migrate

Wenn Sie im Modell einen Fehler machen und die Datenbank erneut migrieren und die Datenbank während der Entwicklung löschen können, können Sie sie mit dem folgenden Befehl initialisieren.


//Migrationsdatei löschen
find . -path "*/migrations/0*.py" -delete
find . -path "*/migrations/__pycache__/0*.pyc" -delete

//Datenbank löschen / zurücksetzen
mysql -u root -p

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

mysql.server restart

Erstellen Sie eine Home-Vorlage

Erstellen Sie die Datei main / home.html in ./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>

Homepage anzeigen

Starten Sie den Server mit dem folgenden Befehl

./manage.py runserver

Wenn Sie in Ihrem Browser auf http: // localhost: 8000 / zugreifen, sollte ein Bildschirm mit der Aufschrift Hello djanog !! angezeigt werden. Wenn Sie auf http: // localhost: 8000 / accounts / signup / zugreifen, wird der Bildschirm zur Kontoerstellung angezeigt. Wenn Sie auf http: // localhost: 8000 / accounts / login / zugreifen, wird der Anmeldebildschirm angezeigt.

Beispielsweise wird der folgende Bildschirm angezeigt. スクリーンショット 2019-08-16 23.41.31.png

Verweise

Für viele Teile dieses Artikels habe ich auf die folgenden Lehrbücher verwiesen. Vielleicht reicht dieser Artikel nicht aus, um ihn zu ergänzen. Kaufen Sie also die folgenden Bücher! Es ist ein wirklich gutes Buch.

[Django-Lehrbücher, die im Feld << Basics >>] verwendet werden können (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)

[PYTHON] Starten Sie ein Django-Projekt