--- title: "Córas fíordheimhnithe Django a úsáid" version: 6.0 locale: ga source: https://docs.djangoproject.com/ga/6.0/topics/auth/default/ canonical: https://djangodocs.dev/ga/6.0/topics/auth/default/ --- # Córas fíordheimhnithe Django a úsáid 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 \. 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í [`User`](/ga/6.0/ref/contrib/auth/#django.contrib.auth.models.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'`](/ga/6.0/ref/contrib/auth/#django.contrib.auth.models.User.is_superuser) or admin [`'staff'`](/ga/6.0/ref/contrib/auth/#django.contrib.auth.models.User.is_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: - [`username`](/ga/6.0/ref/contrib/auth/#django.contrib.auth.models.User.username) - [`password`](/ga/6.0/ref/contrib/auth/#django.contrib.auth.models.User.password) - [`email`](/ga/6.0/ref/contrib/auth/#django.contrib.auth.models.User.email) - [`first_name`](/ga/6.0/ref/contrib/auth/#django.contrib.auth.models.User.first_name) - [`last_name`](/ga/6.0/ref/contrib/auth/#django.contrib.auth.models.User.last_name) Féach an:class: doiciméadú iomlán API \\`le haghaidh tagartha iomlán, tá an doiciméadú a leanas níos dírithe ar thasc. ### úsáideoirí a chruthú 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: ```pycon >>> 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() ``` \Má tá riarachán Django suiteáilte agat, is féidir leat freis:ref: úsáideoirí a chruthú go idirghníomhach. ### Superusers a chruthú Cruthaigh sárúsáideoirí ag baint úsáide as an ordú:djadmin: createsuperuser: ```console $ python manage.py createsuperuser --username=joe --email=joe@example.com ``` *Windows* ```doscon ...\> 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 \\`nó: rogha: \`--ríomhphost, spreagfaidh sé tú do na \luachanna sin. ### Athrú pasfhocail 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). \ 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*`](/ga/6.0/ref/django-admin/#django-admin-changepassword) 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. You can also change a password programmatically, using [`set_password()`](/ga/6.0/ref/contrib/auth/#django.contrib.auth.models.User.set_password): ```pycon >>> from django.contrib.auth.models import User >>> u = User.objects.get(username="john") >>> u.set_password("new password") >>> u.save() ``` \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 \\`agus:ref: \`foirmeacha is féidir a úsáid chun ligean d'úsáideoirí a \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íordheimhnithe #### `authenticate(request=None, **credentials)` #### `aauthenticate(request=None, **credentials)` *Asynchronous version*: `aauthenticate()` Use [`authenticate()`](#django.contrib.auth.authenticate) to verify a set of credentials. It takes credentials as keyword arguments, `username` and `password` for the default case, checks them against each [authentication backend](/ga/6.0/topics/auth/customizing/#authentication-backends), and returns a [`User`](/ga/6.0/ref/contrib/auth/#django.contrib.auth.models.User) object if the credentials are valid for a backend. If the credentials aren't valid for any backend or if a backend raises [`PermissionDenied`](/ga/6.0/ref/exceptions/#django.core.exceptions.PermissionDenied), it returns `None`. For example: ``` 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. > **Note** > > Is bealach ar leibhéal íseal é seo chun tacar dintiúir a fhíordheimhniú; mar shampla, úsáideann an: class: ~django.contrib.auth.middleware.remoteUserMiddleware é. Mura bhfuil do chóras fíordheimhnithe féin á scríobh agat, is dócha nach n-úsáidfidh tú é seo. Ina ionad sin má tá tú ag lorg bealach chun úsáideoir a logáil isteach, bain úsáid as an:class: ~django.contrib.auth.views.loginView. ## Ceadanna agus Údarú 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`](/ga/6.0/ref/contrib/auth/#django.contrib.auth.models.User) objects have two many-to-many fields: `groups` and `user_permissions`. [`User`](/ga/6.0/ref/contrib/auth/#django.contrib.auth.models.User) objects can access their related objects in the same way as any other [Django model](/ga/6.0/topics/db/models/): ``` 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éamhshocrai 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 \; 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 \\`(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í [`django.contrib.auth.models.Group`](/ga/6.0/ref/contrib/auth/#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áraitheach Cé gur féidir ceadanna saincheaptha a shainiú laisti \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\`: ``` 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`. > **Teastaíonn a gcineál ábhair féin ó mhúnlaí** > > Más mian leat: ref: ceadanna do mhúnla seachfhreastala a chruthú\, pas `for_concrete_model=false` chuig:meth: .contentTypeManager.get\_for\_model chun an ContentType\` cuí a fháil: > > ``` > content_type = ContentType.objects.get_for_model( > BlogPostProxy, for_concrete_model=False > ) > ``` ### Cacháil ceadanna 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: ``` 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í proxy 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: ``` 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")] ``` ```pycon >>> # 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áin \ \Úsáideann Django: doc: seisiúin agus middleware chun an córas fíordheimhnithe a cheangal la:class: iarr rudaí . \Soláthraíonn siad seo a: attr: request.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: ``` if request.user.is_authenticated: # Do something for authenticated users. ... else: # Do something for anonymous users. ... ``` Nó i radharc asincrónach: ``` 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 isteach 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)` #### `alogin(request, user, backend=None)` *Asynchronous version*: `alogin()` To log a user in, from a view, use [`login()`](#django.contrib.auth.login). It takes an [`HttpRequest`](/ga/6.0/ref/request-response/#django.http.HttpRequest) object and a [`User`](/ga/6.0/ref/contrib/auth/#django.contrib.auth.models.User) object. [`login()`](#django.contrib.auth.login) saves the user's ID in the session, using Django's session framework. 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. This example shows how you might use both [`authenticate()`](#django.contrib.auth.authenticate) and [`login()`](#django.contrib.auth.login): ``` 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ú 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 \\`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. Use the value of the `user.backend` attribute, if present. This allows pairing [`authenticate()`](#django.contrib.auth.authenticate) and [`login()`](#django.contrib.auth.login): [`authenticate()`](#django.contrib.auth.authenticate) sets the `user.backend` attribute on the user object it returns. 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 amach #### `logout(request)` #### `alogout(request)` *Asynchronous version*: `alogout()` To log out a user who has been logged in via [`django.contrib.auth.login()`](#django.contrib.auth.login), use [`django.contrib.auth.logout()`](#django.contrib.auth.logout) within your view. It takes an [`HttpRequest`](/ga/6.0/ref/request-response/#django.http.HttpRequest) object and has no return value. Example: ``` from django.contrib.auth import logout def logout_view(request): logout(request) # Redirect to a success page. ``` Note that [`logout()`](#django.contrib.auth.logout) doesn't throw any errors if the user wasn't logged in. When you call [`logout()`](#django.contrib.auth.logout), the session data for the current request is completely cleaned out. All existing data is removed. This is to prevent another person from using the same web browser to log in and have access to the previous user's session data. If you want to put anything into the session that will be available to the user immediately after logging out, do that *after* calling [`django.contrib.auth.logout()`](#django.contrib.auth.logout). ### Rochtain a theorannú ar úsáideoirí logáilte isteach #### An bealach amh \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: ``` 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: ``` 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_required` #### `login_required(redirect_field_name='next', login_url=None)` Mar aicearra, is féidir leat an maisitheoir áisiúil: func: ~django.contrib.auth.decorators.login\_required a úsáid: ``` from django.contrib.auth.decorators import login_required @login_required def my_view(request): ... ``` [`login_required()`](#django.contrib.auth.decorators.login_required) does the following: - Mura bhfuil an t-úsáideoir logáilte isteach, atreoraigh chuig:setting: settings.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```: ``` 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()`](#django.contrib.auth.decorators.login_required) also takes an optional `login_url` parameter. Example: ``` from django.contrib.auth.decorators import login_required @login_required(login_url="/accounts/login/") def my_view(request): ... ``` \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: ``` from django.contrib.auth import views as auth_views path("accounts/login/", auth_views.LoginView.as_view()), ``` \Glacann an: setting: settings.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ú. > **Note** > > NÍ sheiceálann an maisitheoir `login_required` an bhratach `is_active` ar úsáideoir, ach diúltaíonn an réamhshocraithe:setting: AUTHENTICATION\_BACKENDS úsáideoirí neamhghníomhacha. > **See also** > > Má tá tuairimí saincheaptha á scríobh agat do riarachán Django (nó má theastaíonn an seiceáil údaraithe céanna uait a úsáideann na tuairimí ionsuite), b'fhéidir go bhfaighidh tú an:func: django.contrib.admin.views.decorators.staff\_member\_required rogha úsáideach seachas login\_required () . #### An meascán `LoginRequiredMixin` 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\` \ 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 LoginRequiredMixin` 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: ``` from django.contrib.auth.mixins import LoginRequiredMixin class MyView(LoginRequiredMixin, View): login_url = "/login/" redirect_field_name = "redirect_to" ``` > **Note** > > Díreach mar an maisitheoir `login_required`, NÍ sheiceálann an meascán seo an bhratach `is_active` ar úsáideoir, ach diúltaíonn an réamhshocraithe:setting: AUTHENTICATION\_BACKENDS úsáideoirí neamhghníomhacha. #### An maisitheoir `login_not_required` 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()` 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áil 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. \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: ``` 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')` 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`: ``` 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()`](#django.contrib.auth.decorators.user_passes_test) takes a required argument: a callable that takes a [`User`](/ga/6.0/ref/contrib/auth/#django.contrib.auth.models.User) object and returns `True` if the user is allowed to view the page. Note that [`user_passes_test()`](#django.contrib.auth.decorators.user_passes_test) does not automatically check that the [`User`](/ga/6.0/ref/contrib/auth/#django.contrib.auth.models.User) is not anonymous. [`user_passes_test()`](#django.contrib.auth.decorators.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. \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: ``` @user_passes_test(email_check, login_url="/login/") def my_view(request): ... ``` #### `class UserPassesTestMixin` Nuair a úsáideann tú: doc: tuairimí rang-bhunaithe ', is féidir leat an \`\`UserPassestestMixin\` a úsáid chun \ é seo a dhéanamh. #### `test_func()` 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: ``` 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()` 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). > **Cruachadh UserPassestestMixin** > > Mar gheall ar an mbealach a chuirtear `UserPassestestMixin` i bhfeidhm, ní féidir leat iad a chruachadh i do liosta oidhreachta. NÍ oibríonn an méid seo a leanas: > > ``` > class TestMixin1(UserPassesTestMixin): > def test_func(self): > return self.request.user.email.endswith("@example.com") > > > class TestMixin2(UserPassesTestMixin): > def test_func(self): > return self.request.user.username.startswith("django") > > > class MyView(TestMixin1, TestMixin2, View): ... > ``` > > Dá ndéanfadh `TestMixin1` glaoch ar ```super () ``agus go gcuirfeadh an toradh sin san áireamh, ní oibreodh ``TestMixin1``` neamhspleách níos mó. #### An maisitheoir `ceadú_riachtana` #### `permission_required(perm, login_url=None, raise_exception=False)` It's a relatively common task to check whether a user has a particular permission. For that reason, Django provides a shortcut for that case: the [`permission_required()`](#django.contrib.auth.decorators.permission_required) decorator: ``` from django.contrib.auth.decorators import permission_required @permission_required("polls.add_choice") def my_view(request): ... ``` \Díreach cosúil leis an modh:meth: ~django.contrib.auth.models.user.has\_perm, glacann ainmneacha ceada an fhoirm ```”. “``(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. Note that [`permission_required()`](#django.contrib.auth.decorators.permission_required) also takes an optional `login_url` parameter: ``` from django.contrib.auth.decorators import permission_required @permission_required("polls.add_choice", login_url="/loginpage/") def my_view(request): ... ``` \Mar atá sa maisitheoir: func: ~django.contrib.auth.decorators.login\_required, réamhshocraithe login\_url : socrú: Settings.login\_url . \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: ``` 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 RequiredMixin` Chun seiceálacha ceada a chur i bhfeidhm chuig:doc: tuairimí rang-bhunaithe ', is féidir leat an \`\`PermissionRequiredMixin\` \ a úsáid: #### `class PermissionRequiredMixin` 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`: ``` 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()` 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()` Returns a boolean denoting whether the current user has permission to execute the decorated view. By default, this returns the result of calling [`has_perms()`](/ga/6.0/ref/contrib/auth/#django.contrib.auth.models.User.has_perms) with the list of permissions returned by [`get_permission_required()`](#django.contrib.auth.mixins.PermissionRequiredMixin.get_permission_required). ### Iarrataí neamhúdaraithe a atreorú i dtuairimí bunaithe 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\ í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 AccessMixin` #### `login_url` Default return value for [`get_login_url()`](#django.contrib.auth.mixins.AccessMixin.get_login_url). Defaults to `None` in which case [`get_login_url()`](#django.contrib.auth.mixins.AccessMixin.get_login_url) falls back to [`settings.LOGIN_URL`](/ga/6.0/ref/settings/#std-setting-LOGIN_URL). #### `permission_denied_message` Luach tuairisceáin réamhshocraithe le haghaidh: meth: get\_permission\_denied\_message. Réamhshocraithe chuig teaghrán folamh. #### `redirect_field_name` Luach tuairisceáin réamhshocraithe le haghaidh: meth: get\_redirect\_field\_name. Réamhshocraithe go "eile” . #### `raise_exception` If this attribute is set to `True`, a [`PermissionDenied`](/ga/6.0/ref/exceptions/#django.core.exceptions.PermissionDenied) exception is raised when the conditions are not met. When `False` (the default), anonymous users are redirected to the login page. #### `get_login_url()` Tugann sé an URL ar ais a atreorófar úsáideoirí nach rachaidh an tástáil chuig. \Tuairisceáin: attr: login\_url má tá sé socraithe, nó: setting: settings.login\_url ar shlí eile. #### `get_permission_denied_message()` 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()` 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()` 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ú pasfhocal If your [`AUTH_USER_MODEL`](/ga/6.0/ref/settings/#std-setting-AUTH_USER_MODEL) inherits from [`AbstractBaseUser`](/ga/6.0/topics/auth/customizing/#django.contrib.auth.models.AbstractBaseUser) or implements its own [`get_session_auth_hash()`](/ga/6.0/topics/auth/customizing/#django.contrib.auth.models.AbstractBaseUser.get_session_auth_hash) method, authenticated sessions will include the hash returned by this function. In the [`AbstractBaseUser`](/ga/6.0/topics/auth/customizing/#django.contrib.auth.models.AbstractBaseUser) case, this is an HMAC of the password field. Django verifies that the hash in the session for each request matches the one that's computed during the request. This allows a user to log out all of their sessions by changing their password. 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)` #### `aupdate_session_auth_hash(request, user)` *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: ``` 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: ... ``` > **Note** > > Since > [`get_session_auth_hash()`](/ga/6.0/topics/auth/customizing/#django.contrib.auth.models.AbstractBaseUser.get_session_auth_hash) > is based on [`SECRET_KEY`](/ga/6.0/ref/settings/#std-setting-SECRET_KEY), secret key values must be > rotated to avoid invalidating existing sessions when updating your site to > use a new secret. See [`SECRET_KEY_FALLBACKS`](/ga/6.0/ref/settings/#std-setting-SECRET_KEY_FALLBACKS) for details. ### Radhairc Fíordheimhni 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 \\`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í 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: ``` 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/// [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 \ 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: ``` 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: ``` urlpatterns = [ path( "change-password/", auth_views.PasswordChangeView.as_view(template_name="change-password.html"), ), ] ``` Is iad na tuairimí go léir:doc: class-based \, rud a ligeann duit iad a shaincheapadh go héasca trí fho-aicmiú. #### Gach tuairim fíordheimhni 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 LoginView` Ainm URL: \*\* logáil isteach \`\` Féach: doc: an doiciméadú URL le haghaidh sonraí maidir le patrúin URL \ ainmnithe a úsáid. Modhanna agus Gnéithe \*\* #### `template_name` 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_page` An URL le atreorú chuig tar éis logáil isteach. Réamhshocraithe chuig: socrú: LOGIN\_REDIRECT\_URL. #### `redirect_field_name` 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` má chuirtear an paraiméadar ``GET ``` a thugtar. #### `authentication_form` 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_context` Foclóir sonraí comhthéacs a chuirfear leis na sonraí comhthéacs réamhshocraithe a chuirtear chuig an teimpléad. #### `redirect_authenticated_user` 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`. > **Warning** > > Má chumasaíonn tú `redirect_autenticated_user`, beidh láithreáin ghréasáin eile in ann a chinneadh an bhfuil a gcuairteoirí fíordheimhnithe ar do shuíomh trí URLanna atreoraithe a iarraidh chuig comhaid íomhá ar do shuíomh Gréasáin. Chun an sceitheadh faisnéise seo “ \< \>” a sheachaint, óstach na híomhánna go léir agus do favicon ar fearann ar leithligh. > > Is féidir lúb atreoraithe a bheith mar thoradh ar `redirect_autenticated_user` a chumasú nuair a úsáidtear an maisitheoir: func: .permission\_required mura n-úsáidtear an paraiméadar `raise_exception`. #### `success_url_allowed_hosts` \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()` 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 \`. \Mura gcuirtear ```next ``ar fáil, atreoraíonn sé 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`. \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: ``` 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`: ```html+django {% extends "base.html" %} {% block content %} {% if form.errors %}

Your username and password didn't match. Please try again.

{% endif %} {% if next %} {% if user.is_authenticated %}

Your account doesn't have access to this page. To proceed, please login with an account that has access.

{% else %}

Please login to see this page.

{% endif %} {% endif %}
{% csrf_token %}
{{ form.username.label_tag }} {{ form.username }}
{{ form.password.label_tag }} {{ form.password }}
{# Assumes you set up the password_reset view in your URLconf #}

Lost password?

{% 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\` \ 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 LogoutView` Logáil úsáideoir amach ar iarratais POST . Ainm URL: \*\* logáil isteach \`\` Tréithe: \*\* #### `next_page` An URL le atreorú chuig tar éis logáil amach. Réamhshocraithe chuig: socrú: LOGOUT\_REDIRECT\_URL. #### `template_name` 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_name` 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_context` Foclóir sonraí comhthéacs a chuirfear leis na sonraí comhthéacs réamhshocraithe a chuirtear chuig an teimpléad. #### `success_url_allowed_hosts` \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`. \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)` 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. \Réamhshocraithe to:setting: settings.login\_url mura gcuirtear ar fáil. #### `class PasswordChangeView` Ainm URL: \*\* `password_change` Ligeann sé d'úsáideoir a phasfhocal a athrú. Tréithe: \*\* #### `template_name` 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_url` An URL le atreorú chuig tar éis athrú pasfhocal rathúil. Réamhshocraithe go `` `'password_change_done' ``. #### `form_class` 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_context` 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 PasswordChangeDoneView` Ainm URL: \*\* `` `password_change_done `` An leathanach a thaispeántar tar éis d'úsáideoir a phasfhocal a athrú. Tréithe: \*\* #### `template_name` 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_context` Foclóir sonraí comhthéacs a chuirfear leis na sonraí comhthéacs réamhshocraithe a chuirtear chuig an teimpléad. #### `class PasswordResetView` 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. > **Note** > > Bí ar an eolas go gcosnaíonn ríomhphost a sheoladh ama breise, dá bhrí sin b'fhéidir go mbeadh tú leochaileach d'ionsaí uainiúcháin áireamh seoltaí ríomhphoist mar gheall ar difríocht idir fad iarratais athshocraithe ar sheoladh ríomhphoist atá ann cheana agus fad iarratais athshocraithe ar sheoladh ríomhphoist nach bhfuil ann. Chun an lasbhreas a laghdú, is féidir leat pacáiste 3ú páirtí a úsáid a cheadaíonn ríomhphoist a sheoladh go hincrónach, m.sh.: pypi: django-mailer. Tréithe: \*\* #### `template_name` 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_class` 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_name` 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_name` 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_generator` 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_url` An URL le atreorú chuig tar éis iarratas rathúil athshocraithe pasfhocal. Réamhshocraithe go `` `'password_reset_done' ``. #### `from_email` Seoladh ríomhphoist bailí. De réir réamhshocraithe úsáideann Django an:setting: DEFAULT\_FROM\_EMAIL. #### `extra_context` Foclóir sonraí comhthéacs a chuirfear leis na sonraí comhthéacs réamhshocraithe a chuirtear chuig an teimpléad. #### `html_email_template_name` 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_context` 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`. \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): ```html+django 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 PasswordResetDoneView` 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. > **Note** > > Mura bhfuil an seoladh ríomhphoist a chuirtear ar fáil sa chóras ann, tá an t-úsáideoir neamhghníomhach, nó má tá pasfhocal neamhúsáidte aige, atreorófar an t-úsáideoir chuig an radharc seo fós ach ní sheolfar aon ríomhphost. Tréithe: \*\* #### `template_name` 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_context` Foclóir sonraí comhthéacs a chuirfear leis na sonraí comhthéacs réamhshocraithe a chuirtear chuig an teimpléad. #### `class PasswordResetConfirmView` 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_name` 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_generator` 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_login` 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_backend` 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_class` Foirm a úsáidfear chun an pasfhocal a shocrú. Réamhshocraithe chuig: aicme: ~django.contrib.auth.forms.setPasswordForm. #### `success_url` URL chun a atreorú tar éis an athshocrú pasfhocal a dhéanamh. Réamhshocraithe go `'password_reset_complete'`. #### `extra_context` Foclóir sonraí comhthéacs a chuirfear leis na sonraí comhthéacs réamhshocraithe a chuirtear chuig an teimpléad. #### `reset_url_token` 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 PasswordResetCompleteView` 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_name` Ainm iomlán teimpléad chun an radharc a thaispeáint. Réamhshocraithe chuig: file: clárúcháin/password\_reset\_complete.html. #### `extra_context` Foclóir sonraí comhthéacs a chuirfear leis na sonraí comhthéacs réamhshocraithe a chuirtear chuig an teimpléad. ### Feidhmeanna cúnta #### `redirect_to_login(next, login_url=None, redirect_field_name='next')` 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. \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ógtha 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: > **Note** > > Déanann na foirmeacha fíordheimhnithe ionsuite toimhde áirithe faoin tsamhail úsáideora a bhfuil siad ag obair leis. Má tá a: ref: samhail úsáideora saincheaptha \\`á úsáid agat, b'fhéidir go mbeadh sé riachtanach d'fhoirmeacha féin a shainiú don chóras fíordheimhnithe. \Le haghaidh tuilleadh faisnéise, féach ar an doiciméadú fao:ref: úsáid na bhfoirmeacha fíordheimhnithe ionsuite le samhlacha úsáideora saincheaptha . #### `class AdminPasswordChangeForm` Foirm a úsáidtear sa chomhéadan riaracháin chun pasfhocal úsáideora a athrú, \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 AdminUserCreationForm` Foirm a úsáidtear sa chomhéadan riaracháin chun úsáideoir nua a chruthú. Oidhreacht ó:class: UserCreationForm. It includes an additional `usable_password` field, enabled by default. If `usable_password` is enabled, it verifies that `password1` and `password2` are non empty and match, validates the password using [`validate_password()`](/ga/6.0/topics/auth/passwords/#django.contrib.auth.password_validation.validate_password), and sets the user's password using [`set_password()`](/ga/6.0/ref/contrib/auth/#django.contrib.auth.models.User.set_password). If `usable_password` is disabled, no password validation is done, and password-based authentication is disabled for the user by calling [`set_unusable_password()`](/ga/6.0/ref/contrib/auth/#django.contrib.auth.models.User.set_unusable_password). #### `class AuthenticationForm` 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)` 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”: ``` 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: ``` 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 BaseUserCreationForm` 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. It has three fields: `username` (from the user model), `password1`, and `password2`. It verifies that `password1` and `password2` match, validates the password using [`validate_password()`](/ga/6.0/topics/auth/passwords/#django.contrib.auth.password_validation.validate_password), and sets the user's password using [`set_password()`](/ga/6.0/ref/contrib/auth/#django.contrib.auth.models.User.set_password). #### `class PasswordChangeForm` Foirm chun ligean d'úsáideoir a phasfhocal a athrú. #### `class PasswordResetForm` 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)` Ú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 SetPasswordForm` Foirm a ligeann d'úsáideoir a phasfhocal a athrú gan an sean-phasfhocal a iontráil. #### `class UserChangeForm` Foirm a úsáidtear sa chomhéadan riaracháin chun faisnéis agus ceadanna úsáideora a athrú. #### `class UserCreationForm` 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 dteimpl 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 \. > **Teicniúlacht** > > Go teicniúil, ní chuirtear na hathróga seo ar fáil ach amháin i gcomhthéacs an teimpléid má úsáideann tú: class: ~django.template.requestContext agus cumasaítear an próiseálaí comhthéacs 'django.contrib.auth.context\_processors.auth'. Tá sé sa chomhad socruithe réamhshocraithe a ghintear. \Le haghaidh tuilleadh, féach an:ref: RequestContext docs . #### Úsáideoirí 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}}`: ```html+django {% if user.is_authenticated %}

Welcome, {{ user.username }}. Thanks for logging in.

{% else %}

Welcome, new user. Please log in.

{% endif %} ``` Níl an athróg comhthéacs teimpléad seo ar fáil mura bhfuil `RequestContext` á úsáid. #### Ceada 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 é. \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': ```html+django {% if perms.foo %} ``` \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: ```html+django {% if perms.foo.add_vote %} ``` Seo sampla níos iomláine de cheadanna a sheiceáil i dteimpléad: ```html+django {% if perms.foo %}

You have permission to do something in the foo app.

{% if perms.foo.add_vote %}

You can vote!

{% endif %} {% if perms.foo.add_driving %}

You can drive!

{% endif %} {% else %}

You don't have permission to do anything in the foo app.

{% endif %} ``` Is féidir ceadanna a lorg suas freisin le ráitis `{% má tá i%}`. Mar shampla: ```html+django {% if 'foo' in perms %} {% if 'foo.add_vote' in perms %}

In lookup works, too.

{% endif %} {% endif %} ``` ## Úsáideoirí a bhainistiú sa riarachán 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ú 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ú pasfhocail 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 \. 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ú.