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.
\nAuthentication backends provide an extensible\nsystem for when a username and password stored with the user model need to be\nauthenticated against a different service than Django's default.
\nIs féidir leat do mhúnlaí:ref: `ceadanna saincheaptha <custom-permissions>`a thabhairt ar féidir a sheiceáil trí chóras údaraithe Django.
\n<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 `.
\nB'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.
\nMar 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.
\nMar 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.
\nFé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.
\nBehind the scenes, Django maintains a list of "authentication backends" that it\nchecks for authentication. When somebody calls\ndjango.contrib.auth.authenticate() -- as described in How to log\na user in -- Django tries authenticating across\nall of its authentication backends. If the first authentication method fails,\nDjango 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.
\nDe réir réamhshocraithe, tá :setting: AUTHENTICATION_BACKENDS socraithe go:
\n["django.contrib.auth.backends.ModelBackend"]\nSin 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
\nTá 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.
\nMá 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.
\n\n<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:
from django.contrib.auth.backends import BaseBackend\n\n\nclass MyBackend(BaseBackend):\n def authenticate(self, request, username=None, password=None):\n # Check the username/password and return a user.\n ...\nAch d'fhéadfadh sé comhartha a fhíordheimhniú freisin, mar sin:
\nfrom django.contrib.auth.backends import BaseBackend\n\n\nclass MyBackend(BaseBackend):\n def authenticate(self, request, token=None):\n # Check the token and return a user.\n ...\nAr 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.
\nIs é 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.
\nSeo 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:
\nfrom django.conf import settings\nfrom django.contrib.auth.backends import BaseBackend\nfrom django.contrib.auth.hashers import check_password\nfrom django.contrib.auth.models import User\n\n\nclass SettingsBackend(BaseBackend):\n """\n Authenticate against the settings ADMIN_LOGIN and ADMIN_PASSWORD.\n\n Use the login name and a hash of the password. For example:\n\n ADMIN_LOGIN = 'admin'\n ADMIN_PASSWORD = 'pbkdf2_sha256$30000$Vo0VlMnkR4Bk$qEvtdyZRWTcOsCnI/oQ7fVOu1XAURIZYoOZ3iq8Dr4M='\n """\n\n def authenticate(self, request, username=None, password=None):\n login_valid = settings.ADMIN_LOGIN == username\n pwd_valid = check_password(password, settings.ADMIN_PASSWORD)\n if login_valid and pwd_valid:\n try:\n user = User.objects.get(username=username)\n except User.DoesNotExist:\n # Create a new user. There's no need to set a password\n # because only the password from settings.py is checked.\n user = User(username=username) # is_active defaults to True.\n user.is_staff = True\n user.is_superuser = True\n user.save()\n return user\n return None\n\n def get_user(self, user_id):\n try:\n return User.objects.get(pk=user_id)\n except User.DoesNotExist:\n return None\n<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:
class Task(models.Model):\n ...\n\n class Meta:\n permissions = [\n ("change_task_status", "Can change the status of tasks"),\n ("close_task", "Can remove a task by setting its status as closed"),\n ]\nIs é 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
\nuser.has_perm("app.close_task")\nTá 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
\nMá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ú:
\nfrom django.contrib.auth.models import User\n\n\nclass Employee(models.Model):\n user = models.OneToOneField(User, on_delete=models.CASCADE)\n department = models.CharField(max_length=100)\nAg 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
\n>>> u = User.objects.get(username="fsmith")\n>>> freds_department = u.employee.department\nChun 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:
from django.contrib import admin\nfrom django.contrib.auth.admin import UserAdmin as BaseUserAdmin\nfrom django.contrib.auth.models import User\n\nfrom my_user_profile_app.models import Employee\n\n\n# Define an inline admin descriptor for Employee model\n# which acts a bit like a singleton\nclass EmployeeInline(admin.StackedInline):\n model = Employee\n can_delete = False\n verbose_name_plural = "employee"\n\n\n# Define a new User admin\nclass UserAdmin(BaseUserAdmin):\n inlines = [EmployeeInline]\n\n\n# Re-register UserAdmin\nadmin.site.unregister(User)\nadmin.site.register(User, UserAdmin)\nNí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í.
\nMar 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
\nD'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.
\nLigeann 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:
\nAUTH_USER_MODEL = "myapp.MyUser"\nDé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.
\nMá 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:
\nfrom django.contrib.auth.models import AbstractUser\n\n\nclass User(AbstractUser):\n pass\nNá 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:
\nfrom django.contrib import admin\nfrom django.contrib.auth.admin import UserAdmin\nfrom .models import User\n\nadmin.site.register(User, UserAdmin)\nAthraithe: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.
\nNí 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.
\nMar 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.
\nIna 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.)
\nNí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.
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.
\nIn 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.
\nNuair 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:
\nfrom django.conf import settings\nfrom django.db import models\n\n\nclass Article(models.Model):\n author = models.ForeignKey(\n settings.AUTH_USER_MODEL,\n on_delete=models.CASCADE,\n )\nAgus 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:
\nfrom django.conf import settings\nfrom django.db.models.signals import post_save\n\n\ndef post_save_receiver(sender, instance, created, **kwargs):\n pass\n\n\npost_save.connect(post_save_receiver, sender=settings.AUTH_USER_MODEL)\nGo 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.
\nMá 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:
from django.apps import apps\nfrom django.contrib.auth import get_user_model\nfrom django.core.signals import setting_changed\nfrom django.dispatch import receiver\n\n\n@receiver(setting_changed)\ndef user_model_swapped(*, setting, **kwargs):\n if setting == "AUTH_USER_MODEL":\n apps.clear_cache()\n from myapp import some_module\n\n some_module.UserModel = get_user_model()\nNuair 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.
\nAg 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
\nMá ú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.
\nIs é 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:
\nSreang 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.
\nSa sampla seo a leanas, úsáidtear an réimse ``aitheantóir` mar an réimse aitheantais:
\nclass MyUser(AbstractBaseUser):\n identifier = models.CharField(max_length=40, unique=True)\n ...\n USERNAME_FIELD = "identifier"\nSreang 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.
\nLiosta 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:
\nclass MyUser(AbstractBaseUser):\n ...\n date_of_birth = models.DateField()\n height = models.FloatField()\n ...\n REQUIRED_FIELDS = ["date_of_birth", "height"]\nA boolean attribute that indicates whether the user is considered\n"active". This attribute is provided as an attribute on\nAbstractBaseUser defaulting to True. How you choose to\nimplement it will depend on the details of your chosen auth backends.\nSee the documentation of the is_active attribute on the built-in\nuser model for details.
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.
\nRoghnach. 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 `.
\nTá na tréithe agus na modhanna seo a leanas ar fáil ar aon fho-aicme de:class: ~django.contrib.auth.models.abstractBaseUser:
\nTugann luach an réimse ainmnithe ag USERNAME_FIELD ar ais.
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.
\nTugann 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.
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
\nTré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.
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.
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.
\nWhen the raw_password is None, the password will be set to an\nunusable password, as if\nset_unusable_password()\nwere used.
Leagan asincrón: ``acheck_password () ``
\nTugann 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.)
Marks the user as having no password set. This isn't the same as\nhaving a blank string for a password.\ncheck_password() for\nthis user will never return True. Doesn't save the\nAbstractBaseUser 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.
\nReturns False if\nset_unusable_password()\nhas been called for this user.
Tugann sé HMAC ar an réimse pasfhocal ar ais. Úsáidtear le haghaidh: ref: `seision-invalidation-on-pasfho-athraithe'.
\nTugann sé HMAC an réimse pasfhocal ag baint úsáid:setting: SECRET_KEY_FALLBACKS. Úsáidtear ag ``get_user () ``.
\nAbstractUser subclasses AbstractBaseUser:
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.
\nBa 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:
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:
def create_user(self, email, date_of_birth, password=None):\n # create user here\n ...\nBa 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:
def create_superuser(self, email, date_of_birth, password=None):\n # create superuser here\n ...\nMaidir 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.
\nBaseUserManager provides the following\nutility methods:
Déanann seoltaí ríomhphoist a normalú trí chuid fearainn den seoladh ríomhphoist a íoslaghdú.
\nAsynchronous version: aget_by_natural_key()
Aisghabhann sé sampla úsáideora ag baint úsáide as ábhar an réimse atá ainmnithe ag USERNAME_FIELD.
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í `.
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.
\nTá na foirmeacha seo a leanas comhoiriúnach le haon fho-aicme de:class: ~django.contrib.auth.Models.AbstractBaseUser:
\nAuthenticationForm: Uses the username\nfield specified by USERNAME_FIELD.
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:
\nPasswordResetForm: Assumes that the user\nmodel has a field that stores the user's email address with the name returned\nby get_email_field_name() (email by\ndefault) that can be used to identify the user and a boolean field named\nis_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:
\n\nMá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:
from django.contrib.auth.forms import UserCreationForm\nfrom myapp.models import CustomUser\n\n\nclass CustomUserCreationForm(UserCreationForm):\n class Meta(UserCreationForm.Meta):\n model = CustomUser\n fields = UserCreationForm.Meta.fields + ("custom_field",)\nMá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ú:
\nTugann sé ar ais True má cheadaítear don úsáideoir rochtain a bheith aige ar an suíomh riaracháin.
Tugann sé ar ais True má tá an cuntas úsáideora gníomhach faoi láthair.
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.
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.
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.
\nPermissionsMixin provides the following\nmethods and attributes:
Boolean. Ainmníonn sé go bhfuil gach cead ag an úsáideoir seo gan iad a shannadh go sainráite.
\nFilleann sé tacar teaghráin ceadanna atá ag an úsáideoir go díreach.
\nMá chuirtear obj isteach, ní thugann sé ach ceadanna úsáideora don réad sonrach seo ar ais.
Tugann sé tacar teaghráin ceada atá ag an úsáideoir ar ais, trína ngrúpaí.
\nMá chuirtear obj isteach, ní thugann sé ach ceadanna grúpa don réad sonrach seo ar ais.
Tugann sé tacar teaghráin ceada atá ag an úsáideoir ar ais, trí cheadanna grúpa agus úsáideora araon.
\nMá chuirtear obj isteach, ní thugann sé ach na ceadanna don réad sonrach seo ar ais.
<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.
<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.
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í.
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.
\nMá ú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.
\nSeo 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
\nBheadh an cód seo go léir ina gcónaí i gcomhad models.py d'aip fíordheimhnithe saincheaptha:
\nfrom django.db import models\nfrom django.contrib.auth.models import BaseUserManager, AbstractBaseUser\n\n\nclass MyUserManager(BaseUserManager):\n def create_user(self, email, date_of_birth, password=None):\n """\n Creates and saves a User with the given email, date of\n birth and password.\n """\n if not email:\n raise ValueError("Users must have an email address")\n\n user = self.model(\n email=self.normalize_email(email),\n date_of_birth=date_of_birth,\n )\n\n user.set_password(password)\n user.save(using=self._db)\n return user\n\n def create_superuser(self, email, date_of_birth, password=None):\n """\n Creates and saves a superuser with the given email, date of\n birth and password.\n """\n user = self.create_user(\n email,\n password=password,\n date_of_birth=date_of_birth,\n )\n user.is_admin = True\n user.save(using=self._db)\n return user\n\n\nclass MyUser(AbstractBaseUser):\n email = models.EmailField(\n verbose_name="email address",\n max_length=255,\n unique=True,\n )\n date_of_birth = models.DateField()\n is_active = models.BooleanField(default=True)\n is_admin = models.BooleanField(default=False)\n\n objects = MyUserManager()\n\n USERNAME_FIELD = "email"\n REQUIRED_FIELDS = ["date_of_birth"]\n\n def __str__(self):\n return self.email\n\n def has_perm(self, perm, obj=None):\n "Does the user have a specific permission?"\n # Simplest possible answer: Yes, always\n return True\n\n def has_module_perms(self, app_label):\n "Does the user have permissions to view the app `app_label`?"\n # Simplest possible answer: Yes, always\n return True\n\n @property\n def is_staff(self):\n "Is the user a member of staff?"\n # Simplest possible answer: All admins are staff\n return self.is_admin\nAnsin, 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:
\nfrom django import forms\nfrom django.contrib import admin\nfrom django.contrib.auth.models import Group\nfrom django.contrib.auth.admin import UserAdmin as BaseUserAdmin\nfrom django.contrib.auth.forms import ReadOnlyPasswordHashField\nfrom django.core.exceptions import ValidationError\n\nfrom customauth.models import MyUser\n\n\nclass UserCreationForm(forms.ModelForm):\n """A form for creating new users. Includes all the required\n fields, plus a repeated password."""\n\n password1 = forms.CharField(label="Password", widget=forms.PasswordInput)\n password2 = forms.CharField(\n label="Password confirmation", widget=forms.PasswordInput\n )\n\n class Meta:\n model = MyUser\n fields = ["email", "date_of_birth"]\n\n def clean_password2(self):\n # Check that the two password entries match\n password1 = self.cleaned_data.get("password1")\n password2 = self.cleaned_data.get("password2")\n if password1 and password2 and password1 != password2:\n raise ValidationError("Passwords don't match")\n return password2\n\n def save(self, commit=True):\n # Save the provided password in hashed format\n user = super().save(commit=False)\n user.set_password(self.cleaned_data["password1"])\n if commit:\n user.save()\n return user\n\n\nclass UserChangeForm(forms.ModelForm):\n """A form for updating users. Includes all the fields on\n the user, but replaces the password field with admin's\n disabled password hash display field.\n """\n\n password = ReadOnlyPasswordHashField()\n\n class Meta:\n model = MyUser\n fields = ["email", "password", "date_of_birth", "is_active", "is_admin"]\n\n\nclass UserAdmin(BaseUserAdmin):\n # The forms to add and change user instances\n form = UserChangeForm\n add_form = UserCreationForm\n\n # The fields to be used in displaying the User model.\n # These override the definitions on the base UserAdmin\n # that reference specific fields on auth.User.\n list_display = ["email", "date_of_birth", "is_admin"]\n list_filter = ["is_admin"]\n fieldsets = [\n (None, {"fields": ["email", "password"]}),\n ("Personal info", {"fields": ["date_of_birth"]}),\n ("Permissions", {"fields": ["is_admin"]}),\n ]\n # add_fieldsets is not a standard ModelAdmin attribute. UserAdmin\n # overrides get_fieldsets to use this attribute when creating a user.\n add_fieldsets = [\n (\n None,\n {\n "classes": ["wide"],\n "fields": ["email", "date_of_birth", "password1", "password2"],\n },\n ),\n ]\n search_fields = ["email"]\n ordering = ["email"]\n filter_horizontal = []\n\n\n# Now register the new UserAdmin...\nadmin.site.register(MyUser, UserAdmin)\n# ... and, since we're not using Django's built-in permissions,\n# unregister the Group model from admin.\nadmin.site.unregister(Group)\nFaoi 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`:
\nAUTH_USER_MODEL = "customauth.MyUser"\nTo optimize performance when called from an async context authentication,\nbackends can implement async versions of each function - aget_user(user_id)\nand aauthenticate(request, **credentials). When an authentication backend\nextends BaseBackend and async versions of these functions are not provided,\nthey will be automatically synthesized with sync_to_async. This has\nperformance penalties.
While an async interface is optional, a synchronous interface is always\nrequired. There is no automatic synthesis for a synchronous interface if an\nasync interface is implemented.
\nDjango's out-of-the-box authentication backends have native async support. If\nthese native backends are extended take special care to make sure the async\nversions of modified functions are modified as well.
\n