Code

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


Ignore:
Timestamp:
11/12/07 04:18:47 (6 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}}}