Changes between Version 1 and Version 2 of DjangoDocumentKoreanTranslation/authentication.txt


Ignore:
Timestamp:
11/12/2007 06:18:47 AM (8 years ago)
Author:
spike
Comment:

--

Legend:

Unmodified
Added
Removed
Modified
  • DjangoDocumentKoreanTranslation/authentication.txt

    v1 v2  
    11{{{
    22=============================
     3>>!
    34User authentication in Django
    4 >>
     5<<!
     6>>!!
    57장고의 사용자 인증
    6 <<
     8<<!!
    79=============================
    810
     11>>!
    912Django comes with a user authentication system. It handles user accounts,
    1013groups, permissions and cookie-based user sessions. This document explains how
    1114things work.
    12 >>
     15<<!
     16>>!!
    1317장고는 사용자 인증 시스템을 가지고 있습니다. 사용자 계정, 그룹,
    1418허용권한(permission)과 쿠키를 기반으로 한 세션(session)을 지원합니다.
    15 <<
    16 
     19<<!!
     20
     21>>!
    1722Overview
    18 >>
     23<<!
     24>>!!
    1925개요
    20 <<
     26<<!!
    2127========
    2228
     29>>!
    2330The auth system consists of:
    24 >>
    25 인증 시스템은 다음으로 구성되어 있습니다:
    26 <<
    27 
     31<<!
     32>>!!
     33인증 시스템은 다음으로 구성되어 있습니다.:
     34<<!!
     35
     36>>!
    2837    * Users
    2938    * Permissions: Binary (yes/no) flags designating whether a user may perform
     
    3342    * Messages: A simple way to queue messages for given users.
    3443
    35 >>
    36          * 사용자
    37          * 허용권한(permission): 작업 단위로 허용 여부를 바이너리(binary)로 구분
    38          * 그룹: 하나 이상의 사용자에게 label과 허용권한(permission)을 부여
    39          * 메세지: 사용자에게 메세지를 전달
    40 <<
    41 
     44<<!
     45>>!!
     46    * 사용자
     47    * 허용권한(permission): 작업 단위로 허용 여부를 바이너리(binary)로 구분
     48    * 그룹: 하나 이상의 사용자에게 label과 허용권한(permission)을 부여
     49    * 메세지: 사용자에게 메세지를 전달
     50<<!!
     51>>!
    4252Installation
    43 >>
     53<<!
     54>>!!
    4455설치
    45 <<
     56<<!!
    4657============
    4758
     59>>!
    4860Authentication support is bundled as a Django application in
    4961``django.contrib.auth``. To install it, do the following:
    50 >>
     62<<!
     63>>!!
    5164인증은 장고의 ``django.contrib.auth``에 포함되어 있습니다. 설치는
    52 다음을 따르세요:
    53 <<
    54 
     65다음을 따르세요.:
     66<<!!
     67
     68>>!
    5569    1. Put ``'django.contrib.auth'`` in your ``INSTALLED_APPS`` setting.
    5670    2. Run the command ``manage.py syncdb``.
    5771
    58 >>
     72<<!
     73>>!!
    5974    1. ``'django.contrib.auth'``을 여러분의 settings.py의 ``INSTALLED_APPS``에
    60         추가하세요.
     75    추가하세요.
    6176    2. ``manage.py syncdb``을 실행하세요.
    62 <<
    63 
     77
     78<<!!
     79>>!
    6480Note that the default ``settings.py`` file created by
    6581``django-admin.py startproject`` includes ``'django.contrib.auth'`` in
     
    6884can run that command as many times as you'd like, and each time it'll only
    6985install what's needed.
    70 >>
     86<<!
     87>>!!
    7188참고로 ``'django.contrib.auth'``는 ``django-admin.py startproject``로
    7289자동으로 만들어지는 ``settings.py``의 ``INSTALLED_APPS`` 항목에
     
    7491이미 포함되어 있다면 ``manage.py syncdb``로 몇번이든 새로 인증시스템을
    7592설치할 수 있습니다.
    76 <<
    77 
     93<<!!
     94
     95>>!
    7896The ``syncdb`` command creates the necessary database tables, creates
    7997permission objects for all installed apps that need 'em, and prompts you to
    8098create a superuser account the first time you run it.
    81 >>
     99<<!
     100>>!!
    82101``syncdb`` 명령은 설치된 어플리케이션(installed apps)에 필요한
    83102데이터베이스 테이블을 새로 만들고 처음 실행하는 경우에 관리자 계정을
    84103추가로 만듭니다.
    85 <<
    86 
     104<<!!
     105
     106>>!
    87107Once you've taken those steps, that's it.
    88 >>
     108<<!
     109>>!!
    89110위 과정은 한번으로 충분합니다.
    90 <<
    91 
     111<<!!
     112
     113>>!
    92114Users
    93 >>
     115<<!
     116>>!!
    94117사용자
    95 <<
     118<<!!
    96119=====
    97120
     121>>!
    98122Users are represented by a standard Django model, which lives in
    99123`django/contrib/auth/models.py`_.
    100 >>
     124<<!
     125>>!!
    101126사용자는 `django/contrib/auth/models.py`_에 구현된 장고 모델(Django
    102127model)로 표현됩니다.
    103 <<
     128<<!!
    104129
    105130.. _django/contrib/auth/models.py: http://code.djangoproject.com/browser/django/trunk/django/contrib/auth/models.py
    106131
     132>>!
    107133API reference
    108 >>
     134<<!
     135>>!!
    109136API 참고
    110 <<
     137<<!!
    111138-------------
    112139
     140>>!
    113141Fields
    114 >>
     142<<!
     143>>!!
    115144필드(field)
    116 <<
     145<<!!
    117146~~~~~~
    118147
     148>>!
    119149``User`` objects have the following fields:
    120 >>
    121 ``User`` 객체(object)는 다음과 같은 필드(field)를 가지고 있습니다:
    122 <<
    123 
     150<<!
     151>>!!
     152``User`` 객체(object)는 다음과 같은 필드(field)를 가지고 있습니다.:
     153<<!!
     154
     155>>!
    124156    * ``username`` -- Required. 30 characters or fewer. Alphanumeric characters
    125157      only (letters, digits and underscores).
     
    141173      Is set to the current date/time by default when the account is created.
    142174
    143 >>
    144          * ``username`` -- 반드시 필요. 최대 30자까지. 반드시 문자나 숫자,
    145           '.'이나 '_' ``first_name`` -- 추가 선택. 최대 30자까지.
     175<<!
     176>>!!
     177    * ``username`` -- 반드시 필요. 최대 30자까지. 반드시 문자나 숫자,
     178      '.'이나 '_' ``first_name`` -- 추가 선택. 최대 30자까지.
    146179    * ``last_name`` -- 추가 선택. 최대 30자까지.
    147180    * ``email`` -- 추가 선택. 이메일 주소.
    148         * ``password`` -- 반드시 필요. 비밀번호를 해쉬(hash)로 저장합니다.
    149           장고는 비밀번호를 읽을 수 있도록(raw password) 저장하지 않습니다.
    150           비밀번호는 무한정 길어질 수 있고 어떤 글자도 포함될 수 있습니다.
    151           아래 "Passwords" 항목을 읽어보세요.
     181    * ``password`` -- 반드시 필요. 비밀번호를 해쉬(hash)로 저장합니다.
     182      장고는 비밀번호를 읽을 수 있도록(raw password) 저장하지 않습니다.
     183      비밀번호는 무한정 길어질 수 있고 어떤 글자도 포함될 수 있습니다.
     184      아래 "Passwords" 항목을 읽어보세요.
    152185    * ``is_staff`` -- Boolean. 관리자 사이트에 접근할 수 있는 여부
    153          * ``is_active`` -- Boolean. 로그인할 수 있는 여부. 사용자를
    154           제거하는 대신 이 항목을 ``False``로 설정하세요.
    155          * ``is_superuser`` -- Boolean. 모든 허용권한(permission)을
    156           가지도록 합니다.
    157          * ``last_login`` -- 사용자가 마지막으로 로그인할 날짜와
    158           시간(datetime). 기본으로 현재 시간(date/time)이 저장됩니다.
    159 
    160          * ``date_joined`` -- 사용자가 만들어진 날짜와 시간(datetime).
    161           기본으로 현재 시간(date/time)이 저장됩니다.
    162 <<
    163 
    164 
     186    * ``is_active`` -- Boolean. 로그인할 수 있는 여부. 사용자를
     187      제거하는 대신 이 항목을 ``False``로 설정하세요.
     188    * ``is_superuser`` -- Boolean. 모든 허용권한(permission)을
     189      가지도록 합니다.
     190    * ``last_login`` -- 사용자가 마지막으로 로그인할 날짜와
     191      시간(datetime). 기본으로 현재 시간(date/time)이 저장됩니다.
     192
     193    * ``date_joined`` -- 사용자가 만들어진 날짜와 시간(datetime).
     194      기본으로 현재 시간(date/time)이 저장됩니다.
     195<<!!
     196>>!
    165197Methods
    166 >>
     198<<!
     199>>!!
    167200메소드(method)
    168 <<
     201<<!!
    169202~~~~~~~
    170203
     204>>!
    171205``User`` objects have two many-to-many fields: ``groups`` and
    172206``user_permissions``. ``User`` objects can access their related
    173207objects in the same way as any other `Django model`_::
    174 >>
     208<<!
     209>>!!
    175210``User`` 객체(object)는 두 개의 ``many-to-many field``를 가집니다.:
    176 ``groups``과 ``user_permissions``. ``User`` 객체(object)(object)
    177 다른 `Django model`_과 같은 방법으로 연관된 객체(object)(object)
     211``groups``과 ``user_permissions``. ``User`` 객체(object)
     212다른 `Django model`_과 같은 방법으로 연관된 객체(object)
    178213접근할 수 있습니다.::
    179 <<
     214<<!!
    180215
    181216    myuser.groups = [group_list]
     
    188223    myuser.user_permissions.clear()
    189224
     225>>!
    190226In addition to those automatic API methods, ``User`` objects have the following
    191227custom methods:
    192 >>
     228<<!
     229>>!!
    193230미리 정의된 이러한 메소드(method)와 함께, ``User`` 객체(object)는
    194231다음과 같은 특별한 메소드(method)를 가지고 있습니다.
    195 <<
    196 
     232<<!!
     233
     234>>!
    197235    * ``is_anonymous()`` -- Always returns ``False``. This is a way of
    198236      differentiating ``User`` and ``AnonymousUser`` objects. Generally, you
     
    258296
    259297
    260 >>
    261          * ``is_anonymous()`` -- 항상 ``False``를 반환합니다. 이것으로
    262           ``User``와 ``AnonymousUser``를 구분할 수 있습니다. 일반적으로
    263           ``is_authenticated()``을 사용하는 게 유리합니다.
    264 
    265          * ``is_authenticated()`` -- 항상 ``True``를 반환합니다. 사용자가
    266           인증을 통과했는지 말해줍니다. 단, 이 메소드(method)는 사용자의
    267           허용권한(permission)이 아니라 사용자가 정확한 ``username``과
    268           ``password``로 인증을 통과했는지만 판단합니다.
    269 
    270          * ``get_full_name()`` -- ``first_name``과 ``last_name``를
    271           빈칸(space)으로 묶어서 가져옵니다.
    272 
    273          * ``set_password(raw_password)`` -- 사용자 비밀번호를 지정합니다.
    274           ``User``객체(object)에 직접 비밀번호를 저장하지 마세요.
    275 
    276          * ``check_password(raw_password)`` -- 주어진 사용자 비밀번호가
    277           정확한지 검사합니다.
    278 
    279          * ``set_unusable_password()`` -- **장고 개발버전에 새롭게 추가**
    280                 비밀번호를 사용하지 않도록 합니다. 단, 이것은 ``password``
    281                 필드(field)를 빈공백(blank string)으로 처리하는 것과는 다릅니다.
    282                 ``password`` 필드(field)에 빈 공백(blank string)으로 저장하면
    283                 ``check_password``는 ``True``를 반환하지 않습니다.
    284                 ``User``객체(object)에 직접 저장하지 마세요.
    285 
    286                 이 방법은 LDAP 디렉토리 서비스와 같이 외부 인증시스템을 사용할
    287                 경우에 사용하세요.
    288 
    289          * ``has_usable_password()`` -- **장고 개발버전에 새롭게 추가**
    290                  ``set_unusable_password()``가 설정된 사용자는 ``False``를
    291                  반환합니다.
    292 
    293          * ``get_group_permissions()`` -- 사용자가 속한 그룹의
    294           허용권한(permission) 리스트(list)를 반환합니다.
    295 
    296          * ``get_all_permissions()`` -- 사용자과 사용자의 그룹의
    297           허용권한(permission) 리스트(list)를 반환합니다.
    298 
    299          * ``has_perm(perm)`` -- 사용자가 ``"package.codename"``에 명시된
    300           특정한 허용권한(permission)을 가지고 있는지 검사합니다.
    301           ``is_active``가 ``False``인 경우 항상 ``False``를 반환합니다.
    302 
    303          * ``has_perms(perm_list)`` -- ``"package.codename"``에 명시된
    304           허용권한(permission)들을 가지고 있는지 검사합니다.
    305           ``is_active``가 ``False``인 경우 항상 ``False``를 반환합니다.
    306 
    307          * ``has_module_perms(package_name)`` -- 사용자가 특정한 장고
    308           패키지(package)과 관련된 허용권한(permission)을 가지고 있는지
    309           검사합니다. ``is_active``가 ``False``인 경우 항상 ``False``를
    310           반환합니다.
    311 
    312          * ``get_and_delete_messages()`` -- 사용자에게 전달될 ``Message``
    313           객체(object) 리스트(list)를 큐(queue)에서 가져오고, 가져온 다음
    314           큐(queue)에서 삭제합니다.
    315 
    316          * ``email_user(subject, message, from_email=None)`` -- 사용자에게
    317           메일 메세지를 보냅니다. ``from_email``항목이 ``None``일 경우에는
    318           `DEFAULT_FROM_EMAIL`_ 설정이 사용됩니다.
    319 
    320          * ``get_profile()`` -- 사용자의 사이트 프로필(site-specifi
    321           profile)을 가져옵니다. 사이트의 프로필이 없을 때는
    322           ``django.contrib.auth.models.SiteProfileNotAvailable``
    323           예외(Exception)가 발생합니다.
    324 <<
    325 
     298<<!
     299>>!!
     300    * ``is_anonymous()`` -- 항상 ``False``를 반환합니다. 이것으로
     301      ``User``와 ``AnonymousUser``를 구분할 수 있습니다. 일반적으로
     302      ``is_authenticated()``을 사용하는 것이 유리합니다.
     303
     304    * ``is_authenticated()`` -- 항상 ``True``를 반환합니다. 사용자가
     305      인증을 통과했는지 말해줍니다. 단, 이 메소드(method)는 사용자의
     306      허용권한(permission)이 아니라 사용자가 정확한 ``username``과
     307      ``password``로 인증을 통과했는지만 판단합니다.
     308
     309    * ``get_full_name()`` -- ``first_name``과 ``last_name``를
     310      빈칸(space)으로 묶어서 가져옵니다.
     311
     312    * ``set_password(raw_password)`` -- 사용자 비밀번호를 지정합니다.
     313      ``User``객체(object)에 직접 비밀번호를 저장하지 마세요.
     314
     315    * ``check_password(raw_password)`` -- 주어진 사용자 비밀번호가
     316      정확한지 검사합니다.
     317
     318    * ``set_unusable_password()`` -- **장고 개발버전에 새롭게 추가**
     319      비밀번호를 사용하지 않도록 합니다. 단, 이것은 ``password``
     320      필드(field)를 빈공백(blank string)으로 처리하는 것과는 다릅니다.
     321      ``password`` 필드(field)에 빈 공백(blank string)으로 저장하면
     322      ``check_password``는 ``True``를 반환하지 않습니다.
     323      ``User``객체(object)에 직접 저장하지 마세요.
     324
     325      이 방법은 LDAP 디렉토리 서비스와 같이 외부 인증시스템을 사용할
     326      경우에 사용하세요.
     327
     328    * ``has_usable_password()`` -- **장고 개발버전에 새롭게 추가**
     329      ``set_unusable_password()``가 설정된 사용자는 ``False``를
     330      반환합니다.
     331
     332    * ``get_group_permissions()`` -- 사용자가 속한 그룹의
     333      허용권한(permission) 리스트(list)를 반환합니다.
     334
     335    * ``get_all_permissions()`` -- 사용자과 사용자의 그룹의
     336      허용권한(permission) 리스트(list)를 반환합니다.
     337
     338    * ``has_perm(perm)`` -- 사용자가 ``"package.codename"``에 명시된
     339      특정한 허용권한(permission)을 가지고 있는지 검사합니다.
     340      ``is_active``가 ``False``인 경우 항상 ``False``를 반환합니다.
     341
     342    * ``has_perms(perm_list)`` -- ``"package.codename"``에 명시된
     343      허용권한(permission)들을 가지고 있는지 검사합니다.
     344      ``is_active``가 ``False``인 경우 항상 ``False``를 반환합니다.
     345
     346    * ``has_module_perms(package_name)`` -- 사용자가 특정한 장고
     347      패키지(package)과 관련된 허용권한(permission)을 가지고 있는지
     348      검사합니다. ``is_active``가 ``False``인 경우 항상 ``False``를
     349      반환합니다.
     350
     351    * ``get_and_delete_messages()`` -- 사용자에게 전달될 ``Message``
     352      객체(object) 리스트(list)를 큐(queue)에서 가져오고, 가져온 다음
     353      큐(queue)에서 삭제합니다.
     354
     355    * ``email_user(subject, message, from_email=None)`` -- 사용자에게
     356      메일 메세지를 보냅니다. ``from_email``항목이 ``None``일 경우에는
     357      `DEFAULT_FROM_EMAIL`_ 설정이 사용됩니다.
     358
     359    * ``get_profile()`` -- 사용자의 사이트 프로필(site-specifi
     360      profile)을 가져옵니다. 사이트의 프로필이 없을 때는
     361      ``django.contrib.auth.models.SiteProfileNotAvailable``
     362      예외(Exception)가 발생합니다.
     363
     364<<!!
    326365.. _Django model: ../model-api/
    327366.. _DEFAULT_FROM_EMAIL: ../settings/#default-from-email
    328367
     368>>!
    329369Manager functions
    330 >>
     370<<!
     371>>!!
    331372관리 함수(function)들
    332 <<
     373<<!!
    333374~~~~~~~~~~~~~~~~~
    334375
     376>>!
    335377The ``User`` model has a custom manager that has the following helper functions:
    336 >>
     378<<!
     379>>!!
    337380``User``모델(model)은 유용한 함수(function)들을 가지고 있습니다.
    338 <<
    339 
     381<<!!
     382
     383>>!
    340384    * ``create_user(username, email, password=None)`` -- Creates, saves and
    341385      returns a ``User``. The ``username``, ``email`` and ``password`` are set
     
    352396      ``1``, ``I`` and ``0``).
    353397
    354 >>
    355          * ``create_user(username, email, password=None)`` -- 사용자를
    356           만들고 ``User``객체(object)를 반환합니다. 만들어진 사용자는
    357           ``is_active=True``로 지정됩니다.
    358 
    359                 비밀번호가 주어지지 않는 경우에 ``set_unusable_password()``
    360                 메소드(method)가 호출됩니다.
    361 
    362       _`Creating users`에서 예제를 참고하세요.
    363 
    364     * ``make_random_password(length=10, allowed_chars='abcdefghjkmnpqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ23456789')``
    365                 주어진 길이와 글자들로 임의의 비밀번호를 만듭니다. (참고로
    366                 기본으로 지정된 ``allowed_chars``에는 ``1``, ``I`` and ``0``와
    367                 같은 햇갈리는 글자들은 제외되었습니다.)
    368 <<
    369 
     398<<!
     399>>!!
     400    * ``create_user(username, email, password=None)`` -- 사용자를
     401      만들고 ``User``객체(object)를 반환합니다. 만들어진 사용자는
     402      ``is_active=True``로 지정됩니다.
     403
     404      비밀번호가 주어지지 않는 경우에 ``set_unusable_password()``
     405      메소드(method)가 호출됩니다.
     406
     407      _`사용자 만들기`에서 예제를 참고하세요.
     408
     409   * ``make_random_password(length=10, allowed_chars='abcdefghjkmnpqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ23456789')``
     410     주어진 길이와 글자들로 임의의 비밀번호를 만듭니다. (참고로
     411     기본으로 지정된 ``allowed_chars``에는 ``1``, ``I`` and ``0``와
     412     같은 햇갈리는 글자들은 제외되었습니다.)
     413<<!!
     414>>!
    370415Basic usage
    371 >>
     416<<!
     417>>!!
    372418기본적인 사용법
    373 <<
     419<<!!
    374420-----------
    375421
     422>>!
    376423Creating users
    377 >>
     424<<!
     425>>!!
    378426사용자 만들기
    379 <<
     427<<!!
    380428~~~~~~~~~~~~~~
    381429
     430>>!
    382431The most basic way to create users is to use the ``create_user`` helper
    383432function that comes with Django::
    384 >>
     433<<!
     434>>!!
    385435일반적으로 ``create_user`` 함수(function)를 사용해서 사용자를
    386436만듭니다.::
    387 <<
    388 
    389 
     437<<!!
    390438    >>> from django.contrib.auth.models import User
    391439    >>> user = User.objects.create_user('john', 'lennon@thebeatles.com', 'johnpassword')
    392440
     441>>!
    393442    # At this point, user is a User object that has already been saved
    394443    # to the database. You can continue to change its attributes
    395444    # if you want to change other fields.
    396 >>
    397          # 여기서 사용자 객체(object)는 이미 데이터베이스에
    398          # 저장되었습니다. 객체(object)의 속성(attribute)을 변경할 수
    399          # 있습니다.
    400 <<
     445<<!
     446>>!!
     447     # 여기서 사용자 객체(object)는 이미 데이터베이스에
     448     # 저장되었습니다. 객체(object)의 속성(attribute)을 변경할 수
     449     # 있습니다.
     450<<!!
    401451    >>> user.is_staff = True
    402452    >>> user.save()
    403453
     454>>!
    404455Changing passwords
    405 >>
     456<<!
     457>>!!
    406458비밀번호 바꾸기
    407 <<
     459<<!!
    408460~~~~~~~~~~~~~~~~~~
    409461
     462>>!
    410463Change a password with ``set_password()``::
    411 >>
    412 ``set_password()``로 비밀번호를 변경합니다::
    413 <<
     464<<!
     465>>!!
     466``set_password()``로 비밀번호를 변경합니다.::
     467<<!!
    414468
    415469    >>> from django.contrib.auth.models import User
     
    418472    >>> u.save()
    419473
     474>>!
    420475Don't set the ``password`` attribute directly unless you know what you're
    421476doing. This is explained in the next section.
    422 >>
     477<<!
     478>>!!
    423479특별한 이유가 없다면, 비밀번호를 ``User``객체(object)의 ``password``
    424480속성(attribute)으로 지정하는 방법으로 변경하는 것은 바람직하지
    425481않습니다. 이유는 다음 섹션에서 설명합니다.
    426 <<
    427 
     482<<!!
     483
     484>>!
    428485Passwords
    429 >>
     486<<!
     487>>!!
    430488비밀번호
    431 <<
     489<<!!
    432490---------
    433491
     492>>!
    434493The ``password`` attribute of a ``User`` object is a string in this format::
    435 >>
    436 ``User``객체(object)의 ``password``속성(attribute)은 다음과 같이 구성됩니다::
    437 <<
     494<<!
     495>>!!
     496``User``객체(object)의 ``password``속성(attribute)은 다음과 같이 구성됩니다.::
     497<<!!
    438498
    439499    hashtype$salt$hash
    440500
     501>>!
    441502That's hashtype, salt and hash, separated by the dollar-sign character.
    442 >>
     503<<!
     504>>!!
    443505달러표시(dollar-sign)로 구분된 hashtype, salt 그리고 hash의 조합입니다.
    444 <<
    445 
     506<<!!
     507
     508>>!
    446509Hashtype is either ``sha1`` (default), ``md5`` or ``crypt`` -- the algorithm
    447 used to perform a one-way hash of the password. Salt is a random string used to
    448 salt the raw password to create the hash. Note that the ``crypt`` method is only
    449 supported on platforms that have the standard Python ``crypt`` module available,
    450 and ``crypt`` support is only available in the Django development version.
    451 >>
     510used to perform a one-way hash of the password. Salt is a random string used
     511to salt the raw password to create the hash. Note that the ``crypt`` method is
     512only supported on platforms that have the standard Python ``crypt`` module
     513available, and ``crypt`` support is only available in the Django development
     514version.
     515<<!
     516>>!!
    452517Hashtype은 ``sha1`` (기본), ``md5`` 혹은 ``crypt`` 중 하나입니다. --
    453518비밀번호를 거꾸로 풀 수 없는 알고리즘입니다. Salt는 hash를 만드는
     
    455520``crypt`` 방법은 ``crypt`` 모듈을 포함하고 있는 표준 Python이 지원하는
    456521플랫폼에서만 지원되고, ``crypt``는 장고 개발버전에서만 지원됩니다.
    457 <<
    458 
    459 
     522<<!!
     523
     524>>!
    460525For example::
    461 >>
     526<<!
     527>>!!
    462528예로::
    463 <<
     529<<!!
    464530
    465531    sha1$a1976$a36cc8cbf81742a8fb52e221aaeab48ed7f58ab4
    466532
     533>>!
    467534The ``User.set_password()`` and ``User.check_password()`` functions handle
    468535the setting and checking of these values behind the scenes.
    469 >>
     536<<!
     537>>!!
    470538``User.set_password()``와 ``User.check_password()`` 메소드(method)가
    471539이 값들을 처리할 수 있습니다.
    472 <<
    473 
    474 
     540<<!!
     541
     542>>!
    475543Previous Django versions, such as 0.90, used simple MD5 hashes without password
    476544salts. For backwards compatibility, those are still supported; they'll be
    477545converted automatically to the new style the first time ``User.check_password()``
    478546works correctly for a given user.
    479 >>
     547<<!
     548>>!!
    4805490.90같은 이전 장고 버전에서는 간단하게 Salt 없이 MD5가 사용됩니다.
    481550이전 버전을 위해서 이 방법도 여전히 유효합니다; 다만
    482551``User.check_password()``가 실행되면 자동으로 새로운 형식으로
    483552변경됩니다.
    484 <<
    485 
     553<<!!
     554
     555>>!
    486556Anonymous users
    487 >>
     557<<!
     558>>!!
    488559익명사용자
    489 <<
     560<<!!
    490561---------------
    491562
     563>>!
    492564``django.contrib.auth.models.AnonymousUser`` is a class that implements
    493565the ``django.contrib.auth.models.User`` interface, with these differences:
    494 >>
     566<<!
     567>>!!
    495568``django.contrib.auth.models.AnonymousUser``는
    496569``django.contrib.auth.models.User``를 본받았지만 몇 가지 차이점이 있습니다.:
    497 <<
    498 
     570<<!!
     571
     572>>!
    499573    * ``id`` is always ``None``.
    500574    * ``is_staff`` and ``is_superuser`` are always False.
     
    507581      ``set_groups()`` and ``set_permissions()`` raise ``NotImplementedError``.
    508582
    509 >>
     583<<!
     584>>!!
    510585    * ``id``는 항상 ``None``.
    511586    * ``is_staff``와 ``is_superuser``는 항상 ``False``.
     
    515590    * ``is_authenticated()``는 ``False``.
    516591    * ``has_perm()``는 항상 ``False``.
    517          * ``set_password()``, ``check_password()``, ``save()``,
    518           ``delete()``, ``set_groups()`` 그리고 ``set_permissions()``는
    519           ``NotImplementedError`` 예외(Exception)를 발생시킵니다.
    520 <<
    521 
    522 
     592    * ``set_password()``, ``check_password()``, ``save()``,
     593      ``delete()``, ``set_groups()`` 그리고 ``set_permissions()``는
     594      ``NotImplementedError`` 예외(Exception)를 발생시킵니다.
     595<<!!
     596>>!
    523597In practice, you probably won't need to use ``AnonymousUser`` objects on your
    524598own, but they're used by Web requests, as explained in the next section.
    525 >>
     599<<!
     600>>!!
    526601실제로 ``AnonymousUser``를 필요 없을지도 모르지만, 다음 섹션에서
    527602설명하는 Web requests에서 사용됩니다.
    528 <<
    529 
     603<<!!
     604
     605>>!
    530606Creating superusers
    531 >>
     607<<!
     608>>!!
    532609관리자 만들기
    533 <<
     610<<!!
    534611-------------------
    535612
     613>>!
    536614``manage.py syncdb`` prompts you to create a superuser the first time you run
    537615it after adding ``'django.contrib.auth'`` to your ``INSTALLED_APPS``. But if
     
    539617``create_superuser.py`` utility. Just run this command::
    540618
    541 >>
     619<<!
     620>>!!
    542621settings.py의 ``INSTALLED_APPS``에 ``'django.contrib.auth'``를 추가한
    543622상태에서 처음 ``manage.py syncdb``를 실행시키면 관리자 계정을
    544623만듭니다. 나중에 관리자 계정을 따로 만들려면 ``create_superuser.py``를
    545624사용할 수 있습니다.::
    546 <<
     625<<!!
    547626
    548627    python /path/to/django/contrib/auth/create_superuser.py
    549628
     629>>!
    550630Make sure to substitute ``/path/to/`` with the path to the Django codebase on
    551631your filesystem.
    552 >>
     632<<!
     633>>!!
    553634``/path/to/``를 장고를 설치한 디렉토리로 바꿔주세요.
    554 <<
    555 
    556 
     635<<!!
     636
     637
     638>>!
    557639Authentication in Web requests
    558 >>
     640<<!
     641>>!!
    559642Web requests에서 인증하기
    560 <<
     643<<!!
    561644==============================
    562645
     646>>!
    563647Until now, this document has dealt with the low-level APIs for manipulating
    564648authentication-related objects. On a higher level, Django can hook this
    565649authentication framework into its system of `request objects`_.
    566 >>
     650<<!
     651>>!!
    567652지금까지 이 문서는 인증과 관련된 객체(object)들을 다루는, 낮은
    568653수준(low-level)에서 API를 설명했습니다. 장고는 인증
    569654프레임워크(authentication framework)를 `request objects`_와
    570655연결시킵니다.
    571 <<
    572 
     656<<!!
     657
     658>>!
    573659First, install the ``SessionMiddleware`` and ``AuthenticationMiddleware``
    574660middlewares by adding them to your ``MIDDLEWARE_CLASSES`` setting. See the
    575661`session documentation`_ for more information.
    576 >>
     662<<!
     663>>!!
    577664먼저 장고의 미들웨어(middleware) 중에 ``SessionMiddleware``와
    578665``AuthenticationMiddleware``를 settings.py의 ``MIDDLEWARE_CLASSES``에
    579666추가합니다. 자세한 내용은 `session documentation`_를 참고하세요.
    580 <<
    581 
     667<<!!
     668
     669>>!
    582670Once you have those middlewares installed, you'll be able to access
    583671``request.user`` in views. ``request.user`` will give you a ``User`` object
     
    585673``request.user`` will be set to an instance of ``AnonymousUser`` (see the
    586674previous section). You can tell them apart with ``is_authenticated()``, like so::
    587 >>
     675<<!
     676>>!!
    588677한번 이들 미들웨어(middleware)를 설치하면 뷰(views)에서
    589678``request.user``를 접근할 수 있습니다. ``request.user``는 현재
     
    591680로그인하지 않았다면, ``AnonymousUser``객체(object)를 대신 가리킵니다.
    592681(이전 섹션을 참고하세요.) 다음과 같이 ``is_authenticated()``로 구분할
    593 수 있습니다.
    594 <<
     682수 있습니다.::
     683<<!!
    595684
    596685    if request.user.is_authenticated():
    597                   # 인증된 사용자의 경우,
     686         # 인증된 사용자의 경우,
    598687    else:
    599                   # 인증되지 않은 사용자의 경우,
     688         # 인증되지 않은 사용자의 경우,
    600689
    601690.. _request objects: ../request_response/#httprequest-objects
    602691.. _session documentation: ../sessions/
    603692
     693>>!
    604694How to log a user in
    605 >>
     695<<!
     696>>!!
    606697로그인시키는 방법은
    607 <<
     698<<!!
    608699--------------------
    609700
     701>>!
    610702Django provides two functions in ``django.contrib.auth``: ``authenticate()``
    611703and ``login()``.
    612 >>
    613 장고는 ``django.contrib.auth``에서 두가지 함수(function)를 제공합니다:
     704<<!
     705>>!!
     706장고는 ``django.contrib.auth``에서 두가지 함수(function)를 제공합니다.:
    614707``authenticate()``와 ``login()``.
    615 <<
    616 
     708<<!!
     709
     710>>!
    617711To authenticate a given username and password, use ``authenticate()``. It
    618712takes two keyword arguments, ``username`` and ``password``, and it returns
    619713a ``User`` object if the password is valid for the given username. If the
    620714password is invalid, ``authenticate()`` returns ``None``. Example::
    621 >>
     715<<!
     716>>!!
    622717사용자 이름과 패스워드로 인증하려면 ``authenticate()``
    623718함수(function)를 사용하세요. 이 함수는 ``username``와 ``password``라는
     
    625720``User``객체를 반환합니다. 그렇지 않으면 ``None``을 반환합니다. 예를
    626721들면::
    627 <<
     722<<!!
    628723
    629724    from django.contrib.auth import authenticate
     
    637732        print "주어진 사용자 이름과 비밀번호가 정확하지 않습니다."
    638733
     734>>!
    639735To log a user in, in a view, use ``login()``. It takes an ``HttpRequest``
    640736object and a ``User`` object. ``login()`` saves the user's ID in the session,
    641737using Django's session framework, so, as mentioned above, you'll need to make
    642738sure to have the session middleware installed.
    643 >>
     739<<!
     740>>!!
    644741뷰(view)에서 사용자 로그인을 처리하려면 ``HttpRequest``와 ``User``를
    645742가지고 ``login()`` 메소드(method)를 사용하세요. ``login()``
     
    647744세션(session)에 사용자 ID를 저장합니다. 물론 세션 미들웨어(session
    648745middleware)를 설치했는지 확인해야합니다.
    649 <<
    650 
     746<<!!
     747
     748>>!
    651749This example shows how you might use both ``authenticate()`` and ``login()``::
    652 >>
    653 아래 ``authenticate()``와 ``login()``를 사용하는 예를 설명합니다.
     750<<!
     751>>!!
     752아래 ``authenticate()``와 ``login()``를 사용하는 예를 설명합니다.::
     753<<!!
    654754
    655755    from django.contrib.auth import authenticate, login
    656756
    657757    def my_view(request):
    658 <<
    659758        username = request.POST['username']
    660759        password = request.POST['password']
     
    663762            if user.is_active:
    664763                login(request, user)
    665                                         # 인증된 사용자를 위한 페이지로 이동합니다.
     764                # 인증된 사용자를 위한 페이지로 이동합니다.
    666765            else:
    667                                         # '중지된 사용자'라는 메세지를 표시합니다.
     766                # '중지된 사용자'라는 메세지를 표시합니다.
    668767        else:
    669768            # Return an 'invalid login' error message.
    670                                 # 로그인되지 않았다는 에러 메세지를 표시합니다.
    671 
     769            # 로그인되지 않았다는 에러 메세지를 표시합니다.
     770
     771>>!
    672772Manually checking a user's password
    673 >>
     773<<!
     774>>!!
    674775비밀번호를 손수 검사하는 방법
    675 <<
     776<<!!
    676777-----------------------------------
    677778
     779>>!
    678780If you'd like to manually authenticate a user by comparing a
    679781plain-text password to the hashed password in the database, use the
     
    682784value of a user's ``password`` field in the database to check against,
    683785and returns ``True`` if they match, ``False`` otherwise.
    684 >>
     786<<!
     787>>!!
    685788``django.contrib.auth.models.check_password`` 함수(function)를
    686789사용해서 글자로 표현된 비밀번호(plain-text password)와 데이터베이스에
     
    689792비밀번호와 데이터베이스에 저장된 hash처리된 비밀번호. 동일한 경우
    690793``True``를 반환합니다. 그렇지 않을 경우에는 ``False``.
    691 <<
    692 
     794<<!!
     795
     796>>!
    693797How to log a user out
    694 >>
     798<<!
     799>>!!
    695800로그아웃시키는 방법
    696 <<
     801<<!!
    697802---------------------
    698803
     804>>!
    699805To log out a user who has been logged in via ``django.contrib.auth.login()``,
    700806use ``django.contrib.auth.logout()`` within your view. It takes an
    701807``HttpRequest`` object and has no return value. Example::
    702 >>
     808<<!
     809>>!!
    703810``django.contrib.auth.login()``로 사용자를 로그아웃시키려면
    704811뷰(view)에서 ``django.contrib.auth.logout()``를 사용하기 바랍니다.
    705812``HttpRequest``가 주어져야 합니다. 예를 들면::
    706 <<
     813<<!!
    707814
    708815    from django.contrib.auth import logout
     
    710817    def logout_view(request):
    711818        logout(request)
    712                   # 로그아웃한 사용자를 위한 페이지로 이동합니다.
    713 
     819        # 로그아웃한 사용자를 위한 페이지로 이동합니다.
     820
     821>>!
    714822Note that ``logout()`` doesn't throw any errors if the user wasn't logged in.
    715 >>
     823<<!
     824>>!!
    716825참고로 ``logout()``은 로그인하지 않은 사용자인 경우에도
    717826예외(Exception)를 발생시키지 않습니다.
    718 <<
    719 
     827<<!!
     828
     829>>!
    720830Limiting access to logged-in users
    721 >>
     831<<!
     832>>!!
    722833접근 제한하기
    723 <<
     834<<!!
    724835----------------------------------
    725836
     837>>!
    726838The raw way
    727 >>
     839<<!
     840>>!!
    728841낮은 수준에서 처리하는 방법
    729 <<
     842<<!!
    730843~~~~~~~~~~~
    731844
     845>>!
    732846The simple, raw way to limit access to pages is to check
    733847``request.user.is_authenticated()`` and either redirect to a login page::
    734 >>
     848<<!
     849>>!!
    735850간단하게 ``request.user.is_authenticated()``로 검사해서 원하는 로그인
    736851페이지로 이동시킬 수 있습니다.::
    737 <<
     852<<!!
    738853
    739854    from django.http import HttpResponseRedirect
     
    744859        # ...
    745860
     861>>!
    746862...or display an error message::
    747 >>
     863<<!
     864>>!!
    748865...에러 메세지를 표시하도록 할 수도 있습니다.::
    749 <<
     866<<!!
    750867
    751868    def my_view(request):
     
    754871        # ...
    755872
     873>>!
    756874The login_required decorator
    757 >>
     875<<!
     876>>!!
    758877로그인한 사용자를 체크하는 decorator
    759 <<
     878<<!!
    760879~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    761880
     881>>!
    762882As a shortcut, you can use the convenient ``login_required`` decorator::
    763 >>
     883<<!
     884>>!!
    764885간단하게 사용하기 위해서 ``login_required`` decorator를 사용할 수
    765 있습니다::
    766 <<
     886있습니다.::
     887<<!!
    767888
    768889    from django.contrib.auth.decorators import login_required
     
    772893    my_view = login_required(my_view)
    773894
     895>>!
    774896Here's an equivalent example, using the more compact decorator syntax
    775897introduced in Python 2.4::
    776 >>
     898<<!
     899>>!!
    777900Python 2.4부터 지원하는 decorator를 사용해서 좀더 간단하게 표시할 수
    778 있습니다.
    779 <<
     901있습니다.::
     902<<!!
    780903
    781904    from django.contrib.auth.decorators import login_required
     
    785908        # ...
    786909
     910>>!
    787911In the Django development version, ``login_required`` also takes an optional
    788912``redirect_field_name`` parameter. Example::
    789 >>
     913<<!
     914>>!!
    790915장고 개발버전에서는 ``login_required`` decorator는
    791916``redirect_field_name``이라는 키워드 인수(keyword argument)를 지정할
    792 수 있습니다.
    793 <<
     917수 있습니다.::
     918<<!!
    794919
    795920   
     
    800925    my_view = login_required(redirect_field_name='redirect_to')(my_view)
    801926
     927>>!
    802928Again, an equivalent example of the more compact decorator syntax introduced in Python 2.4::
    803 >>
     929<<!
     930>>!!
    804931Python 2.4에서 decorator를 사용한 좀더 간략한 표현을 사용할 수
    805 있습니다::
    806 <<
     932있습니다.::
     933<<!!
    807934   
    808935    from django.contrib.auth.decorators import login_required
     
    812939        # ...
    813940
     941>>!
    814942``login_required`` does the following:
    815 >>
    816 ``login_required``는 다음과 같은 역할을 합니다:
    817 <<
    818 
     943<<!
     944>>!!
     945``login_required``는 다음과 같은 역할을 합니다.:
     946<<!!
     947
     948>>!
    819949    * If the user isn't logged in, redirect to ``settings.LOGIN_URL``
    820950      (``/accounts/login/`` by default), passing the current absolute URL
     
    825955      free to assume the user is logged in.
    826956
    827 >>
    828          * 로그인에 실패하면, ``settings.LOGIN_URL``으로
    829           이동(redirect)합니다. 이때 이 URL에는 query string으로 ``next``를
    830           이름으로 하는 ``redirect_field_name``을 값으로 함께 가지게
    831           됩니다.
    832                
    833                 예를 들면:
     957<<!
     958>>!!
     959    * 로그인에 실패하면, ``settings.LOGIN_URL``으로
     960      이동(redirect)합니다. 이때 이 URL에는 query string으로 ``next``를
     961      이름으로 하는 ``redirect_field_name``을 값으로 함께 가지게
     962      됩니다.
     963       
     964      예를 들면:
    834965      ``/accounts/login/?next=/polls/3/``.
    835966
    836          * 사용자가 정상적으로 로그인하면, 뷰(view)가 실행됩니다.
    837           뷰(view)의 코드는 사용자가 로그인했다고 가정합니다.
    838 <<
    839 
    840 
     967    * 사용자가 정상적으로 로그인하면, 뷰(view)가 실행됩니다.
     968      뷰(view)의 코드는 사용자가 로그인했다고 가정합니다.
     969<<!!
     970
     971
     972>>!
    841973Note that you'll need to map the appropriate Django view to ``settings.LOGIN_URL``.
    842974For example, using the defaults, add the following line to your URLconf::
    843 >>
     975<<!
     976>>!!
    844977그리고 ``settings.LOGIN_URL``에 설정된 뷰(view)를 지정해야 합니다.
    845 예를 들면 URLconf에 다음을 추가하세요:
    846 <<
     978예를 들면 URLconf에 다음을 추가하세요.::
     979<<!!
    847980
    848981    (r'^accounts/login/$', 'django.contrib.auth.views.login'),
    849982
     983>>!
    850984Here's what ``django.contrib.auth.views.login`` does:
    851 >>
     985<<!
     986>>!!
    852987``django.contrib.auth.views.login``가 하는 역할은:
    853 <<
    854 
     988<<!!
     989
     990>>!
    855991    * If called via ``GET``, it displays a login form that POSTs to the same
    856992      URL. More on this in a bit.
     
    861997      (which defaults to ``/accounts/profile/``). If login isn't successful,
    862998      it redisplays the login form.
    863 >>
     999<<!
     1000>>!!
    8641001    * ``GET`` 방식으로 호출하면 그냥 로그인 폼(form)을 보여줍니다.
    865          * ``POST`` 방식으로 호출하면, 로그인을 시도합니다. 로그인에
    866           성공하면 뷰(view)는 ``next``에 지정된 URL로 이동(redirect)합니다.
    867           ``next``가 지정되어 있지 않으면
    868           ``settings.LOGIN_REDIRECT_URL``로 이동합니다. (기본값은
    869           ``/accounts/profile/``) 로그인에 실패하면 다시 로그인 페이지로
    870           이동합니다.
    871 <<
    872 
     1002    * ``POST`` 방식으로 호출하면, 로그인을 시도합니다. 로그인에
     1003      성공하면 뷰(view)는 ``next``에 지정된 URL로 이동(redirect)합니다.
     1004      ``next``가 지정되어 있지 않으면
     1005      ``settings.LOGIN_REDIRECT_URL``로 이동합니다. (기본값은
     1006      ``/accounts/profile/``) 로그인에 실패하면 다시 로그인 페이지로
     1007      이동합니다.
     1008<<!!
     1009
     1010>>!
    8731011It's your responsibility to provide the login form in a template called
    8741012``registration/login.html`` by default. This template gets passed three
    8751013template context variables:
    876 >>
     1014<<!
     1015>>!!
    8771016기본으로 정해진 ``registration/login.html``은 직접 구현해야 합니다. 이
    8781017템플릿(template)은 세가지 context 변수를 받습니다.
    879 <<
    880 
     1018<<!!
     1019
     1020>>!
    8811021    * ``form``: A ``FormWrapper`` object representing the login form. See the
    8821022      `forms documentation`_ for more on ``FormWrapper`` objects.
     
    8891029      `site framework docs`_.
    8901030
    891 >>
    892          * ``form``: 로그인 폼(form)을 표현하는
    893           ``FormWrapper``객체(object). ``FormWrapper``에 대해서는
    894           `forms documentation`_ 참고하세요.
    895          * ``next``: 로그인에 성공한 뒤에 이동할 URL. query string도 포함할
    896           수 있습니다.
    897          * ``site_name``: 현재 ``SITE_ID``를 참조한 ``Site``의 이름. 장고
    898           개발버전을 사용하고 사이트 프레임워크(site framework)를 사용하지
    899           않는다면, ``request.META['SERVER_NAME']``의 값이 사용됩니다.
    900           사이트(site)에 관해서는 `site framework docs`_를 참고하세요.
    901 <<
    902 
     1031<<!
     1032>>!!
     1033    * ``form``: 로그인 폼(form)을 표현하는
     1034      ``FormWrapper``객체(object). ``FormWrapper``에 대해서는
     1035      `forms documentation`_ 참고하세요.
     1036    * ``next``: 로그인에 성공한 뒤에 이동할 URL. query string도 포함할
     1037      수 있습니다.
     1038    * ``site_name``: 현재 ``SITE_ID``를 참조한 ``Site``의 이름. 장고
     1039      개발버전을 사용하고 사이트 프레임워크(site framework)를 사용하지
     1040      않는다면, ``request.META['SERVER_NAME']``의 값이 사용됩니다.
     1041      사이트(site)에 관해서는 `site framework docs`_를 참고하세요.
     1042<<!!
     1043
     1044>>!
    9031045If you'd prefer not to call the template ``registration/login.html``, you can
    9041046pass the ``template_name`` parameter via the extra arguments to the view in
    9051047your URLconf. For example, this URLconf line would use ``myapp/login.html``
    9061048instead::
    907 >>
     1049<<!
     1050>>!!
    9081051``registration/login.html`` 대신 템플릿(template)을 지정하고 싶으면,
    9091052URLconf를 설정할 때 뷰(view)에 ``template_name``을 인수(argument)로
    9101053지정할 수 있습니다. 예를 들면 ``myapp/login.html``을 사용하고 싶다면::
    911 <<
     1054<<!!
    9121055
    9131056    (r'^accounts/login/$', 'django.contrib.auth.views.login', {'template_name': 'myapp/login.html'}),
    9141057
     1058>>!
    9151059Here's a sample ``registration/login.html`` template you can use as a starting
    9161060point. It assumes you have a ``base.html`` template that defines a ``content``
    9171061block::
    918 >>
     1062<<!
     1063>>!!
    9191064``registration/login.html`` 템플릿(template) 예입니다. 여기서는
    9201065``base.html`` 템플릿(template)을 content 블록(content block)으로
    921 사용한다고 설정했습니다.
    922 <<
     1066사용한다고 설정했습니다.::
     1067<<!!
    9231068
    9241069    {% extends "base.html" %}
     
    9451090.. _site framework docs: ../sites/
    9461091
     1092>>!
    9471093Other built-in views
    948 >>
     1094<<!
     1095>>!!
    9491096이외에 다른 뷰(view)들
    950 <<
     1097<<!!
    9511098--------------------
    9521099
     1100>>!
    9531101In addition to the ``login`` view, the authentication system includes a
    9541102few other useful built-in views:
    955 >>
     1103<<!
     1104>>!!
    9561105``login`` 뷰(view) 이외에 인증 시스템에는 몇가지 뷰(view)들을 추가로
    9571106제공하고 있습니다.
    958 <<
     1107<<!!
    9591108
    9601109``django.contrib.auth.views.logout``
    9611110~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    9621111
     1112>>!
    9631113**Description:**
    964 >>
     1114<<!
     1115>>!!
    9651116**설명:**
    966 <<
    967 
     1117<<!!
     1118
     1119>>!
    9681120Logs a user out.
    969 >>
     1121<<!
     1122>>!!
    9701123사용자를 로그아웃시킵니다.
    971 <<
    972 
     1124<<!!
     1125
     1126>>!
    9731127**Optional arguments:**
    974 >>
     1128<<!
     1129>>!!
    9751130**추가 인수(argument):**
    976 <<
    977 
     1131<<!!
     1132
     1133>>!
    9781134    * ``template_name``: The full name of a template to display after
    9791135      logging the user out. This will default to
    9801136      ``registration/logged_out.html`` if no argument is supplied.
    981 >>
    982          * ``template_name``: 로그아웃시킨 다음 사용할 템플릿(template)의
    983           전체 이름. 지정하지 않으면 ``registration/logged_out.html``이
    984           기본으로 사용됩니다.
    985 <<
    986 
     1137<<!
     1138>>!!
     1139    * ``template_name``: 로그아웃시킨 다음 사용할 템플릿(template)의
     1140      전체 이름. 지정하지 않으면 ``registration/logged_out.html``이
     1141      기본으로 사용됩니다.
     1142<<!!
     1143
     1144>>!
    9871145**Template context:**
    988 >>
     1146<<!
     1147>>!!
    9891148**템플릿(template) context:**
    990 <<
    991 
     1149<<!!
     1150
     1151>>!
    9921152    * ``title``: The string "Logged out", localized.
     1153<<!
     1154>>!!
    9931155    * ``title``: "Logged out"(언어설정에 따라 번역됩니다).
     1156<<!!
    9941157
    9951158``django.contrib.auth.views.logout_then_login``
    9961159~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    9971160
     1161>>!
    9981162**Description:**
    999 >>
     1163<<!
     1164>>!!
    10001165**설명:**
    1001 <<
    1002 
     1166<<!!
     1167
     1168>>!
    10031169Logs a user out, then redirects to the login page.
    1004 >>
     1170<<!
     1171>>!!
    10051172로그아웃시킨 다음, 로그인 페이지로 이동(redirect)합니다.
    1006 <<
    1007 
     1173<<!!
     1174
     1175>>!
    10081176**Optional arguments:**
    1009 >>
     1177<<!
     1178>>!!
    10101179**추가 인수(argument):**
    1011 <<
    1012 
     1180<<!!
     1181
     1182>>!
    10131183    * ``login_url``: The URL of the login page to redirect to. This
    10141184      will default to ``settings.LOGIN_URL`` if not supplied.
    1015 >>
    1016          * ``login_url``: 이동할 로그인 페이지의 URL. 지정하지 않으면
    1017           기본으로 ``settings.LOGIN_URL``을 사용합니다.
    1018 <<
     1185<<!
     1186>>!!
     1187    * ``login_url``: 이동할 로그인 페이지의 URL. 지정하지 않으면
     1188      기본으로 ``settings.LOGIN_URL``을 사용합니다.
     1189<<!!
    10191190
    10201191``django.contrib.auth.views.password_change``
    10211192~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    10221193
     1194>>!
    10231195**Description:**
    1024 >>
     1196<<!
     1197>>!!
    10251198**설명:**
    1026 <<
    1027 
     1199<<!!
     1200
     1201>>!
    10281202Allows a user to change their password.
    1029 >>
     1203<<!
     1204>>!!
    10301205사용자가 패스워드를 변경할 수 있는 페이지를 제공합니다.
    1031 <<
    1032 
     1206<<!!
     1207
     1208>>!
    10331209**Optional arguments:**
    1034 >>
     1210<<!
     1211>>!!
    10351212**추가 인수(argument):**
    1036 <<
    1037 
     1213<<!!
     1214
     1215>>!
    10381216    * ``template_name``: The full name of a template to use for
    10391217      displaying the password change form. This will default to
    10401218      ``registration/password_change_form.html`` if not supplied.
    1041 >>
    1042          * ``template_name``: 패스워드를 변경할 수 있는 폼(form)을 포함한
    1043           템플릿(template) 이름을 지정합니다. 따로 지정하지 않으면
    1044           ``registration/password_change_form.html``을 사용합니다.
    1045 <<
    1046 
     1219<<!
     1220>>!!
     1221    * ``template_name``: 패스워드를 변경할 수 있는 폼(form)을 포함한
     1222      템플릿(template) 이름을 지정합니다. 따로 지정하지 않으면
     1223      ``registration/password_change_form.html``을 사용합니다.
     1224<<!!
     1225
     1226>>!
    10471227**Template context:**
    1048 >>
     1228<<!
     1229>>!!
    10491230**템플릿(template) context:**
    1050 <<
    1051 
     1231<<!!
     1232
     1233>>!
    10521234    * ``form``: The password change form.
    1053 >>
     1235<<!
     1236>>!!
    10541237    * ``form``: 패스워드 변경에 필요한 폼(form).
    1055 <<
     1238<<!!
    10561239
    10571240``django.contrib.auth.views.password_change_done``
    10581241~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    10591242
     1243>>!
    10601244**Description:**
    1061 >>
     1245<<!
     1246>>!!
    10621247**설명:**
    1063 <<
    1064 
     1248<<!!
     1249
     1250>>!
    10651251The page shown after a user has changed their password.
    1066 >>
     1252<<!
     1253>>!!
    10671254사용자 패스워드를 변경한 다음 보게될 페이지.
    1068 <<
    1069 
     1255<<!!
     1256
     1257>>!
    10701258**Optional arguments:**
    1071 >>
     1259<<!
     1260>>!!
    10721261**추가 인수(argument):**
    1073 <<
    1074 
     1262<<!!
     1263
     1264>>!
    10751265    * ``template_name``: The full name of a template to use. This will
    10761266      default to ``registration/password_change_done.html`` if not
    10771267      supplied.
    1078 >>
    1079          * ``template_name``: 사용할 템플릿(template) 전체 이름. 지정하지
    1080           않으면 ``registration/password_change_done.html``을 사용합니다.
    1081 <<
     1268<<!
     1269>>!!
     1270    * ``template_name``: 사용할 템플릿(template) 전체 이름. 지정하지
     1271      않으면 ``registration/password_change_done.html``을 사용합니다.
     1272<<!!
    10821273
    10831274``django.contrib.auth.views.password_reset``
    10841275~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    10851276
     1277>>!
    10861278**Description:**
    1087 >>
     1279<<!
     1280>>!!
    10881281**설명:**
    1089 <<
    1090 
     1282<<!!
     1283
     1284>>!
    10911285Allows a user to reset their password, and sends them the new password
    10921286in an email.
    1093 >>
     1287<<!
     1288>>!!
    10941289사용자가 패스워드를 초기화할 수 있도록 합니다. 새로운 비밀번호는
    10951290장고에서 지정하고 새 비밀번호는 이메일로 전달합니다.
    1096 <<
    1097 
     1291<<!!
     1292
     1293>>!
    10981294**Optional arguments:**
    1099 >>
     1295<<!
     1296>>!!
    11001297**추가 인수(argument):**
    1101 <<
    1102 
     1298<<!!
     1299
     1300>>!
    11031301    * ``template_name``: The full name of a template to use for
    11041302      displaying the password reset form. This will default to
     
    11081306      generating the email with the new password. This will default to
    11091307      ``registration/password_reset_email.html`` if not supplied.
    1110 >>
    1111          * ``template_name``: 사용할 템플릿(template) 전체 이름. 따로
    1112           지정하지 않으면 ``registration/password_reset_form.html``를
    1113           사용합니다.
    1114 
    1115          * ``email_template_name``: 사용할 템플릿(template) 전체 이름. 따로
    1116           지정하지 않으면 ``registration/password_reset_email.html``를
    1117           사용합니다.
    1118 <<
    1119 
     1308<<!
     1309>>!!
     1310    * ``template_name``: 사용할 템플릿(template) 전체 이름. 따로
     1311      지정하지 않으면 ``registration/password_reset_form.html``를
     1312      사용합니다.
     1313
     1314    * ``email_template_name``: 사용할 템플릿(template) 전체 이름. 따로
     1315      지정하지 않으면 ``registration/password_reset_email.html``를
     1316      사용합니다.
     1317<<!!
     1318
     1319>>!
    11201320**Template context:**
    1121 >>
     1321<<!
     1322>>!!
    11221323**템플릿(template) context:**
    1123 <<
    1124 
     1324<<!!
     1325
     1326>>!
    11251327    * ``form``: The form for resetting the user's password.
    1126 >>
     1328<<!
     1329>>!!
    11271330    * ``form``: 패스워드 초기화에 사용될 폼(form).
    1128 <<
     1331<<!!
    11291332
    11301333``django.contrib.auth.views.password_reset_done``
    11311334~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    11321335
     1336>>!
    11331337**Description:**
    1134 >>
     1338<<!
     1339>>!!
    11351340**설명:**
    1136 <<
    1137 
     1341<<!!
     1342
     1343>>!
    11381344The page shown after a user has reset their password.
    1139 >>
     1345<<!
     1346>>!!
    11401347패스워드를 초기화하고나서 보여줄 페이지
    1141 <<
    1142 
     1348<<!!
     1349
     1350>>!
    11431351**Optional arguments:**
    1144 >>
     1352<<!
     1353>>!!
    11451354**추가 인수(argument):**
    1146 <<
    1147 
     1355<<!!
     1356
     1357>>!
    11481358    * ``template_name``: The full name of a template to use. This will
    11491359      default to ``registration/password_reset_done.html`` if not
    11501360      supplied.
    1151 >>
    1152          * ``template_name``: 사용할 템플릿(template) 전체 이름. 따로
    1153           지정하지 않으면 ``registration/password_reset_done.html``를
    1154           사용합니다.
    1155 <<
     1361<<!
     1362>>!!
     1363     * ``template_name``: 사용할 템플릿(template) 전체 이름. 따로
     1364      지정하지 않으면 ``registration/password_reset_done.html``를
     1365      사용합니다.
     1366<<!!
    11561367
    11571368``django.contrib.auth.views.redirect_to_login``
    11581369~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    11591370
     1371>>!
    11601372**Description:**
    1161 >>
     1373<<!
     1374>>!!
    11621375**설명:**
    1163 <<
    1164 
     1376<<!!
     1377
     1378>>!
    11651379Redirects to the login page, and then back to another URL after a
    11661380successful login.
    1167 >>
     1381<<!
     1382>>!!
    11681383로그인페이지로 이동(redirect)시킵니다. 로그인 이후 다시 다른 URL로
    11691384이동시킵니다.
    1170 <<
    1171 
     1385<<!!
     1386
     1387>>!
    11721388**Required arguments:**
    1173 >>
     1389<<!
     1390>>!!
    11741391**필요한 인수(argument):**
    1175 <<
    1176 
     1392<<!!
     1393
     1394>>!
    11771395    * ``next``: The URL to redirect to after a successful login.
     1396<<!
     1397>>!!
    11781398    * ``next``: 로그인에 성공한 뒤에 이동(redirect)할 페이지 URL
    1179 
     1399<<!!
     1400
     1401>>!
    11801402**Optional arguments:**
    1181 >>
     1403<<!
     1404>>!!
    11821405**추가 인수(argument):**
    1183 <<
    1184 
     1406<<!!
     1407
     1408>>!
    11851409    * ``login_url``: The URL of the login page to redirect to. This
    11861410      will default to ``settings.LOGIN_URL`` if not supplied.
    1187 >>
    1188          * ``login_url``: 이동할 로그인 페이지의 URL. 따로 지정하지 않으면
    1189           ``settings.LOGIN_URL``을 사용합니다.
    1190 <<
    1191 
     1411<<!
     1412>>!!
     1413    * ``login_url``: 이동할 로그인 페이지의 URL. 따로 지정하지 않으면
     1414      ``settings.LOGIN_URL``을 사용합니다.
     1415<<!!
     1416
     1417>>!
    11921418Built-in manipulators
    1193 >>
     1419<<!
     1420>>!!
    11941421기본으로 사용할 수 있는 폼(form)
    1195 <<
     1422<<!!
    11961423---------------------
    11971424
     1425>>!
    11981426If you don't want to use the built-in views, but want the convenience
    11991427of not having to write manipulators for this functionality, the
    12001428authentication system provides several built-in manipulators:
    1201 >>
     1429<<!
     1430>>!!
    12021431위에 설명한 인증과 관련된 뷰(view)를 사용하지 않으면서 장고가
    12031432제공하는 인증과 관련된 폼(form)을 그대로 사용하고 싶다면 아래 장고에서
    1204 제공하는 폼(form)들이 있습니다:
    1205 <<
    1206 
    1207     * ``django.contrib.auth.forms.UserCreationForm``: A manipulator
    1208       for creating a new user.
     1433제공하는 폼(form)들이 있습니다.:
     1434<<!!
     1435
     1436>>!
    12091437    * ``django.contrib.auth.forms.AdminPasswordChangeForm``: A
    12101438      manipulator used in the admin interface to change a user's
     
    12201448      for resetting a user's password and emailing the new password to
    12211449      them.
    1222 
    1223 >>
    1224          * ``django.contrib.auth.forms.AdminPasswordChangeForm``: 관리자
    1225           화면에서 사용하는 사용자 비밀번호를 변경할 수 있는 폼(form)
    1226 
    1227          * ``django.contrib.auth.forms.AuthenticationForm``: 사용자
    1228           로그인에 사용하는 폼(form)
    1229 
    1230          * ``django.contrib.auth.forms.PasswordChangeForm``: 사용자가
    1231           패스워드를 변경할 수 있도록 하는 폼(form)
    1232 
    1233          * ``django.contrib.auth.forms.PasswordResetForm``: 사용자 비밀번호
    1234           초기화에 사용하는 폼(form)
    1235 
    1236          * ``django.contrib.auth.forms.UserCreationForm``: 새로운 사용자를
    1237           만드는 폼(form)
    1238 <<
    1239 
     1450    * ``django.contrib.auth.forms.UserCreationForm``: A manipulator
     1451      for creating a new user.
     1452
     1453<<!
     1454>>!!
     1455    * ``django.contrib.auth.forms.AdminPasswordChangeForm``: 관리자
     1456      화면에서 사용하는 사용자 비밀번호를 변경할 수 있는 폼(form)
     1457
     1458    * ``django.contrib.auth.forms.AuthenticationForm``: 사용자
     1459      로그인에 사용하는 폼(form)
     1460
     1461    * ``django.contrib.auth.forms.PasswordChangeForm``: 사용자가
     1462      패스워드를 변경할 수 있도록 하는 폼(form)
     1463
     1464    * ``django.contrib.auth.forms.PasswordResetForm``: 사용자 비밀번호
     1465      초기화에 사용하는 폼(form)
     1466
     1467    * ``django.contrib.auth.forms.UserCreationForm``: 새로운 사용자를
     1468      만드는 폼(form)
     1469<<!!
     1470
     1471>>!
    12401472Limiting access to logged-in users that pass a test
    1241 >>
     1473<<!
     1474>>!!
    12421475로그인된 사용자 접근 제한하기
    1243 <<
     1476<<!!
    12441477---------------------------------------------------
    12451478
     1479>>!
    12461480To limit access based on certain permissions or some other test, you'd do
    12471481essentially the same thing as described in the previous section.
    1248 >>
     1482<<!
     1483>>!!
    12491484허용권한(permission)에 의해서 접근을 제하는 방법은 이전 섹션에서
    12501485설명한 것과 다르지 않습니다.
    1251 <<
    1252 
     1486<<!!
     1487
     1488>>!
    12531489The simple way is to run your test on ``request.user`` in the view directly.
    12541490For example, this view checks to make sure the user is logged in and has the
    12551491permission ``polls.can_vote``::
    1256 >>
     1492<<!
     1493>>!!
    12571494간단하게 뷰(view)에서 ``request.user``를 가지고 검사할 수 있습니다.
    12581495예를 들어서 아래 뷰(view)는 사용자가 로그인되었는지,
    1259 ``poll.can_vote``라는 허용권한(permission)을 가지고 있는지 검사합니다.
    1260 <<
     1496``poll.can_vote``라는 허용권한(permission)을 가지고 있는지 검사합니다.::
     1497<<!!
    12611498
    12621499    def my_view(request):
    12631500        if not (request.user.is_authenticated() and request.user.has_perm('polls.can_vote')):
    1264             return HttpResponse("투표할 수 없습니다..")
     1501            return HttpResponse("투표할 수 없습니다.")
    12651502        # ...
    12661503
     1504>>!
    12671505As a shortcut, you can use the convenient ``user_passes_test`` decorator::
    1268 >>
    1269 더 간단하게 ``user_passes_test`` decorator를 사용할 수 있습니다.
    1270 <<
     1506<<!
     1507>>!!
     1508더 간단하게 ``user_passes_test`` decorator를 사용할 수 있습니다.::
     1509<<!!
    12711510
    12721511    from django.contrib.auth.decorators import user_passes_test
     
    12761515    my_view = user_passes_test(lambda u: u.has_perm('polls.can_vote'))(my_view)
    12771516
     1517>>!
    12781518We're using this particular test as a relatively simple example. However, if
    12791519you just want to test whether a permission is available to a user, you can use
    12801520the ``permission_required()`` decorator, described later in this document.
    1281 >>
     1521<<!
     1522>>!!
    12821523간단한 예를 들었습니다. 조금 뒤에 허용권한(permission) 여부만 검사할
    12831524수 있는 decorator를 말씀드립니다.
    1284 <<
    1285 
     1525<<!!
     1526
     1527>>!
    12861528Here's the same thing, using Python 2.4's decorator syntax::
    1287 >>
    1288 Python 2.4 이상에서는 decorator를 사용할 수 있습니다.
    1289 <<
     1529<<!
     1530>>!!
     1531Python 2.4 이상에서는 decorator를 사용할 수 있습니다.::
     1532<<!!
    12901533
    12911534    from django.contrib.auth.decorators import user_passes_test
     
    12951538        # ...
    12961539
     1540>>!
    12971541``user_passes_test`` takes a required argument: a callable that takes a
    12981542``User`` object and returns ``True`` if the user is allowed to view the page.
    12991543Note that ``user_passes_test`` does not automatically check that the ``User``
    13001544is not anonymous.
    1301 >>
     1545<<!
     1546>>!!
    13021547``user_passes_test``는 인수(argument)를 필요로 합니다: ``User``
    13031548객체(object)를 인수(argument)로 받아서 허용권한(permission)이 있으면
    13041549``True``를 반환하는 함수(function)입니다. ``user_passes_test``은
    13051550``User``객체(object)를 직접 검사하지 않습니다.
    1306 <<
    1307 
     1551<<!!
     1552
     1553>>!
    13081554``user_passes_test()`` takes an optional ``login_url`` argument, which lets you
    13091555specify the URL for your login page (``settings.LOGIN_URL`` by default).
    1310 >>
     1556<<!
     1557>>!!
    13111558``user_passes_test()``는 또한 ``login_url``을 인수(argument)로
    13121559받습니다. 반환되는 결과에 따라서 이동할 로그인 페이지URL을 지정할 수
    13131560있습니다. 지정하지 않으면``settings.LOGIN_URL``이 사용됩니다.
    1314 <<
    1315 
     1561<<!!
     1562
     1563>>!
    13161564Example in Python 2.3 syntax::
    1317 >>
     1565<<!
     1566>>!!
    13181567Python 2.3에서는::
    1319 <<
     1568<<!!
    13201569
    13211570    from django.contrib.auth.decorators import user_passes_test
     
    13251574    my_view = user_passes_test(lambda u: u.has_perm('polls.can_vote'), login_url='/login/')(my_view)
    13261575
     1576>>!
    13271577Example in Python 2.4 syntax::
    1328 >>
     1578<<!
     1579>>!!
    13291580Python 2.4에서는::
    1330 <<
     1581<<!!
    13311582
    13321583    from django.contrib.auth.decorators import user_passes_test
     
    13361587        # ...
    13371588
     1589>>!
    13381590The permission_required decorator
    1339 >>
     1591<<!
     1592>>!!
    13401593permission_required decorator
    1341 <<
     1594<<!!
    13421595~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    13431596
     1597>>!
    13441598It's a relatively common task to check whether a user has a particular
    13451599permission. For that reason, Django provides a shortcut for that case: the
    13461600``permission_required()`` decorator. Using this decorator, the earlier example
    13471601can be written as::
    1348 >>
     1602<<!
     1603>>!!
    13491604앞서 설명한 대로 ``permission_required()`` decorator는 사용자가 어떤
    1350 허용권한(permission)을 갖고 있는지 검사하는 기본적인 방법입니다.
    1351 <<
     1605허용권한(permission)을 갖고 있는지 검사하는 기본적인 방법입니다.::
     1606<<!!
    13521607
    13531608
     
    13581613    my_view = permission_required('polls.can_vote')(my_view)
    13591614
     1615>>!
    13601616Note that ``permission_required()`` also takes an optional ``login_url``
    13611617parameter. Example::
    1362 >>
     1618<<!
     1619>>!!
    13631620``permission_required()``는 추가로 ``login_url``을 인수(argument)로
    13641621받습니다. 예를 들어서::
    1365 <<
     1622<<!!
    13661623
    13671624    from django.contrib.auth.decorators import permission_required
     
    13711628    my_view = permission_required('polls.can_vote', login_url='/loginpage/')(my_view)
    13721629
     1630>>!
    13731631As in the ``login_required`` decorator, ``login_url`` defaults to
    13741632``settings.LOGIN_URL``.
    1375 >>
     1633<<!
     1634>>!!
    13761635``login_required`` decorator처럼 ``login_url``도 따로 지정하지 않으면
    13771636``settings.LOGIN_URL``이 기본으로 사용됩니다.
    1378 <<
    1379 
     1637<<!!
     1638
     1639>>!
    13801640Limiting access to generic views
    1381 >>
     1641<<!
     1642>>!!
    13821643일반적인 뷰(view)에서 접근 제한하기
    1383 <<
     1644<<!!
    13841645--------------------------------
    13851646
     1647>>!
    13861648To limit access to a `generic view`_, write a thin wrapper around the view,
    13871649and point your URLconf to your wrapper instead of the generic view itself.
    13881650For example::
    1389 >>
     1651<<!
     1652>>!!
    13901653일반적인 뷰(view)(`generic view`_)에서 접근을 제한을 제한하려면
    13911654뷰(view)을 처리하는 함수(function)를 만들고 URLconf에 원래 뷰(view)
    13921655대신 함수(function)를 지정해줍니다. 예를 들어서::
    1393 <<
     1656<<!!
    13941657
    13951658    from django.views.generic.date_based import object_detail
     
    14011664.. _generic view: ../generic_views/
    14021665
     1666>>!
    14031667Permissions
    1404 >>
     1668<<!
     1669>>!!
    14051670허용권한(permission)
    1406 <<
     1671<<!!
    14071672===========
    14081673
     1674>>!
    14091675Django comes with a simple permissions system. It provides a way to assign
    14101676permissions to specific users and groups of users.
    1411 >>
     1677<<!
     1678>>!!
    14121679장고는 간단한 허용권한(permission) 시스템을 갖고 있습니다. 사용자와
    14131680사용자의 그룹에 허용권한(permission)을 할당하는 방법을 제공합니다.
    1414 <<
    1415 
     1681<<!!
     1682
     1683>>!
    14161684It's used by the Django admin site, but you're welcome to use it in your own
    14171685code.
    1418 >>
     1686<<!
     1687>>!!
    14191688장고 관리자 사이트에서 주로 사용되지만, 여러분의 사이트에
    14201689적용해보세요.
    1421 <<
    1422 
     1690<<!!
     1691
     1692>>!
    14231693The Django admin site uses permissions as follows:
    1424 >>
     1694<<!
     1695>>!!
    14251696장고 관리 사이트는 아래와 같이 허용권한(permission)을 사용합니다.
    1426 <<
    1427 
     1697<<!!
     1698
     1699>>!
    14281700    * Access to view the "add" form and add an object is limited to users with
    14291701      the "add" permission for that type of object.
     
    14341706      permission for that type of object.
    14351707
    1436 >>
    1437          * 폼(form)을 통해서 새로운 객체(object)를 추가할 때 객체(object)
    1438           type에 대한 "add"(더하기) 허용권한(permission)으로 뷰(view)에
    1439           대한 사용자 접근을 제한합니다.
    1440 
    1441          * 폼(form)을 통해서 객체(object)의 속성(attribute)을 변경할 때
    1442           객체(object) type에 대한 "change"(바꾸기)
    1443           허용권한(permission)으로 뷰(view)에 대한 사용자 접근을
    1444           제한합니다.
    1445 
    1446          * 폼(form)을 통해서 객체(object)를 지울 때 객체(object) type에 대한
    1447           "delete"(지우기) 허용권한(permission)으로 뷰(view)에 대한 사용자
    1448           접근을 제한합니다.
    1449 <<
    1450 
     1708<<!
     1709>>!!
     1710    * 폼(form)을 통해서 새로운 객체(object)를 추가할 때 객체(object)
     1711      type에 대한 "add"(더하기) 허용권한(permission)으로 뷰(view)에
     1712      대한 사용자 접근을 제한합니다.
     1713
     1714    * 폼(form)을 통해서 객체(object)의 속성(attribute)을 변경할 때
     1715      객체(object) type에 대한 "change"(바꾸기)
     1716      허용권한(permission)으로 뷰(view)에 대한 사용자 접근을
     1717      제한합니다.
     1718
     1719    * 폼(form)을 통해서 객체(object)를 지울 때 객체(object) type에 대한
     1720      "delete"(지우기) 허용권한(permission)으로 뷰(view)에 대한 사용자
     1721      접근을 제한합니다.
     1722<<!!
     1723
     1724>>!
    14511725Permissions are set globally per type of object, not per specific object
    14521726instance. For example, it's possible to say "Mary may change news stories," but
     
    14551729certain status, publication date or ID." The latter functionality is something
    14561730Django developers are currently discussing.
    1457 >>
     1731<<!
     1732>>!!
    14581733허용권한(permission)은 특정한 객체(object)에 대해서가 아니라,
    14591734객체(object) 타입 별로 전역적(globally)으로 지정됩니다. 예를 들어서
     
    14631738기사를 바꿀 수 있습니다."라는 식으로는 불가능합니다. 이 부분은 장고
    14641739개발자들끼리 얘기 중입니다.
    1465 <<
    1466 
     1740<<!!
     1741
     1742>>!
    14671743Default permissions
    1468 >>
     1744<<!
     1745>>!!
    14691746허용권한(permission)의 기본
    1470 <<
     1747<<!!
    14711748-------------------
    14721749
     1750>>!
    14731751Three basic permissions -- add, change and delete -- are automatically created
    14741752for each Django model that has a ``class Admin`` set. Behind the scenes, these
    14751753permissions are added to the ``auth_permission`` database table when you run
    14761754``manage.py syncdb``.
    1477 >>
     1755<<!
     1756>>!!
    14781757세가지 기본 허용권한(permission) -- 더하기(add), 바꾸기(change),
    14791758지우기(delete) --는 ``class Admin``이 지정된 장고 모델(model)을 만들면
     
    14811760실행되면 데이터베이스에는 ``auth_permission`` 테이블이 생성되는데 이
    14821761테이블에 해당 모델(model)에 대한 허용권한(permission)이 저장됩니다.
    1483 <<
    1484 
     1762<<!!
     1763
     1764>>!
    14851765Note that if your model doesn't have ``class Admin`` set when you run
    14861766``syncdb``, the permissions won't be created. If you initialize your database
     
    14881768``manage.py syncdb`` again. It will create any missing permissions for
    14891769all of your installed apps.
    1490 >>
     1770<<!
     1771>>!!
    14911772물론 ``class Admin``을 모델(model)에 지정하지 않은 채로 ``syncdb``를
    14921773실행하면 허용권한(permission)은 부여되지 않습니다. ``class Admin``를
    14931774모델(model)에 추가하고 다시 ``manage.py syncdb``를 실행하세요. 그러면
    14941775빠졌던 허용권한(permission)이 새로 부여됩니다.
    1495 <<
    1496 
     1776<<!!
     1777
     1778>>!
    14971779Custom permissions
    1498 >>
     1780<<!
     1781>>!!
    14991782개발자가 정의한 허용권한(permission)
    1500 <<
     1783<<!!
    15011784------------------
    15021785
     1786>>!
    15031787To create custom permissions for a given model object, use the ``permissions``
    15041788`model Meta attribute`_.
    1505 >>
     1789<<!
     1790>>!!
    15061791`model Meta attribute`_에 ``permissions``을 추가해서 개발자가 직접
    15071792정의한 허용권한(permission)을 사용할 수 있습니다.
    1508 <<
    1509 
     1793<<!!
     1794
     1795>>!
    15101796This example model creates three custom permissions::
    1511 >>
    1512 아래 모델(model)은 세가지 허용권한(permission)을 만들었습니다.
    1513 <<
     1797<<!
     1798>>!!
     1799아래 모델(model)은 세가지 허용권한(permission)을 만들었습니다.::
     1800<<!!
    15141801
    15151802    class USCitizen(models.Model):
     
    15221809            )
    15231810
     1811>>!
    15241812The only thing this does is create those extra permissions when you run
    15251813``syncdb``.
    1526 >>
     1814<<!
     1815>>!!
    15271816이것도 또한 ``syncdb``를 할 때 추가로 지정된 허용권한(permission)으로
    15281817추가됩니다.
    1529 <<
     1818<<!!
    15301819
    15311820.. _model Meta attribute: ../model-api/#meta-options
    15321821
     1822>>!
    15331823API reference
    1534 >>
     1824<<!
     1825>>!!
    15351826API 참고
    1536 <<
     1827<<!!
    15371828-------------
    15381829
     1830>>!
    15391831Just like users, permissions are implemented in a Django model that lives in
    15401832`django/contrib/auth/models.py`_.
    1541 >>
     1833<<!
     1834>>!!
    15421835사용자 클래스(class)처럼 허용권한(permission)은
    15431836`django/contrib/auth/models.py`_이 정의하는 장고 모델(model)에서
    15441837구현되어 있습니다.
    1545 <<
     1838<<!!
    15461839
    15471840.. _django/contrib/auth/models.py: http://code.djangoproject.com/browser/django/trunk/django/contrib/auth/models.py
    15481841
     1842>>!
    15491843Fields
    1550 >>
     1844<<!
     1845>>!!
    15511846필드(field)
    1552 <<
     1847<<!!
    15531848~~~~~~
    15541849
     1850>>!
    15551851``Permission`` objects have the following fields:
    1556 >>
    1557 ``Permission``객체(object)는 아래와 같은 필드(field)를 가지고 있습니다:
    1558 <<
    1559 
     1852<<!
     1853>>!!
     1854``Permission``객체(object)는 아래와 같은 필드(field)를 가지고 있습니다.:
     1855<<!!
     1856
     1857>>!
    15601858    * ``name`` -- Required. 50 characters or fewer. Example: ``'Can vote'``.
    15611859    * ``content_type`` -- Required. A reference to the ``django_content_type``
     
    15631861    * ``codename`` -- Required. 100 characters or fewer. Example: ``'can_vote'``.
    15641862
    1565 >>
     1863<<!
     1864>>!!
    15661865    * ``name`` -- 반드시 필요. 최대 50자까지. 예: ``'Can vote'``.
    1567         * ``content_type`` -- 반드시 필요. ``django_content_type``
    1568           테이블이 정의에 따릅니다.
     1866    * ``content_type`` -- 반드시 필요. ``django_content_type``
     1867      테이블이 정의에 따릅니다.
    15691868    * ``codename`` -- 반드시 필요. 최대 100자까지. 예: ``'can_vote'``.
    1570 <<
    1571 
     1869<<!!
     1870
     1871>>!
    15721872Methods
    1573 >>
     1873<<!
     1874>>!!
    15741875메소드(method)
    1575 <<
     1876<<!!
    15761877~~~~~~~
    15771878
     1879>>!
    15781880``Permission`` objects have the standard data-access methods like any other
    15791881`Django model`_.
    1580 >>
     1882<<!
     1883>>!!
    15811884``Permission``객체(object)는 다른 `Django model`_에서처럼 데이터에
    15821885접근하는 일관된 메소드(method)를 제공합니다.
    1583 <<
    1584 
     1886<<!!
     1887
     1888>>!
    15851889Authentication data in templates
    1586 >>
     1890<<!
     1891>>!!
    15871892템플릿(template)에서 인증과 관련된 데이터
    1588 <<
     1893<<!!
    15891894================================
    15901895
     1896>>!
    15911897The currently logged-in user and his/her permissions are made available in the
    15921898`template context`_ when you use ``RequestContext``.
    1593 >>
     1899<<!
     1900>>!!
    15941901``RequestContext``를 사용할 경우 현재 로그인된 사용자와 이 사용자에
    15951902부여된 허용권한(permission)은 `template context`_를 통해서 접근할 수
    15961903있습니다.
    1597 <<
    1598 
     1904<<!!
     1905
     1906>>!
    15991907.. admonition:: Technicality
    1600 >>
     1908<<!
     1909>>!!
    16011910.. admonition:: 좀더 자세히
    1602 <<
    1603 
     1911<<!!
     1912
     1913>>!
    16041914   Technically, these variables are only made available in the template context
    16051915   if you use ``RequestContext`` *and* your ``TEMPLATE_CONTEXT_PROCESSORS``
    16061916   setting contains ``"django.core.context_processors.auth"``, which is default.
    16071917   For more, see the `RequestContext docs`_.
    1608 >>
    1609         이 변수들은 설정(settings) 중 ``TEMPLATE_CONTEXT_PROCESSORS``에
    1610         ``"django.core.context_processors.auth"``를 추가하고
    1611         ``RequestContext``를 사용할 경우에만 가능합니다. 자세한 내용은
    1612         `RequestContext docs`_를 참고하세요.
    1613 <<
     1918<<!
     1919>>!!
     1920    이 변수들은 설정(settings) 중 ``TEMPLATE_CONTEXT_PROCESSORS``에
     1921    ``"django.core.context_processors.auth"``를 추가하고
     1922    ``RequestContext``를 사용할 경우에만 가능합니다. 자세한 내용은
     1923    `RequestContext docs`_를 참고하세요.
     1924<<!!
    16141925
    16151926
    16161927   .. _RequestContext docs: ../templates_python/#subclassing-context-requestcontext
    16171928
     1929>>!
    16181930Users
    1619 >>
     1931<<!
     1932>>!!
    16201933사용자
    1621 <<
     1934<<!!
    16221935-----
    16231936
     1937>>!
    16241938The currently logged-in user, either a ``User`` instance or an``AnonymousUser``
    16251939instance, is stored in the template variable ``{{ user }}``::
    1626 >>
     1940<<!
     1941>>!!
    16271942``User``객체(object) 혹은 ``AnonymousUser``객체(object) 모두
    1628 템플릿(template) 변수, ``{{ user }}``에 저장됩니다::
    1629 <<
     1943템플릿(template) 변수, ``{{ user }}``에 저장됩니다.::
     1944<<!!
    16301945
    16311946    {% if user.is_authenticated %}
     
    16351950    {% endif %}
    16361951
     1952>>!
    16371953Permissions
    1638 >>
     1954<<!
     1955>>!!
    16391956허용권한(permission)
    1640 <<
     1957<<!!
    16411958-----------
    16421959
     1960>>!
    16431961The currently logged-in user's permissions are stored in the template variable
    16441962``{{ perms }}``. This is an instance of ``django.core.context_processors.PermWrapper``,
    16451963which is a template-friendly proxy of permissions.
    1646 >>
     1964<<!
     1965>>!!
    16471966로그인된 사용자의 허용권한(permission)은 템플릿(template) 변수,
    16481967``{{ perms }}``에 저장됩니다. ``{{ perms }}``은
    16491968``django.core.context_processors.PermWrapper``의 객체(object)입니다.
    1650 <<
    1651 
     1969<<!!
     1970
     1971>>!
    16521972In the ``{{ perms }}`` object, single-attribute lookup is a proxy to
    16531973``User.has_module_perms``. This example would display ``True`` if the logged-in
    16541974user had any permissions in the ``foo`` app::
    1655 >>
     1975<<!
     1976>>!!
    16561977``{{ perms }}``은 ``User.has_module_perms``을 직접 가리킵니다.
    16571978즉, 어플리케이션(app) 이름으로 허용권한(permission)을 객체(object)
    1658 속성(attribute)으로 가져올 수 있습니다.
    1659 <<
     1979속성(attribute)으로 가져올 수 있습니다.::
     1980<<!!
    16601981
    16611982    {{ perms.foo }}
    16621983
     1984>>!
    16631985Two-level-attribute lookup is a proxy to ``User.has_perm``. This example would
    16641986display ``True`` if the logged-in user had the permission ``foo.can_vote``::
    1665 >>
     1987<<!
     1988>>!!
    16661989``User.has_perms``를 통해서 접근 여부를 허용권한(permission) 이름으로
    1667 객체(object) 속성(attribute)으로 가져올 수 있습니다.
    1668 <<
     1990객체(object) 속성(attribute)으로 가져올 수 있습니다.::
     1991<<!!
    16691992
    16701993    {{ perms.foo.can_vote }}
    16711994
     1995>>!
    16721996Thus, you can check permissions in template ``{% if %}`` statements::
    1673 >>
     1997<<!
     1998>>!!
    16741999다음과 같이 템플릿(template)의 ``{% if %}`` 구문으로
    1675 허용권한(permission)을 검사할 수 있습니다::
    1676 <<
     2000허용권한(permission)을 검사할 수 있습니다.::
     2001<<!!
    16772002
    16782003    {% if perms.foo %}
     
    16902015.. _template context: ../templates_python/
    16912016
     2017>>!
    16922018Groups
    1693 >>
     2019<<!
     2020>>!!
    16942021그룹
    1695 <<
     2022<<!!
    16962023======
    16972024
     2025>>!
    16982026Groups are a generic way of categorizing users so you can apply permissions, or
    16992027some other label, to those users. A user can belong to any number of groups.
    1700 >>
     2028<<!
     2029>>!!
    17012030그룹은 사용자를 분류하는 일반적인 방법입니다. 그룹으로 사용자들을
    17022031묶어서 허용권한(permission)을 적용하고 이름을 부여할 수 있습니다.
    17032032하나의 사용자는 여러 그룹에 속할 수 있습니다.
    1704 <<
    1705 
     2033<<!!
     2034
     2035>>!
    17062036A user in a group automatically has the permissions granted to that group. For
    17072037example, if the group ``Site editors`` has the permission
    17082038``can_edit_home_page``, any user in that group will have that permission.
    1709 >>
     2039<<!
     2040>>!!
    17102041그룹에 포함된 사용자는 자동으로 그 그룹의 허용권한(permission)을
    17112042가지게 됩니다. 예를 들어서 ``Site editors``라는 그룹은
     
    17132044그룹에 속한 사용자들도 ``can_edit_home_page`` 허용권한(permission)을
    17142045부여받게 됩니다.
    1715 <<
    1716 
     2046<<!!
     2047
     2048>>!
    17172049Beyond permissions, groups are a convenient way to categorize users to give
    17182050them some label, or extended functionality. For example, you could create a
     
    17202052access to a members-only portion of your site, or send them members-only e-mail
    17212053messages.
    1722 >>
     2054<<!
     2055>>!!
    17232056허용권한(permission) 이외에 그룹은 사용자들을 쉽게 분류해서 관리할 수
    17242057있도록 해줍니다. 예를 들어서 ``'Special users'``라는 그룹을 만들고
    17252058사이트에 이 그룹에 속한 사용자들만 접근할 수 있는 페이지를 제공하거나
    17262059이 그룹에 속한 사용자들 모두에게 메일을 보낼 수도 있습니다.
    1727 <<
    1728 
     2060<<!!
     2061
     2062>>!
    17292063Messages
    1730 >>
     2064<<!
     2065>>!!
    17312066메세지
    1732 <<
     2067<<!!
    17332068========
    17342069
     2070>>!
    17352071The message system is a lightweight way to queue messages for given users.
    1736 >>
     2072<<!
     2073>>!!
    17372074메세지 시스템은 사용자들에게 쉽게 메세지를 보낼 수 있는 큐(queue)
    17382075형태의 시스템입니다. (역자주: 장고에서 얘기하는 메세지 시스템은 메일을
    17392076발송을 의미하지 않습니다. 장고의 메세지 시스템은 페이지에 간단한 작업
    17402077결과 메세지를 표시하는 데 주로 사용됩니다. 아래 예제를 참고하세요.)
    1741 <<
    1742 
     2078<<!!
     2079
     2080>>!
    17432081A message is associated with a ``User``. There's no concept of expiration or
    17442082timestamps.
    1745 >>
     2083<<!
     2084>>!!
    17462085메세지는 ``User`` 객체(object)와 묶여 있습니다. 단 메세지를 보낸
    17472086시간은 기록하지 않습니다.
    1748 <<
    1749 
     2087<<!!
     2088
     2089>>!
    17502090Messages are used by the Django admin after successful actions. For example,
    17512091``"The poll Foo was created successfully."`` is a message.
    1752 >>
     2092<<!
     2093>>!!
    17532094주로 메세지는 장고 관리 페이지에서 어떤 작업을 끝냈을 때 사용됩니다.
    17542095예를 들어서 ``"The poll Foo was created successfully."``가
    17552096메세지입니다.
    1756 <<
    1757 
     2097<<!!
     2098
     2099>>!
    17582100The API is simple:
    1759 >>
    1760 API는 간단합니다:
    1761 <<
    1762 
     2101<<!
     2102>>!!
     2103API는 간단합니다.:
     2104<<!!
     2105
     2106>>!
    17632107    * To create a new message, use
    17642108      ``user_obj.message_set.create(message='message_text')``.
     
    17672111      and deletes the messages from the queue.
    17682112
    1769 >>
    1770          * ``user_obj.message_set.create(message='message_text')``로 새
    1771           메세지를 만들 수 있습니다.
    1772 
    1773          * ``user_obj.get_and_delete_messages()``는 이
    1774           사용자에게 전달된 ``Message``를 리스트(list) 형태로 반환합니다.
    1775 <<
    1776 
     2113<<!
     2114>>!!
     2115    * ``user_obj.message_set.create(message='message_text')``로 새
     2116      메세지를 만들 수 있습니다.
     2117
     2118    * ``user_obj.get_and_delete_messages()``는 이
     2119      사용자에게 전달된 ``Message``를 리스트(list) 형태로 반환합니다.
     2120<<!!
     2121
     2122>>!
    17772123In this example view, the system saves a message for the user after creating
    17782124a playlist::
    1779 >>
    1780 아래 예에서, playlist를 만든 다음 사용자에게 메세지를 남깁니다.
    1781 <<
     2125<<!
     2126>>!!
     2127아래 예에서, playlist를 만든 다음 사용자에게 메세지를 남깁니다.::
     2128<<!!
    17822129
    17832130    def create_playlist(request, songs):
     
    17882135            context_instance=RequestContext(request))
    17892136
     2137>>!
    17902138When you use ``RequestContext``, the currently logged-in user and his/her
    17912139messages are made available in the `template context`_ as the template variable
    17922140``{{ messages }}``. Here's an example of template code that displays messages::
    1793 >>
     2141<<!
     2142>>!!
    17942143``RequestContext``을 사용할 수 있는 상태에서 로그인한 사용자의
    17952144메세지는 `template context`_의 템플릿(template) 변수로 가져올 수
    1796 있습니다.
    1797 <<
     2145있습니다.::
     2146<<!!
    17982147
    17992148    {% if messages %}
     
    18052154    {% endif %}
    18062155
     2156>>!
    18072157Note that ``RequestContext`` calls ``get_and_delete_messages`` behind the
    18082158scenes, so any messages will be deleted even if you don't display them.
    1809 >>
     2159<<!
     2160>>!!
    18102161``RequestContext``는 메세지가 보이는 것과 상관 없이
    18112162``get_and_delete_messages``를 호출해서 사용자에게 할당된 메세지를
    18122163지웁니다.
    1813 <<
    1814 
     2164<<!!
     2165
     2166>>!
    18152167Finally, note that this messages framework only works with users in the user
    18162168database. To send messages to anonymous users, use the `session framework`_.
    1817 >>
     2169<<!
     2170>>!!
    18182171장고 메세지 시스템은 데이터베이스에 등록된 사용자에게만 사용할 수
    18192172있습니다. 등록되지 않은 익명(anonymous) 사용자에게도 적용하고 싶다면
    18202173`session framework`_를 활용하는 방법이 있습니다.
    1821 <<
     2174<<!!
    18222175
    18232176.. _session framework: ../sessions/
    18242177
     2178>>!
    18252179Other authentication sources
    1826 >>
     2180<<!
     2181>>!!
    18272182이외 인증과 관련된 소스
    1828 <<
     2183<<!!
    18292184============================
    18302185
     2186>>!
    18312187The authentication that comes with Django is good enough for most common cases,
    18322188but you may have the need to hook into another authentication source -- that
    18332189is, another source of usernames and passwords or authentication methods.
    1834 >>
     2190<<!
     2191>>!!
    18352192장고의 인증 시스템은 대체로 일반적인 요구사항을 만족시키고 있습니다.
    18362193하지만, 다른 인증시스템과 연동하는 경우도 있을 수 있습니다.
    1837 <<
    1838 
     2194<<!!
     2195
     2196>>!
    18392197For example, your company may already have an LDAP setup that stores a username
    18402198and password for every employee. It'd be a hassle for both the network
    18412199administrator and the users themselves if users had separate accounts in LDAP
    18422200and the Django-based applications.
    1843 >>
     2201<<!
     2202>>!!
    18442203예를 들어서, 여러분의 회사가 직원 계정을 LDAP로 관리하고 있는 경우에는
    18452204장고 인증시스템과 LDAP에서 각각 계정을 관리하기는 어려울 것입니다.
    1846 <<
    1847 
     2205<<!!
     2206
     2207>>!
    18482208So, to handle situations like this, the Django authentication system lets you
    18492209plug in another authentication sources. You can override Django's default
    18502210database-based scheme, or you can use the default system in tandem with other
    18512211systems.
    1852 >>
     2212<<!
     2213>>!!
    18532214그래서 이런 상황을 해결하기 위해서 장고의 인증시스템은 다른
    18542215인증시스템을 이용할 수 있는 방법은 제공합니다. 장고의 기본
    18552216데이터베이스 구조를 다시 작성하거나 다른 인증시스템과 함께 사용할 수
    18562217있습니다.
    1857 <<
    1858 
     2218<<!!
     2219
     2220>>!
    18592221Specifying authentication backends
    1860 >>
     2222<<!
     2223>>!!
    18612224인증 저장소(authentication backends)
    1862 <<
     2225<<!!
    18632226----------------------------------
    18642227
     2228>>!
    18652229Behind the scenes, Django maintains a list of "authentication backends" that it
    18662230checks for authentication. When somebody calls
     
    18692233If the first authentication method fails, Django tries the second one, and so
    18702234on, until all backends have been attempted.
    1871 >>
     2235<<!
     2236>>!!
    18722237장고는 내부적으로 "인증 저장소"의 목록을 가지고 있습니다.
    18732238``django.contrib.auth.authenticate()``가 호출되면 -- "로그인시키는
     
    18752240시도합니다. 첫번째 저장소(backend)에서 실패하면 다음 번
    18762241저장소(backend)로 시도하는 식으로 모든 저장소(backend)를 사용합니다.
    1877 <<
    1878 
     2242<<!!
     2243
     2244>>!
    18792245The list of authentication backends to use is specified in the
    18802246``AUTHENTICATION_BACKENDS`` setting. This should be a tuple of Python path
    18812247names that point to Python classes that know how to authenticate. These classes
    18822248can be anywhere on your Python path.
    1883 >>
     2249<<!
     2250>>!!
    18842251인증 저장소(backend) 목록은 ``AUTHENTICATION_BACKENDS`` 설정에
    18852252튜플(tuple) 형태로 지정합니다.
    1886 <<
    1887 
     2253<<!!
     2254
     2255>>!
    18882256By default, ``AUTHENTICATION_BACKENDS`` is set to::
    1889 >>
     2257<<!
     2258>>!!
    18902259기본적으로, ``AUTHENTICATION_BACKENDS``는::
    1891 <<
     2260<<!!
    18922261
    18932262    ('django.contrib.auth.backends.ModelBackend',)
    18942263
     2264>>!
    18952265That's the basic authentication scheme that checks the Django users database.
    1896 >>
     2266<<!
     2267>>!!
    18972268이것은 장고 사용자 데이터베이스를 다루는 기본 인증
    18982269저장소(backend)입니다.
    1899 <<
    1900 
     2270<<!!
     2271
     2272>>!
    19012273The order of ``AUTHENTICATION_BACKENDS`` matters, so if the same username and
    19022274password is valid in multiple backends, Django will stop processing at the
    19032275first positive match.
    1904 >>
     2276<<!
     2277>>!!
    19052278``AUTHENTICATION_BACKENDS``에서는 순서가 중요합니다. 여러
    19062279저장소(backend)에 같은 사용자와 비밀번호가 있는 경우에는, 먼저 인증에
    1907 성공하는 저장소(backend)가 사용됩니다..
    1908 <<
    1909 
     2280성공하는 저장소(backend)가 사용됩니다.
     2281<<!!
     2282
     2283>>!
    19102284Writing an authentication backend
    1911 >>
     2285<<!
     2286>>!!
    19122287인증 저장소(authentication backend) 작성하기
    1913 <<
     2288<<!!
    19142289---------------------------------
    19152290
     2291>>!
    19162292An authentication backend is a class that implements two methods:
    19172293``get_user(user_id)`` and ``authenticate(**credentials)``.
    1918 >>
     2294<<!
     2295>>!!
    19192296인증 저장소(backend)는 두가지 메소드(method)만 구현하면
    19202297됩니다:``get_user(user_id)``, ``authenticate(**credentials)``
    1921 <<
    1922 
     2298<<!!
     2299
     2300>>!
    19232301The ``get_user`` method takes a ``user_id`` -- which could be a username,
    19242302database ID or whatever -- and returns a ``User`` object.
    1925 >>
     2303<<!
     2304>>!!
    19262305``get_user`` 메소드(method)는 ``user_id``를 인수(argument)도 받아서
    19272306``User``를 반환합니다. -- 저장소(backend)에 저장된 사용자 이름입니다.
    1928 <<
    1929 
     2307<<!!
     2308
     2309>>!
    19302310The  ``authenticate`` method takes credentials as keyword arguments. Most of
    19312311the time, it'll just look like this::
    1932 >>
     2312<<!
     2313>>!!
    19332314``authenticate`` 메소드(method)는 키워드 인수(keyword argument)를
    1934 받습니다. 대부분 이런 형태를 보입니다::
    1935 <<
     2315받습니다. 대부분 이런 형태를 보입니다.::
     2316<<!!
    19362317
    19372318    class MyBackend:
     
    19392320            # username과 password를 검사해서 ``User``를 반환합니다.
    19402321
     2322>>!
    19412323But it could also authenticate a token, like so::
    1942 >>
    1943 다음처럼 token을 받기도 합니다::
    1944 <<
     2324<<!
     2325>>!!
     2326다음처럼 token을 받기도 합니다.::
     2327<<!!
    19452328
    19462329    class MyBackend:
     
    19482331            # token을 검사해서 ``User``를 반환합니다.
    19492332
     2333>>!
    19502334Either way, ``authenticate`` should check the credentials it gets, and it
    19512335should return a ``User`` object that matches those credentials, if the
    19522336credentials are valid. If they're not valid, it should return ``None``.
    1953 >>
     2337<<!
     2338>>!!
    19542339``authenticate`` 메소드(method)는 인증조건(credentials)을 검사해서
    19552340인증을 통과하면 ``User``를, 아니면 ``None``을 반환합니다.
    1956 <<
    1957 
     2341<<!!
     2342
     2343>>!
    19582344The Django admin system is tightly coupled to the Django ``User`` object
    19592345described at the beginning of this document. For now, the best way to deal with
     
    19622348can either write a script to do this in advance, or your ``authenticate``
    19632349method can do it the first time a user logs in.
    1964 >>
     2350<<!
     2351>>!!
    19652352장고 관리 시스템은 이 문서 처음에서 설명한 것처럼 ``User``
    19662353객체(object)와 밀접하게 물려있습니다. 따라서 다른 인증시스템(예를
     
    19692356것입니다. 따라서 따로 스크립트를 작성하거나 사용자가 로그인할 때
    19702357``authenticate`` 메소드(method)를 호출해줄 수도 있습니다.
    1971 <<
    1972 
     2358<<!!
     2359
     2360>>!
    19732361Here's an example backend that authenticates against a username and password
    19742362variable defined in your ``settings.py`` file and creates a Django ``User``
    19752363object the first time a user authenticates::
    1976 >>
    1977 ``settings.py``에 정의된 사용자와 패스워드로 인증하는 예입니다.
    1978 <<
     2364<<!
     2365>>!!
     2366``settings.py``에 정의된 사용자와 패스워드로 인증하는 예입니다.::
     2367<<!!
    19792368
    19802369    from django.conf import settings
     
    19832372    class SettingsBackend:
    19842373        """
     2374>>!
    19852375        Authenticate against the settings ADMIN_LOGIN and ADMIN_PASSWORD.
    19862376
     
    19902380        ADMIN_PASSWORD = 'sha1$4e987$afbcf42e21bd417fb71db8c66b321e9fc33051de'
    19912381
    1992 >>
     2382<<!
     2383>>!!
    19932384        ADMIN_LOGIN와 ADMIN_PASSWORD 설정으로 인증을 시도합니다.
    19942385
    1995                   로그인 이륾과 hash처리된 비밀번호를 사용합니다. 예를 들어:
     2386        로그인 이름과 hash처리된 비밀번호를 사용합니다. 예를 들어:
    19962387
    19972388        ADMIN_LOGIN = 'admin'
    19982389        ADMIN_PASSWORD = 'sha1$4e987$afbcf42e21bd417fb71db8c66b321e9fc33051de'
    1999 <<
     2390<<!!
    20002391        """
    20012392        def authenticate(self, username=None, password=None):
     
    20062397                    user = User.objects.get(username=username)
    20072398                except User.DoesNotExist:
     2399>>!
    20082400                    # Create a new user. Note that we can set password
    20092401                    # to anything, because it won't be checked; the password
    20102402                    # from settings.py will.
    2011 >>
    2012                                                   # 새로운 사용자를 만듭니다. settings.py에 정의된
    2013                                                   # 패스워드를 그대로 사용합니다.
    2014 <<
     2403<<!
     2404>>!!
     2405                    # 새로운 사용자를 만듭니다. settings.py에 정의된
     2406                    # 패스워드를 그대로 사용합니다.
     2407<<!!
    20152408                    user = User(username=username, password='get from settings.py')
    20162409                    user.is_staff = True
     
    20262419                return None
    20272420
     2421>>!
    20282422Handling authorization in custom backends
    2029 >>
     2423<<!
     2424>>!!
    20302425다른 인증 저장소(custom backends) 다루기
    2031 <<
     2426<<!!
    20322427-----------------------------------------
    20332428
     2429>>!
    20342430Custom auth backends can provide their own permissions.
    2035 >>
     2431<<!
     2432>>!!
    20362433다른 인증 저장소(backend)는 나름대로의 허용권한(permission)을 제공할
    20372434수 있습니다.
    2038 <<
    2039 
     2435<<!!
     2436
     2437>>!
    20402438The user model will delegate permission lookup functions
    20412439(``get_group_permissions()``, ``get_all_permissions()``, ``has_perm()``, and
    20422440``has_module_perms()``) to any authentication backend that implements these
    20432441functions.
    2044 >>
     2442<<!
     2443>>!!
    20452444user 모델(model)의 허용권한(permission)에 접근하는
    20462445함수(function)들(``get_group_permissions()``,
     
    20482447``has_module_perms()``)은 인증 저장소(backend)가 구현한
    20492448함수(function)에 의존합니다.
    2050 <<
    2051 
     2449<<!!
     2450
     2451>>!
    20522452The permissions given to the user will be the superset of all permissions
    20532453returned by all backends. That is, Django grants a permission to a user that any
    20542454one backend grants.
    2055 >>
     2455<<!
     2456>>!!
    20562457사용자에게 부여된 허용권한(permission)은 모든 저장소(backend)가 가진
    20572458모든 허용권한(permission)의 일부분입니다. 즉, 사용자는 어떤 인증
    20582459저장소(backend)가 허용한다면 허용권한(permission)을 가질 수 있습니다.
    2059 <<
    2060 
     2460<<!!
     2461
     2462>>!
    20612463The simple backend above could implement permissions for the magic admin fairly
    20622464simply::
    2063 >>
     2465<<!
     2466>>!!
    20642467간단한 저장소(backend)를 구현한 예입니다. 관리자의
    2065 허용권한(permission)을 검사합니다::
    2066 <<
     2468허용권한(permission)을 검사합니다.::
     2469<<!!
    20672470       
    20682471    class SettingsBackend:
     
    20762479                return False
    20772480               
     2481>>!
    20782482This gives full permissions to the user granted access in the above example. Notice
    20792483that the backend auth functions all take the user object as an argument, and
    20802484they also accept the same arguments given to the associated ``User`` functions.
    2081 >>
     2485<<!
     2486>>!!
    20822487위 예는 관리자에게 모든 허용권한(permission)을 허용합니다. 인증
    20832488저장소(backend)의 함수(function)들은 ``User``객체(object)와 ``User``
    20842489메소드(method)가 받은 인수(argument)를 함께 전달받습니다.
    2085 <<
    2086 
     2490<<!!
     2491
     2492>>!
    20872493A full authorization implementation can be found in
    20882494``django/contrib/auth/backends.py`` _, which is the default backend and queries
    20892495the ``auth_permission`` table most of the time.
    2090 >>
     2496<<!
     2497>>!!
    20912498인증에 관해서는 ``auth_permission`` 테이블을 사용하는 기본 인증
    20922499저장소(backend)인 ``django/contrib/auth/backends.py``를 참고하세요.
    2093 <<
     2500<<!!
    20942501
    20952502.. _django/contrib/auth/backends.py: http://code.djangoproject.com/browser/django/trunk/django/contrib/auth/backends.py
     2503
    20962504}}}
Back to Top