Córas fíordheimhnithe Django a úsáidLink to this heading

Míníonn an doiciméad seo úsáid chóras fíordheimhnithe Django ina chumraíocht réamhshocraithe. Tá an chumraíocht seo tagtha chun cinn chun freastal ar na riachtanais tionscadail is coitianta, ag láimhseáil raon réasúnta leathan tascanna, agus tá pasfhocail agus ceadanna curtha i bhfeidhm Maidir le tionscadail ina bhfuil riachtanais fíordheimhnithe difriúil ó na réamhshocraithe, tacaíonn Django le fairsing:doc: `síneadh agus saincheapach' fíordheimhnithe </topics/auth/customizing>.

Soláthraíonn fíordheimhniú Django fíordheimhniú agus údarú le chéile agus go ginearálta tugtar an córas fíordheimhnithe air, toisc go bhfuil na gnéithe seo cúpláilte

``Úsáideoir ``rudaíLink to this heading

User objects are the core of the authentication system. They typically represent the people interacting with your site and are used to enable things like restricting access, registering user profiles, associating content with creators etc. Only one class of user exists in Django's authentication framework, i.e., 'superusers' or admin 'staff' users are just user objects with special attributes set, not different classes of user objects.

Is iad príomhthréithe an úsáideora réamhshocraithe:

Féach an:class: `doiciméadú iomlán API <django.contrib.auth.models.User>`le haghaidh tagartha iomlán, tá an doiciméadú a leanas níos dírithe ar thasc.

úsáideoirí a chruthúLink to this heading

Is é an bealach is díreach chun úsáideoirí a chruthú ná an fheidhm chúntóra san áireamh: meth: ~django.contrib.auth.models.userManager.create_user a úsáid:

Python console
>>> from django.contrib.auth.models import User
>>> user = User.objects.create_user("john", "lennon@thebeatles.com", "johnpassword")

# At this point, user is a User object that has already been saved
# to the database. You can continue to change its attributes
# if you want to change other fields.
>>> user.last_name = "Lennon"
>>> user.save()

<auth-admin>Má tá riarachán Django suiteáilte agat, is féidir leat freis:ref: úsáideoirí a chruthú go idirghníomhach.

Superusers a chruthúLink to this heading

Cruthaigh sárúsáideoirí ag baint úsáide as an ordú:djadmin: createsuperuser:

Linux / macOS

Shell
$ python manage.py createsuperuser --username=joe --email=joe@example.com

Windows

Windows
...\> py manage.py createsuperuser --username=joe --email=joe@example.com

Cuirfear pasfhocal ort. Tar éis duit ceann a iontráil, cruthófar an t-úsáideoir láithreach. Má fhágann tú na roghanna: rogha: --ainm úsáideora <createsuperuser --username>`nó: rogha: `--ríomhphost, spreagfaidh sé tú do na <createsuperuser --email>luachanna sin.

Athrú pasfhocailLink to this heading

Ní stóráilíonn Django pasfhocail amh (téacs soiléir) ar an tsamhail úsáideora, ach ach hash amháin (féach: doc: `doiciméadú ar an gcaoi a mbainistítear pasfhocail `le haghaidh sonraí iomlána). </topics/auth/passwords> Mar gheall air seo, ná déan iarracht tréith pasfhocal an úsáideora a ionramháil go díreach. Sin é an fáth go n-úsáidtear feidhm chúntóra agus úsáideoir á chruthú.

Chun pasfhocal úsáideora a athrú, tá roinnt roghanna agat:

manage.py changepassword *username* offers a method of changing a user's password from the command line. It prompts you to change the password of a given user which you must enter twice. If they both match, the new password will be changed immediately. If you do not supply a user, the command will attempt to change the password whose username matches the current system user.

Is féidir leat pasfhocal a athrú go cláraitheach freisin, ag baint úsáid:meth: `~django.contrib.auth.models.user.set_password () `:

Python console
>>> from django.contrib.auth.models import User
>>> u = User.objects.get(username="john")
>>> u.set_password("new password")
>>> u.save()

<auth-admin>Má tá riarachán Django suiteáilte agat, is féidir leat pasfhocail an úsáideora a athrú ar leathanaigh riaracháin an chórais fíordheimhniúcháin: ref: `.

Soláthraíonn Django freis:ref: views <built-in-auth-views>`agus:ref: `foirmeacha is féidir a úsáid chun ligean d'úsáideoirí a <built-in-auth-forms>gcuid pasfhocail féin a athrú.

Athrú pasfhocal úsáideora logálfar amach a seisiúin go léir. Féach: Ref: `seision-invalidation-on-pasfho-athraithe' le haghaidh sonraí.

Úsáideoirí fíordheimhnitheLink to this heading

authenticate(request=None, **credentials)Link to this definition
aauthenticate(request=None, **credentials)Link to this definition

Asynchronous version: aauthenticate()

Úsáid: func: ~django.contrib.auth.autenticate () `chun tacar dintiúir a fhíorú. Glacann sé dintiúir mar argóintí eochairfhocal, ``ainm úsáideora ``agus `pasfhocal` don chás réamhshocraithe, seiceálann sé iad i gcoinne gach ceann:ref: backend fíordheimhniúcháin `, agus filleann a:class: `~django.contrib.auth.models.user<authentication-backends>` réad na dintiúir bailí le haghaidh cúltaca. Mura bhfuil na dintiúir bailí d'aon chúltaca ardaíonn cúltaca: class: `~django.core.exceptions.permissionDenied`, filleann ``None. Mar shampla:

Code
from django.contrib.auth import authenticate

user = authenticate(username="john", password="secret")
if user is not None:
    # A backend authenticated the credentials
    ...
else:
    # No backend authenticated the credentials
    ...

Is é request roghnaí:class: ~django.http.httpRequest a chuirtear ar an modh ``fíordheimhniú () ``de na cúltaca fíordheimhnithe.

Ceadanna agus ÚdarúLink to this heading

Tagann Django le córas ceadanna ionsuite. Soláthraíonn sé bealach chun ceadanna a shannadh d'úsáideoirí agus do ghrúpaí úsáideoirí ar leith.

Úsáideann suíomh riaracháin Django é, ach tá fáilte romhat é a úsáid i do chód féin.

Úsáideann suíomh riaracháin Django ceadanna mar seo a leanas:

  • Tá rochtain ar rudaí féachana teoranta d'úsáideoirí a bhfuil an cead “amharc” nó “athraigh” acu don chineál réada sin.

  • Tá rochtain chun an fhoirm “cuir leis” a fheiceáil agus réad a chur leis teoranta d'úsáideoirí a bhfuil cead “cuir leis” don chineál réada sin.

  • Tá rochtain chun an liosta athraithe a fheiceáil, féachaint ar an bhfoirm “athraigh” agus réad a athrú teoranta d'úsáideoirí a bhfuil cead “athraithe” acu don chineál réada sin.

  • Tá rochtain chun réad a scriosadh teoranta d'úsáideoirí a bhfuil cead “scrios” acu don chineál réada sin.

Is féidir ceadanna a shocrú ní amháin in aghaidh an chineál réada, ach freisin de réir shampla réad ar leith. Trí úsáid a:meth: ~django.contrib.admin.modeladmin.has_view_permission, :meth: ~django.contrib.admin.modeladmin.has_add_permission, :meth: ~django.contrib.admin.modeladmin.has_change_permission agus:meth: ~django.contrib.Modhanna admin.modeladmin.has_delete_permission a sholáthraíonn an rang:class: ~django.contrib.admin.modelAdmin, is féidir ceadanna a shaincheapadh do chásanna réad éagsúla den chineál céanna.

User objects have two many-to-many fields: groups and user_permissions. User objects can access their related objects in the same way as any other Django model:

Code
myuser.groups.set([group_list])
myuser.groups.add(group, group, ...)
myuser.groups.remove(group, group, ...)
myuser.groups.clear()
myuser.user_permissions.set([permission_list])
myuser.user_permissions.add(permission, permission, ...)
myuser.user_permissions.remove(permission, permission, ...)
myuser.user_permissions.clear()

Ceadanna réamhshocraiLink to this heading

Nuair a liostaítear django.contrib.auth i do shuíomh: INSTALLED_APPS, cinnteoidh sé go gcruthaítear ceithre chead réamhshocraithe -- cuir, athrú, scrios agus amharc - do gach samhail Django atá sainmhínithe i gceann de d'fheidhmchláir suiteáilte.

Cruthófar na ceadanna seo nuair a rith t:djadmin: manage.py migration <migrate>; an chéad uair a reáchtáil tú `migrate tar éis django.contrib.auth a chur chuig:setting: INSTALLED_APPS, cruthófar na ceadanna réamhshocraithe do gach samhail atá suiteáilte roimhe seo, chomh maith le haghaidh aon mhúnlaí nua atá suiteáilte ag an am sin. Ina dhiaidh sin, cruthóidh sé ceadanna réamhshocraithe do mhúnlaí nua gach uair 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).

Ag glacadh leis go bhfuil feidhmchlár agat le an:attr: ~django.db.models.options.app_label foo agus samhail darb ainm Bar, chun tástáil a dhéanamh ar cheadanna bunúsacha ba chóir duit a úsáid:

  • cuir leis: ``user.has_perm ('foo.add_bar') ``

  • athrú: ``user.has_perm ('foo.change_bar') ``

  • scrios: ``user.has_perm ('foo.delete_bar') ``

  • amharc: ``user.has_perm ('foo.view_bar') ``

Is annamh a bhíonn rochtain dhíreach ar an msamhail:class: ~django.contrib.auth.models.permission.

GrúpaíLink to this heading

django.contrib.auth.models.Group models are a generic way of categorizing users so you can apply permissions, or some other label, to those users. A user can belong to any number of groups.

Tá na ceadanna deonaithe don ghrúpa sin go huathoibríoch ag úsáideoir i ngrúpa. Mar shampla, má tá an cead can_edit_home_page` ag an ngrúpa eagarthóirí láithreáin, beidh an cead sin ag aon úsáideoir sa ghrúpa sin.

Seachas ceadanna, is bealach áisiúil iad grúpaí chun úsáideoirí a chatagóiriú chun roinnt lipéad, nó feidhmiúlacht leathnaithe a thabhairt Mar shampla, d'fhéadfá grúpa ````Úsáideoirí speisialta' a chruthú, agus d'fhéadfá cód a scríobh a d'fhéadfadh, abair, rochtain a thabhairt dóibh ar chuid de do shuíomh do bhaill amháin, nó teachtaireachtaí ríomhphoist do bhaill amháin a sheoladh chucu.

Ceadanna a chruthú go cláraitheachLink to this heading

Cé gur féidir ceadanna saincheaptha a shainiú laisti <custom-permissions>gh de rang Meta` samhail, is féidir leat ceadanna a chruthú go díreach freisin. Mar shampla, is féidir leat an cead ``can_publish ``a chruthú do mhúnla ``blogpost i myapp`:

Code
from myapp.models import BlogPost
from django.contrib.auth.models import Permission
from django.contrib.contenttypes.models import ContentType

content_type = ContentType.objects.get_for_model(BlogPost)
permission = Permission.objects.create(
    codename="can_publish",
    name="Can Publish Posts",
    content_type=content_type,
)

Is féidir an cead a shannadh ansin do a:class: ~django.contrib.auth.models.user tríd a thréith user_permissions nó chuig a:class: ~django.contrib.auth.models.group trína tréith permissions.

Cacháil ceadannaLink to this heading

Cuireann an: Class: ~django.contrib.auth.backends.modelBackend ceadanna ar an réad úsáideora tar éis an chéad uair is gá iad a fháil le haghaidh seiceáil ceadanna. De ghnáth bíonn sé seo go breá don timthriall iarrata-freagartha ós rud é nach ndéantar ceadanna a sheiceáil de ghnáth díreach tar éis iad a chur leis (sa riarachán, mar shampla). Má tá ceadanna á chur leis agus iad a sheiceáil díreach ina dhiaidh sin, i dtástáil nó i radharc mar shampla, is é an réiteach is éasca an t-úsáideoir a fháil ón mbunachar sonraí a ath-fháil. Mar shampla:

Code
from django.contrib.auth.models import Permission, User
from django.contrib.contenttypes.models import ContentType
from django.shortcuts import get_object_or_404

from myapp.models import BlogPost


def user_gains_perms(request, user_id):
    user = get_object_or_404(User, pk=user_id)
    # any permission check will cache the current set of permissions
    user.has_perm("myapp.change_blogpost")

    content_type = ContentType.objects.get_for_model(BlogPost)
    permission = Permission.objects.get(
        codename="change_blogpost",
        content_type=content_type,
    )
    user.user_permissions.add(permission)

    # Checking the cached permission set
    user.has_perm("myapp.change_blogpost")  # False

    # Request new instance of User
    # Be aware that user.refresh_from_db() won't clear the cache.
    user = get_object_or_404(User, pk=user_id)

    # Permission cache is repopulated from the database
    user.has_perm("myapp.change_blogpost")  # True

    ...

Múnlaí proxyLink to this heading

Oibríonn samhlacha seachfhreastalaí go díreach ar an mbealach céanna Cruthaítear ceadanna ag baint úsáide as cineál ábhair féin an tsamhail seachfhreastalaí Ní fhaigheann samhlacha seachfhreastalaí ceadanna an tsamhail choincréite a fho-aicmigh siad:

Code
class Person(models.Model):
    class Meta:
        permissions = [("can_eat_pizzas", "Can eat pizzas")]


class Student(Person):
    class Meta:
        proxy = True
        permissions = [("can_deliver_pizzas", "Can deliver pizzas")]
Python console
>>> # Fetch the content type for the proxy model.
>>> content_type = ContentType.objects.get_for_model(Student, for_concrete_model=False)
>>> student_permissions = Permission.objects.filter(content_type=content_type)
>>> [p.codename for p in student_permissions]
['add_student', 'change_student', 'delete_student', 'view_student',
'can_deliver_pizzas']
>>> for permission in student_permissions:
...     user.user_permissions.add(permission)
...
>>> user.has_perm("app.add_person")
False
>>> user.has_perm("app.can_eat_pizzas")
False
>>> user.has_perms(("app.add_student", "app.can_deliver_pizzas"))
True

Fíordheimhniú in iarratais gréasáinLink to this heading

</topics/http/sessions> <django.http.HttpRequest>Úsáideann Django: doc: seisiúin agus middleware chun an córas fíordheimhnithe a cheangal la:class: `iarr rudaí `.

<django.http.HttpRequest.auser>Soláthraíonn siad seo a: attr: request.user <django.http.HttpRequest.user>`tréith agus a:meth: `request.auser modh async ar gach iarratas a léiríonn an t-úsáideoir reatha. Mura bhfuil an t-úsáideoir reatha logáil isteach, socraítear an tréith seo go sampla de:class: ~django.contrib.auth.models.anonymousUser, ar shlí eile beidh sé ina shampla de:class: ~django.contrib.auth.models.user.

Is féidir leat iad a insint óna chéile la:attr: ~django.contrib.auth.models.user.is_Authenticated, mar sin:

Code
if request.user.is_authenticated:
    # Do something for authenticated users.
    ...
else:
    # Do something for anonymous users.
    ...

Nó i radharc asincrónach:

Code
user = await request.auser()
if user.is_authenticated:
    # Do something for authenticated users.
    ...
else:
    # Do something for anonymous users.
    ...

Conas úsáideoir a logáil isteachLink to this heading

Má tá úsáideoir fíordheimhnithe agat gur mhaith leat a cheangal leis an seisiún reatha - déantar é seo le feidhm a:func: ~django.contrib.auth.login.

login(request, user, backend=None)Link to this definition
alogin(request, user, backend=None)Link to this definition

Asynchronous version: alogin()

Chun úsáideoir a logáil isteach, ó radharc, bain úsáid as: func: ~django.contrib.auth.login () `. Tógann sé: aicme: `~django.http.httpRequest réad agus a:class: ~django.contrib.auth.models.user réad. :func: Sábhálann `~django.contrib.auth.login () `ID an úsáideora sa seisiún, ag baint úsáide as creat seisiúin Django.

Tabhair faoi deara go gcoinnítear aon tacar sonraí le linn an tseisiúin gan ainm sa seisiún tar éis úsáideoir logáil isteach.

Taispeánann an sampla seo conas a d'fhéadfá an dá cheann a úsáid:func: ~django.contrib.auth.auth.autenticate () `agus:func: `~django.contrib.auth.login ():

Code
from django.contrib.auth import authenticate, login


def my_view(request):
    username = request.POST["username"]
    password = request.POST["password"]
    user = authenticate(request, username=username, password=password)
    if user is not None:
        login(request, user)
        # Redirect to a success page.
        ...
    else:
        # Return an 'invalid login' error message.
        ...

An cúltaca fíordheimhnithe a roghnúLink to this heading

Nuair a logálann úsáideoir isteach, sábhálfar aitheantas an úsáideora agus an cúltaca a úsáideadh le haghaidh fíordheimhnithe i seisiún an úsáideora. Ligeann sé seo an chéanna: ref: `backend fíordheimhniúcháin <authentication-backends>`sonraí an úsáideora a fháil ar iarratas amach anseo. Roghnaítear an cúltaca fíordheimhnithe le sábháil sa seisiún mar seo a leanas:

  1. Úsáid luach an argóint roghnach ``backend`, má chuirtear ar fáil.

  2. Úsáid luach an tréith user.backend, má tá sé ann. Ceadaíonn sé seo péireáil: func: ~django.contrib.auth.autenticate () `agus:func: `~django.contrib.auth.login (): :func: ~django.contrib.auth.auth.autenticate () `socraíonn an tréith ``user.backend` ar an réad úsáideora a fhilleann sé.

  3. Úsáid an backend in:setting: AUTHENTICATION_BACKENDS, mura bhfuil ach ceann amháin ann.

  4. Seachas sin, ardaigh eisceacht.

I gcásanna 1 agus 2, ba chóir go mbeadh luach an argóint backend nó an tréith user.backend ina shreang cosán allmhairiúcháin poncaí (cosúil leis sin a fhaightear in:setting: AUTHENTICATION_BACKENDS), ní an aicme cúltaca iarbhír.

Conas úsáideoir a logáil amachLink to this heading

logout(request)Link to this definition
alogout(request)Link to this definition

Asynchronous version: alogout()

Chun logáil amach úsáideoir atá logáilte isteach trí:func: django.contrib.auth.login () `, bain úsáid as: func: `django.contrib.auth.logout () laistigh de d'amharc. Tógann sé réad: class: ~django.http.httpRequest agus níl aon luach tuairisceáin aige. Sampla:

Code
from django.contrib.auth import logout


def logout_view(request):
    logout(request)
    # Redirect to a success page.

Tabhair faoi deara nach gcaitheann :func: `~django.contrib.auth.logout () `aon earráidí mura raibh an t-úsáideoir logáilte isteach.

Nuair a ghlaonn tú: func: `~django.contrib.auth.logout () `, glantar sonraí na seisiúin don iarraidh reatha go hiomlán amach. Baintear na sonraí go léir atá ann cheana. Is é seo chun cosc a chur ar dhuine eile an brabhsálaí gréasáin céanna a úsáid chun logáil isteach agus rochtain a fháil ar shonraí seisiún an úsáideora roimhe seo. Más mian leat rud ar bith a chur isteach sa seisiún a bheidh ar fáil don úsáideoir díreach tar éis logáil amach, déan sean*tar éis dó* glaoi:func: `django.contrib.auth.logout () `.

Rochtain a theorannú ar úsáideoirí logáilte isteachLink to this heading

An bealach amhLink to this heading

<django.contrib.auth.models.User.is_authenticated>Is é an bealach amh chun rochtain ar leathanaigh a theorannú ná seiceál:attr: `request.user.is_authorated `agus ceachtar acu a atreorú chuig leathanach logála isteach:

Code
from django.conf import settings
from django.shortcuts import redirect


def my_view(request):
    if not request.user.is_authenticated:
        return redirect(f"{settings.LOGIN_URL}?next={request.path}")
    # ...

... nó teachtaireacht earráide a thaispeáint:

Code
from django.shortcuts import render


def my_view(request):
    if not request.user.is_authenticated:
        return render(request, "myapp/login_error.html")
    # ...

An maisitheoir login_requiredLink to this heading

login_required(redirect_field_name='next', login_url=None)Link to this definition

Mar aicearra, is féidir leat an maisitheoir áisiúil: func: ~django.contrib.auth.decorators.login_required a úsáid:

Code
from django.contrib.auth.decorators import login_required


@login_required
def my_view(request): ...

login_required() does the following:

  • Mura bhfuil an t-úsáideoir logáilte isteach, atreoraigh chuig:setting: settings.login_url <LOGIN_URL>, ag dul ar an gcosán iomlán reatha sa sreangán fiosrúcháin. Sampla: /cuntais/logáil isteach/? next =/polls/3/.

  • Má tá an t-úsáideoir logáilte isteach, déan an radharc a dhéanamh de ghnáth. Tá an cód amharc saor in aisce glacadh leis go bhfuil an t-úsáideoir logáilte isteach.

De réir réamhshocraithe, stóráiltear an cosán ar chóir an t-úsáideoir a atreorú chuig nuair a fhíordheimhniú rathúil i bparaiméadar teaghrán ceisteanna ar a dtugtar "next” `. Más fearr leat ainm difriúil a úsáid don pharaiméadar seo, glacann: :func: `~django.contrib.auth.decorators.login_required` paraiméadar roghnach ``redirect_field_name:

Code
from django.contrib.auth.decorators import login_required


@login_required(redirect_field_name="my_redirect_field")
def my_view(request): ...

Tabhair faoi deara má sholáthraíonn tú luach do redirect_field_name`, is dócha go mbeidh ort do theimpléad logála isteach a shaincheapadh freisin, ós rud é go n-úsáidfidh an athróg comhthéacs teimpléid a stóráilíonn an cosán atreoraithe luach redirect_field_name mar eochair seachas ``"next” `(an réamhshocraithe).

login_required() also takes an optional login_url parameter. Example:

Code
from django.contrib.auth.decorators import login_required


@login_required(login_url="/accounts/login/")
def my_view(request): ...

<LOGIN_URL>Tabhair faoi deara mura sonraíonn tú an paraiméadar ``login_url ``, beidh ort a chinntiú go bhfuil baint i gceart la:setting: `settings.login_URL `agus d'amharc logála isteach. Mar shampla, ag baint úsáide as na réamhshocruithe, cuir na línte seo a leanas le do URLConf:

Code
from django.contrib.auth import views as auth_views

path("accounts/login/", auth_views.LoginView.as_view()),

<naming-url-patterns>Glacann an: setting: settings.login_URL <LOGIN_URL>`le hainmneacha feidhm amharc agus:ref: `patrúin URL ainmnithe. Ligeann sé seo duit do radharc logála isteach a athmhapáil go saor laistigh de do URLConf gan an socrú a nuashonrú.

An meascán LoginRequiredMixinLink to this heading

Nuair a úsáideann tú: doc: tuairimí rang-bhunaithe ', is féidir leat an t-iompar céanna a bhaint amach agus le ``login_required` </topics/class-based-views/index> tríd an LoginRequiredMixin` a úsáid. Ba chóir go mbeadh an meascán seo ag an suíomh is clé sa liosta oidhreachta.

class LoginRequiredMixinLink to this definition

Má tá an mixin seo á úsáid ag amharc, atreorófar gach iarratas ó úsáideoirí neamh-fhíordheimhnithe chuig an leathanach logála isteach nó taispeánfar earráid toirmiscthe HTTP 403, ag brath ar an bparaiméadar: attr: ~django.contrib.auth.mixins.accessmixin.raise_exception.

Is féidir leat aon cheann de na paraiméadair de:class: ~django.contrib.auth.mixins.accessMixin a shocrú chun láimhseáil úsáideoirí neamhúdaraithe a shaincheapadh:

Code
from django.contrib.auth.mixins import LoginRequiredMixin


class MyView(LoginRequiredMixin, View):
    login_url = "/login/"
    redirect_field_name = "redirect_to"

An maisitheoir login_not_requiredLink to this heading

Nuair a bhíonn: Class: ~django.contrib.auth.middleware.loginrequiredMiddleware suiteáilte, teastaíonn fíordheimhniú de réir réamhshocraithe ó gach radharc. B'fhéidir go mbeidh ar roinnt tuairimí, mar shampla an radharc logála isteach, an t-iompar seo a dhíchumas

login_not_required()Link to this definition

Ceadaíonn sé iarratais neamhfhíordheimhnithe chuig an radharc seo nuai:class: ~django.contrib.auth.middleware.loginrequiredMiddleware suiteáilte.

Rochtain a theorannú ar úsáideoirí logáilte isteach a rachaidh tástáilLink to this heading

Chun rochtain a theorannú bunaithe ar cheadanna áirithe nó ar thástáil éigin eile, déanfá an rud céanna go bunúsach mar a thuairiscítear sa chuid roimhe seo.

<django.http.HttpRequest.user>Is féidir leat do thástáil a reáchtáil ar:attr: `request.user `sa radharc go díreach. Mar shampla, seiceálann an radharc seo chun a chinntiú go bhfuil ríomhphost ag an úsáideoir sa réimse atá ag teastáil agus mura bhfuil, atreoraíonn sé chuig an leathanach logála isteach:

Code
from django.shortcuts import redirect


def my_view(request):
    if not request.user.email.endswith("@example.com"):
        return redirect("/login/?next=%s" % request.path)
    # ...
user_passes_test(test_func, login_url=None, redirect_field_name='next')Link to this definition

Mar aicearra, is féidir leat an maisitheoir áisiúil user_passes_test a úsáid a dhéanann atreorú nuair a fhilleann an t-inghlaoch False:

Code
from django.contrib.auth.decorators import user_passes_test


def email_check(user):
    return user.email.endswith("@example.com")


@user_passes_test(email_check)
def my_view(request): ...

user_passes_test() takes a required argument: a callable that takes a User object and returns True if the user is allowed to view the page. Note that user_passes_test() does not automatically check that the User is not anonymous.

user_passes_test() takes two optional arguments:

log_url

Ligeann duit an URL a shonrú a atreorófar úsáideoirí nach rachaidh an tástáil chuig. <LOGIN_URL>D'fhéadfadh go mbeadh sé ina leathanach logála isteach agus réamhshocraithe to:setting: `settings.login_url `mura sonraíonn tú ceann amháin.

ainm_redirect_field

Mar an gcéanna le haghaidh: func: ~django.contrib.auth.decorators.login_required. Ag socrú é go ``None ``baintear é as an URL, rud a d'fhéadfá a dhéanamh má tá tú ag atreorú úsáideoirí nach dtéann an tástáil chuig leathanach neamh-logála isteach nach bhfuil “an chéad leathanach eile” ann.

Mar shampla:

Code
@user_passes_test(email_check, login_url="/login/")
def my_view(request): ...
class UserPassesTestMixinLink to this definition

Nuair a úsáideann tú: doc: tuairimí rang-bhunaithe ', is féidir leat an ``UserPassestestMixin` a úsáid chun </topics/class-based-views/index> é seo a dhéanamh.

test_func()Link to this definition

Caithfidh tú an modh test_func () ``den rang a shárú chun an tástáil a dhéantar a sholáthar. Ina theannta sin, is féidir leat aon cheann de na paraiméadair de:class: `~django.contrib.auth.mixins.accessMixin a shocrú chun láimhseáil úsáideoirí neamhúdaraithe a shaincheapadh:

Code
from django.contrib.auth.mixins import UserPassesTestMixin


class MyView(UserPassesTestMixin, View):
    def test_func(self):
        return self.request.user.email.endswith("@example.com")
get_test_func()Link to this definition

Is féidir leat an modh ``get_test_func () ``a shárú freisin chun feidhm ainmnithe difriúil a úsáideann an mixin dá sheiceálacha (in ionad:meth: test_func).

An maisitheoir ceadú_riachtanaLink to this heading

permission_required(perm, login_url=None, raise_exception=False)Link to this definition

Is tasc réasúnta coitianta é a sheiceáil an bhfuil cead áirithe ag úsáideoir. Ar an gcúis sin, soláthraíonn Django aicearra don chás sin: the:func: `~django.contrib.auth.decorators.permission_required () `decorator:

Code
from django.contrib.auth.decorators import permission_required


@permission_required("polls.add_choice")
def my_view(request): ...

<app label>Díreach cosúil leis an modh:meth: ~django.contrib.auth.models.user.has_perm, glacann ainmneacha ceada an fhoirm ”. <permission codename>“``(ie ``polls.add_choice le haghaidh cead ar mhúnla san iarratas polls).

Féadfaidh an maisitheoir ceadanna in-athraithe a ghlacadh freisin, agus sa chás sin caithfidh na ceadanna go léir a bheith ag an úsáideoir chun rochtain a fháil ar an radharc.

Tabhair faoi deara go dtógann: func: `~django.contrib.auth.decorators.permission_required () `paraiméadar roghnach ``login_url ``freisin:

Code
from django.contrib.auth.decorators import permission_required


@permission_required("polls.add_choice", login_url="/loginpage/")
def my_view(request): ...

<LOGIN_URL>Mar atá sa maisitheoir: func: ~django.contrib.auth.decorators.login_required, réamhshocraithe ``login_url ``: socrú: `Settings.login_url `.

<http_forbidden_view>Má thugtar an paraiméadar raise_exception, ardóidh an maisitheoir:exc: ~django.core.exceptions.permissiondenied, ag iarraidh:ref: `an amharc 403 (HTTP Forbidden) `in ionad atreorú chuig an leathanach logála isteach.

Más mian leat raise_exception a úsáid ach deis a thabhairt d'úsáideoirí logáil isteach ar dtús, is féidir leat an maisitheoir: func: ~django.contrib.auth.decorators.login_required a chur leis:

Code
from django.contrib.auth.decorators import login_required, permission_required


@login_required
@permission_required("polls.add_choice", raise_exception=True)
def my_view(request): ...

Seachnaíonn sé seo lúb atreoraithe freisin nuai:class: .loginView Redirect_Authenticated_user=True agus níl na ceadanna riachtanacha go léir ag an úsáideoir logáilte isteach.

An meascán Ceadúnas RequiredMixinLink to this heading

Chun seiceálacha ceada a chur i bhfeidhm chuig:doc: tuairimí rang-bhunaithe ', is féidir leat an ``PermissionRequiredMixin` </ref/class-based-views/index> a úsáid:

class PermissionRequiredMixinLink to this definition

Seiceálann an meascán seo, díreach cosúil leis an maisitheoir permission_required, an bhfuil gach cead tugtha ag an úsáideoir a rochtain ar radharc. Ba chóir duit an cead a shonrú (nó ceadanna inathraithe) ag baint úsáide as an paraiméadar permission_required:

Code
from django.contrib.auth.mixins import PermissionRequiredMixin


class MyView(PermissionRequiredMixin, View):
    permission_required = "polls.add_choice"
    # Or multiple of permissions:
    permission_required = ["polls.view_choice", "polls.change_choice"]

Is féidir leat aon cheann de na paraiméadair de:class: ~django.contrib.auth.mixins.accessMixin a shocrú chun láimhseáil úsáideoirí neamhúdaraithe a shaincheapadh.

Féadfaidh tú na modhanna seo a shárú freisin:

get_permission_required()Link to this definition

Tugann sé ainmneacha ceada a úsáideann an mixin ar ais. Réamhshocraithe go dtí an tréith permission_required, a thiontú go tuple más gá.

has_permission()Link to this definition

Filleann boolean a thugann le fios an bhfuil cead ag an úsáideoir reatha an radharc maisithe a fhorghníomhú. De réir réamhshocraithe, filleann sé seo toradh glaoi:meth: ~django.contrib.auth.models.user.has_perms () `leis an liosta ceadanna ar ais ar:meth: `get_permission_required ().

Iarrataí neamhúdaraithe a atreorú i dtuairimí bunaitheLink to this heading

Chun láimhseáil srianta rochtana in:doc: tuairimí rang-bhunaithe 'a mhaolú, is féidir an ``AccessMixin` a úsáid chun iompar radharc a chumrú nuair a dhiúlta</ref/class-based-views/index> ítear rochtain. Diúltaítear rochtain d'úsáideoirí fíordheimhnithe le freagra toirmiscthe HTTP 403. Atreoraítear úsáideoirí gan ainm chuig an leathanach logála isteach nó taispeántar freagra toirmiscthe HTTP 403, ag brath ar thréith: attr: ~django.contrib.auth.mixins.accessmixin.raise_exception.

class AccessMixinLink to this definition
login_urlLink to this definition

Luach tuairisceáin réamhshocraithe le haghaidh: meth: get_login_url. <LOGIN_URL>Réamhshocraithe go None ina dtagann cás: meth: get_login_url ar ais chuig: socrú: `settings.login_url `.

permission_denied_messageLink to this definition

Luach tuairisceáin réamhshocraithe le haghaidh: meth: get_permission_denied_message. Réamhshocraithe chuig teaghrán folamh.

redirect_field_nameLink to this definition

Luach tuairisceáin réamhshocraithe le haghaidh: meth: get_redirect_field_name. Réamhshocraithe go ``"eile” ``.

raise_exceptionLink to this definition

Má tá an tréith seo socraithe go True, ardaítear eisceacht: a:class: ~django.core.Exceptions.PermissionDenied nuair nach gcomhlíontar na coinníollacha. Nuair a dhéantar False` (an réamhshocrú), atreoraítear úsáideoirí gan ainm chuig an leathanach logála isteach.

get_login_url()Link to this definition

Tugann sé an URL ar ais a atreorófar úsáideoirí nach rachaidh an tástáil chuig. <LOGIN_URL>Tuairisceáin: attr: login_url má tá sé socraithe, nó: setting: `settings.login_url `ar shlí eile.

get_permission_denied_message()Link to this definition

Nuair: attr: raise_exception True, is féidir an modh seo a úsáid chun an teachtaireacht earráide a chuirtear chuig an láimhseálaí earráide a rialú lena thaispeáint don úsáideoir. Tugann an tréith: attr: permission_denied_message ar ais de réir réamhshocraithe.

get_redirect_field_name()Link to this definition

Tugann sé ainm an pharaiméadair fiosrúcháin ina mbeidh an URL ba chóir an t-úsáideoir a atreorú chuig tar éis logáil isteach rathúil. Má shocraíonn tú é seo go ``None ``, ní chuirfear paraiméadar ceisteanna leis. Tugann an tréith: attr: redirect_field_name ar ais de réir réamhshocraithe.

handle_no_permission()Link to this definition

Ag brath ar luach raise_exception, ardaíonn an modh eisceacht a:exc: ~django.core.exceptions.permissionDenied nó atreoraíonn an t-úsáideoir chuig an login_url `, roghnach lena n-áirítear an redirect_field_name má tá sé socraithe.

Neamhbhailí seisiúin ar athrú pasfhocalLink to this heading

Má tá do: setting: AUTH_USER_MODEL oidhreacht ó:class: ~django.contrib.auth.models.abstractBaseUser nó má chuireann sé a modh féin: meth: ~django.contrib.auth.models.abstractBaseUser.get_session_auth_hash () `san áireamh seisiúin fhíordheimhnithe an hash ar ais ag an bhfeidhm seo. Sa chás: class: `~django.contrib.auth.Models.AbstractBaseUser, is HMAC é seo den réimse pasfhocal. Fíoraíonn Django go n-oireann an hash sa seisiún do gach iarratas leis an gceann a ríomhtar le linn na hiarratais. Ligeann sé seo d'úsáideoir a gcuid seisiúin go léir a logáil amach trína bhfocal faire a athrú.

Na tuairimí athraithe pasfhocal réamhshocraithe san áireamh le Django, :class: ~django.contrib.auth.views.passwordChangeView agus an radharc user_change_password in:mod: django.contrib.auth admin, nuashonraigh an seisiún leis an hash pasfhocal nua ionas nach logálfaidh úsáideoir a phasfhocal féin. Má tá amharc saincheaptha athraithe pasfhocal agat agus má theastaíonn uait iompar den chineál céanna a bheith agat, bain úsáid as an bhfeidhm:func: update_session_auth_hash.

update_session_auth_hash(request, user)Link to this definition
aupdate_session_auth_hash(request, user)Link to this definition

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

Tógann an fheidhm seo an t-iarratas reatha agus an réad úsáideora nuashonraithe as a ndíorthófar an hash seisiúin nua agus nuashonraíonn sé an hash seisiúin go cuí. Rothlaíonn sé an eochair seisiúin freisin ionas go ndéanfar fianán seisiúin goidte a chur ar bhailí.

Úsáid sampla:

Code
from django.contrib.auth import update_session_auth_hash


def password_change(request):
    if request.method == "POST":
        form = PasswordChangeForm(user=request.user, data=request.POST)
        if form.is_valid():
            form.save()
            update_session_auth_hash(request, form.user)
    else:
        ...

Radhairc FíordheimhniLink to this heading

Soláthraíonn Django roinnt tuairimí is féidir leat a úsáid chun logáil isteach, logáil amach agus bainistíocht pasfhocal a láimhseáil. Úsáideann siad seo na foirmeacha: ref: `stoc auth <built-in-auth-forms>`ach is féidir leat dul i do fhoirmeacha féin freisin.

Ní sholáthraíonn Django aon teimpléad réamhshocraithe do na tuairimí fí Ba chóir duit do theimpléid féin a chruthú do na tuairimí is mian leat a úsáid. Tá comhthéacs an teimpléid doiciméadaithe i ngach amharc, féach:ref: all-autentiúcháin-views.

Úsáid na tuairimíLink to this heading

Tá modhanna difriúla ann chun na tuairimí seo a chur i bhfeidhm i do thionscadal Is é an bealach is éasca ná an URLConf a chuirtear ar fáil a áireamh in django.contrib.auth.urls i do URLConf féin, mar shampla:

Code
urlpatterns = [
    path("accounts/", include("django.contrib.auth.urls")),
]

Áireofar seo na patrúin URL seo a leanas:

Text
accounts/login/ [name='login']
accounts/logout/ [name='logout']
accounts/password_change/ [name='password_change']
accounts/password_change/done/ [name='password_change_done']
accounts/password_reset/ [name='password_reset']
accounts/password_reset/done/ [name='password_reset_done']
accounts/reset/<uidb64>/<token>/ [name='password_reset_confirm']
accounts/reset/done/ [name='password_reset_complete']

Soláthraíonn na tuairimí ainm URL le haghaidh tagartha níos éasca. Féach: doc: an doiciméadú URL le haghaidh sonraí maidir le patrúin URL </topics/http/urls> ainmnithe a úsáid.

Más mian leat níos mó smachta ar do URLanna, is féidir leat tagairt a dhéanamh do radharc ar leith i do URLConf:

Code
from django.contrib.auth import views as auth_views

urlpatterns = [
    path("change-password/", auth_views.PasswordChangeView.as_view()),
]

Tá argóintí roghnacha ag na tuairimí is féidir leat a úsáid chun iompar an radharc a athrú. Mar shampla, más mian leat an t-ainm teimpléid a úsáideann amharc a athrú, is féidir leat an argóint template_name a sholáthar. Bealach chun é seo a dhéanamh ná argóintí eochairfhocal a sholáthar sa URLConf, cuirfear iad seo ar aghaidh chuig an dearcadh. Mar shampla:

Code
urlpatterns = [
    path(
        "change-password/",
        auth_views.PasswordChangeView.as_view(template_name="change-password.html"),
    ),
]

Is iad na tuairimí go léir:doc: class-based </topics/class-based-views/index>, rud a ligeann duit iad a shaincheapadh go héasca trí fho-aicmiú.

Gach tuairim fíordheimhniLink to this heading

Seo liosta leis na tuairimí go léir a sholáthraíonn django.contrib.auth. Le haghaidh sonraí cur chun feidhme féach:ref: using-the-views.

class LoginViewLink to this definition

**Ainm URL: ** ``logáil isteach ``

Féach: doc: an doiciméadú URL le haghaidh sonraí maidir le patrúin URL </topics/http/urls> ainmnithe a úsáid.

**Modhanna agus Gnéithe **

template_nameLink to this definition

Ainm teimpléad le taispeáint don amharc a úsáidtear chun an t-úsáideoir a logáil isteach. Réamhshocraithe chuig: file: clárúcháin/logain.html.

next_pageLink to this definition

An URL le atreorú chuig tar éis logáil isteach. Réamhshocraithe chuig: socrú: LOGIN_REDIRECT_URL.

redirect_field_nameLink to this definition

Ainm réimse GET ina bhfuil an URL le atreorú chuig tar éis logáil isteach. Réamhshocraithe go `next ``. Sáraíonn an URL:meth: `get_default_redirect_url` chuirtear an paraiméadar ``GET a thugtar.

authentication_formLink to this definition

Is féidir glaoch (rang foirme de ghnáth) le húsáid le haghaidh fíordheimhnithe. Réamhshocraithe chuig: aicme: ~django.contrib.auth.forms.AuthenticationForm.

extra_contextLink to this definition

Foclóir sonraí comhthéacs a chuirfear leis na sonraí comhthéacs réamhshocraithe a chuirtear chuig an teimpléad.

redirect_authenticated_userLink to this definition

Déanfar boolean a rialaíonn cibé acu úsáideoirí fíordheimhnithe a rochtann rochtain ar an leathanach logála isteach a atreorú amhail is dá ndearna siad logáil isteach go rathúil. Réamhshocraithe go False.

success_url_allowed_hostsLink to this definition

<django.http.HttpRequest.get_host>A: aicme: tac óstach, i dteann:meth: request.get_host () `, atá sábháilte le hathreorú tar éis logáil isteach. Réamhshocraithe go folamh: class: `set.

get_default_redirect_url()Link to this definition

Filleann sé an URL le atreorú chuig tar éis logáil isteach. Réiteann agus filleann an cur i bhfeidhm réamhshocraithe: attr: next_page má tá sé socraithe, nó:setting: LOGIN_REDIRECT_URL ar shlí eile.

Seo cad a dhéanann ``LoginView ``:

  • Má thugtar air trí GET`, taispeánann sé foirm logála isteach a Postálann chuig an URL céanna. Níos mó faoi seo i mbeagán.

  • Má ghlaonn sé trí POST ``le dintiúir a chuirtear isteach ag an úsáideoir, déanann sé iarracht an t-úsáideoir a logáil isteach. Má éiríonn logáil isteach, atreoraíonn an radharc chuig an URL a shonraítear in ``next `. <LOGIN_REDIRECT_URL>Mura gcuirtear next ``ar fáil, atreoraíonn chuig:setting: `settings.login_redirect_url `(a dhéanann réamhshocraithe go ``/cuntas/próifíl/). Mura n-éiríonn le logáil isteach, athaispeánann sé an fhoirm logála isteach.

Tá sé de fhreagracht ort an html a sholáthar don teimpléad logála isteach, ar a dtugtar registration/login.html de réir réamhshocraithe. Rinne an teimpléad seo ceithre athróg comhthéacs teimplé

  • ``foirm ``: A:Class: ~Django.Forms.Form réad a léiríonn an: aicme: ~django.contrib.auth.forms.AuthenticationForm.

  • next: An URL le atreorú chuig tar éis logáil isteach rathúil. D'fhéadfadh go mbeadh teaghrán ceisteanna ann freisin.

  • site: An reatha: aicme: ~django.contrib.sites.models.site, de réir an socrú: socrú: SITE_ID. Mura bhfuil creat an láithreáin suiteáilte agat, socraítear é seo go sampla de:class: ~django.contrib.sites.requests.requestsite, a fhaigheann ainm an láithreáin agus an fearainn ón reatha:class: ~django.http.httpRequest.

  • site_name: Ailias le haghaidh site.name. <django.http.HttpRequest.META>Mura bhfuil creat an láithreáin suiteáilte agat, socraítear é seo go luach de:attr: request.meta ['SERVER_NAME'] `. Le haghaidh tuilleadh eolais ar shuíomhanna, féach:doc: `/ref/contrib/sites.

Más fearr leat gan glaoch ar an teimpléad:file: registration/login.html, is féidir leat an paraiméadar template_name a chur ar aghaidh trí na hargóintí breise chuig an modh as_view` i do URLConf. Mar shampla, úsáidfeadh an líne URLConf seo:file: myapp/login.html ina ionad:

Code
path("accounts/login/", auth_views.LoginView.as_view(template_name="myapp/login.html")),

Is féidir leat ainm an réimse GET a shonrú ina bhfuil an URL le atreorú chuig tar éis logáil isteach ag baint úsáide as redirect_field_name. De réir réamhshocraithe, tugtar “next” ar an réimse.

Seo teimpléad sampla:file: registration/login.html is féidir leat a úsáid mar phointe tosaigh. Glacann sé leis go bhfuil teimpléad a:file: base.html agat a shainmhíníonn bloc content:

Django template
{% extends "base.html" %}

{% block content %}

{% if form.errors %}
<p>Your username and password didn't match. Please try again.</p>
{% endif %}

{% if next %}
    {% if user.is_authenticated %}
    <p>Your account doesn't have access to this page. To proceed,
    please login with an account that has access.</p>
    {% else %}
    <p>Please login to see this page.</p>
    {% endif %}
{% endif %}

<form method="post" action="{% url 'login' %}">
{% csrf_token %}
<table>
<tr>
    <td>{{ form.username.label_tag }}</td>
    <td>{{ form.username }}</td>
</tr>
<tr>
    <td>{{ form.password.label_tag }}</td>
    <td>{{ form.password }}</td>
</tr>
</table>

<input type="submit" value="login">
<input type="hidden" name="next" value="{{ next }}">
</form>

{# Assumes you set up the password_reset view in your URLconf #}
<p><a href="{% url 'password_reset' %}">Lost password?</a></p>

{% endblock %}

Má tá fíordheimhniú saincheaptha agat (féach: doc: Fíordheimhniú Saincheapach') is féidir leat foirm fíordheimhnithe saincheaptha a úsáid tríd an tréith ``foirm autentication_form` </topics/auth/customizing> a shocrú. Ní mór don fhoirm seo glacadh le hargóint eochairfhocal iarraidh` ina modh ``__init__ () ``agus modh ``get_user () a sholáthar a thugann an réad úsáideora fíordheimhnithe ar ais (ní ghlaofar an modh seo ach amháin tar éis bailíochtú foirme rathúil).

class LogoutViewLink to this definition

Logáil úsáideoir amach ar iarratais ``POST ``.

**Ainm URL: ** ``logáil isteach ``

**Tréithe: **

next_pageLink to this definition

An URL le atreorú chuig tar éis logáil amach. Réamhshocraithe chuig: socrú: LOGOUT_REDIRECT_URL.

template_nameLink to this definition

Ainm iomlán teimpléid le taispeáint tar éis an t-úsáideoir a logáil amach. Réamhshocraithe chuig: file: clárúcháin/logged_out.html.

redirect_field_nameLink to this definition

Ainm réimse GET ina bhfuil an URL le atreorú chuig tar éis logáil amach. Réamhshocraithe go 'next t'. Sáraíonn an URL:attr: next_page má chuirtear an paraiméadar GET a thugtar.

extra_contextLink to this definition

Foclóir sonraí comhthéacs a chuirfear leis na sonraí comhthéacs réamhshocraithe a chuirtear chuig an teimpléad.

success_url_allowed_hostsLink to this definition

<django.http.HttpRequest.get_host>A: aicme: tac óstach, i dteann:meth: request.get_host () `, atá sábháilte le hathreorú tar éis logáil amach. Réamhshocraithe go folamh: class: `set.

** Comhthéacs teimpléad: **

  • title: An teaghrán “Logáilte amach”, logánaithe.

  • site: An reatha: aicme: ~django.contrib.sites.models.site, de réir an socrú: socrú: SITE_ID. Mura bhfuil creat an láithreáin suiteáilte agat, socraítear é seo go sampla de:class: ~django.contrib.sites.requests.requestsite, a fhaigheann ainm an láithreáin agus an fearainn ón reatha:class: ~django.http.httpRequest.

  • site_name: Ailias le haghaidh site.name. <django.http.HttpRequest.META>Mura bhfuil creat an láithreáin suiteáilte agat, socraítear é seo go luach de:attr: request.meta ['SERVER_NAME'] `. Le haghaidh tuilleadh eolais ar shuíomhanna, féach:doc: `/ref/contrib/sites.

logout_then_login(request, login_url=None)Link to this definition

Logáil úsáideoir amach ar iarratais ``POST ``, ansin atreoraíonn sé chuig an leathanach logála isteach.

**Ainm URL: ** Níl URL réamhshocraithe ar fáil

** Argóintí roghnacha: **

  • login_url: URL an leathanaigh logála isteach le atreorú chuig. <LOGIN_URL>Réamhshocraithe to:setting: `settings.login_url `mura gcuirtear ar fáil.

class PasswordChangeViewLink to this definition

**Ainm URL: ** password_change

Ligeann sé d'úsáideoir a phasfhocal a athrú.

**Tréithe: **

template_nameLink to this definition

Ainm iomlán teimpléid le húsáid chun an fhoirm athraithe pasfhocal a thaispeáint. Réamhshocraithe to:file: clárúcháin/password_change_form.html mura gcuirtear ar fáil.

success_urlLink to this definition

An URL le atreorú chuig tar éis athrú pasfhocal rathúil. Réamhshocraithe go `'password_change_done'.

form_classLink to this definition

Foirm saincheaptha “athraigh pasfhocal” a chaithfidh glacadh le hargóint eochairfhocal ``úsáideoir ``. Tá an fhoirm freagrach as pasfhocal an úsáideora a athrú i ndáiríre. Réamhshocraithe chuig: aicme: ~django.contrib.auth.forms.PasswordChangeForm.

extra_contextLink to this definition

Foclóir sonraí comhthéacs a chuirfear leis na sonraí comhthéacs réamhshocraithe a chuirtear chuig an teimpléad.

** Comhthéacs teimpléad: **

  • foirm: An fhoirm athraithe pasfhocal (féach form_class thuas).

class PasswordChangeDoneViewLink to this definition

**Ainm URL: ** `password_change_done

An leathanach a thaispeántar tar éis d'úsáideoir a phasfhocal a athrú.

**Tréithe: **

template_nameLink to this definition

Ainm iomlán teimpléad le húsáid. Réamhshocraithe to:file: clárúcháin/password_change_done.html mura gcuirtear ar fáil.

extra_contextLink to this definition

Foclóir sonraí comhthéacs a chuirfear leis na sonraí comhthéacs réamhshocraithe a chuirtear chuig an teimpléad.

class PasswordResetViewLink to this definition

**Ainm URL: ** `password_reset

Ligeann sé d'úsáideoir a bhfocal faire a athshocrú trí nasc úsáide aonuaire a ghiniúint is féidir a úsáid chun an pasfhocal a athshocrú, agus an nasc sin a sheoladh chuig seoladh ríomhphoist cláraithe an úsáideora.

Seolfaidh an dearcadh seo ríomhphost má chomhlíontar na coinníollacha seo a leanas:

  • Tá an seoladh ríomhphoist a chuirtear ar fáil sa chóras.

  • Tá an t-úsáideoir iarrtha gníomhach (User.is_Active is True).

  • Tá pasfhocal inúsáidte ag an úsáideoir iarrtha. Ní cheadaítear d'úsáideoirí a bhfuil pasfhocal neamhúsáidte orthu (féach: ~django.contrib.auth.models.user.set_unusable_password) athshocrú pasfhocal a iarraidh chun mí-úsáid a chosc agus foinse fíordheimhnithe seachtrach cosúil le LDAP á úsáid acu.

Mura gcomhlíontar aon cheann de na coinníollacha seo níl, ní sheolfar aon ríomhphost, ach ní gheobhaidh an t-úsáideoir aon teachtaireacht earráide ach an oiread. Coscann sé seo faisnéis a sceitheadh chuig ionsaitheoirí ionchasacha Más mian leat teachtaireacht earráide a sholáthar sa chás seo, is féidir leat subclass:class: ~django.contrib.auth.forms.passwordResetForm agus an tréith ``form_class ``a úsáid.

**Tréithe: **

template_nameLink to this definition

Ainm iomlán teimpléid le húsáid chun an fhoirm athshocraithe pasfhocal a thaispeáint. Réamhshocraithe to:file: clárúcháin/password_reset_form.html mura gcuirtear ar fáil.

form_classLink to this definition

Foirm a úsáidfear chun ríomhphost an úsáideora a fháil chun an pasfhocal a athshocrú dó. Réamhshocraithe chuig: aicme: ~django.contrib.auth.forms.PasswordResetForm.

email_template_nameLink to this definition

Ainm iomlán teimpléid le húsáid chun an ríomhphost a ghiniúint leis an nasc pasfhocal athshocraithe. Réamhshocraithe to:file: registration/password_reset_email.html mura gcuirtear ar fáil.

subject_template_nameLink to this definition

Ainm iomlán teimpléid le húsáid le haghaidh ábhar an ríomhphoist leis an nasc pasfhocal athshocraithe. Réamhshocraithe to:file: clárúcháin/password_reset_subject.txt mura gcuirtear ar fáil.

token_generatorLink to this definition

Sampla den rang chun an nasc aonuaire a sheiceáil. Beidh sé seo réamhshocraithe go default_token_generator, is sampla é de django.contrib.auth.tokens.passwordResetTokenGenerator.

success_urlLink to this definition

An URL le atreorú chuig tar éis iarratas rathúil athshocraithe pasfhocal. Réamhshocraithe go `'password_reset_done'.

from_emailLink to this definition

Seoladh ríomhphoist bailí. De réir réamhshocraithe úsáideann Django an:setting: DEFAULT_FROM_EMAIL.

extra_contextLink to this definition

Foclóir sonraí comhthéacs a chuirfear leis na sonraí comhthéacs réamhshocraithe a chuirtear chuig an teimpléad.

html_email_template_nameLink to this definition

Ainm iomlán teimpléid le húsáid chun ríomhphost ilpháirteach a: mimetype: text/html a ghiniúint leis an nasc athshocraithe pasfhocal. De réir réamhshocraithe, ní sheoltar ríomhphost HTML.

extra_email_contextLink to this definition

Foclóir sonraí comhthéacs a bheidh ar fáil sa teimpléad ríomhphoist. Is féidir é a úsáid chun luachanna comhthéacs teimpléad réamhshocraithe atá liostaithe thíos a shárú m.sh. réimse.

** Comhthéacs teimpléad: **

  • foirm ``: An fhoirm (féach ``form_class thuas) chun pasfhocal an úsáideora a athshocrú.

** comhthéacs teimpléad ríomhphoist: **

  • email: Ainm le haghaidh user.email

  • user: An reatha: aicme: ~django.contrib.auth.models.user, de réir réimse foirme ríomhphost. Níl ach úsáideoirí gníomhacha in ann a gcuid pasfhocail a athshocrú (User.is_Active is True).

  • site_name: Ailias le haghaidh site.name. <django.http.HttpRequest.META>Mura bhfuil creat an láithreáin suiteáilte agat, socraítear é seo go luach de:attr: request.meta ['SERVER_NAME'] `. Le haghaidh tuilleadh eolais ar shuíomhanna, féach:doc: `/ref/contrib/sites.

  • domain: Ainm le haghaidh site.domain. Mura bhfuil creat an láithreáin suiteáilte agat, socraítear é seo go luach ``request.get_host () ``.

  • “prótacal”: http nó https

  • uid: Príomh-eochair an úsáideora ionchódaithe i mbonn 64.

  • token: Comhartha chun a sheiceáil go bhfuil an nasc athshocraithe bailí.

Sampla clárúcháin/password_reset_email.html (teimpléad comhlacht ríomhphoist):

Django template
Someone asked for password reset for email {{ email }}. Follow the link below:
{{ protocol}}://{{ domain }}{% url 'password_reset_confirm' uidb64=uid token=token %}

Úsáidtear an comhthéacs teimpléid céanna do theimpléad ábhair. Caithfidh an t-ábhar a bheith ina sreang téacs simplí líne aonair.

class PasswordResetDoneViewLink to this definition

**Ainm URL: ** `password_reset_done

An leathanach a thaispeántar tar éis nasc a sheoladh chuig úsáideoir chun a bhfocal faire a athshocrú. Tugtar an radharc seo de réir réamhshocraithe mura bhfuil socrú URL sainráite success_url ag an:class: PasswordResetView.

**Tréithe: **

template_nameLink to this definition

Ainm iomlán teimpléad le húsáid. Réamhshocraithe to:file: clárúcháin/password_reset_done.html mura gcuirtear ar fáil.

extra_contextLink to this definition

Foclóir sonraí comhthéacs a chuirfear leis na sonraí comhthéacs réamhshocraithe a chuirtear chuig an teimpléad.

class PasswordResetConfirmViewLink to this definition

**Ainm URL: ** `password_reset_confirm

Cuireann sé foirm i láthair chun pasfhocal nua a iontráil.

**Argóintí eochairfhocal ón URL: **

  • uidb64: Aitheantas an úsáideora ionchódaithe i mbonn 64.

  • token: Comhartha chun a sheiceáil go bhfuil an pasfhocal bailí.

**Tréithe: **

template_nameLink to this definition

Ainm iomlán teimpléad chun an dearcadh pasfhocal deimhnithe a thaispeáint. Is é an luach réamhshocraithe:file: clárúcháin/password_reset_confirm.html.

token_generatorLink to this definition

Sampla den rang chun an pasfhocal a sheiceáil. Beidh sé seo réamhshocraithe go default_token_generator, is sampla é de django.contrib.auth.tokens.passwordResetTokenGenerator.

post_reset_loginLink to this definition

Boolean a léiríonn an chóir an t-úsáideoir a fhíordheimhniú go huathoibríoch tar éis athshocrú pasfhocal rathúil. Réamhshocraithe go False.

post_reset_login_backendLink to this definition

Conair poncaí chuig an gcúltaca fíordheimhnithe le húsáid agus úsáideoir á fhíordheimhniú má tá post_reset_login True. Ní gá ach amháin má tá iolr:setting: AUTHENTICATION_BACKENDS cumraithe agat. Réamhshocraithe go None.

form_classLink to this definition

Foirm a úsáidfear chun an pasfhocal a shocrú. Réamhshocraithe chuig: aicme: ~django.contrib.auth.forms.setPasswordForm.

success_urlLink to this definition

URL chun a atreorú tar éis an athshocrú pasfhocal a dhéanamh. Réamhshocraithe go 'password_reset_complete'.

extra_contextLink to this definition

Foclóir sonraí comhthéacs a chuirfear leis na sonraí comhthéacs réamhshocraithe a chuirtear chuig an teimpléad.

reset_url_tokenLink to this definition

Paraiméadar comhartha a thaispeántar mar chomhpháirt d'URLanna athshocraithe pas Réamhshocraithe go ```'pasfhocal a shocraí'.

** Comhthéacs teimpléad: **

  • foirm ``: An fhoirm (féach ``form_class thuas) chun pasfhocal an úsáideora nua a shocrú.

  • validlink: Boolean, Fíor má tá an nasc (teaglaim de uidb64 agus token`) bailí nó neamhúsáidte fós.

class PasswordResetCompleteViewLink to this definition

**Ainm URL: ** `password_reset_complete

Cuireann sé dearcadh i láthair a chuireann in iúl don úsáideoir go bhfuil an pasfhocal athraithe go rathúil.

**Tréithe: **

template_nameLink to this definition

Ainm iomlán teimpléad chun an radharc a thaispeáint. Réamhshocraithe chuig: file: clárúcháin/password_reset_complete.html.

extra_contextLink to this definition

Foclóir sonraí comhthéacs a chuirfear leis na sonraí comhthéacs réamhshocraithe a chuirtear chuig an teimpléad.

Feidhmeanna cúntaLink to this heading

redirect_to_login(next, login_url=None, redirect_field_name='next')Link to this definition

Atreoraíonn sé chuig an leathanach logála isteach, agus ansin ar ais chuig URL eile tar éis logáil isteach rathúil.

** Argóintí riachtanacha: **

  • next: An URL le atreorú chuig tar éis logáil isteach rathúil.

** Argóintí roghnacha: **

  • login_url: URL an leathanaigh logála isteach le atreorú chuig. <LOGIN_URL>Réamhshocraithe to:setting: `settings.login_url `mura gcuirtear ar fáil.

  • redirect_field_name: Ainm réimse GET ina bhfuil an URL le atreorú chuig tar éis logáil isteach. Sáraigh `next ``má chuirtear an paraiméadar ``GET a thugtar ar rith.

Foirmeacha tógthaLink to this heading

Mura dteastaíonn uait na tuairimí ionsuite a úsáid, ach mura dteastaíonn uait an áisiúlacht gan foirmeacha a scríobh don fheidhmiúlacht seo, soláthraíonn an córas fíordheimhnithe roinnt foirmeacha ionsuite in:mod: django.contrib.auth.forms:

class AdminPasswordChangeFormLink to this definition

Foirm a úsáidtear sa chomhéadan riaracháin chun pasfhocal úsáideora a athrú, <django.contrib.auth.models.User.set_unusable_password>lena n-áirítear an cumas an:meth: `pasfhocal neamhúsáidte `a shocrú, a chuireann bac ar an úsáideoir logáil isteach le fíordheimhniú bunaithe ar phasfhocal.

Glacann sé an ``úsáideoir ``mar an chéad argóint seasaimh.

class AdminUserCreationFormLink to this definition

Foirm a úsáidtear sa chomhéadan riaracháin chun úsáideoir nua a chruthú. Oidhreacht ó:class: UserCreationForm.

Cuimsíonn sé réimse breise `usable_password, cumasaithe de réir réamhshocraithe. Má tá usable_password cumasaithe, fíoraíonn sé nach bhfuil password1` agus password2` folamh agus comhoiriúnach, bailíochnaíonn sé an pasfhocal ag baint úsáid:func: ~django.contrib.auth.password_validation.validate_password, agus socraíonn sé pasfhocal an úsáideora ag baint úsáidea:meth: ~django.contrib.auth.contrib.Models.user.set_password () `. Má dhíchumasaítear ``usable_password`, ní dhéantar aon bhailíochtú pasfhocal, agus díchumasaítear fíordheimhniú pasfhocal don úsáideoir trí ghlaoch:: `~django.contrib.auth.models.user.set_unusable_password () `.

class AuthenticationFormLink to this definition

Foirm chun úsáideoir a logáil isteach.

Glacann sé “iarratas” mar a chéad argóint seasaimh, a stóráiltear ar an sampla foirme le húsáid ag fo-aicmí.

confirm_login_allowed(user)Link to this definition

De réir réamhshocraithe, diúltaíonn AuthenticationForm ``úsáideoirí a bhfuil a bhratach ``is_active socraithe go False. Féadfaidh tú an t-iompar seo a shárú le beartas saincheaptha chun a chinneadh cé na húsáideoirí is féidir leo logáil isteach. Déan é seo le foirm saincheaptha a dhéanann fo-aicme AuthenticationForm ``agus a sháraíonn an modh ``confirm_login_allow (). Ba chóir go n-ardódh an modh seo a:exc: ~django.core.exceptions.validationError mura bhféadfadh an t-úsáideoir tugtha logáil isteach.

Mar shampla, chun ligean do gach úsáideoir logáil isteach beag beann ar stádas “gníomhach”:

Code
from django.contrib.auth.forms import AuthenticationForm


class AuthenticationFormWithInactiveUsersOkay(AuthenticationForm):
    def confirm_login_allowed(self, user):
        pass

(Sa chás seo, beidh ort cúltaca fíordheimhnithe a úsáid freisin a cheadaíonn úsáideoirí neamhghníomhacha, mar shampla:class: ~django.contrib.auth.backends.allowAllUsersModelBackend.)

Nó chun ligean ach roinnt úsáideoirí gníomhacha logáil isteach:

Code
class PickyAuthenticationForm(AuthenticationForm):
    def confirm_login_allowed(self, user):
        if not user.is_active:
            raise ValidationError(
                _("This account is inactive."),
                code="inactive",
            )
        if user.username.startswith("b"):
            raise ValidationError(
                _("Sorry, accounts starting with 'b' aren't welcome here."),
                code="no_b_users",
            )
class BaseUserCreationFormLink to this definition

A: Class: ~Django.Forms.ModelForm chun úsáideoir nua a chruthú. Is é seo an bunaicme molta más gá duit an fhoirm chruthaithe úsáideora a shaincheapadh.

Tá trí réimse aige: ainm úsáideora ``(ón tsamhail úsáideora), ``pasfhocal1, agus pasfhocal 2. Fíoraíonn sé go n-oireann password1 agus password2`, bailíochtú an pasfhocal ag baint úsáidea:func: ~django.contrib.auth.password_validation.validate_password, agus socraíonn sé pasfhocal an úsáideora ag baint úsáidea:meth: `~django.contrib.auth.models.user.set_password () `.

class PasswordChangeFormLink to this definition

Foirm chun ligean d'úsáideoir a phasfhocal a athrú.

class PasswordResetFormLink to this definition

Foirm chun nasc úsáide aon-uaire a ghiniúint agus a sheoladh ríomhphoist chun pasfhocal úsáideora a athshocrú.

send_mail(subject_template_name, email_template_name, context, from_email, to_email, html_email_template_name=None)Link to this definition

Úsáideann sé na hargóintí chun EmailMultiAlternatives a sheoladh. Is féidir é a athsheoladh chun an chaoi a sheoltar an ríomhphost chuig an úsáideoir a shaincheapadh. Má roghnaíonn tú an modh seo a shárú, bí ar an gcuimhne ar eisceachtaí féideartha a ardaíodh mar gheall ar theipeanna seolta ríomhphoist

Paraiméadair:
  • subject_template_name -- an teimpléad don ábhar.

  • email_template_name -- an teimpléad don chomhlacht ríomhphoist.

  • context -- comhthéacs a chuirtear chuig an subject_template, email_teimple, agus html_email_teimple (mura bhfuil sé None).

  • from_email -- ríomhphost an tseoltóra.

  • to_email -- ríomhphost an iarratóra.

  • html_email_template_name -- an teimpléad don chomhlacht HTML; réamhshocraithe go None, sa chás sin seoltar ríomhphost gnáth-théacs.

De réir réamhshocraithe, líonann save () ``an `context leis na hathróga céanna a théann: class: ~django.contrib.auth.views.passwordResetView chuig a chomhthéacs ríomhphoist.

class SetPasswordFormLink to this definition

Foirm a ligeann d'úsáideoir a phasfhocal a athrú gan an sean-phasfhocal a iontráil.

class UserChangeFormLink to this definition

Foirm a úsáidtear sa chomhéadan riaracháin chun faisnéis agus ceadanna úsáideora a athrú.

class UserCreationFormLink to this definition

Oidhreacht ó:class: BaseUserCreationForm. Chun cabhrú le mearbhall le hainmneacha úsáideora comhchosúla a chosc, ní cheadaíonn an fhoirm ainmneacha úsáideora atá difriúil

Sonraí fíordheimhnithe i dteimplLink to this heading

Cuirtear an t-úsáideoir logáilte isteach faoi láthair agus a gceadanna ar fáil in:doc: template context nuair a úsáideann tú :class: ~django.template.requestContext </ref/templates/api>.

ÚsáideoiríLink to this heading

Agus teimpléad:class: ~django.template.requestContext á rindreáil, stóráiltear an t-úsáideoir logáilte isteach faoi láthair, a:class: ~django.contrib.auth.models.user nó sampla: :class: ~django.contrib.auth.models.anonymousUser, san athróg teimpléad {{user}}:

Django template
{% if user.is_authenticated %}
    <p>Welcome, {{ user.username }}. Thanks for logging in.</p>
{% else %}
    <p>Welcome, new user. Please log in.</p>
{% endif %}

Níl an athróg comhthéacs teimpléad seo ar fáil mura bhfuil RequestContext á úsáid.

CeadaLink to this heading

Stóráiltear ceadanna an úsáideora logáilte isteach faoi láthair san athróg teimpléad {{perms}}. Seo sampla de django.contrib.auth.context_processors.permWrapper, seachfhreastalaí ceadanna atá cairdiúil don teimpléad é.

<django.contrib.auth.models.User.has_module_perms>Is seachfhreastalaí é cuardach aontréithe de {{perms}} a mheas mar boolean seachfhreastalaí:meth: `User.has_module_perms () `. Mar shampla, chun seiceáil an bhfuil aon cheadanna ag an úsáideoir logáilte isteach san aip `foo':

Django template
{% if perms.foo %}

<django.contrib.auth.models.User.has_perm>Is seachfhreastalaí é cuardach tréithe dhá leibhéal a mheas mar boolean chun: meth: User.has_perm () `. Mar shampla, chun seiceáil an bhfuil an cead ``foo.add_vote` ag an úsáideoir logáilte isteach:

Django template
{% if perms.foo.add_vote %}

Seo sampla níos iomláine de cheadanna a sheiceáil i dteimpléad:

Django template
{% if perms.foo %}
    <p>You have permission to do something in the foo app.</p>
    {% if perms.foo.add_vote %}
        <p>You can vote!</p>
    {% endif %}
    {% if perms.foo.add_driving %}
        <p>You can drive!</p>
    {% endif %}
{% else %}
    <p>You don't have permission to do anything in the foo app.</p>
{% endif %}

Is féidir ceadanna a lorg suas freisin le ráitis {% i%}. Mar shampla:

Django template
{% if 'foo' in perms %}
    {% if 'foo.add_vote' in perms %}
        <p>In lookup works, too.</p>
    {% endif %}
{% endif %}

Úsáideoirí a bhainistiú sa riarachánLink to this heading

Nuair a bhíonn django.contrib.admin ``agus ``django.contrib.auth` suiteáilte agat, soláthraíonn an riarachán bealach áisiúil chun úsáideoirí, grúpaí agus ceadanna a fheiceáil agus a bhainistiú. Is féidir úsáideoirí a chruthú agus a scriosadh cosúil le haon samhail Django. Is féidir grúpaí a chruthú, agus is féidir ceadanna a shannadh d'úsáideoirí nó do ghrúpaí. Stóráiltear agus taispeántar log d'eagarthóirí úsáideora ar mhúnlaí a dhéantar laistigh den riarachán freisin.

úsáideoirí a chruthúLink to this heading

Ba chóir duit nasc le “Úsáideoirí” a fheiceáil sa chuid “Auth” den phríomhleathanach innéacs riaracháin. Tá an leathanach riaracháin “Cuir úsáideoir leis” difriúil ná leathanaigh riaracháin caighdeánacha sa mhéid go n-éilíonn sé ort ainm úsáideora agus pasfhocal a roghnú sula ligfidh sé duit an chuid eile de réimsí an úsáideora a chur in eagar. Nó, ar an leathanach seo, is féidir leat ainm úsáideora a roghnú agus fíordheimhniú bunaithe ar phasfhocal a dhíchumasú don úsáideoir.

Tabhair faoi deara freisin: más mian leat go mbeadh cuntas úsáideora in ann úsáideoirí a chruthú ag baint úsáide as suíomh riaracháin Django, beidh ort cead a thabhairt dóibh úsáideoirí a chur leis agus úsáideoirí a athrú (ie, na ceadanna “Cuir úsáideoir leis” agus “Athraigh úsáideoir”). Má tá cead ag cuntas úsáideoirí a chur leis ach gan iad a athrú, ní bheidh an cuntas sin in ann úsáideoirí a chur leis. Cén fáth? Toisc má tá cead agat úsáideoirí a chur leis, tá an chumhacht agat sárúsáideoirí a chruthú, ar féidir leo úsáideoirí eile a athrú ansin. Mar sin éilíonn Django ceadúna* agus* athraithe a chur leis mar bheart slándála beag.

Bí tuisceanach faoi conas a ligeann tú d'úsáideoirí ceadanna a bhainistiú Má thugann tú an cumas do neamh-sárúsáideoir úsáideoirí a chur in eagar, tá sé seo mar an gcéanna sa deireadh le stádas sárúsáideora a thabhairt dóibh toisc go mbeidh siad in ann ceadanna úsáideoirí lena n-áirítear iad féin a ardú!

Athrú pasfhocailLink to this heading

Ní thaispeántar pasfhocail úsáideora sa riarachán (ná ní stóráiltear sa bhunachar sonraí), ach taispeántar na:doc: `sonraí stórála pasfhocal </topics/auth/passwords>. San áireamh i dtaispeáint na faisnéise seo tá nasc le foirm athraithe pasfhocal a ligeann do riarthóirí pasfhocail úsáideora a athrú nó a dhíshocrú.