Aplikasi pengurusan akaun Django (pendaftaran dan pengaktifan

Apa yang diharapkan daripada artikel ini?

Kami telah mencipta struktur rangka projek dalam artikel sebelumnya, artikel ini akan membinanya. ia akan meliputi

• Struktur pangkalan data akaun, termasuk pengguna dan kod pengesahan.
• Penyeri bersiri model.
• Pandangan Akaun untuk pendaftaran akaun, pengaktifan. artikel seterusnya hendaklah merangkumi paparan yang lain, seperti log masuk, menyegarkan token, menukar kata laluan, melupakan kata laluan dan menghantar semula kod.

Saya akan cuba mengupas sebanyak mungkin butiran tanpa membosankan anda, tetapi saya masih mengharapkan anda membiasakan diri dengan beberapa aspek Python dan Django.

versi akhir kod sumber boleh didapati di https://github.com/saad4software/alive-diary-backend

Pesanan siri

Semak artikel sebelum ini jika berminat!

1. Projek AI dari Scratch, The Idea, Alive Diary
2. Buktikan ia boleh dilaksanakan dengan Google AI Studio
3. Persediaan Projek API Django
4. Apl pengurusan akaun Django (1), pendaftaran dan pengaktifan (Anda di sini ?)

Persediaan apl akaun

mari buat fail penyeri dalam apl

from rest_framework import serializers
from app_account.models import *

app_account/serializers.py

dan fail url

from django.urls import path, include
from .views import *

urlpatterns = [

]

app_account/urls.py

akhirnya, mari sambungkan url apl ke url projek dengan mengedit fail url projek sebagai

from django.contrib import admin
from django.urls import path, include

urlpatterns = [
    path('admin/', admin.site.urls),
    path('api/account/', include('app_account.urls')),

]

alive_diary/urls.py

Kini kami boleh menghubungi mana-mana url akaun dengan awalan "api/account/"

Para Model

model utama untuk apl akaun ialah model Pengguna sudah tentu

from django.db import models
from django.contrib.auth.models import AbstractUser
from datetime import timedelta, datetime

class User(AbstractUser):
    userTypes = (
        ('A', 'Admin'),
        ('C', 'Client'),
    )

    role = models.CharField(max_length=1, choices=userTypes, default="C")

    hobbies = models.CharField(max_length=255, null=True, blank=True)
    job = models.CharField(max_length=100, null=True, blank=True)
    bio = models.TextField(null=True, blank=True)

    country_code = models.CharField(max_length=10, null=True, blank=True)
    expiration_date = models.DateTimeField(default=datetime.now()+timedelta(days=30))

app_account/models.py

Biasanya, adalah lebih baik untuk memastikan model Pengguna semudah mungkin dan mengalihkan butiran lain ke model Profil dengan perhubungan satu dengan satu dengan Pengguna, tetapi untuk memudahkan perkara, saya akan menambah maklumat pengguna yang diperlukan terus kepada model Pengguna kali ini.

Kami mewarisi model AbstractUser, AbstractUser termasuk berbilang medan

class AbstractUser(AbstractBaseUser, PermissionsMixin):
    username = models.CharField(...)
    first_name = models.CharField(...)
    last_name = models.CharField(...)
    email = models.EmailField(...)
    is_staff = models.BooleanField(...)
    is_active = models.BooleanField(...),
    date_joined = models.DateTimeField(...)

yang paling penting ialah:

• nama pengguna akan digunakan untuk log masuk.
• is_active akan digunakan untuk menghalang akaun yang tidak disahkan daripada log masuk.
• is_staff akan membezakan admin (dengan nilai benar) daripada pengguna biasa.

Kami juga telah menambah berbilang medan untuk pengguna projek ini iaitu

• peranan untuk membezakan pentadbir daripada akaun pelanggan, kami boleh menggunakan is_staff untuk projek mudah ini kerana kami hanya mempunyai dua peranan, tetapi projek yang lebih besar boleh mempunyai lebih daripada 2 peranan, menjadikan medan ini penting untuk pengendalian kebenaran.
• hobi, pekerjaan, bio Mengetahui lebih lanjut tentang pengguna boleh membantu membina refleksi yang lebih baik, oleh itu kami meminta hobi, pekerjaan dan cara pengguna menggambarkan dirinya.
• kod_negara untuk statistik
• tarikh tamat tempoh untuk tarikh tamat tempoh berasaskan langganan.

Kami juga memerlukan model kod Pengesahan untuk menyimpan dan menjejaki kod pengesahan untuk pengaktifan akaun, melupakan kata laluan dan menghantar semula kod.

from rest_framework import serializers
from app_account.models import *

app_account/models.py

Ia bersambung dengan model Pengguna dan menjana nilai rawak nombor kod 6 digit. ia juga mempunyai masa tamat tempoh 24 jam. kami juga telah memfailkan e-mel sekiranya pengguna ingin mengesahkan berbilang alamat e-mel, ia jarang berlaku dan boleh dialih keluar untuk apl ini. Mari beralih ke penyeri bersiri seterusnya.

API Pendaftaran

mari mulakan dengan serializer

from django.urls import path, include
from .views import *

urlpatterns = [

]

app_account/serializers.py

Kami menggunakan ModelSerializer, daripada rangka kerja rehat Django. kami memilih model pengguna get_user_model() dalam kelas Meta dan senarai medan bersiri.

Kami telah menambah dua medan tambahan pada model bersiri, kata laluan1 dan kata laluan2. Untuk mengesahkan ia mempunyai nilai yang sama, kami telah menimpa kaedah pengesahan. dan untuk menguatkuasakan menggunakan e-mel yang sah sebagai nama pengguna, kami telah menambah pengesah medan untuk medan nama pengguna.
fungsi is_valid_email sepatutnya kelihatan seperti ini

from django.contrib import admin
from django.urls import path, include

urlpatterns = [
    path('admin/', admin.site.urls),
    path('api/account/', include('app_account.urls')),

]

common/utils.py

Secara peribadi, saya tidak suka ungkapan biasa, saya tidak pernah memahaminya, tetapi ia nampaknya merupakan cara terbaik untuk mengesahkan e-mel. Jika anda mendapat cara yang lebih baik, sila kongsi dengan kami.

Memandangkan medan baharu kami kata laluan1 dan kata laluan2 bukan milik model pengguna asal, kami mengalih keluarnya daripada kamus data dan menambah medan kata laluan untuk menggunakan data penyeri terus untuk mencipta pengguna baharu.

Dilema amalan terbaik Serializer

• Adakah penyeri bersiri menggunakan pertanyaan pangkalan data dan mengedit pangkalan data?
• atau patutkah mereka hanya membuat pengesahan jenis medan asas (rentetan, integer, ...)?

Sebenarnya tiada jawapan yang jelas, contohnya, penyeri model rangka kerja Django Rest nampaknya membuat pertanyaan untuk medan unik, seperti ralat penyeri yang kami dapat apabila cuba mencipta penggunaan dengan nama yang sama, ia dihasilkan oleh penyeri, bukan pandangan.
Kaedah Cipta, Simpan, Kemas kini menulis nilai ke pangkalan data.
Namun, mengakses pangkalan data hanya dalam paparan nampaknya lebih sejajar dengan Pemisahan Kebimbangan dan Fleksibiliti.

Apa yang anda rasa lebih baik?

Saya telah banyak membaca tentang mengasingkan perkara, malah mengasingkan pertanyaan pangkalan data daripada kaedah mengemas kini pangkalan data. jadi mari kita cuba lakukan itu. mencipta AccountActivateView dalam fail views.py sepatutnya kelihatan seperti.

Dalam kes kami, kami boleh menulis ganti kaedah cipta untuk RegisterSerializer untuk mencipta pengguna baharu dan kod pengesahan serta-merta, malah menghantar kod pengesahan daripada serializer.

Tetapi sebaliknya, saya akan mengekalkan operasi berkaitan model dalam fail paparan

Jom beralih ke paparan pendaftaran

from rest_framework import serializers
from app_account.models import *

app_account/views.py

Kami menggunakan CreatAPIView daripada rangka kerja yang lain, ia menerima permintaan POST dengan skema serializer_class, BrowsableAPIRenderer membina antara muka web untuk API ini dan JSONRenderer bertanggungjawab untuk membina respons JSON.

Menulis ganti kaedah perform_create membolehkan kami mengawal mekanisme penciptaan pengguna, kami mencipta segera pengguna, memastikan medan is_active ditetapkan kepada False, kemudian mencipta segera kod pengesahan yang disambungkan kepada model pengguna baharu, dan akhirnya menghantar e-mel dengan kod pengesahan kepada pengguna.

Menghantar e-mel memerlukan konfigurasi yang betul untuk medan e-mel dalam fail tetapan, sila beritahu saya jika anda menghadapi masalah dalam perkara ini untuk membuat artikel berasingan untuknya

Akhir sekali, mari tambah url API

from django.urls import path, include
from .views import *

urlpatterns = [

]

app_account/urls.py

Bagus, jom cuba

from django.contrib import admin
from django.urls import path, include

urlpatterns = [
    path('admin/', admin.site.urls),
    path('api/account/', include('app_account.urls')),

]

membuka http://localhost:8555/api/account/register, kita sepatutnya dapat melihat sesuatu seperti ini (ia disebabkan oleh BrowsableAPIRenderer)

medan yang diperlukan ialah nama pengguna, kata laluan1 dan kata laluan2, kami menjangkakan e-mel tersebut akan digunakan sebagai nama pengguna.
ia kelihatan baik, ia mencipta model pengguna dengan model kod pengesahan yang disambungkan kepadanya (menggunakan SqlBrowser untuk membuka fail db SQLite). Tetapi respons lalai kelihatan seperti ini dengan status 201.

from django.db import models
from django.contrib.auth.models import AbstractUser
from datetime import timedelta, datetime

class User(AbstractUser):
    userTypes = (
        ('A', 'Admin'),
        ('C', 'Client'),
    )

    role = models.CharField(max_length=1, choices=userTypes, default="C")

    hobbies = models.CharField(max_length=255, null=True, blank=True)
    job = models.CharField(max_length=100, null=True, blank=True)
    bio = models.TextField(null=True, blank=True)

    country_code = models.CharField(max_length=10, null=True, blank=True)
    expiration_date = models.DateTimeField(default=datetime.now()+timedelta(days=30))

Saya Lebih suka semua respons mempunyai skema ini

class AbstractUser(AbstractBaseUser, PermissionsMixin):
    username = models.CharField(...)
    first_name = models.CharField(...)
    last_name = models.CharField(...)
    email = models.EmailField(...)
    is_staff = models.BooleanField(...)
    is_active = models.BooleanField(...),
    date_joined = models.DateTimeField(...)

• status hendaklah sama ada "berjaya" atau "ralat"
• kod ialah kod status respons
• data ialah data respons sebenar
• mesej harus mengandungi teks ralat atau sebarang mesej lain

Tetapi bagaimana untuk melakukannya?
Cara terbaik ialah dengan melaksanakan fungsi JSON renderer tersuai. jom buat

import random

class VerificationCode(models.Model):
    user = models.ForeignKey(User, on_delete=models.CASCADE)
    code = models.CharField(max_length=6, default=random.randint(111111, 999999))
    email = models.EmailField()
    expiration_date = models.DateTimeField(default=datetime.now()+timedelta(days=1))

    def __str__(self):
        return self.user.username

common/utils.py

Kami mewarisi daripada JSONRenderer dan menimpa kaedah pemaparan. ralat penyeri bersiri.

• bermula dengan membaca kod status respons dan meletakkannya dalam medan kod
• dan kami mengalihkan data respons sebenar ke medan data dalam skema respons kami
• untuk membezakan ralat daripada respons yang berjaya, kami menyemak kod status. Jika kod status adalah dalam keluarga 200, ia adalah respons yang berjaya
• jika tidak, ia adalah satu kesilapan. jadi kami menukar status kepada "ralat", dan mengekstrak mesej ralat daripada medan butiran respons (jika ada).
• Ralat pengesahan serializer tidak mempunyai medan butiran, ia ialah kamus yang menunjukkan mesej ralat (nilai) untuk setiap nama medan (kunci), jadi kami mencipta fungsi kecil dict2string untuk menukarnya kepada rentetan ringkas. Saya rasa ia boleh dipertingkatkan lagi, bolehkah anda membantu dengannya?

itu sahaja untuk skema respons, mari cuba gunakannya sekarang!
dalam views.py tambahkan pemapar tersuai kami pada kelas paparan daftar

from rest_framework import serializers
from app_account.models import *

app_account/views.py

menjalankan pelayan, dan membuka http://localhost:8555/api/account/register/ menunjukkan perbezaan secara langsung

kita boleh lihat skema kita dalam mesej ralat ?, baik, mari cuba daftarkan pengguna baharu, saya akan panggil "test5@gmail.com"

nampak hebat, sekarang mari kita uji ralat pengesahan serializer, kami akan cuba mendaftarkan pengguna yang sama sekali lagi

Hebat, ini adalah respons ralat pengesahan, ia telah disiri sebagai medan:mesej
apa yang berlaku selepas pendaftaran? ia adalah pengesahan
daftar -> sahkan e-mel -> log masuk -> apapun

API Pengaktifan

Kami ingin menyemak sama ada pengguna mendapat kod pengaktifan yang kami hantar semasa pendaftaran atau tidak, jika pengguna menghantar kod yang betul, kami akan mengaktifkan akaun mereka, jika tidak, kami akan meminta mereka menyemaknya semula, atau mungkin hantar semula kod (API lain untuk kemudian)
Sama seperti proses penciptaan API pendaftaran, mari kita mulakan dengan serializer

from django.urls import path, include
from .views import *

urlpatterns = [

]

Ini tidak berkaitan dengan model pangkalan data tertentu, jadi kami mewarisi daripada Serializer generik, perhatikan bahawa serializer adalah serupa dengan borang, jadi kami menetapkan medan dan peraturan pengesahannya.
Kami menggunakan dua medan rentetan (CharField), kedua-duanya diperlukan, nama pengguna iaitu alamat e-mel pengguna dan kod.

from django.contrib import admin
from django.urls import path, include

urlpatterns = [
    path('admin/', admin.site.urls),
    path('api/account/', include('app_account.urls')),

]

app_account/views.py

Memandangkan kami menggunakan paparan API tersuai, kami mewarisi daripada APIView, ia menawarkan 5 fungsi (dapatkan, siarkan, letak, padam dan tampal). Kami menyahsiri data permintaan daripada permintaan POST dan mengesahkan jenisnya, kemudian membuat pertanyaan untuk mencari sama ada data yang diberikan wujud atau tidak, jika wujud, kami mengaktifkan pengguna dan mengalih keluar objek kod daripada jadualnya. jika tidak, kami menghantar mesej ralat mengatakan ia adalah "invalid_code". akhirnya, fail URL harus dikemas kini untuk memasukkan URL paparan ini

from rest_framework import serializers
from app_account.models import *

app_account/urls.py

Kini kami boleh membuka URL http://localhost:8555/api/account/activate/, kami menggunakan paparan API tersuai, jadi ia tidak mendapat medan yang diperlukan

Kami boleh mendapatkan kod daripada pangkalan data (untuk tujuan ujian). Permintaan itu sepatutnya kelihatan seperti

from django.urls import path, include
from .views import *

urlpatterns = [

]

Jika semuanya berjalan dengan jayanya, respons sepatutnya kelihatan seperti

from django.contrib import admin
from django.urls import path, include

urlpatterns = [
    path('admin/', admin.site.urls),
    path('api/account/', include('app_account.urls')),

]

Itu sahaja
Mari kita bungkus! Saya tahu kita belum log masuk, tetapi ia menjadi artikel yang sangat panjang, mari kita sambung dalam artikel seterusnya

Nantikan ?

Atas ialah kandungan terperinci Aplikasi pengurusan akaun Django (pendaftaran dan pengaktifan. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!