djangodocs

Django 6.1
Gaeilge
Documentation contents

Fíordheimhniú a shaincheapadh i Django

Tá an fíordheimhniú a thagann le Django go maith go leor don chuid is mó de na cásanna coitianta, ach b'fhéidir go mbeidh riachtanais agat nach gcomhlíonann na réamhshocruithe lasmuigh den bhosca. Éilíonn fíordheimhniú a shaincheapadh i do thionscadail tuiscint a fháil ar na pointí den chóras atá curtha ar fáil atá inleathnaithe nó Soláthraíonn an doiciméad seo sonraí faoi conas is féidir an córas auth a shaincheapadh.

Authentication backends provide an extensible system for when a username and password stored with the user model need to be authenticated against a different service than Django's default.

Is féidir leat do mhúnlaí:ref: `ceadanna saincheaptha <custom-permissions>`a thabhairt ar féidir a sheiceáil trí chóras údaraithe Django.

<auth-custom-user>Is féidir leat: ref: `an tsamhail réamhshocraithe ```Úsáideoir <extending-user>``a leathnú, nó:ref: `samhail iomlán saincheaptha a chur in ionad `.

Foinsí fíordheimhnithe eile

B'fhéidir go mbeidh uaireanta go mbeidh gá duit dul isteach i bhfoinse fíordheimhnithe eile - is é sin, foinse eile ainmneacha úsáideora agus pasfhocail nó modhanna fíordheimhnithe.

Mar shampla, b'fhéidir go bhfuil socrú LDAP ag do chuideachta cheana féin a stóráilíonn ainm úsáideora agus pasfhocal do gach fostaí. Bheadh sé ina fhadhb don riarthóir líonra agus do na húsáideoirí féin araon dá mbeadh cuntais ar leithligh ag úsáideoirí in LDAP agus sna feidhmchláir bhunaithe ar Django.

Mar sin, chun cásanna mar seo a láimhseáil, ligeann córas fíordheimhnithe Django duit foinsí fíordheimhnithe eile a phlugáil isteach. Is féidir leat scéim réamhshocraithe bunaithe ar bhunachar sonraí Django a shárú, nó is féidir leat an córas réamhshocraithe a úsáid i dteannta le córais eile.

Féach an:ref: `tagairt cúltaca fíordheimhniúcháin <authentication-backends-reference>`le haghaidh faisnéise faoi na cúltaca fíordheimhnithe atá san áireamh le Django.

Cúlpháirtithe fíordheimhnithe

Behind the scenes, Django maintains a list of "authentication backends" that it checks for authentication. When somebody calls django.contrib.auth.authenticate() -- as described in How to log a user in -- Django tries authenticating across all of its authentication backends. If the first authentication method fails, Django tries the second one, and so on, until all backends have been attempted.

Sonraítear liosta na gcúltaca fíordheimhnithe atá le húsáid sa shocrú:: AUTHENTICATION_BACKENDS. Ba chóir go mbeadh sé seo ina liosta d'ainmneacha cosáin Python a chuireann in iúl ar ranganna Python a bhfuil a fhios acu conas a fhí Is féidir leis na ranganna seo a bheith áit ar bith ar do chonair Python.

De réir réamhshocraithe, tá :setting: AUTHENTICATION_BACKENDS socraithe go:

Code
["django.contrib.auth.backends.ModelBackend"]

Sin an cúltaca fíordheimhnithe bunúsach a sheiceálann bunachar sonraí úsáideoirí Django agus a cheistionn na ceadanna ionsuite. Ní sholáthraíonn sé cosaint i gcoinne ionsaithe brute force trí aon mheicníocht teorannaithe rátaí. Féadfaidh tú do mheicníocht teorannaithe rátaí féin a chur i bhfeidhm i gcúl saincheaptha auth, nó na meicníochtaí a sholáthraíonn mórchuid na bhfreastalaithe gréasáin a úsáid

Tá an t-ordú de:setting: AUTHENTICATION_BACKENDS tábhachtach, mar sin má tá an t-ainm úsáideora agus an pasfhocal céanna bailí i gcúltaca iolracha, stopfaidh Django le próiseáil ag an gcéad chluiche dearfach.

Má ardaíonn cúltaca eisceacht a:class: ~django.core.exceptions.permissiondenied, teipeann ar fhíordheimhniú láithreach. Ní sheiceálfaidh Django na cúltaca a leanann.

Cúlcheann fíordheimhnithe a scríobh

<authorization_methods>Is aicme é cúltaca fíordheimhnithe a chuireann dhá mhodh riachtanacha i bhfeidhm: get_user (user_id) ``agus ``fíordheimhniú (iarraidh, **dintiúir), chomh maith le sraith cead roghnach a bhaineann le:ref: `modhanna údaraithe `.

Tógann an modh get_user user_id -- a d'fhéadfadh a bheith ina ainm úsáideora, ID bunachar sonraí nó cibé rud, ach caithfidh gurb é a bheith mar phríomh-eochair do réad úsáideora -- agus filleann sé réad úsáideora nó None.

Glacann an modh fíordheimhniú` argóint agus dintiúir ``iarrata mar argóintí eochairfhocal. An chuid is mó den am, beidh cuma seo air:

Code
from django.contrib.auth.backends import BaseBackend


class MyBackend(BaseBackend):
    def authenticate(self, request, username=None, password=None):
        # Check the username/password and return a user.
        ...

Ach d'fhéadfadh sé comhartha a fhíordheimhniú freisin, mar sin:

Code
from django.contrib.auth.backends import BaseBackend


class MyBackend(BaseBackend):
    def authenticate(self, request, token=None):
        # Check the token and return a user.
        ...

Ar aon bhealach, ba cheart do ``fíordheimhniú () ``na dintiúir a fhaigheann sé a sheiceáil agus réad úsáideora a mheaitseálann na dintiúir sin a thabhairt ar ais má tá na dintiúir bail Mura bhfuil siad bailí, ba chóir dó ``None ``a thabhairt ar ais.

Is é request an:class: ~django.http.httpRequest agus d'fhéadfadh sé a bheith None mura gcuirfí ar fáil é chuig:func: ~django.contrib.auth.auth.autenticate (a chuireann ar aghaidh chuig an gcúltaca é).

<user-objects>Tá riarachán Django ceangailte go docht leis an Django: ref: Réad úsáideora `. Mar shampla, chun rochtain a fháil ar an riarachán, caithfidh :attr: `.user.is_staff agus:attr: .user.is_active a bheith True (féach: .adminsite.has_permission le haghaidh sonraí).

Is é an bealach is fearr le déileáil leis seo ná réad Django ``Úsáideoir ``a chruthú do gach úsáideoir atá ann do chúltaca (m.sh., i do eolaire LDAP, do bhunachar sonraí SQL seachtrach, srl.). Is féidir leat script a scríobh chun é seo a dhéanamh roimh ré, nó is féidir le do mhodh “fíordheimhnithe” é a dhéanamh an chéad uair a logálann úsáideoir isteach.

Seo cúltaca sampla a fhíordheimhníonn i gcoinne athróg ainm úsáideora agus pasfhocal atá sainmhínithe i do chomhad settings.py agus a chruthaíonn réad Django ``Úsáideoir ``an chéad uair a fhíordheimhníonn úsáideoir. Sa sampla seo, is sárúsáideoir é an réad Django ``Úsáideoir ``a chruthaítear a bheidh rochtain iomlán aige ar an riarachán:

Code
from django.conf import settings
from django.contrib.auth.backends import BaseBackend
from django.contrib.auth.hashers import check_password
from django.contrib.auth.models import User


class SettingsBackend(BaseBackend):
    """
    Authenticate against the settings ADMIN_LOGIN and ADMIN_PASSWORD.

    Use the login name and a hash of the password. For example:

    ADMIN_LOGIN = 'admin'
    ADMIN_PASSWORD = 'pbkdf2_sha256$30000$Vo0VlMnkR4Bk$qEvtdyZRWTcOsCnI/oQ7fVOu1XAURIZYoOZ3iq8Dr4M='
    """

    def authenticate(self, request, username=None, password=None):
        login_valid = settings.ADMIN_LOGIN == username
        pwd_valid = check_password(password, settings.ADMIN_PASSWORD)
        if login_valid and pwd_valid:
            try:
                user = User.objects.get(username=username)
            except User.DoesNotExist:
                # Create a new user. There's no need to set a password
                # because only the password from settings.py is checked.
                user = User(username=username)  # is_active defaults to True.
                user.is_staff = True
                user.is_superuser = True
                user.save()
            return user
        return None

    def get_user(self, user_id):
        try:
            return User.objects.get(pk=user_id)
        except User.DoesNotExist:
            return None

Údarú láimhseála i gcúltaca saincheap

Is féidir le cúltaca saincheaptha auth a gceadanna féin a sholáthar.

The user model and its manager will delegate permission lookup functions (get_user_permissions(), get_group_permissions(), get_all_permissions(), has_perm(), has_module_perms(), and with_perm()) to any authentication backend that implements these functions.

Is iad na ceadanna a thugtar don úsáideoir ná superset de na ceadanna go léir a chuireann gach cúltaca ar ais. Is é sin, tugann Django cead d'úsáideoir a dheonaíonn aon chúltaca amháin.

If a backend raises a PermissionDenied exception in has_perm() or has_module_perms(), the authorization will immediately fail and Django won't check the backends that follow.

D'fhéadfadh cúltaca ceadanna a chur i bhfeidhm don riarachán draíochta mar seo:

Code
from django.contrib.auth.backends import BaseBackend


class MagicAdminBackend(BaseBackend):
    def has_perm(self, user_obj, perm, obj=None):
        return user_obj.username == settings.ADMIN_LOGIN

Tugann sé seo ceadanna iomlána don úsáideoir a deonaíodh rochtain sa sampla thuas. Tabhair faoi deara, chomh maith leis na hargóintí céanna a thugtar do na feidhmeanna comhcheangail:class: Django.Contrib.Auth.Models.User, glacann na feidhmeanna cúltaca an réad úsáideora, a d'fhéadfadh a bheith ina úsáideoir gan ainm, mar argóint.

Is féidir cur i bhfeidhm iomlán údaraithe a fháil sa rang ModelBackend in:source: django/contrib/auth/backends.py, arb é an cúltaca réamhshocraithe agus fiosraíonn sé an tábla auth_permission` an chuid is mó den am.

Údarú d'úsáideoirí gan ainm

Is é úsáideoir gan ainm ceann nach bhfuil fíordheimhnithe i.e. níor sholáthraíonn siad aon sonraí fíordheimhnithe bailí. Mar sin féin, ní gá go gciallaíonn sé sin nach bhfuil údaraithe acu aon rud a dhéanamh. Ag an leibhéal is bunúsaí, údaraíonn an chuid is mó de na suíomhanna Gréasáin úsáideoirí gan ainm an chuid is mó den suíomh a bhrabhsáil, agus ceadaíonn go leor tuairimí a phostá

Níl áit ag creat ceada Django chun ceadanna a stóráil d'úsáideoirí gan ainm. Mar sin féin, b'fhéidir gurb é an réad úsáideora a chuirtear chuig cúltaca fíordheimhnithe ná: class: django.contrib.auth.models.anonymousUser réad, rud a ligeann don chúltaca iompar údaraithe saincheaptha a shonrú d'úsáideoirí gan ainm. Tá sé seo úsáideach go háirithe d'údair aipeanna in-athúsáidte, ar féidir leo gach ceist údaraithe a tharmligean chuig an gcúltaca auth, seachas socruithe a theastaíonn uathu, mar shampla, chun rochtain gan ainm a rialú.

Údarú d'úsáideoirí neamhriach

Is é úsáideoir neamhghníomhach ceann a bhfuil a réimse ai:attr: ~django.contrib.auth.models.user.is_active socraithe go False. Cuireann an: Class: ~django.contrib.auth.backends.modelBackend agus:class: ~django.contrib.auth.backends.remoteUserBackend cosc ar na húsáideoirí seo fíordheimhniú. Mura bhfuil réimse: attr: ~django.contrib.auth.models.customUser.is_active ag samhail úsáideora saincheaptha, beidh cead ag gach úsáideoir fíordheimhniú.

Is féidir leat:class: ~django.contrib.auth.backends.allowAllUsersModelBackend nó:class: ~django.contrib.auth.backends.allowAllUsersRemoteUserBackend más mian leat ligean d'úsáideoirí neamhghníomhacha a fhíordheimhniú.

Ligeann an tacaíocht d'úsáideoirí gan ainm sa chóras ceada cás ina bhfuil ceadanna ag úsáideoirí gan ainm rud éigin a dhéanamh agus nach ndéanann úsáideoirí fíordheimhnithe neamhghníomhacha.

Ná déan dearmad tástáil a dhéanamh ar thréith is_active an úsáideora i do mhodhanna ceada cúltaca féin.

Ceadanna réad a láimh

Tá bunús ag creat ceada Django do cheadanna réada, cé nach bhfuil aon chur i bhfeidhm dó sa chroí. Ciallaíonn sé sin go gcuirfidh seiceáil ceadanna réada ar ais i gcónaí False` nó liosta folamh (ag brath ar an seiceáil a dhéantar). Gheobhaidh cúltaca fíordheimhnithe na paraiméadair eochairfhocal obj agus user_obj do gach modh údaraithe a bhaineann le réad agus féadfaidh sé cead leibhéal an réada a thabhairt ar ais de réir mar is cuí.

Ceadanna saincheaptha

<meta-options>Chun ceadanna saincheaptha a chruthú do réad samhail ar leith, bain úsáid as an permissions:ref: `model Meta tréith `.

Cruthaíonn an tsamhail Task` sampla seo dhá chead saincheaptha, ie gníomhartha is féidir le húsáideoirí nó nach féidir le húsáideoirí a dhéanamh le cásanna Task, go sonrach le d'iarratas:

Code
class Task(models.Model):
    ...

    class Meta:
        permissions = [
            ("change_task_status", "Can change the status of tasks"),
            ("close_task", "Can remove a task by setting its status as closed"),
        ]

Is é an t-aon rud a dhéanann sé seo na ceadanna breise sin a chruthú nuair a rith tú: djadmin: manage.py migration <migrate>`(tá an fheidhm a chruthaíonn ceadanna ceangailte leis an gcomhartha: data: `~django.db.models.signals.post_migrate). Tá do chód i gceannas ar luach na gceadanna seo a sheiceáil nuair a bhíonn úsáideoir ag iarraidh rochtain a fháil ar an bhfeidhmiúlacht a sholáthraíonn an feidhmchlár (stádas tascanna a athrú nó cúraimí a dhúnadh.) Ag leanúint leis an sampla thuas, seiceálann na seiceálacha seo a leanas más féidir le húsáideoir tascanna

Code
user.has_perm("app.close_task")

An tsamhail ``Úsáideoir ``atá ann cheana a leathnú

Tá dhá bhealach ann chun an tsamhail réamhshocraithe: class: ~django.contrib.auth.models.user a leathnú gan do mhúnla féin a chur in ionad. Más iompraíochta amháin iad na hathruithe a theastaíonn uait, agus mura dteastaíonn aon athrú uathu ar an méid atá stóráilte sa bhunachar sonraí, is féidir leat a:ref: samhail seachfhreastala a chruthú bun <proxy-models>aithe ar:class: ~django.contrib.auth.models.user. Ligeann sé seo aon cheann de na gnéithe a thairgeann samhlacha seachfhreastalaí lena n-áirítear ordú réamhshocraithe, bainisteoirí saincheaptha nó modhanna

Más mian leat faisnéis a bhaineann le ``Úsáideoir ``a stóráil, is féidir leat a:class: ~django.db.models.onetoonefield a úsáid chuig samhail ina bhfuil na réimsí le haghaidh faisnéise breise. Is minic a thugtar samhail phróifíle ar an tsamhail duine le duine seo, mar d'fhéadfadh sé faisnéis neamh-aitheantais a stóráil faoi úsáideoir láithreáin. Mar shampla d'fhéadfá samhail Fostaithe a chruthú:

Code
from django.contrib.auth.models import User


class Employee(models.Model):
    user = models.OneToOneField(User, on_delete=models.CASCADE)
    department = models.CharField(max_length=100)

Ag glacadh leis an bhFostaí atá ann cheana Fred Smith a bhfuil samhail Úsáideora agus Fostaithe aige, is féidir leat rochtain a fháil ar an bhfaisnéis ghaolmhar ag baint úsáide as coinbhinsiúin

Python console
>>> u = User.objects.get(username="fsmith")
>>> freds_department = u.employee.department

Chun réimsí samhail phróifíle a chur leis an leathanach úsáideora sa admin, sainmhínigh an:class: ~django.contrib.admin.inlineModelAdmin (don shampla seo, úsáidfimid a:class: ~django.contrib.admin.stackedInline) i admin.py` d'aip agus cuirfimid le rang UserAdmin atá cláraithe leis an aip aicme: ~django.contrib.auth.models.user aicme:

Code
from django.contrib import admin
from django.contrib.auth.admin import UserAdmin as BaseUserAdmin
from django.contrib.auth.models import User

from my_user_profile_app.models import Employee


# Define an inline admin descriptor for Employee model
# which acts a bit like a singleton
class EmployeeInline(admin.StackedInline):
    model = Employee
    can_delete = False
    verbose_name_plural = "employee"


# Define a new User admin
class UserAdmin(BaseUserAdmin):
    inlines = [EmployeeInline]


# Re-register UserAdmin
admin.site.unregister(User)
admin.site.register(User, UserAdmin)

Níl na samhlacha próifíle seo speisialta ar bhealach ar bith - níl siad ach samhlacha Django a bhfuil nasc duine le duine acu le samhail úsáideora. Mar sin, ní chruthaítear iad go huathoibríoch nuair a chruthaítear úsáideoir, ach a: attr: d'fhéadfaí django.db.models.signals.post_save a úsáid chun samhlacha gaolmhara a chruthú nó a nuashonrú de réir mar is cuí.

Mar thoradh ar mhúnlaí gaolmhara a úsáid tá ceisteanna breise nó páirtí chun na sonraí gaolmhara Ag brath ar do riachtanais, d'fhéadfadh samhail úsáideora saincheaptha a chuimsíonn na réimsí gaolmhara a bheith mar do rogha níos fearr, áfach, d'fhéadfadh caidreamh atá ann cheana leis an tsamhail úsáideora réamhshocraithe laistigh d'aipeanna do thionscadail údar

Samhail saincheaptha ```Úsáideoir ``a chur in ionad

D'fhéadfadh riachtanais fíordheimhnithe a bheith ag roinnt cineálacha tionscadail nach bhfuil samhail ionsuite Django: ~django.contrib.auth.models.User oiriúnach i gcónaí. Mar shampla, ar roinnt suíomhanna bíonn sé níos ciallmhaire seoladh ríomhphoist a úsáid mar do chomhartha aitheantais in ionad ainm úsáideora.

Ligeann Django duit an tsamhail úsáideora réamhshocraithe a shárú trí luach a sholáthar don socrú: setting: AUTH_USER_MODEL a thagann tagairt do mhúnla saincheaptha:

Code
AUTH_USER_MODEL = "myapp.MyUser"

Déanann an péire poncaigh seo cur síos ar: attr: ~django.apps.appconfig.label den aip Django (a chaithfidh a bheith i do: setting: INSTALLED_APPS), agus ainm an tsamhail Django is mian leat a úsáid mar do mhúnla úsáideora.

Múnla úsáideora saincheaptha a úsáid agus tionscadal á thosú

Má tá tionscadal nua á thosú agat, is féidir leat samhail úsáideora saincheaptha a chur ar bun a iompraíonn go cosúil leis an tsamhail úsáideora réamhshocraithe trí fho-aicmiú:class: ~django.contrib.auth.models.abstractUser:

Code
from django.contrib.auth.models import AbstractUser


class User(AbstractUser):
    pass

Ná déan dearmad a chur in iúl: setting: AUTH_USER_MODEL dó. Déan é seo sula gcruthaítear aon imirce nó sula rith manage.py migrate den chéad uair.

Chomh maith leis sin, cláraigh an tsamhail i admin.py` an aip:

Code
from django.contrib import admin
from django.contrib.auth.admin import UserAdmin
from .models import User

admin.site.register(User, UserAdmin)

Athrú go samhail úsáideora saincheaptha lár-thionscadail

Athraithe:SETTING: AUTH_USER_MODEL is féidir tar éis duit táblaí bunachar sonraí a chruthú, ach féadann sé a bheith casta, ós rud é go mbíonn tionchar aige ar eochracha eachtracha agus ar chaidrimh go leor, mar shampla.

Ní féidir an t-athrú seo a dhéanamh go huathoibríoch agus éilíonn sé do scéim a shocrú de láimh, do chuid sonraí a bhogadh ón sean-tábla úsáideora, agus b'fhéidir roinnt imirce a athchur de láimh. Féach: ticéad: 25313 le haghaidh imlíne ar na céimeanna.

Mar gheall ar theorainneacha ar ghné spleáchais dhinimiciúil Django do mhúnlaí inmhalartaithe, caithfear an tsamhail dá dtagraí:setting: AUTH_USER_MODEL a chruthú sa chéad imirce dá aip (ar a dtugtar 0001_initial` de ghnáth); ar shlí eile, beidh saincheisteanna spleáchais agat.

Ina theannta sin, féadfaidh tú rith isteach i “CircularDependencyError” agus tú ag rith d'imirce mar ní bheidh Django in ann an lúb spleáchais a bhriseadh go huathoibríoch mar gheall ar an spleáchas dinimiciúil. Má fheiceann tú an earráid seo, ba cheart duit an lúb a bhriseadh tríd na samhlacha a mbraitheann do mhúnla úsáideora orthu a bhogadh isteach sa dara imirce. (Is féidir leat triail a bhaint as dhá ghnáthshamhail a dhéanamh a bhfuil “ForeignKey'” acu lena chéile agus a fheiceáil conas a réitíonn ``makemigrations` an spleáchas ciorclach sin más mian leat a fheiceáil conas a dhéantar é de ghnáth.)

Aipeanna in-athúsáidte agus ``AUTH_USER_MODEL ``

Níor cheart d'aipeanna in-athúsáidte samhail úsáideora saincheaptha a chur Féadfaidh tionscadal go leor aipeanna a úsáid, agus ní fhéadfaí dhá aip in-athúsáidte a chuir samhail úsáideora saincheaptha i bhfeidhm a úsáid le chéile. Más gá duit faisnéis in aghaidh an úsáideora a stóráil i d'aip, bain úsáid as a:class: ~django.db.models.foreignKey nó:class: ~django.db.models.onetoonefield go settings.auth_user_model mar a thuairiscítear thíos.

Ag tagairt don tsamhail ``Úsáideoir ``

Má thagraíonn tú: class: ~django.contrib.auth.models.user go díreach (mar shampla, trí thagairt dó i eochair eachtrach), ní oibreoidh do chód i dtionscadail ina n-athraíodh an socrú: AUTH_USER_MODEL go samhail úsáideora difriúil.

get_user_model()

In ionad tagairt a dhéanamh do:class: ~django.contrib.auth.models.user go díreach, ba cheart duit tagairt a dhéanamh don tsamhail úsáideora ag baint úsáide as ``django.contrib.auth.get_user_model () ``. Tabharfaidh an modh seo an tsamhail úsáideora atá gníomhach faoi láthair ar ais - an tsamhail úsáideora saincheaptha má shonraítear ceann amháin, nó: class: ~django.contrib.auth.models.user ar shlí eile.

Nuair a shainmhíníonn tú eochair eachtrach nó caidreamh go leor leis an tsamhail úsáideora, ba cheart duit an tsamhail saincheaptha a shonrú ag baint úsáide as an socrú: setting: AUTH_USER_MODEL. Mar shampla:

Code
from django.conf import settings
from django.db import models


class Article(models.Model):
    author = models.ForeignKey(
        settings.AUTH_USER_MODEL,
        on_delete=models.CASCADE,
    )

Agus tú ag nascadh le comharthaí a sheolann an tsamhail úsáideora, ba cheart duit an tsamhail saincheaptha a shonrú ag baint úsáide as an socrú: setting: AUTH_USER_MODEL. Mar shampla:

Code
from django.conf import settings
from django.db.models.signals import post_save


def post_save_receiver(sender, instance, created, **kwargs):
    pass


post_save.connect(post_save_receiver, sender=settings.AUTH_USER_MODEL)

Go ginearálta, is éasca tagairt a dhéanamh don tsamhail úsáideora leis an socrú: “AUTH_USER_MODEL” sa chód a fhorghníomhaítear ag am allmhairithe, áfach, is féidir glaoch ar `get_user_model () ``agus Django ag allmhairiú samhlacha, ionas gur féidir leat ``Models.foreignKey (get_user_model (),...) `a úsáid.

Má dhéantar tástáil ar d'aip le samhlacha úsáideora iolracha, ag baint úsáide as @override_settings (AUTH_USER_MODEL =...) mar shampla, agus má dhéanann tú taisce toradh ``get_user_model () ``in athróg leibhéal modúl, b'fhéidir go mbeidh ort éisteacht leis an gcomhartha: data: ~django.test.signals.setting_changed chun an taisce a ghlanadh. Mar shampla:

Code
from django.apps import apps
from django.contrib.auth import get_user_model
from django.core.signals import setting_changed
from django.dispatch import receiver


@receiver(setting_changed)
def user_model_swapped(*, setting, **kwargs):
    if setting == "AUTH_USER_MODEL":
        apps.clear_cache()
        from myapp import some_module

        some_module.UserModel = get_user_model()

Samhail úsáideora saincheaptha a shonrú

Nuair a thosaíonn tú do thionscadal le samhail úsáideora saincheaptha, stad chun machnamh a dhéanamh an é seo an rogha ceart do do thionscadal.

Ag coinneáil gach faisnéis a bhaineann le húsáideoirí i samhail amháin, cuirtear an gá le ceisteanna bunachar sonraí breise nó níos casta chun samhlacha gaolmhara Ar an láimh eile, b'fhéidir go mbeadh sé níos oiriúnaí faisnéis úsáideora atá sonrach le aip a stóráil i samhail a bhfuil gaol aige le do mhúnla úsáideora saincheaptha. Ligeann sé sin do gach aip a riachtanais sonraí úsáideora féin a shonrú gan toimhdeanna a d'fhéadfadh aipeanna eile a d'fhéadfadh a bheith contrártha Ciallaíonn sé freisin go gcoinneoidh tú do mhúnla úsáideora chomh simplí agus is féidir, dírithe ar fhíordheimhniú, agus ag leanúint na n-íosriachtanais ag súil go gcomhlíonfaidh Django samhlacha úsáideora

Má úsáideann tú an cúltaca fíordheimhnithe réamhshocraithe, ansin caithfidh réimse uathúil amháin a bheith ag do mhúnla is féidir a úsáid chun críocha aitheantais. Is féidir leis seo a bheith ina ainm úsáideora, seoladh ríomhphoist, nó aon tréith uathúil eile. Ceadaítear réimse ainm úsáideora neamh-uathúil má úsáideann tú cúltaca fíordheimhnithe saincheaptha ar féidir leo tacú leis.

Is é an bealach is éasca chun samhail úsáideora saincheaptha comhlíontach a thógáil ná oidhreacht ó:class: ~django.contrib.auth.models.AbstractBaseUser. :class: ~django.contrib.auth.models.AbstractBaseUser soláthraíonn croífheidhmiú samhail úsáideora, lena n-áirítear pasfhocail hashed agus athshocruithe pasfhocal tokenized. Ní mór duit roinnt príomhshonraí cur chun feidhme a sholáthar ansin:

class models.CustomUser
USERNAME_FIELD

Sreang a chuireann síos ar ainm an réimse ar an tsamhail úsáideora a úsáidtear mar an aitheantóir uathúil. De ghnáth is ainm úsáideora de chineál éigin é seo, ach is féidir leis a bheith ina sheoladh ríomhphoist, nó aon aitheantóir uathúil eile. Caithfidh an réimse** a bheith uathúil (m.sh. go bhfuil Unique=True` socraithe ina sainmhíniú), mura n-úsáideann tú cúltaca fíordheimhnithe saincheaptha atá in ann tacú le hainmneacha úsáideora neamh-uathúla.

Sa sampla seo a leanas, úsáidtear an réimse ``aitheantóir` mar an réimse aitheantais:

Code
class MyUser(AbstractBaseUser):
    identifier = models.CharField(max_length=40, unique=True)
    ...
    USERNAME_FIELD = "identifier"
EMAIL_FIELD

Sreang a thugann cur síos ar ainm an réimse ríomhphoist ar an tsamhail ``Úsáideoir ``. Cuirtear an luach seo ar ais ag: meth: ~Models.AbstractBaseUser.get_email_field_name.

REQUIRED_FIELDS

Liosta de na hainmneacha réimse a spreagfar agus úsáideoir á chruthú tríd an ordú bainistíochta: djadmin: createsuperuser. Spreagfar an t-úsáideoir luach a sholáthar do gach ceann de na réimsí seo. Caithfidh sé aon réimse a áireamh ina bhfuil: attr: ~django.db.models.field.blank False nó neamhshainithe agus féadfaidh sé réimsí breise a bheith san áireamh gur mhaith leat a spreagadh dóibh nuair a chruthaítear úsáideoir idirghníomhach. Níl aon éifeacht ag REQUIRED_FIELDS i gcodanna eile de Django, cosúil le húsáideoir a chruthú sa riarachán.

Mar shampla, seo an sainmhíniú páirteach ar mhúnla úsáideora a shainmhíníonn dhá réimse riachtanacha - dáta breithe agus airde:

Code
class MyUser(AbstractBaseUser):
    ...
    date_of_birth = models.DateField()
    height = models.FloatField()
    ...
    REQUIRED_FIELDS = ["date_of_birth", "height"]
is_active

A boolean attribute that indicates whether the user is considered "active". This attribute is provided as an attribute on AbstractBaseUser defaulting to True. How you choose to implement it will depend on the details of your chosen auth backends. See the documentation of the is_active attribute on the built-in user model for details.

get_full_name()

Roghnach. Aitheantóir foirmiúil níos faide don úsáideoir amhail a n-ainm iomlán. Má chuirtear i bhfeidhm é, tá sé seo le feiceáil in éineacht leis an ainm úsáideora i stair réad in:mod: django.contrib.admin.

get_short_name()

Roghnach. Aitheantóir gairid neamhfhoirmiúil don úsáideoir amhail a gcéadainm. Má chuirtear i bhfeidhm, cuireann sé seo in ionad an t-ainm úsáideora sa bheannacht chuig an úsáideoir i gceannteideal de:mod: `django.contrib.admin `.

Tá na tréithe agus na modhanna seo a leanas ar fáil ar aon fho-aicme de:class: ~django.contrib.auth.models.abstractBaseUser:

class models.AbstractBaseUser
get_username()

Tugann luach an réimse ainmnithe ag USERNAME_FIELD ar ais.

clean()

Normalizíonn an t-ainm úsáideora trí ghlaoch: meth: normalize_username. Má sháraigh tú an modh seo, bí cinnte glaoch ar ``super () ``chun an normalú a choinneáil.

classmethod get_email_field_name()

Tugann ainm an réimse ríomhphoist a shonraítear leis an tréith: attr: ~Models.CUSTOMUSER.EMAIL_FIELD ar ais. Réamhshocraithe go 'r-phost' mura sonraítear EMAIL_FIELD.

classmethod normalize_username(username)

Cuireann normalú Unicode NFKC i bhfeidhm ar ainmneacha úsáideora ionas go measfar carachtair comhionann ó thaobh amhairc a bhfuil pointí cód Unicode éagsúla acu mar

is_authenticated

Tréith léite amháin atá True i gcónaí (seachas AnonymousUser.is_Authenticated atá False i gcónaí). Is bealach é seo chun a rá an bhfuil an t-úsáideoir fíordheimhnithe. Ní thugann sé seo le tuiscint ar aon cheadanna agus ní sheiceálann sé an bhfuil an t-úsáideoir gníomhach nó an bhfuil seisiún bailí aige. Cé go seiceálfaidh tú an tréith seo de ghnáth ar request.user` chun a fháil amach an bhfuil sé áitithe ag an:class: ~django.contrib.auth.middleware.AuthenticationMiddleware (a léiríonn an t-úsáideoir logáilte isteach faoi láthair), ba chóir go mbeadh a fhios agat gurb é an tréith seo True` d'aon shampla: ~Models.User.

is_anonymous

Tréith léitheoireachta amháin atá i gcónaí False. Is bealach é seo chun rudaí: class: ~Models.User agus:class: ~Models.anonymousUser a idirdhealú. Go ginearálta, ba cheart duit úsáid a bhaint as: attr: ~Models.User.is_Authenticated leis an tréith seo.

set_password(raw_password)

Socraíonn pasfhocal an úsáideora chuig an sreang amh a thugtar, ag tabhairt aire don hashing pasfhocal. Ní shábhálann sé an réad:class: ~django.contrib.auth.Models.AbstractBaseUser.

When the raw_password is None, the password will be set to an unusable password, as if set_unusable_password() were used.

check_password(raw_password)
acheck_password(raw_password)

Leagan asincrón: ``acheck_password () ``

Tugann sé ar ais True más é an teaghrán amh a thugtar an focal faire ceart don úsáideoir. (Tugann sé seo aire don hashing pasfhocal agus an comparáid a dhéanamh.)

set_unusable_password()

Marks the user as having no password set. This isn't the same as having a blank string for a password. check_password() for this user will never return True. Doesn't save the AbstractBaseUser object.

B'fhéidir go mbeidh sé seo ag teastáil uait má tharlaíonn fíordheimhniú d'iarratas i gcoinne foinse sheachtrach atá ann cheana mar eolaire LDAP.

has_usable_password()

Returns False if set_unusable_password() has been called for this user.

get_session_auth_hash()

Tugann sé HMAC ar an réimse pasfhocal ar ais. Úsáidtear le haghaidh: ref: `seision-invalidation-on-pasfho-athraithe'.

get_session_auth_fallback_hash()

Tugann sé HMAC an réimse pasfhocal ag baint úsáid:setting: SECRET_KEY_FALLBACKS. Úsáidtear ag ``get_user () ``.

AbstractUser subclasses AbstractBaseUser:

class models.AbstractUser
clean()

Déanann an ríomhphost a normalú trí ghlaoch: meth: .baseUserManager.Normalize_email. Má sháraigh tú an modh seo, bí cinnte glaoch ar ``super () ``chun an normalú a choinneáil.

Bainisteoir a scríobh le haghaidh samhail úsáideora saincheaptha

Ba chóir duit bainisteoir saincheaptha a shainiú do do mhúnla úsáideora freisin. Má shainmhíníonn do mhúnla úsáideora réimsí username, email, is_staff`, is_active`, is_superuser`, last_login, agus date_joined mar an gcéanna le húsáideoir réamhshocraithe Django, is féidir leat Djangos:class: ~django.contrib.auth.models.Bainisteoir '; áfach, má shainmhíníonn do mhúnla úsáideora réimsí éagsúla, beidh ort bainisteoir saincheaptha a shainiú a leathnaí:class: `~django.contrib.auth.models.baseUserManager ag soláthar dhá mhodh breise:

class models.CustomUserManager
create_user(username_field, password=None, **other_fields)

Ba chóir go nglacfadh fréamhshamhail create_user () ``leis an réimse ainm úsáideora, móide gach réimse riachtanach mar argóintí. Mar shampla, má úsáideann do mhúnla úsáideora ```email mar réimse an ainm úsáideora, agus má tá date_of_birth aige mar réimse riachtanach, ansin ba chóir create_user a shainiú mar:

Code
def create_user(self, email, date_of_birth, password=None):
    # create user here
    ...
create_superuser(username_field, password=None, **other_fields)

Ba chóir go nglacfadh fréamhshamhail create_superuser () ``leis an réimse ainm úsáideora, móide gach réimse riachtanach mar argóintí. Mar shampla, má úsáideann do mhúnla úsáideora ```email mar réimse an ainm úsáideora, agus má tá date_of_birth aige mar réimse riachtanach, ansin ba chóir create_superuser a shainiú mar:

Code
def create_superuser(self, email, date_of_birth, password=None):
    # create superuser here
    ...

Maidir le a:class: ~.FOREIGNKEY in:attr: .USERNAME_FIELD nó:attr: .REQUIRED_FIELDS, faigheann na modhanna seo luach na:attr: ~.FOREIGNKEY.TO_FIELD (the:attr: ~django.db.models.field.primary_key de réir réamhshocraithe) de shampla atá ann cheana.

BaseUserManager provides the following utility methods:

class models.BaseUserManager
classmethod normalize_email(email)

Déanann seoltaí ríomhphoist a normalú trí chuid fearainn den seoladh ríomhphoist a íoslaghdú.

get_by_natural_key(username)
aget_by_natural_key(username)

Asynchronous version: aget_by_natural_key()

Aisghabhann sé sampla úsáideora ag baint úsáide as ábhar an réimse atá ainmnithe ag USERNAME_FIELD.

Réamhshocraithe ``Úsáideoir ``Django a leathnú

Má tá tú sásta go hiomlán le samhail Django:Class: ~django.contrib.auth.models.user, ach gur mhaith leat roinnt faisnéise próifíle breise a chur leis, d'fhéadfá subclass:class: django.contrib.auth.models.abstractUser agus do réimsí próifíl saincheaptha a chur leis, cé go mholfaimis samhail ar leithligh mar a thuairiscítear in:ref: specifying-custom-user-model. <abstract-base-classes>Soláthraíonn AbstractUser cur i bhfeidhm iomlán an réamhshocraithe:class: ~django.contrib.auth.models.user mar an:ref: `samhail teibí `.

Úsáideoirí saincheaptha agus na foirmeacha auth ionsuite

Déanann ionsuite Django: ref: fo <built-in-auth-forms>irmeacha `agus:ref: `tuairimí toimhdeanna áirithe faoin t <built-in-auth-views>samhail úsáideora a bhfuil siad ag obair leis.

Tá na foirmeacha seo a leanas comhoiriúnach le haon fho-aicme de:class: ~django.contrib.auth.Models.AbstractBaseUser:

Déanann na foirmeacha seo a leanas toimhde faoin tsamhail úsáideora agus is féidir iad a úsáid mar atá má chomhlíontar na toimhdeanna sin:

  • PasswordResetForm: Assumes that the user model has a field that stores the user's email address with the name returned by get_email_field_name() (email by default) that can be used to identify the user and a boolean field named is_active to prevent password resets for inactive users.

Faoi dheireadh, tá na foirmeacha seo a leanas ceangailte len:class: ~django.contrib.auth.models.user agus ní mór iad a athscríobh nó a leathnú chun oibriú le samhail úsáideora saincheaptha:

Más fo-aicme de Abstractuser é do mhúnla úsáideora saincheaptha, ansin is féidir leat na foirmeacha seo a leathnú ar an mbealach seo:

Code
from django.contrib.auth.forms import UserCreationForm
from myapp.models import CustomUser


class CustomUserCreationForm(UserCreationForm):
    class Meta(UserCreationForm.Meta):
        model = CustomUser
        fields = UserCreationForm.Meta.fields + ("custom_field",)

Úsáideoirí saincheaptha agus:mod: django.contrib.admin

Más mian leat go n-oibreoidh do mhúnla úsáideora saincheaptha leis an riarachán freisin, caithfidh do mhúnla úsáideora roinnt tréithe agus modhanna breise a shainiú. Ligeann na modhanna seo don riarachán rochtain an úsáideora ar ábhar riaracháin a rialú:

class models.CustomUser
is_staff

Tugann sé ar ais True má cheadaítear don úsáideoir rochtain a bheith aige ar an suíomh riaracháin.

is_active

Tugann sé ar ais True má tá an cuntas úsáideora gníomhach faoi láthair.

has_perm(perm, obj=None):

Tugann sé ar ais True má tá an cead ainmnithe ag an úsáideoir. Má chuirtear obj` ar fáil, ní mór an cead a sheiceáil i gcoinne cás réad ar leith.

has_module_perms(app_label):

Tugann sé ar ais True má tá cead ag an úsáideoir rochtain a fháil ar mhúnlaí san aip ar leith.

Beidh ort freisin do mhúnla úsáideora saincheaptha a chlárú leis an riarachán. Má leathnaíonn do mhúnla úsáideora saincheaptha Django.Contrib.Auth.Models.AbstractUser, is féidir leat rang Django.Contrib.Auth.Admin.UserAdmin atá ann cheana Django a úsáid. Mar sin féin, má leathnaíonn do mhúnla úsáideora: class: ~django.contrib.auth.Models.AbstractBaseUser, beidh ort rang saincheaptha ModelAdmin` a shainiú. B'fhéidir go mbeadh sé indéanta an réamhshocraithe ``Django.Contrib.Auth.Admin.UserAdmin a fho-aicmiú; áfach, beidh ort aon cheann de na sainmhínithe a thagraíonn do réimsí ar Django.Contrib.Auth.Models.AbstractUser` nach bhfuil ar do rang úsáideora saincheaptha.

Úsáideoirí agus ceadanna saincheaptha

Chun go mbeidh sé éasca creat ceada Django a áireamh i do rang úsáideora féin, soláthraíonn Django: class: ~django.contrib.auth.models.permissionsMixin. Is samhail teibí é seo is féidir leat a áireamh san ordlathas ranga do do mhúnla úsáideora, ag tabhairt na modhanna agus na réimsí bunachar sonraí go léir atá riachtanach duit chun tacú le samhail ceada Django.

PermissionsMixin provides the following methods and attributes:

class models.PermissionsMixin
is_superuser

Boolean. Ainmníonn sé go bhfuil gach cead ag an úsáideoir seo gan iad a shannadh go sainráite.

get_user_permissions(obj=None)

Filleann sé tacar teaghráin ceadanna atá ag an úsáideoir go díreach.

Má chuirtear obj isteach, ní thugann sé ach ceadanna úsáideora don réad sonrach seo ar ais.

get_group_permissions(obj=None)

Tugann sé tacar teaghráin ceada atá ag an úsáideoir ar ais, trína ngrúpaí.

Má chuirtear obj isteach, ní thugann sé ach ceadanna grúpa don réad sonrach seo ar ais.

get_all_permissions(obj=None)

Tugann sé tacar teaghráin ceada atá ag an úsáideoir ar ais, trí cheadanna grúpa agus úsáideora araon.

Má chuirtear obj isteach, ní thugann sé ach na ceadanna don réad sonrach seo ar ais.

has_perm(perm, obj=None)

<app label>Tugann True ar ais má tá an cead sonraithe ag an úsáideoir, áit a bhfuil perm sa fhormáid ”. <permission codename><topic-authorization>“``(féach:ref: `ceadanna `). Má tá: attr: `.user.is_active` agus:attr: `~.user.is_superuser` araon ``True, filleann an modh seo True i gcónaí.

Má chuirtear obj isteach, ní sheiceálfaidh an modh seo cead don tsamhail, ach don réad sonrach seo.

has_perms(perm_list, obj=None)

<app label>Tugann sé “True” ar ais má tá gach ceann de na ceadanna sonraithe ag an úsáideoir, áit a bhfuil gach perm sa fhormáid ”. <permission codename>“. Má tá: attr: .user.is_active agus:attr: ~.user.is_superuser araon True, filleann an modh seo True i gcónaí.

Má chuirtear obj isteach, ní sheiceálfaidh an modh seo ceadanna don tsamhail, ach don réad ar leith.

has_module_perms(package_name)

Tugann sé ar ais True má tá aon cheadanna ag an úsáideoir sa phacáiste tugtha (lipéad an aip Django). Má tá: attr: .user.is_active agus:attr: ~.user.is_superuser araon True, filleann an modh seo True i gcónaí.

Úsáideoirí saincheaptha agus samhlacha seachta

Teorainn amháin ar mhúnlaí úsáideora saincheaptha is ea go mbriseofar samhail úsáideora saincheaptha aon mhúnla seachfhreastalaí:class: ~django.contrib.auth.models.user. Caithfidh samhlacha seachfhreastalaí a bheith bunaithe ar rang bonn coincréite; trí mhúnla úsáideora saincheaptha a shainiú, baineann tú cumas Django an bunaicme a aithint go hiontaofa.

Má úsáideann do thionscadal samhlacha seachfhreastalaí, ní mór duit an seachfhreastalaí a mhodhnú chun an tsamhail úsáideora atá in úsáid i do thionscadal a leathnú, nó iompar do sheachfhreastalaí a chumasc i d'fho-aicme: ~django.contrib.auth.models.user.

Sampla iomlán

Seo sampla d'aip úsáideora saincheaptha a chomhlíonann riarachán. Úsáideann an tsamhail úsáideora seo seoladh ríomhphoist mar an t-ainm úsáideora, agus tá dáta breithe riachtanach aige; ní sholáthraíonn sé aon chead seiceáil thar bhratach ``admin ``ar an gcuntas úsáideora. Bheadh an tsamhail seo comhoiriúnach leis na foirmeacha agus na tuairimí auth ionsuite go léir, ach amháin na foirmeacha cruthaithe úsáideora. Léiríonn an sampla seo an chaoi a n-oibríonn an chuid is mó de na comhpháirteanna le chéile, ach níl sé beartaithe iad a chóipeáil go díreach i dtionscadail

Bheadh an cód seo go léir ina gcónaí i gcomhad models.py d'aip fíordheimhnithe saincheaptha:

Code
from django.db import models
from django.contrib.auth.models import BaseUserManager, AbstractBaseUser


class MyUserManager(BaseUserManager):
    def create_user(self, email, date_of_birth, password=None):
        """
        Creates and saves a User with the given email, date of
        birth and password.
        """
        if not email:
            raise ValueError("Users must have an email address")

        user = self.model(
            email=self.normalize_email(email),
            date_of_birth=date_of_birth,
        )

        user.set_password(password)
        user.save(using=self._db)
        return user

    def create_superuser(self, email, date_of_birth, password=None):
        """
        Creates and saves a superuser with the given email, date of
        birth and password.
        """
        user = self.create_user(
            email,
            password=password,
            date_of_birth=date_of_birth,
        )
        user.is_admin = True
        user.save(using=self._db)
        return user


class MyUser(AbstractBaseUser):
    email = models.EmailField(
        verbose_name="email address",
        max_length=255,
        unique=True,
    )
    date_of_birth = models.DateField()
    is_active = models.BooleanField(default=True)
    is_admin = models.BooleanField(default=False)

    objects = MyUserManager()

    USERNAME_FIELD = "email"
    REQUIRED_FIELDS = ["date_of_birth"]

    def __str__(self):
        return self.email

    def has_perm(self, perm, obj=None):
        "Does the user have a specific permission?"
        # Simplest possible answer: Yes, always
        return True

    def has_module_perms(self, app_label):
        "Does the user have permissions to view the app `app_label`?"
        # Simplest possible answer: Yes, always
        return True

    @property
    def is_staff(self):
        "Is the user a member of staff?"
        # Simplest possible answer: All admins are staff
        return self.is_admin

Ansin, chun an tsamhail úsáideora saincheaptha seo a chlárú le riarachán Django, bheadh an cód seo a leanas ag teastáil i gcomhad admin.py an aip:

Code
from django import forms
from django.contrib import admin
from django.contrib.auth.models import Group
from django.contrib.auth.admin import UserAdmin as BaseUserAdmin
from django.contrib.auth.forms import ReadOnlyPasswordHashField
from django.core.exceptions import ValidationError

from customauth.models import MyUser


class UserCreationForm(forms.ModelForm):
    """A form for creating new users. Includes all the required
    fields, plus a repeated password."""

    password1 = forms.CharField(label="Password", widget=forms.PasswordInput)
    password2 = forms.CharField(
        label="Password confirmation", widget=forms.PasswordInput
    )

    class Meta:
        model = MyUser
        fields = ["email", "date_of_birth"]

    def clean_password2(self):
        # Check that the two password entries match
        password1 = self.cleaned_data.get("password1")
        password2 = self.cleaned_data.get("password2")
        if password1 and password2 and password1 != password2:
            raise ValidationError("Passwords don't match")
        return password2

    def save(self, commit=True):
        # Save the provided password in hashed format
        user = super().save(commit=False)
        user.set_password(self.cleaned_data["password1"])
        if commit:
            user.save()
        return user


class UserChangeForm(forms.ModelForm):
    """A form for updating users. Includes all the fields on
    the user, but replaces the password field with admin's
    disabled password hash display field.
    """

    password = ReadOnlyPasswordHashField()

    class Meta:
        model = MyUser
        fields = ["email", "password", "date_of_birth", "is_active", "is_admin"]


class UserAdmin(BaseUserAdmin):
    # The forms to add and change user instances
    form = UserChangeForm
    add_form = UserCreationForm

    # The fields to be used in displaying the User model.
    # These override the definitions on the base UserAdmin
    # that reference specific fields on auth.User.
    list_display = ["email", "date_of_birth", "is_admin"]
    list_filter = ["is_admin"]
    fieldsets = [
        (None, {"fields": ["email", "password"]}),
        ("Personal info", {"fields": ["date_of_birth"]}),
        ("Permissions", {"fields": ["is_admin"]}),
    ]
    # add_fieldsets is not a standard ModelAdmin attribute. UserAdmin
    # overrides get_fieldsets to use this attribute when creating a user.
    add_fieldsets = [
        (
            None,
            {
                "classes": ["wide"],
                "fields": ["email", "date_of_birth", "password1", "password2"],
            },
        ),
    ]
    search_fields = ["email"]
    ordering = ["email"]
    filter_horizontal = []


# Now register the new UserAdmin...
admin.site.register(MyUser, UserAdmin)
# ... and, since we're not using Django's built-in permissions,
# unregister the Group model from admin.
admin.site.unregister(Group)

Faoi dheireadh, sonraigh an tsamhail saincheaptha mar an tsamhail úsáideora réamhshocraithe do do thionscadal ag baint úsáide as an socrú: setting: AUTH_USER_MODEL i do settings.py`:

Code
AUTH_USER_MODEL = "customauth.MyUser"

Adding an async interface

To optimize performance when called from an async context authentication, backends can implement async versions of each function - aget_user(user_id) and aauthenticate(request, **credentials). When an authentication backend extends BaseBackend and async versions of these functions are not provided, they will be automatically synthesized with sync_to_async. This has performance penalties.

While an async interface is optional, a synchronous interface is always required. There is no automatic synthesis for a synchronous interface if an async interface is implemented.

Django's out-of-the-box authentication backends have native async support. If these native backends are extended take special care to make sure the async versions of modified functions are modified as well.

View as Markdown Edit this page on GitHub Official version