---
title: "Fíordheimhniú a shaincheapadh i Django"
version: 5.2
locale: ga
source: https://docs.djangoproject.com/ga/5.2/topics/auth/customizing/
canonical: https://djangodocs.dev/ga/5.2/topics/auth/customizing/
---
# 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](#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

Taobh thiar de na radhairc, coinníonn Django liosta de “cúltaca fíordheimhnithe” a sheiceálann sé le haghaidh fíordheimhnithe. \<how-to-log-a-user-in\>Nuair a ghlaonn duine éigin:func: django.contrib.auth.auth.autenticate () \`-- mar a thuairiscítear in:ref: \`Conas úsáideoir a logáil isteach -- Déanann Django iarracht a fhíordheimhniú ar fud na cúltaca fíordheimhnithe go léir. Má theipeann ar an gcéad mhodh fíordheimhnithe, déanann Django iarracht an dara ceann, agus mar sin de, go dtí go ndéantar iarracht ar gach cúltaca.

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:

```
["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.

> **Note**
>
> Nuair a bheidh úsáideoir fíordheimhnithe, stóráilíonn Django cén cúltaca a úsáideadh chun an t-úsáideoir a fhíordheimhniú i seisiún an úsáideora, agus athúsáideann sé an cúltaca céanna ar feadh ré an tseisiúin sin aon uair a bhíonn rochtain ar an úsáideoir fíordheimhnithe faoi láthair. Ciallaíonn sé seo go héifeachtach go ndéantar foinsí fíordheimhnithe a stóráil ar bhonn in aghaidh na seisiúin, mar sin má athraíonn tú: socrú: AUTHENTICATION\_BACKENDS, beidh ort sonraí seisiúin a ghlanadh más gá duit iallach a chur ar úsáideoirí athfhíordheimhniú ag úsáid modhanna éagsúla. Bealach simplí chun é sin a dhéanamh ná Session.Objects.all () .delete () a fhorghníomhú.

### 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:

```
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:

```
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:

```
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.

Tarmligfidh an tsamhail úsáideora agus a bhainisteoir feidhmeanna cuardaigh ceada (:meth: ~django.contrib.auth.models.user.get\_user\_permuses () \`, :meth: \`~django.contrib.auth.models.user.get\_group\_permuses (), :meth: ~django.contrib.auth.models.get\_all\_Permissions () \`, :meth: \`~django.contrib.auth.models.user.has\_perm (), :meth: ~django.contrib.auth.models.user.has\_module\_perms () \`, agus:meth: \`~django.contrib.auth.models.usermanager.with\_perm (fíordheimhniú)) chuig aon chúlcheann a chuireann na feidhmeanna seo i bhfeidhm.

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.

Má ardaíonn cúltaca eisceacht a:class: ~django.core.exceptions.permissionDenied in:meth: ~django.contrib.auth.models.user.has\_perm () \`nó:meth: \`~django.contrib.auth.models.user.has\_module\_perms (), teipeann ar an údarú láithreach agus ní sheiceálfaidh Django na cúltaca a leanann.

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

```
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:

```
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

```
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ú:

```
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

```pycon
>>> 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:

```
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:

```
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:

```
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:

```
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:

```
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:

```
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:

```
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:

```
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:

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

> **Note**
>
> Ní mór go mbeadh na réimsí riachtanacha go léir ar do mhúnla úsáideora ag `REQUIRED_FIELDS` ach níor chóir go mbeadh an `USERNAME_FIELD` nó `PASFHOCAL` ann mar a spreagfar na réimsí seo i gcónaí.

#### `is_active`

Tréith boolean a léiríonn an meastar go bhfuil an t-úsáideoir “gníomhach”. Cuirtear an tréith seo ar fáil mar thréith ar `AbstractBaseUser` réamhshocraithe go `True`. Braithfidh an chaoi a roghnaíonn tú é a chur i bhfeidhm ar shonraí na gcúltaca auth roghnaithe atá agat. \<django.contrib.auth.models.User.is\_active\>Féach doiciméadú an tréith: attr: is\_active ar an tsamhail úsáideora ionsuite le haghaidh sonraí.

#### `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 .

> **Iompórtáil AbstractBaseUser**
>
> Is féidir `AbstractBaseUser` agus `BaseUserManager` a iompórtáil ó `django.contrib.auth.base_user` ionas gur féidir iad a allmhairiú gan `django.contrib.auth` a áireamh in:setting: INSTALLED\_APPS.

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.

Nuair is é an raw\_password `None`, socraítear an pasfhocal go pasfhocal neamhúsáidte, mar a úsáideadh: meth: ~django.contrib.auth.models.abstractbaseUser.set\_unusable\_password () .

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

Marcaíonn sé an t-úsáideoir nach bhfuil aon pasfhocal socraithe aige. Níl sé seo mar an gcéanna le sreang bán a bheith agat le haghaidh pasfhocal. :meth: ~Django.Contrib.Auth.Models.AbstractBaseUser.Check\_Password () \`ní thabharfaidh an t-úsáideoir seo \`\`True\` ar ais riamh. Ní shábhálann sé an réad:class: ~django.contrib.auth.Models.AbstractBaseUser.

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

Tuairisceáin `False` ife:meth: ~django.contrib.auth.models.abstractbaseUser.set\_unusable\_password () a ghlaoadh don úsáideoir seo.

#### `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`](#django.contrib.auth.models.AbstractUser) subclasses [`AbstractBaseUser`](#django.contrib.auth.models.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:

```
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:

```
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`](#django.contrib.auth.models.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`.

> **Changed in Django 5.2**
>
> `aget_by_natural_key()` method was added.

### 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:

- [`AuthenticationForm`](/ga/5.2/topics/auth/default/#django.contrib.auth.forms.AuthenticationForm): Uses the username
  field specified by [`USERNAME_FIELD`](#django.contrib.auth.models.CustomUser.USERNAME_FIELD).
- [`SetPasswordForm`](/ga/5.2/topics/auth/default/#django.contrib.auth.forms.SetPasswordForm)
- [`PasswordChangeForm`](/ga/5.2/topics/auth/default/#django.contrib.auth.forms.PasswordChangeForm)
- [`AdminPasswordChangeForm`](/ga/5.2/topics/auth/default/#django.contrib.auth.forms.AdminPasswordChangeForm)

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`](/ga/5.2/topics/auth/default/#django.contrib.auth.forms.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()`](#django.contrib.auth.models.AbstractBaseUser.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:

- [`UserCreationForm`](/ga/5.2/topics/auth/default/#django.contrib.auth.forms.UserCreationForm)
- [`UserChangeForm`](/ga/5.2/topics/auth/default/#django.contrib.auth.forms.UserChangeForm)

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:

```
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.

> **Note**
>
> Má tá tú ag úsáid saincheaptha `ModelAdmin` is fo-aicme de Django.contrib.auth.admin.userAdmin\`, ansin ní mór duit do réimsí saincheaptha a chur le fieldsets\` (le haghaidh réimsí le húsáid chun úsáideoirí in eagarthóireacht) agus `add_fieldsets` (le haghaidh réimsí le húsáid agus úsáideoir á chruthú). Mar shampla:
>
> ```
> from django.contrib.auth.admin import UserAdmin
>
>
> class CustomUserAdmin(UserAdmin):
>     ...
>     fieldsets = UserAdmin.fieldsets + ((None, {"fields": ["custom_field"]}),)
>     add_fieldsets = UserAdmin.add_fieldsets + ((None, {"fields": ["custom_field"]}),)
> ```
>
> Féach: ref: sampla iomlán \<custom-users-admin-full-example\>\`le haghaidh tuilleadh sonraí.

### Ú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`](#django.contrib.auth.models.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í.

> **PermissionsMixin agus ModelBackend**
>
> Mura gcuireann tú an: class: ~django.contrib.auth.models.permissionsMixin san áireamh, ní mór duit a chinntiú nach gcuireann tú na modhanna ceadanna ar ModelBackend\`. Glacann `ModelBackend` leis go bhfuil réimsí áirithe ar fáil ar do mhúnla úsáideora. Mura soláthraíonn do mhúnla úsáideora na réimsí sin, gheobhaidh tú earráidí bunachar sonraí nuair a sheiceálann tú ceadanna.

### Ú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:

```
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:

```
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\`:

```
AUTH_USER_MODEL = "customauth.MyUser"
```

#### Adding an async interface

> **New in Django 5.2**

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](/ga/5.2/topics/async/#async-performance).

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.