django-registration-2.2/0000755000076700007670000000000013011716531014543 5ustar james00000000000000django-registration-2.2/AUTHORS0000644000076700007670000000206612623771034015626 0ustar james00000000000000The primary author of django-registration is James Bennett, who may be found online at . Over the past eight years of django-registration's development, however, many others have contributed code, documentation and translations, and django-registration would not be what it is without their help. Below is a list of contributors who can be identified from the development history: * Samuel Adam * A. Al-Ibrahim * Adam Alton * Florian Apolloner * Carles Barrobés * Nico den Boer * Rune Bromer * Joost Cassee * Flavio Curella * Baptiste Darthenay * Nebojsa Djordjevic * Liang Feng * Ilya Filippov * Rapahel Hertzog * Recep Kirmizi * Domen Kožar * Meir Kriheli * Björn Kristinsson * Panos Laganakos * Nicola Larosa * Jannis Leidel * Jon Lønne * João Luiz Lorencetti * Italo Maia * Mohsen Mansouryar * Leonardo Manuel Rocha * Nuno Mariz * Andy Mikhailenko * Vladislav Mitov * Marko Mrdjenovic * Michael Niewöhner * Shinya Okano * Young Gyu Park * Duncan Parkes * Patrick Samson * Daniel Samuels * Ernesto Rico Schmidt * Emil Stenström * Jarek Zgoda django-registration-2.2/django_registration.egg-info/0000755000076700007670000000000013011716531022271 5ustar james00000000000000django-registration-2.2/django_registration.egg-info/dependency_links.txt0000644000076700007670000000000113011716531026337 0ustar james00000000000000 django-registration-2.2/django_registration.egg-info/not-zip-safe0000644000076700007670000000000113011716531024517 0ustar james00000000000000 django-registration-2.2/django_registration.egg-info/PKG-INFO0000644000076700007670000000222613011716531023370 0ustar james00000000000000Metadata-Version: 1.1 Name: django-registration Version: 2.2 Summary: An extensible user-registration application for Django Home-page: https://github.com/ubernostrum/django-registration/ Author: James Bennett Author-email: james@b-list.org License: UNKNOWN Description: UNKNOWN Platform: UNKNOWN Classifier: Development Status :: 5 - Production/Stable Classifier: Environment :: Web Environment Classifier: Framework :: Django Classifier: Framework :: Django :: 1.8 Classifier: Framework :: Django :: 1.9 Classifier: Framework :: Django :: 1.10 Classifier: Intended Audience :: Developers Classifier: License :: OSI Approved :: BSD License Classifier: Operating System :: OS Independent Classifier: Programming Language :: Python Classifier: Topic :: Software Development :: Libraries :: Python Modules Classifier: Programming Language :: Python Classifier: Programming Language :: Python :: 2 Classifier: Programming Language :: Python :: 2.7 Classifier: Programming Language :: Python :: 3 Classifier: Programming Language :: Python :: 3.3 Classifier: Programming Language :: Python :: 3.4 Classifier: Programming Language :: Python :: 3.5 Classifier: Topic :: Utilities django-registration-2.2/django_registration.egg-info/SOURCES.txt0000644000076700007670000001171113011716531024156 0ustar james00000000000000AUTHORS LICENSE MANIFEST.in README.rst setup.cfg setup.py django_registration.egg-info/PKG-INFO django_registration.egg-info/SOURCES.txt django_registration.egg-info/dependency_links.txt django_registration.egg-info/not-zip-safe django_registration.egg-info/top_level.txt docs/Makefile docs/conf.py docs/custom-user.rst docs/faq.rst docs/forms.rst docs/hmac.rst docs/index.rst docs/install.rst docs/make.bat docs/model-workflow.rst docs/quickstart.rst docs/settings.rst docs/signals.rst docs/simple-workflow.rst docs/upgrade.rst docs/validators.rst docs/views.rst registration/__init__.py registration/admin.py registration/auth_urls.py registration/forms.py registration/models.py registration/runtests.py registration/signals.py registration/urls.py registration/validators.py registration/views.py registration/backends/__init__.py registration/backends/default/__init__.py registration/backends/default/urls.py registration/backends/default/views.py registration/backends/hmac/__init__.py registration/backends/hmac/urls.py registration/backends/hmac/views.py registration/backends/model_activation/__init__.py registration/backends/model_activation/urls.py registration/backends/model_activation/views.py registration/backends/simple/__init__.py registration/backends/simple/urls.py registration/backends/simple/views.py registration/locale/ar/LC_MESSAGES/django.mo registration/locale/ar/LC_MESSAGES/django.po registration/locale/bg/LC_MESSAGES/django.mo registration/locale/bg/LC_MESSAGES/django.po registration/locale/ca/LC_MESSAGES/django.mo registration/locale/ca/LC_MESSAGES/django.po registration/locale/cs/LC_MESSAGES/django.mo registration/locale/cs/LC_MESSAGES/django.po registration/locale/da/LC_MESSAGES/django.mo registration/locale/da/LC_MESSAGES/django.po registration/locale/de/LC_MESSAGES/django.mo registration/locale/de/LC_MESSAGES/django.po registration/locale/el/LC_MESSAGES/django.mo registration/locale/el/LC_MESSAGES/django.po registration/locale/en/LC_MESSAGES/django.mo registration/locale/en/LC_MESSAGES/django.po registration/locale/es/LC_MESSAGES/django.mo registration/locale/es/LC_MESSAGES/django.po registration/locale/es_AR/LC_MESSAGES/django.mo registration/locale/es_AR/LC_MESSAGES/django.po registration/locale/fa/LC_MESSAGES/django.mo registration/locale/fa/LC_MESSAGES/django.po registration/locale/fr/LC_MESSAGES/django.mo registration/locale/fr/LC_MESSAGES/django.po registration/locale/he/LC_MESSAGES/django.mo registration/locale/he/LC_MESSAGES/django.po registration/locale/hr/LC_MESSAGES/django.mo registration/locale/hr/LC_MESSAGES/django.po registration/locale/is/LC_MESSAGES/django.mo registration/locale/is/LC_MESSAGES/django.po registration/locale/it/LC_MESSAGES/django.mo registration/locale/it/LC_MESSAGES/django.po registration/locale/ja/LC_MESSAGES/django.mo registration/locale/ja/LC_MESSAGES/django.po registration/locale/ko/LC_MESSAGES/django.mo registration/locale/ko/LC_MESSAGES/django.po registration/locale/nb/LC_MESSAGES/django.mo registration/locale/nb/LC_MESSAGES/django.po registration/locale/nl/LC_MESSAGES/django.mo registration/locale/nl/LC_MESSAGES/django.po registration/locale/pl/LC_MESSAGES/django.mo registration/locale/pl/LC_MESSAGES/django.po registration/locale/pt/LC_MESSAGES/django.mo registration/locale/pt/LC_MESSAGES/django.po registration/locale/pt_BR/LC_MESSAGES/django.mo registration/locale/pt_BR/LC_MESSAGES/django.po registration/locale/ru/LC_MESSAGES/django.mo registration/locale/ru/LC_MESSAGES/django.po registration/locale/sl/LC_MESSAGES/django.mo registration/locale/sl/LC_MESSAGES/django.po registration/locale/sr/LC_MESSAGES/django.mo registration/locale/sr/LC_MESSAGES/django.po registration/locale/sv/LC_MESSAGES/django.mo registration/locale/sv/LC_MESSAGES/django.po registration/locale/tr_TR/LC_MESSAGES/django.mo registration/locale/tr_TR/LC_MESSAGES/django.po registration/locale/zh_CN/LC_MESSAGES/django.mo registration/locale/zh_CN/LC_MESSAGES/django.po registration/locale/zh_TW/LC_MESSAGES/django.mo registration/locale/zh_TW/LC_MESSAGES/django.po registration/management/__init__.py registration/management/commands/__init__.py registration/management/commands/cleanupregistration.py registration/migrations/0001_initial.py registration/migrations/__init__.py registration/tests/__init__.py registration/tests/base.py registration/tests/test_forms.py registration/tests/test_hmac_workflow.py registration/tests/test_model_workflow.py registration/tests/test_models.py registration/tests/test_simple_workflow.py registration/tests/test_views.py registration/tests/urls.py registration/tests/views.py registration/tests/templates/registration/activate.html registration/tests/templates/registration/activation_complete.html registration/tests/templates/registration/activation_email.txt registration/tests/templates/registration/activation_email_subject.txt registration/tests/templates/registration/registration_closed.html registration/tests/templates/registration/registration_complete.html registration/tests/templates/registration/registration_form.htmldjango-registration-2.2/django_registration.egg-info/top_level.txt0000644000076700007670000000001513011716531025017 0ustar james00000000000000registration django-registration-2.2/docs/0000755000076700007670000000000013011716531015473 5ustar james00000000000000django-registration-2.2/docs/conf.py0000644000076700007670000000123713011716351016775 0ustar james00000000000000import os on_rtd = os.environ.get('READTHEDOCS', None) == 'True' extensions = [] templates_path = ['_templates'] source_suffix = '.rst' master_doc = 'index' project = u'django-registration' copyright = u'2007-2016, James Bennett' version = '2.2' release = '2.2' exclude_trees = ['_build'] pygments_style = 'sphinx' html_static_path = ['_static'] htmlhelp_basename = 'django-registrationdoc' latex_documents = [ ('index', 'django-registration.tex', u'django-registration Documentation', u'James Bennett', 'manual'), ] if not on_rtd: import sphinx_rtd_theme html_theme = 'sphinx_rtd_theme' html_theme_path = [sphinx_rtd_theme.get_html_theme_path()] django-registration-2.2/docs/custom-user.rst0000644000076700007670000001316713007361516020527 0ustar james00000000000000.. _custom-user: Custom user models ================== When django-registration was first developed, Django's authentication system supported only its own built-in user model, ``django.contrib.auth.models.User``. More recent versions of Django have introduced support for `custom user models `_. Older versions of django-registration did not generally support custom user models due to the additional complexity required; as of version |version|, however, django-registration now can support custom user models. Depending on how significantly your custom user model differs from Django's default, you may need to change only a few lines of code; custom user models significantly different from the default model may require more work to support. Overview -------- The primary issue when using django-registration with a custom user model will be :class:`~registration.forms.RegistrationForm`. ``RegistrationForm`` is a subclass of Django's built-in ``UserCreationForm``, which in turn is a ``ModelForm`` with its model set to ``django.contrib.auth.models.User``. The only changes made by django-registration are to apply the reserved name validator (:class:`registration.validators.ReservedNameValidator`) and make the ``email`` field required (by default, Django's user model makes this field optional; it is required in ``RegistrationForm`` because two of the three built-in workflows of django-registration require an email address in order to send account-activation instructions to the user). As a result, you will always be required to supply a custom form class when using django-registration with a custom user model. In the case where your user model is compatible with the default behavior of django-registration, (see below) you will be able to simply subclass ``RegistrationForm``, set it to use your custom user model as the model, and then configure the views in django-registration to use your form subclass. For example, you might do the following (in a ``forms.py`` module somewhere in your codebase -- do **not** directly edit django-registration's code): .. code-block:: python from registration.forms import RegistrationForm from mycustomuserapp.models import MyCustomUser class MyCustomUserForm(RegistrationForm): class Meta: model = MyCustomUser And then in your URL configuration (example here uses the HMAC activation workflow): .. code-block:: python from django.conf.urls import include, url from registration.backends.hmac.views import RegistrationView from mycustomuserapp.forms import MyCustomUserForm urlpatterns = [ # ... other URL patterns here url(r'^accounts/register/$', RegistrationView.as_view( form_class=MyCustomUserForm ), name='registration_register', ), url(r'^accounts/', include('registration.backends.hmac.urls')), ] If your custom user model is not compatible with the built-in workflows of django-registration (see next section), you will probably need to subclass the provided views (either the base registration views, or the views of the workflow you want to use) and make the appropriate changes for your user model. Determining compatibility of a custom user model ------------------------------------------------ The built-in workflows and other code of django-registration do as much as is possible to ensure compatibility with custom user models; ``django.contrib.auth.models.User`` is never directly imported or referred to, and all code in django-registration instead uses ``settings.AUTH_USER_MODEL`` or ``django.contrib.auth.get_user_model()`` to refer to the user model, and ``USERNAME_FIELD`` when access to the username is required. However, there are still some specific requirements you'll want to be aware of. The two-step activation workflows -- both :ref:`HMAC `- and :ref:`model `-based -- require that your user model have the following fields: * ``email`` -- a textual field (``EmailField``, ``CharField`` or ``TextField``) holding the user's email address. Note that this field is required by ``RegistrationForm``, which is a difference from Django's default ``UserCreationForm``. * ``is_active`` -- a ``BooleanField`` indicating whether the user's account is active. You also *must* specify the attribute ``USERNAME_FIELD`` on your user model to denote the field used as the username. Additionally, your user model must implement the ``email_user`` method for sending email to the user. The model-based activation workflow requires one additional field: * ``date_joined`` -- a ``DateField`` or ``DateTimeField`` indicating when the user's account was registered. :ref:`The simple one-step workflow ` requires that your user model set ``USERNAME_FIELD``, and requires that it define a field named ``password`` for storing the user's password (it will expect to find this value in the ``password1`` field of the registration form); the combination of ``USERNAME_FIELD`` and ``password`` must be sufficient to log a user in. Also note that ``RegistrationForm`` requires the ``email`` field, so either provide that field on your model or subclass ``RegistrationForm``. If your custom user model defines additional fields beyond the minimum requirements, you'll either need to ensure that all of those fields are optional (i.e., can be ``NULL`` in your database, or provide a suitable default value defined in the model), or you'll need to specify the full list of fields to display in the ``fields`` option of your ``RegistrationForm`` subclass.django-registration-2.2/docs/faq.rst0000644000076700007670000002231413007361607017003 0ustar james00000000000000.. _faq: Frequently-asked questions ========================== The following are miscellaneous common questions and answers related to installing/using django-registration, culled from bug reports, emails and other sources. General ------- **How can I support social-media and other auth schemes, like Facebook or GitHub?** By using `django-allauth `_. No single application can or should provide a universal API for every authentication system ever developed; django-registration sticks to making it easy to implement typical signup workflows using Django's own user model and auth system (with some ability to use custom user models), while apps like ``django-allauth`` handle integration with third-party authentication services far more effectively. **What license is django-registration under?** django-registration is offered under a three-clause BSD-style license; this is `an OSI-approved open-source license `_, and allows you a large degree of freedom in modifiying and redistributing the code. For the full terms, see the file ``LICENSE`` which came with your copy of django-registration; if you did not receive a copy of this file, you can view it online at . **What versions of Django and Python are supported?** As of django-registration |version|, Django 1.8, 1.9, and 1.10 are supported, on Python 2.7, 3.3 (Django 1.8 only), 3.4 and 3.5. Although Django 1.8 supported Python 3.2 at initial release, Python 3.2 is now at its end-of-life and django-registration no longer supports it. It is expected that django-registration |version| will work without modification on Python 3.6 once it is released. **I found a bug or want to make an improvement!** The canonical development repository for django-registration is online at . Issues and pull requests can both be filed there. If you'd like to contribute to django-registration, that's great! Just please remember that pull requests should include tests and documentation for any changes made, and that following `PEP 8 `_ is mandatory. Pull requests without documentation won't be merged, and PEP 8 style violations or test coverage below 100% are both configured to break the build. **How secure is django-registration?** In the nine-year history of django-registration, there have been no security issues reported which required new releases to remedy. This doesn't mean, though, that django-registration is perfectly secure: much will depend on ensuring best practices in deployment and server configuration, and there could always be security issues that just haven't been recognized yet. django-registration does, however, try to avoid common security issues: * django-registration |version| only supports versions of Django which were receiving upstream security support at the time of release. * django-registration does not attempt to generate or store passwords, and does not transmit credentials which could be used to log in (the only "credential" ever sent out by django-registration is an activation key used in the two-step activation workflows, and that key can only be used to make an account active; it cannot be used to log in). * django-registration works with Django's own security features (including cryptographic features) where possible, rather than reinventing its own. **How do I run the tests?** django-registration makes use of Django's own built-in unit-testing tools, and supports several ways to execute its test suite: * Within a Django project, simply invoke ``manage.py test registration``. * If you've installed django-registration (so that it's on your Python import path) and Django, but don't yet have a project created or want to test independently of a project, you can run ``registration/runtests.py``, or you can invoke ``python setup.py test`` (which will simply run ``registration/runtests.py``). Additionally, the ``setup.cfg`` file included in django-registration provides configuration for `coverage.py `_, enabling easy recording and reporting of test coverage. Installation and setup ---------------------- **How do I install django-registration?** Full instructions are available in :ref:`the installation guide `. For configuration, see :ref:`the quick start guide `. **Does django-registration come with any sample templates I can use right away?** No, for two reasons: 1. Providing default templates with an application is ranges from hard to impossible, because different sites can have such wildly different design and template structure. Any attempt to provide templates which would work with all the possibilities would probably end up working with none of them. 2. A number of things in django-registration depend on the specific registration workflow you use, including the variables which end up in template contexts. Since django-registration has no way of knowing in advance what workflow you're going to be using, it also has no way of knowing what your templates will need to look like. Fortunately, however, django-registration has good documentation which explains what context variables will be available to templates, and so it should be easy for anyone who knows Django's template system to create templates which integrate with their own site. Configuration ------------- **Should I used the model-based or HMAC activation workflow?** You're free to choose whichever one you think best fits your needs. However, :ref:`the model-based workflow ` is mostly provided for backwards compatibility with older versions of django-registration; it dates to 2007, and though it is still as functional as ever, :ref:`the HMAC workflow ` has less overhead (i.e., no need to install or work with any models) due to being able to take advantage of more modern features in Django. **Do I need to rewrite the views to change the way they behave?** Not always. Any behavior controlled by an attribute on a class-based view can be changed by passing a different value for that attribute in the URLConf. See `Django's class-based view documentation `_ for examples of this. For more complex or fine-grained control, you will likely want to subclass :class:`~registration.views.RegistrationView` or :class:`~registration.views.ActivationView`, or both, add your custom logic to your subclasses, and then create a URLConf which makes use of your subclasses. **I don't want to write my own URLconf because I don't want to write patterns for all the auth views!** You're in luck, then; django-registration provides a URLconf which *only* contains the patterns for the auth views, and which you can include in your own URLconf anywhere you'd like; it lives at ``registration.auth_urls``. **I don't like the names you've given to the URL patterns!** In that case, you should feel free to set up your own URLconf which uses the names you want. **I'm using a custom user model; how do I make that work?** See :ref:`the custom user documentation `. Tips and tricks --------------- **How do I log a user in immediately after registration or activation?** Take a look at the implementation of :ref:`the simple one-step workflow `, which logs a user in immediately after registration. **How do I re-send an activation email?** Assuming you're using :ref:`the model-based workflow `, a `custom admin action `_ is provided for this; in the admin for the :class:`~registration.models.RegistrationProfile` model, simply click the checkbox for the user(s) you'd like to re-send the email for, then select the "Re-send activation emails" action. **How do I manually activate a user?** In :ref:`the model-based workflow `, a custom admin action is provided for this. In the admin for the ``RegistrationProfile`` model, click the checkbox for the user(s) you'd like to activate, then select the "Activate users" action. In the HMAC-based workflow, simply toggle the ``is_active`` field of the user in the admin. **How do I allow Unicode in usernames?** Use Python 3. Django's username validation allows any word character plus some additional characters, but the definition of "word character" depends on the Python version in use. On Python 2, only ASCII will be permitted; on Python 3, usernames containing word characters matched by a regex with the ``UNICODE`` flag will be accepted. django-registration-2.2/docs/forms.rst0000644000076700007670000000773613007361505017372 0ustar james00000000000000.. _forms: .. module:: registration.forms Base form classes ================= Several form classes are provided with django-registration, covering common cases for gathering account information and implementing common constraints for user registration. These forms were designed with django-registration's built-in registration workflows in mind, but may also be useful in other situations. .. class:: RegistrationForm A simple form for registering an account. This is a subclass of Django's built-in ``UserCreationForm``, and has the following fields, all of which are required: ``username`` The username to use for the new account. This is represented as a text input which validates that the username is unique, consists entirely of alphanumeric characters and underscores and is at most 30 characters in length. ``email`` The email address to use for the new account. This is represented as a text input which accepts email addresses up to 75 characters in length. ``password1`` The password to use for the new account. This is represented as a password input (``input type="password"`` in the rendered HTML). ``password2`` The password to use for the new account. This is represented as a password input (``input type="password"`` in the rendered HTML). Because this is a subclass of Django's own ``UserCreationForm``, the constraints on usernames and email addresses match those enforced by Django's default authentication backend for instances of ``django.contrib.auth.models.User``. The repeated entry of the password serves to catch typos. .. note:: **Unicode usernames** There is one important difference in form behavior depending on the version of Python you're using. Django's username validation regex allows a username to contain any word character along with the following set of additional characters: ``.@+-``. However, on Python 2 this regex uses the ``ASCII`` flag (since Python 2's string type is ASCII by default), while on Python 3 it uses the ``UNICODE`` flag (since Python 3's string type is Unicode). This means that usernames containing non-ASCII word characters are only permitted when using Python 3. The validation error for mismatched passwords is attached to the ``password2`` field. This is a backwards-incompatible change from django-registration 1.0. .. note:: **Validation of usernames** Because it's a subclass of Django's ``UserCreationForm``, ``RegistrationForm`` will inherit the base validation defined by Django. It also adds a custom ``clean()`` method which applies one custom validator: :class:`~registration.validators.ReservedNameValidator`. See the documentation for ``ReservedNameValidator`` for notes on why it exists and how to customize its behavior. .. class:: RegistrationFormTermsOfService A subclass of :class:`RegistrationForm` which adds one additional, required field: ``tos`` A checkbox indicating agreement to the site's terms of service/user agreement. .. class:: RegistrationFormUniqueEmail A subclass of :class:`RegistrationForm` which enforces uniqueness of email addresses in addition to uniqueness of usernames. .. class:: RegistrationFormNoFreeEmail A subclass of :class:`RegistrationForm` which disallows registration using addresses from some common free email providers. This can, in some cases, cut down on automated registration by spambots. By default, the following domains are disallowed for email addresses: * ``aim.com`` * ``aol.com`` * ``email.com`` * ``gmail.com`` * ``googlemail.com`` * ``hotmail.com`` * ``hushmail.com`` * ``msn.com`` * ``mail.ru`` * ``mailinator.com`` * ``live.com`` * ``yahoo.com`` To change this, subclass this form and set the class attribute ``bad_domains`` to a list of domains you wish to disallow. django-registration-2.2/docs/hmac.rst0000644000076700007670000002360613007361451017146 0ustar james00000000000000.. _hmac-workflow: .. module:: registration.backends.hmac The HMAC activation workflow ============================ The HMAC workflow, found in ``registration.backends.hmac``, implements a two-step registration process (signup, followed by activation), but unlike the older :ref:`model-based activation workflow ` uses no models and does not store its activation key; instead, the activation key sent to the user is a timestamped, `HMAC `_-verified value. Unless you need to maintain compatibility in an existing install of django-registration which used the model-based workflow, it's recommended you use the HMAC activation workflow for two-step signup processes. Behavior and configuration -------------------------- Since this workflow does not make use of any additional models beyond the user model (either Django's default ``django.contrib.auth.models.User``, or :ref:`a custom user model `), *do not* add ``registration`` to your ``INSTALLED_APPS`` setting. You will need to configure URLs, however. A default URLconf is provided, which you can ``include()`` in your URL configuration; that URLconf is ``registration.backends.hmac.urls``. For example, to place user registration under the URL prefix ``/accounts/``, you could place the following in your root URLconf: .. code-block:: python from django.conf.urls import include, url urlpatterns = [ # Other URL patterns ... url(r'^accounts/', include('registration.backends.hmac.urls')), # More URL patterns ... ] That URLconf also sets up the views from ``django.contrib.auth`` (login, logout, password reset, etc.), though if you want those views at a different location, you can ``include()`` the URLconf ``registration.auth_urls`` to place only the ``django.contrib.auth`` views at a specific location in your URL hierarchy. .. note:: **URL patterns for activation** Although the actual value used in the activation key is the new user account's username, the URL pattern for :class:`~registration.views.backends.hmac.ActivationView` does not need to match all possible legal characters in a username. The activation key that will be sent to the user (and thus matched in the URL) is produced by ``django.core.signing.dumps()``, which base64-encodes its output. Thus, the only characters this pattern needs to match are those from `the URL-safe base64 alphabet `_, plus the colon ("``:``") which is used as a separator. The default URL pattern for the activation view in ``registration.backends.hmac.urls`` handles this for you. This workflow makes use of up to three settings (click for details on each): * :data:`~django.conf.settings.ACCOUNT_ACTIVATION_DAYS` * :data:`~django.conf.settings.REGISTRATION_OPEN` * :data:`~django.conf.settings.REGISTRATION_SALT` (see also :ref:`note below `) By default, this workflow uses :class:`registration.forms.RegistrationForm` as its form class for user registration; this can be overridden by passing the keyword argument ``form_class`` to the registration view. Views ----- .. currentmodule:: registration.backends.hmac.views Two views are provided to implement the signup/activation process. These subclass :ref:`the base views of django-registration `, so anything that can be overridden/customized there can equally be overridden/customized here. There are some additional customization points specific to the HMAC implementation, which are listed below. For an overview of the templates used by these views (other than those specified below), and their context variables, see :ref:`the quick start guide `. .. class:: RegistrationView A subclass of :class:`registration.views.RegistrationView` implementing the signup portion of this workflow. Important customization points unique to this class are: .. method:: create_inactive_user(form) Creates and returns an inactive user account, and calls :meth:`send_activation_email()` to send the email with the activation key. The argument ``form`` is a valid registration form instance passed from :meth:`~registration.views.RegistrationView.register()`. .. method:: get_activation_key(user) Given an instance of the user model, generates and returns an activation key (a string) for that user account. .. method:: get_email_context(activation_key) Returns a dictionary of values to be used as template context when generating the activation email. .. method:: send_activation_email(user) Given an inactive user account, generates and sends the activation email for that account. .. attribute:: email_body_template A string specifying the template to use for the body of the activation email. Default is ``"registration/activation_email.txt"``. .. attribute:: email_subject_template A string specifying the template to use for the subject of the activation email. Default is ``"registration/activation_email_subject.txt"``. Note that, to avoid header-injection vulnerabilities, the result of rendering this template will be forced into a single line of text, stripping newline characters. .. class:: ActivationView A subclass of :class:`registration.views.ActivationView` implementing the activation portion of this workflow. Important customization points unique to this class are: .. method:: get_user(username) Given a username (determined by the activation key), look up and return the corresponding instance of the user model. Returns ``None`` if no such instance exists. In the base implementation, will include ``is_active=False`` in the query to avoid re-activation of already-active accounts. .. method:: validate_key(activation_key) Given the activation key, verifies that it carries a valid signature and a timestamp no older than the number of days specified in the setting ``ACCOUNT_ACTIVATION_DAYS``, and returns the username from the activation key. Returns ``None`` if the activation key has an invalid signature or if the timestamp is too old. How it works ------------ When a user signs up, the HMAC workflow creates a new ``User`` instance to represent the account, and sets the ``is_active`` field to ``False``. It then sends an email to the address provided during signup, containing a link to activate the account. When the user clicks the link, the activation view sets ``is_active`` to ``True``, after which the user can log in. The activation key is simply the username of the new account, signed using `Django's cryptographic signing tools `_ (specifically, ``signing.dumps()`` is used, to produce a guaranteed-URL-safe value). The activation process includes verification of the signature prior to activation, as well as verifying that the user is activating within the permitted window (as specified in the setting ``ACCOUNT_ACTIVATION_DAYS``, mentioned above), through use of Django's ``TimestampSigner``. Comparison to the model-activation workflow ------------------------------------------- The primary advantage of the HMAC activation workflow is that it requires no persistent storage of the activation key. However, this means there is no longer an automated way to differentiate accounts which have been purposefully deactivated (for example, as a way to ban a user) from accounts which failed to activate within a specified window. Additionally, it is possible a user could, if manually deactivated, re-activate their account if still within the activation window; for this reason, when using the ``is_active`` field to "ban" a user, it is best to also set the user's password to an unusable value (i.e., by calling `set_unusable_password() `_ for that user). Calling ``set_unusable_password()`` will also make it easier to query for manually-deactivated users, as their passwords will (when using Django's default ``User`` implementation) begin with the exclamation mark (``!``) character. Since the HMAC activation workflow does not use any models, it also does not make use of the admin interface and thus does not offer a convenient way to re-send an activation email. Users who have difficulty receiving the activation email can simply be manually activated by a site administrator. However, the reduced overhead of not needing to store the activation key makes this generally preferable to :ref:`the model-based workflow `. Security considerations ----------------------- The activation key emailed to the user in the HMAC activation workflow is a value obtained by using Django's cryptographic signing tools. In particular, the activation key is of the form:: encoded_username:timestamp:signature where ``encoded_username`` is the username of the new account, (URL-safe) base64-encoded, ``timestamp`` is a base62-encoded timestamp of the time the user registered, and ``signature`` is a (URL-safe) base64-encoded HMAC of the username and timestamp. Django's implementation uses the value of the ``SECRET_KEY`` setting as the key for HMAC; additionally, it permits the specification of a salt value which can be used to "namespace" different uses of HMAC across a Django-powered site. .. _salt-security: The HMAC activation workflow will use the value (a string) of the setting :data:`~django.conf.settings.REGISTRATION_SALT` as the salt, defaulting to the string ``"registration"`` if that setting is not specified. This value does *not* need to be kept secret (only ``SECRET_KEY`` does); it serves only to ensure that other parts of a site which also produce signed values from user input could not be used as a way to generate activation keys for arbitrary usernames (and vice-versa). django-registration-2.2/docs/index.rst0000644000076700007670000000312113007361415017333 0ustar james00000000000000.. _index: django-registration |version| ============================= django-registration is a simple, extensible application providing user registration functionality for `Django `_-powered Web sites. Although nearly all aspects of the registration process are customizable, out-of-the-box support is provided for two common use cases: * Two-phase registration, consisting of initial signup followed by a confirmation email with instructions for activating the new account. * One-phase registration, where a user signs up and is immediately active and logged in. To get up and running quickly, consult :ref:`the quick start guide `, which describes the steps necessary to configure django-registration for the built-in workflows. For more detailed information, including how to customize the registration process (and support for alternate registration systems), read through the documentation listed below. .. toctree:: :caption: Installation and configuration :maxdepth: 1 install quickstart .. toctree:: :caption: Built-in registration workflows :maxdepth: 1 hmac simple-workflow model-workflow .. toctree:: :caption: For developers :maxdepth: 1 views forms custom-user validators settings signals .. toctree:: :caption: Other documentation :maxdepth: 1 upgrade faq .. seealso:: * `Django's authentication documentation `_. Django's authentication system is used by django-registration's default configuration. django-registration-2.2/docs/install.rst0000644000076700007670000000561113007361426017702 0ustar james00000000000000.. _install: Installation guide ================== Before installing django-registration, you'll need to have a copy of `Django `_ already installed. For information on obtaining and installing Django, consult the `Django download page `_, which offers convenient packaged downloads and installation instructions. The |version| release of django-registration supports Django 1.8, 1.9, and 1.10, on the following Python versions: * Django 1.8 suports Python 2.7, 3.3, 3.4 and 3.5. * Django 1.9 supports Python 2.7, 3.4 and 3.5. * Django 1.10 supports Python 2.7, 3.4 and 3.5. It is expected that django-registration |version| will work without modification on Python 3.6 once it is released. .. important:: **Python 3.2** Although Django 1.8 supported Python 3.2 at the time of its release, the Python 3.2 series has reached end-of-life, and as a result support for Python 3.2 has been dropped from django-registration. Normal installation ------------------- The preferred method of installing django-registration is via ``pip``, the standard Python package-installation tool. If you don't have ``pip``, instructions are available for `how to obtain and install it `_. If you're using Python 2.7.9 or later (for Python 2) or Python 3.4 or later (for Python 3), ``pip`` came bundled with your installation of Python. Once you have ``pip``, simply type:: pip install django-registration Manual installation ------------------- It's also possible to install django-registration manually. To do so, obtain the latest packaged version from `the listing on the Python Package Index `_. Unpack the ``.tar.gz`` file, and run:: python setup.py install Once you've installed django-registration, you can verify successful installation by opening a Python interpreter and typing ``import registration``. If the installation was successful, you'll simply get a fresh Python prompt. If you instead see an ``ImportError``, check the configuration of your install tools and your Python import path to ensure django-registration installed into a location Python can import from. Installing from a source checkout --------------------------------- The development repository for django-registration is at . Presuming you have `git `_ installed, you can obtain a copy of the repository by typing:: git clone https://github.com/ubernostrum/django-registration.git From there, you can use normal git commands to check out the specific revision you want, and install it using ``python setup.py install``. Next steps ---------- To get up and running quickly, check out :ref:`the quick start guide `. For full documentation, see :ref:`the documentation index `.django-registration-2.2/docs/make.bat0000644000076700007670000000565112214057645017117 0ustar james00000000000000@ECHO OFF REM Command file for Sphinx documentation set SPHINXBUILD=sphinx-build set ALLSPHINXOPTS=-d _build/doctrees %SPHINXOPTS% . if NOT "%PAPER%" == "" ( set ALLSPHINXOPTS=-D latex_paper_size=%PAPER% %ALLSPHINXOPTS% ) if "%1" == "" goto help if "%1" == "help" ( :help echo.Please use `make ^` where ^ is one of echo. html to make standalone HTML files echo. dirhtml to make HTML files named index.html in directories echo. pickle to make pickle files echo. json to make JSON files echo. htmlhelp to make HTML files and a HTML help project echo. qthelp to make HTML files and a qthelp project echo. latex to make LaTeX files, you can set PAPER=a4 or PAPER=letter echo. changes to make an overview over all changed/added/deprecated items echo. linkcheck to check all external links for integrity echo. doctest to run all doctests embedded in the documentation if enabled goto end ) if "%1" == "clean" ( for /d %%i in (_build\*) do rmdir /q /s %%i del /q /s _build\* goto end ) if "%1" == "html" ( %SPHINXBUILD% -b html %ALLSPHINXOPTS% _build/html echo. echo.Build finished. The HTML pages are in _build/html. goto end ) if "%1" == "dirhtml" ( %SPHINXBUILD% -b dirhtml %ALLSPHINXOPTS% _build/dirhtml echo. echo.Build finished. The HTML pages are in _build/dirhtml. goto end ) if "%1" == "pickle" ( %SPHINXBUILD% -b pickle %ALLSPHINXOPTS% _build/pickle echo. echo.Build finished; now you can process the pickle files. goto end ) if "%1" == "json" ( %SPHINXBUILD% -b json %ALLSPHINXOPTS% _build/json echo. echo.Build finished; now you can process the JSON files. goto end ) if "%1" == "htmlhelp" ( %SPHINXBUILD% -b htmlhelp %ALLSPHINXOPTS% _build/htmlhelp echo. echo.Build finished; now you can run HTML Help Workshop with the ^ .hhp project file in _build/htmlhelp. goto end ) if "%1" == "qthelp" ( %SPHINXBUILD% -b qthelp %ALLSPHINXOPTS% _build/qthelp echo. echo.Build finished; now you can run "qcollectiongenerator" with the ^ .qhcp project file in _build/qthelp, like this: echo.^> qcollectiongenerator _build\qthelp\django-registration.qhcp echo.To view the help file: echo.^> assistant -collectionFile _build\qthelp\django-registration.ghc goto end ) if "%1" == "latex" ( %SPHINXBUILD% -b latex %ALLSPHINXOPTS% _build/latex echo. echo.Build finished; the LaTeX files are in _build/latex. goto end ) if "%1" == "changes" ( %SPHINXBUILD% -b changes %ALLSPHINXOPTS% _build/changes echo. echo.The overview file is in _build/changes. goto end ) if "%1" == "linkcheck" ( %SPHINXBUILD% -b linkcheck %ALLSPHINXOPTS% _build/linkcheck echo. echo.Link check complete; look for any errors in the above output ^ or in _build/linkcheck/output.txt. goto end ) if "%1" == "doctest" ( %SPHINXBUILD% -b doctest %ALLSPHINXOPTS% _build/doctest echo. echo.Testing of doctests in the sources finished, look at the ^ results in _build/doctest/output.txt. goto end ) :end django-registration-2.2/docs/Makefile0000644000076700007670000000571312214057645017151 0ustar james00000000000000# Makefile for Sphinx documentation # # You can set these variables from the command line. SPHINXOPTS = SPHINXBUILD = sphinx-build PAPER = # Internal variables. PAPEROPT_a4 = -D latex_paper_size=a4 PAPEROPT_letter = -D latex_paper_size=letter ALLSPHINXOPTS = -d _build/doctrees $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) . .PHONY: help clean html dirhtml pickle json htmlhelp qthelp latex changes linkcheck doctest help: @echo "Please use \`make ' where is one of" @echo " html to make standalone HTML files" @echo " dirhtml to make HTML files named index.html in directories" @echo " pickle to make pickle files" @echo " json to make JSON files" @echo " htmlhelp to make HTML files and a HTML help project" @echo " qthelp to make HTML files and a qthelp project" @echo " latex to make LaTeX files, you can set PAPER=a4 or PAPER=letter" @echo " changes to make an overview of all changed/added/deprecated items" @echo " linkcheck to check all external links for integrity" @echo " doctest to run all doctests embedded in the documentation (if enabled)" clean: -rm -rf _build/* html: $(SPHINXBUILD) -b html $(ALLSPHINXOPTS) _build/html @echo @echo "Build finished. The HTML pages are in _build/html." dirhtml: $(SPHINXBUILD) -b dirhtml $(ALLSPHINXOPTS) _build/dirhtml @echo @echo "Build finished. The HTML pages are in _build/dirhtml." pickle: $(SPHINXBUILD) -b pickle $(ALLSPHINXOPTS) _build/pickle @echo @echo "Build finished; now you can process the pickle files." json: $(SPHINXBUILD) -b json $(ALLSPHINXOPTS) _build/json @echo @echo "Build finished; now you can process the JSON files." htmlhelp: $(SPHINXBUILD) -b htmlhelp $(ALLSPHINXOPTS) _build/htmlhelp @echo @echo "Build finished; now you can run HTML Help Workshop with the" \ ".hhp project file in _build/htmlhelp." qthelp: $(SPHINXBUILD) -b qthelp $(ALLSPHINXOPTS) _build/qthelp @echo @echo "Build finished; now you can run "qcollectiongenerator" with the" \ ".qhcp project file in _build/qthelp, like this:" @echo "# qcollectiongenerator _build/qthelp/django-registration.qhcp" @echo "To view the help file:" @echo "# assistant -collectionFile _build/qthelp/django-registration.qhc" latex: $(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) _build/latex @echo @echo "Build finished; the LaTeX files are in _build/latex." @echo "Run \`make all-pdf' or \`make all-ps' in that directory to" \ "run these through (pdf)latex." changes: $(SPHINXBUILD) -b changes $(ALLSPHINXOPTS) _build/changes @echo @echo "The overview file is in _build/changes." linkcheck: $(SPHINXBUILD) -b linkcheck $(ALLSPHINXOPTS) _build/linkcheck @echo @echo "Link check complete; look for any errors in the above output " \ "or in _build/linkcheck/output.txt." doctest: $(SPHINXBUILD) -b doctest $(ALLSPHINXOPTS) _build/doctest @echo "Testing of doctests in the sources finished, look at the " \ "results in _build/doctest/output.txt." django-registration-2.2/docs/model-workflow.rst0000644000076700007670000002471313011526040021176 0ustar james00000000000000.. _model-workflow: .. module:: registration.backends.model_activation The model-based activation workflow =================================== This workflow implements a two-step -- registration, followed by activation -- process for user signup. .. note:: **Use of the model-based workflow is discouraged** The model-based activation workflow was originally the *only* workflow built in to django-registration, and later was the default one. However, it no longer represents the best practice for registration with modern versions of Django, and so it continues to be included only for backwards compatibility with existing installations of django-registration. If you're setting up a new installation and want a two-step process with activation, it's recommended you use :ref:`the HMAC activation workflow ` instead. Also, note that this workflow was previously found in ``registration.backends.default``, and imports from that location still function in django-registration |version| but now raise deprecation warnings. The correct location going forward is ``registration.backends.model_activation``. Default behavior and configuration ---------------------------------- To make use of this workflow, simply add ``registration`` to your ``INSTALLED_APPS``, run ``manage.py migrate`` to install its model, and include the URLconf ``registration.backends.model_activation.urls`` at whatever location you choose in your URL hierarchy. For example: .. code-block:: python from django.conf.urls import include, url urlpatterns = [ # Other URL patterns ... url(r'^accounts/', include('registration.backends.model_activation.urls')), # More URL patterns ... ] This workflow makes use of the following settings: * :data:`~django.conf.settings.ACCOUNT_ACTIVATION_DAYS` * :data:`~django.conf.settings.REGISTRATION_OPEN` By default, this workflow uses :class:`registration.forms.RegistrationForm` as its form class for user registration; this can be overridden by passing the keyword argument ``form_class`` to the registration view. Two views are provided: ``registration.backends.model_activation.views.RegistrationView`` and ``registration.backends.model_activation.views.ActivationView``. These views subclass django-registration's base :class:`~registration.views.RegistrationView` and :class:`~registration.views.ActivationView`, respectively, and implement the two-step registration/activation process. Upon successful registration -- not activation -- the user will be redirected to the URL pattern named ``registration_complete``. Upon successful activation, the user will be redirected to the URL pattern named ``registration_activation_complete``. This workflow uses the same templates and contexts as :ref:`the HMAC activation workflow `, which is covered in :ref:`the quick-start guide `. Refer to the quick-start guide for documentation on those templates and their contexts. How account data is stored for activation ----------------------------------------- During registration, a new instance of the user model (by default, Django's ``django.contrib.auth.models.User`` -- see :ref:`the custom user documentation ` for notes on using a different model) is created to represent the new account, with the ``is_active`` field set to ``False``. An email is then sent to the email address of the account, containing a link the user must click to activate the account; at that point the ``is_active`` field is set to ``True``, and the user may log in normally. Activation is handled by generating and storing an activation key in the database, using the following model: .. currentmodule:: registration.models .. class:: RegistrationProfile A simple representation of the information needed to activate a new user account. This is **not** a user profile; it simply provides a place to temporarily store the activation key and determine whether a given account has been activated. Has the following fields: .. attribute:: user A ``OneToOneField`` to the user model, representing the user account for which activation information is being stored. .. attribute:: activation_key A 40-character ``CharField``, storing the activation key for the account. Initially, the activation key is the hex digest of a SHA1 hash; after activation, this is reset to :attr:`ACTIVATED`. Additionally, one class attribute exists: .. attribute:: ACTIVATED A constant string used as the value of :attr:`activation_key` for accounts which have been activated. And the following methods: .. method:: activation_key_expired() Determines whether this account's activation key has expired, and returns a boolean (``True`` if expired, ``False`` otherwise). Uses the following algorithm: 1. If :attr:`activation_key` is :attr:`ACTIVATED`, the account has already been activated and so the key is considered to have expired. 2. Otherwise, the date of registration (obtained from the ``date_joined`` field of :attr:`user`) is compared to the current date; if the span between them is greater than the value of the setting ``ACCOUNT_ACTIVATION_DAYS``, the key is considered to have expired. :rtype: bool .. method:: send_activation_email(site) Sends an activation email to the address of the account. The activation email will make use of two templates: ``registration/activation_email_subject.txt`` and ``registration/activation_email.txt``, which are used for the subject of the email and the body of the email, respectively. Each will receive the following context: ``activation_key`` The value of :attr:`activation_key`. ``expiration_days`` The number of days the user has to activate, taken from the setting ``ACCOUNT_ACTIVATION_DAYS``. ``user`` The user registering for the new account. ``site`` An object representing the site on which the account was registered; depending on whether ``django.contrib.sites`` is installed, this may be an instance of either ``django.contrib.sites.models.Site`` (if the sites application is installed) or ``django.contrib.sites.models.RequestSite`` (if not). Consult `the documentation for the Django sites framework `_ for details regarding these objects' interfaces. Note that, to avoid header-injection vulnerabilities, the rendered output of ``registration/activation_email_subject.txt`` will be forcibly condensed to a single line. :param site: An object representing the site on which account was registered. :type site: ``django.contrib.sites.models.Site`` or ``django.contrib.sites.models.RequestSite`` :rtype: ``None`` Additionally, :class:`RegistrationProfile` has a custom manager (accessed as ``RegistrationProfile.objects``): .. class:: RegistrationManager This manager provides several convenience methods for creating and working with instances of :class:`RegistrationProfile`: .. method:: activate_user(activation_key) Validates ``activation_key`` and, if valid, activates the associated account by setting its ``is_active`` field to ``True``. To prevent re-activation of accounts, the :attr:`~RegistrationProfile.activation_key` of the :class:`RegistrationProfile` for the account will be set to :attr:`RegistrationProfile.ACTIVATED` after successful activation. Returns the user instance representing the account if activation is successful, ``False`` otherwise. :param activation_key: The activation key to use for the activation. :type activation_key: string, a 40-character SHA1 hexdigest :rtype: user or bool .. method:: expired Return instances of :class:`RegistrationProfile` corresponding to expired users. A user is considered to be "expired" if: * The activation key of the user's :class:`RegistrationProfile` is not set to :attr:`RegistrationProfile.ACTIVATED`, and * The user's ``is_active`` field of is ``False``, and * The user's ``date_joined`` field is more than :data:`~django.conf.settings.ACCOUNT_ACTIVATION_DAYS` in the past. :rtype: ``QuerySet`` of :class:`RegistrationProfile` .. method:: delete_expired_users Removes expired instances of :class:`RegistrationProfile`, and their associated user accounts, from the database. This is useful as a periodic maintenance task to clean out accounts which registered but never activated. A custom management command is provided which will execute this method, suitable for use in cron jobs or other scheduled maintenance tasks: ``manage.py cleanupregistration``. :rtype: ``None`` .. method:: create_inactive_user(form, site, send_email=True) Creates a new, inactive user account and an associated instance of :class:`RegistrationProfile`, sends the activation email and returns the new ``User`` object representing the account. :param form: A bound instance of a subclass of :class:`~registration.forms.RegistrationForm` representing the (already-validated) data the user is trying to register with. :param site: An object representing the site on which the account is being registered. :type site: ``django.contrib.sites.models.Site`` or ``django.contrib.sites.models.RequestSite`` :param send_email: If ``True``, the activation email will be sent to the account (by calling :meth:`RegistrationProfile.send_activation_email`). If ``False``, no email will be sent (but the account will still be inactive). :type send_email: bool :rtype: user .. method:: create_profile(user) Creates and returns a :class:`RegistrationProfile` instance for the account represented by ``user``. The ``RegistrationProfile`` created by this method will have its :attr:`~RegistrationProfile.activation_key` set to a SHA1 hash generated from a combination of the account's username and a random salt. :param user: The user account; an instance of ``django.contrib.auth.models.User``. :type user: ``User`` :rtype: ``RegistrationProfile`` django-registration-2.2/docs/quickstart.rst0000644000076700007670000002314313007361444020426 0ustar james00000000000000.. _quickstart: Quick start guide ================= First you'll need to have Django and django-registration installed; for details on that, see :ref:`the installation guide `. The next steps will depend on which registration workflow you'd like to use. There are three workflows built in to django-registration; one is included largely for backwards compatibility with older releases, while the other two are recommended for new installations. Those two are: * :ref:`The HMAC activation workflow `, which implements a two-step process: a user signs up, then is emailed an activation link and must click it to activate the account. * :ref:`The simple one-step workflow `, in which a user simply signs up and their account is immediately active and logged in. The guide below covers use of these two workflows. .. important:: **Django's authentication system must be installed** Before proceeding with either of the recommended built-in workflows, you'll need to ensure ``django.contrib.auth`` has been installed (by adding it to ``INSTALLED_APPS`` and running ``manage.py migrate`` to install needed database tables). Also, if you're making use of `a custom user model `_, you'll probably want to pause and read :ref:`the custom user compatibility guide ` before using django-registration. Configuring the HMAC activation workflow ---------------------------------------- The configuration process for using the HMAC activation workflow is straightforward: you'll need to specify a couple of settings, connect some URLs and create a few templates. Required settings ~~~~~~~~~~~~~~~~~ Begin by adding the following setting to your Django settings file: :data:`~django.conf.settings.ACCOUNT_ACTIVATION_DAYS` This is the number of days users will have to activate their accounts after registering. If a user does not activate within that period, the account will remain permanently inactive unless a site administrator manually activates it. For example, you might have something like the following in your Django settings:: ACCOUNT_ACTIVATION_DAYS = 7 # One-week activation window; you may, of course, use a different value. You'll also need to have ``django.contrib.auth`` in your ``INSTALLED_APPS`` setting, since all of the registration workflows in django-registration make use of it. .. warning:: You should **not** add ``registration`` to your ``INSTALLED_APPS`` setting if you're following this document. This section is walking you through setup of the :ref:`the HMAC activation workflow `, and that does not make use of any custom models or other features which require ``registration`` to be in ``INSTALLED_APPS``. Only add ``registration`` to your ``INSTALLED_APPS`` setting if you're using :ref:`the model-based activation workflow `, or something derived from it. Setting up URLs ~~~~~~~~~~~~~~~ Each bundled registration workflow in django-registration includes a Django URLconf which sets up URL patterns for :ref:`the views in django-registration `, as well as several useful views in ``django.contrib.auth`` (e.g., login, logout, password change/reset). The URLconf for the HMAC activation workflow can be found at ``registration.backends.hmac.urls``, and so can simply be included in your project's root URL configuration. For example, to place the URLs under the prefix ``/accounts/``, you could add the following to your project's root URLconf: .. code-block:: python from django.conf.urls import include, url urlpatterns = [ # Other URL patterns ... url(r'^accounts/', include('registration.backends.hmac.urls')), # More URL patterns ... ] Users would then be able to register by visiting the URL ``/accounts/register/``, log in (once activated) at ``/accounts/login/``, etc. Another ``URLConf`` is also provided -- at ``registration.auth_urls`` -- which just handles the Django auth views, should you want to put those at a different location. .. _default-templates: Required templates ~~~~~~~~~~~~~~~~~~ You will also need to create several templates required by django-registration, and possibly additional templates required by views in ``django.contrib.auth``. The templates required by django-registration are as follows; note that, with the exception of the templates used for account activation emails, all of these are rendered using a ``RequestContext`` and so will also receive any additional variables provided by `context processors `_. **registration/registration_form.html** Used to show the form users will fill out to register. By default, has the following context: ``form`` The registration form. This will likely be a subclass of :class:`~registration.forms.RegistrationForm`; consult `Django's forms documentation `_ for information on how to display this in a template. **registration/registration_complete.html** Used after successful completion of the registration form. This template has no context variables of its own, and should simply inform the user that an email containing account-activation information has been sent. **registration/activate.html** Used if account activation fails. With the default setup, has the following context: ``activation_key`` The activation key used during the activation attempt. **registration/activation_complete.html** Used after successful account activation. This template has no context variables of its own, and should simply inform the user that their account is now active. **registration/activation_email_subject.txt** Used to generate the subject line of the activation email. Because the subject line of an email must be a single line of text, any output from this template will be forcibly condensed to a single line before being used. This template has the following context: ``activation_key`` The activation key for the new account. ``expiration_days`` The number of days remaining during which the account may be activated. ``user`` The user registering for the new account. ``site`` An object representing the site on which the user registered; depending on whether ``django.contrib.sites`` is installed, this may be an instance of either ``django.contrib.sites.models.Site`` (if the sites application is installed) or ``django.contrib.sites.requests.RequestSite`` (if not). Consult `the documentation for the Django sites framework `_ for details regarding these objects' interfaces. **registration/activation_email.txt** Used to generate the body of the activation email. Should display a link the user can click to activate the account. This template has the following context: ``activation_key`` The activation key for the new account. ``expiration_days`` The number of days remaining during which the account may be activated. ``user`` The user registering for the new account. ``site`` An object representing the site on which the user registered; depending on whether ``django.contrib.sites`` is installed, this may be an instance of either ``django.contrib.sites.models.Site`` (if the sites application is installed) or ``django.contrib.sites.requests.RequestSite`` (if not). Consult `the documentation for the Django sites framework `_ for details regarding these objects. Note that the templates used to generate the account activation email use the extension ``.txt``, not ``.html``. Due to widespread antipathy toward and interoperability problems with HTML email, django-registration defaults to plain-text email, and so these templates should simply output plain text rather than HTML. To make use of the views from ``django.contrib.auth`` (which are set up for you by the default URLconf mentioned above), you will also need to create the templates required by those views. Consult `the documentation for Django's authentication system `_ for details regarding these templates. Configuring the simple one-step workflow -------------------------------------------- Also included is a simpler, :ref:`one-step registration workflow `, where a user signs up and their account is immediately active and logged in. The simple workflow does not require any models other than those provided by Django's own authentication system, so only ``django.contrib.auth`` needs to be in your ``INSTALLED_APPS`` setting. You will need to configure URLs to use the simple workflow; the easiest way is to simply ``include()`` the URLconf ``registration.backends.simple.urls`` in your root URLconf. For example, to place the URLs under the prefix ``/accounts/`` in your URL structure: .. code-block:: python from django.conf.urls import include, url urlpatterns = [ # Other URL patterns ... url(r'^accounts/', include('registration.backends.simple.urls')), # More URL patterns ... ] Users could then register accounts by visiting the URL ``/accounts/register/``. This URLconf will also configure the appropriate URLs for the rest of the built-in ``django.contrib.auth`` views (log in, log out, password reset, etc.). Finally, you will need to create one template: ``registration/registration_form.html``. See :ref:`the list of templates above ` for details of this template's context. django-registration-2.2/docs/settings.rst0000644000076700007670000000374213007361542020076 0ustar james00000000000000.. _settings: .. module:: django.conf.settings Custom settings =============== Although the choice of registration workflow does not necessarily require changes to your Django settings (as registration workflows are selected by including the appropriate URL patterns in your root URLconf), the built-in workflows of django-registration make use of several custom settings. .. data:: ACCOUNT_ACTIVATION_DAYS An ``int`` indicating how long (in days) after signup an account has in which to activate. This setting is required if using one of the built-in two-step workflows: * :ref:`The two-step HMAC activation workflow ` * :ref:`The model-based activation workflow ` .. data:: REGISTRATION_OPEN A ``bool`` indicating whether registration of new accounts is currently permitted. A default of ``True`` is assumed when this setting is not supplied, so specifying it is optional unless you want to temporarily close registration (in which case, set it to ``False``). Used by: * :ref:`The two-step HMAC activation workflow ` * :ref:`The simple one-step workflow ` * :ref:`The model-based activation workflow ` Third-party workflows wishing to use an alternate method of determining whether registration is allowed should subclass :class:`registration.views.RegistrationView` (or a subclass of it from an existing workflow) and override :meth:`~registration.views.RegistrationView.registration_allowed`. .. data:: REGISTRATION_SALT A ``str`` used as an additional "salt" in the process of generating HMAC-signed activation keys. This setting is optional, and a default of ``"registration"`` will be used if not specified. The value of this setting does not need to be kept secret; see :ref:`the note about this salt value and security ` for details. Used by: * :ref:`The two-step HMAC activation workflow ` django-registration-2.2/docs/signals.rst0000644000076700007670000000472313007361553017700 0ustar james00000000000000.. _signals: .. module:: registration.signals Signals used by django-registration =================================== Much of django-registration's customizability comes through the ability to write and use different workflows for user registration. However, there are many cases where only a small bit of additional logic needs to be injected into the registration process, and writing a custom workflow to support this represents an unnecessary amount of work. A more lightweight customization option is provided through two custom signals which the built-in registration workflows send, and custom workflows are encouraged to send, at specific points during the registration process; functions listening for these signals can then add whatever logic is needed. For general documentation on signals and the Django dispatcher, consult `Django's signals documentation `_. This documentation assumes that you are familiar with how signals work and the process of writing and connecting functions which will listen for signals. .. data:: user_activated Sent when a user account is activated (not applicable to all workflows). Provides the following arguments: ``sender`` The :class:`~registration.views.ActivationView` subclass used to activate the user. ``user`` A user-model instance representing the activated account. ``request`` The ``HttpRequest`` in which the account was activated. This signal is automatically sent for you by the base :class:`~registration.views.ActivationView`, so unless you've overridden its ``get()`` method in a subclass you should not need to explicitly send it. .. data:: user_registered Sent when a new user account is registered. Provides the following arguments: ``sender`` The :class:`~registration.views.RegistrationView` subclass used to register the account. ``user`` A user-model instance representing the new account. ``request`` The ``HttpRequest`` in which the new account was registered. This signal is **not** automatically sent for you by the base :class:`~registration.views.RegistrationView`. It is sent by the subclasses implemented for the three included registration workflows, but if you write your own subclass of ``RegistrationView``, you'll need to send this signal as part of the implementation of the :meth:`~registration.views.RegistrationView.register` method.django-registration-2.2/docs/simple-workflow.rst0000644000076700007670000000455713007361460021403 0ustar james00000000000000.. _simple-workflow: .. module:: registration.backends.simple The simple one-step workflow ============================ As an alternative to the :ref:`HMAC ` and :ref:`model-based ` two-step (registration and activation) workflows, django-registration bundles a one-step registration workflow in ``registration.backends.simple``. This workflow is deliberately as simple as possible: 1. A user signs up by filling out a registration form. 2. The user's account is created and is active immediately, with no intermediate confirmation or activation step. 3. The new user is logged in immediately. Configuration ------------- To use this workflow, simply include the URLconf ``registration.backends.simple.urls`` somewhere in your site's own URL configuration. For example: .. code-block:: python from django.conf.urls import include, url urlpatterns = [ # Other URL patterns ... url(r'^accounts/', include('registration.backends.simple.urls')), # More URL patterns ... ] To control whether registration of new accounts is allowed, you can specify the setting :data:`~django.conf.settings.REGISTRATION_OPEN`. Upon successful registration, the user will be redirected to the site's home page -- the URL ``/``. This can be changed by subclassing ``registration.backends.simple.views.RegistrationView`` and overriding the method ``get_success_url()``. The default form class used for account registration will be :class:`registration.forms.RegistrationForm`, although this can be overridden by supplying a custom URL pattern for the registration view and passing the keyword argument ``form_class``, or by subclassing ``registration.backends.simple.views.RegistrationView`` and either overriding ``form_class`` or implementing :meth:`~registration.views.RegistrationView.get_form_class()`, and specifying the custom subclass in your URL patterns. Templates --------- The one-step workflow uses only one custom template: **registration/registration_form.html** Used to show the form users will fill out to register. By default, has the following context: ``form`` The registration form. This will likely be a subclass of :class:`~registration.forms.RegistrationForm`; consult `Django's forms documentation `_ for information on how to display this in a template. django-registration-2.2/docs/upgrade.rst0000644000076700007670000001660213011526224017657 0ustar james00000000000000.. _upgrade: Upgrading from previous versions ================================ Prior to 2.0, the last widely-deployed release of django-registration was 0.8; a 1.0 release was published, and |version| is mostly backwards-compatible with it, but 1.0 appears not to have seen wide adoption. As such, this guide covers the process of upgrading from django-registration 0.8, as well as from 1.0. Backends are now class-based views ---------------------------------- In django-registration 0.8, a registration workflow was implemented as a class with specific methods for the various steps of the registration process. In django-registration 2.0 and later, a registration workflow is implemented as one or more class-based views. In general, the required changes to implement a 0.8 registration workflow in django-registration |version| is: +-------------------------------------------------------------+------------------------------------------------------------------+ | 0.8 backend class implementation | 2.0+ view subclass implementation | +=============================================================+==================================================================+ | Backend class implementing ``register()`` | :meth:`registration.views.RegistrationView.register` | +-------------------------------------------------------------+------------------------------------------------------------------+ | Backend class implementing ``activate()`` | :meth:`registration.views.ActivationView.activate` | +-------------------------------------------------------------+------------------------------------------------------------------+ | Backend class implementing ``registration_allowed()`` | :meth:`registration.views.RegistrationView.registration_allowed` | +-------------------------------------------------------------+------------------------------------------------------------------+ | Backend class implementing ``get_form_class()`` | :meth:`registration.views.RegistrationView.get_form_class()` | +-------------------------------------------------------------+------------------------------------------------------------------+ | Backend class implementing ``post_registration_redirect()`` | :meth:`registration.views.RegistrationView.get_success_url()` | +-------------------------------------------------------------+------------------------------------------------------------------+ | Backend class implementing ``post_activation_redirect()`` | :meth:`registration.views.ActivationView.get_success_url()` | +-------------------------------------------------------------+------------------------------------------------------------------+ URLconf changes --------------- If you were using one of the provided workflows in django-registration 0.8 without modification, you will not need to make any changes; both ``registration.backends.default.urls`` and ``registration.backends.simple.urls`` have been updated in django-registration 2.0+ to correctly point to the new class-based views: +---------------------------------+---------------------------------------------------+ | 0.8 URLconf view reference | |version| URLconf view reference | +=================================+===================================================+ | ``registration.views.register`` | ``registration.views.RegistrationView.as_view()`` | +---------------------------------+---------------------------------------------------+ | ``registration.views.activate`` | ``registration.views.ActivationView.as_view()`` | +---------------------------------+---------------------------------------------------+ However, if you were using the two-step model-activation workflow, you should begin referring to ``registration.backends.model_activation.urls`` instead of ``registration.backends.default.urls`` or ``registration.urls``, as the latter two are deprecated and support for them will be removed in a future release. If you were passing custom arguments to the built-in registration views, those arguments should continue to work, so long as your URLconf is updated to refer to the new class-based views. For details of how to pass custom arguments to class-based views, see `the Django class-based view documentation `_. Template changes ---------------- When using :class:`~registration.forms.RegistrationForm`, the error from mismatched passwords now is attached to the ``password2`` field rather than being a form-level error. To check for and display this error, you will need to change to accessing it via the ``password2`` field rather than via ``non_field_errors()`` or the ``__all__`` key in the errors dictionary. Changes since 1.0 ----------------- If you used django-registration 1.0, or a pre-2.0 checkout of the code, you will need to make some minor adjustments. If you previously used ``registration.backends.default``, you will now see deprecation warnings, as the former "default" workflow is now found in ``registration.backends.model_activation``. Use of ``registration.backends.default`` continues to work in django-registration |version|, but will be removed in the future. Similarly, references to ``registration.urls`` should become references to ``registration.backends.model_activation.urls``, and ``registration.urls`` is deprecated and will be removed in a future release. If you had written custom subclasses of :class:`~registration.views.RegistrationView` or of ``RegistrationView`` subclasses in the built-in workflows, the following changes need to be noted: * The ``register`` method now receives the :class:`~registration.forms.RegistrationForm` instance used during signup, rather than keyword arguments corresponding to the form's ``cleaned_data``. * ``RegistrationForm`` itself is now a subclass of Django's built-in ``UserCreationForm``, and as such is now a ``ModelForm`` subclass. This can cause metaclass conflict errors if you write a class which is a subclass of both ``RegistrationForm`` and a non-``ModelForm`` form class; to avoid this, ensure that subclasses of ``RegistrationForm`` and/or ``ModelForm`` come first in your subclass' method resolution order. * As noted above, the password-mismatch error message is now attached to the ``password2`` field rather than being a form-level error. Changes since 2.0 ----------------- Only one major change occurred between django-registration 2.0 and |version|: the addition in version 2.1 of the :class:`~registration.validators.ReservedNameValidator`, which is now used by default on :class:`~registration.forms.RegistrationForm` and its subclasses. This is technically backwards-incompatible, since a set of usernames which previously could be registered now cannot be registered, but was included because the security benefits outweigh the edge cases of the now-disallowed usernames. If you need to allow users to register with usernames forbidden by this validator, see its documentation for notes on how to customize or disable it. In |version|, the behavior of the :meth:`~registration.models.RegistrationProfile.expired` method was clarified to accommodate user expectations; it does *not* return (and thus, :meth:`~registration.models.RegistrationProfile.delete_expired_users` does not delete) profiles of users who had successfully activated.django-registration-2.2/docs/validators.rst0000644000076700007670000001040313007361533020376 0ustar james00000000000000.. _validators: .. module:: registration.validators Validation utilities ==================== To ease the process of validating user registration data, django-registration includes some validation-related data and utilities in ``registration.validators``. The available error messages are: .. data:: DUPLICATE_EMAIL Error message raised by :class:`~registration.forms.RegistrationFormUniqueEmail` when the supplied email address is not unique. .. data:: FREE_EMAIL Error message raised by :class:`~registration.forms.RegistrationFormNoFreeEmail` when the supplied email address is rejected by its list of free-email domains. .. data:: RESERVED_NAME Error message raised by :class:`~registration.validators.ReservedNameValidator` when it is given a value that is a reserved name. .. data:: TOS_REQUIRED Error message raised by :class:`~registration.forms.RegistrationFormTermsOfService` when the terms-of-service field is not checked. All of these error messages are marked for translation; most have translations into multiple languages already in django-registration. Additionally, one custom validator is provided: .. class:: ReservedNameValidator A custom validator (see `Django's validators documentation `_) which prohibits the use of a reserved name as the value. By default, this validator is applied to the username field of :class:`registration.forms.RegistrationForm` and all of its subclasses. The validator is applied in a form-level ``clean()`` method on ``RegistrationForm``, so to remove it (not recommended), simply subclass ``RegistrationForm`` and override ``clean()``. For no custom form-level validation, you could simply implement it as: .. code-block:: python def clean(self): pass If you want to supply your own custom list of reserved names, you can subclass ``RegistrationForm`` and set the attribute ``reserved_names`` to the list of values you want to disallow. .. note:: **Why reserved names are reserved** Many Web applications enable per-user URLs (to display account information), and some may also create email addresses or even subdomains, based on a user's username. While this is often useful, it also represents a risk: a user might register a name which conflicts with an important URL, email address or subdomain, and this might give that user control over it. django-registration includes a list of reserved names, and rejects them as usernames by default, in order to avoid this issue. The default list of reserved names, if you don't specify one, is :data:`~registration.validators.DEFAULT_RESERVED_NAMES`. The validator will also reject any value beginning with the string ``".well-known"`` (see `RFC 5785 `_). Several constants are provided which are used by this validator: .. data:: SPECIAL_HOSTNAMES A list of hostnames with reserved or special meaning (such as "autoconfig", used by some email clients to automatically discover configuration data for a domain). .. data:: PROTOCOL_HOSTNAMES A list of protocol-specific hostnames sites commonly want to reserve, such as "www" and "mail". .. data:: CA_ADDRESSES A list of email usernames commonly used by certificate authorities when verifying identity. .. data:: RFC_2142 A list of common email usernames specified by `RFC 2142 `_. .. data:: NOREPLY_ADDRESSES A list of common email usernames used for automated messages from a Web site (such as "noreply" and "mailer-daemon"). .. data:: SENSITIVE_FILENAMES A list of common filenames with important meanings, such that usernames should not be allowed to conflict with them (such as "favicon.ico" and "robots.txt"). .. data:: OTHER_SENSITIVE_NAMES Other names, not covered by the above lists, which have the potential to conflict with common URLs or subdomains, such as "blog" and "docs". .. data:: DEFAULT_RESERVED_NAMES A list made of the concatentation of all of the above lists, used as the default set of reserved names for :class:`~registration.validators.ReservedNameValidator`.django-registration-2.2/docs/views.rst0000644000076700007670000001327513007361475017402 0ustar james00000000000000.. _views: .. module:: registration.views Base view classes ================= In order to allow the utmost flexibility in customizing and supporting different workflows, django-registration makes use of Django's support for `class-based views `_. Included in django-registration are two base classes which can be subclassed to implement whatever workflow is required. The built-in workflows in django-registration provide their own subclasses of these views, and the documentation for those workflows will indicate customization points specific to those subclasses. The following reference covers useful attributes and methods of the base classes, for use in writing your own custom subclasses. .. class:: RegistrationView A subclass of Django's `FormView `_, which provides the infrastructure for supporting user registration. Since it's a subclass of ``FormView``, ``RegistrationView`` has all the usual attributes and methods you can override. When writing your own subclass, one method is required: .. method:: register(form) Implement your registration logic here. ``form`` will be the (already-validated) form filled out by the user during the registration process (i.e., a valid instance of :class:`registration.forms.RegistrationForm` or a subclass of it). This method should return the newly-registered user instance, and should send the signal :data:`registration.signals.user_registered`. Note that this is not automatically done for you when writing your own custom subclass, so you must send this signal manually. Useful optional places to override or customize on a ``RegistrationView`` subclass are: .. attribute:: disallowed_url The URL to redirect to when registration is disallowed. Should be a `string name of a URL pattern `_. Default value is ``"registration_disallowed"``. .. attribute:: form_class The form class to use for user registration. Can be overridden on a per-request basis (see below). Should be the actual class object; by default, this class is :class:`registration.forms.RegistrationForm`. .. attribute:: success_url The URL to redirect to after successful registration. A string containing a (relative) URL, or a string name of a URL pattern, or a 3-tuple of arguments suitable for passing to Django's `redirect shortcut `_. Can be overridden on a per-request basis (see below). Default value is ``None``, so that per-request customization is used instead. .. attribute:: template_name The template to use for user registration. Should be a string. Default value is ``registration/registration_form.html``. .. method:: get_form_class() Select a form class to use on a per-request basis. If not overridden, will use :attr:`~form_class`. Should be the actual class object. .. method:: get_success_url(user) Return a URL to redirect to after successful registration, on a per-request or per-user basis. If not overridden, will use :attr:`~success_url`. Should return a string containing a (relative) URL, or a string name of a URL pattern, or a 3-tuple of arguments suitable for passing to Django's ``redirect`` shortcut. .. method:: registration_allowed() Should return a boolean indicating whether user registration is allowed, either in general or for this specific request. .. warning:: Implementing ``form_invalid()`` To work around `a potential performance issue in Django 1.9 `_, ``RegistrationView`` implements the ``form_invalid()`` method. If you choose to override ``form_invalid()`` in a subclass of ``RegistrationView``, be sure to read the implementation and comments in the source code of django-registration first. The relevant bug was fixed in Django 1.9.1, but django-registration will continue to work around it for as long as the Django 1.9 release series is supported. .. class:: ActivationView A subclass of Django's `TemplateView `_ which provides support for a separate account-activation step, in workflows which require that. One method is required: .. method:: activate(*args, **kwargs) Implement your activation logic here. You are free to configure your URL patterns to pass any set of positional or keyword arguments to ``ActivationView``, and they will in turn be passed to this method. This method should return the newly-activated user instance (if activation was successful), or boolean ``False`` if activation was not successful. Useful places to override or customize on an ``ActivationView`` subclass are: .. attribute:: template_name The template to use for user activation. Should be a string. Default value is ``registration/activate.html``. .. method:: get_success_url(user) Return a URL to redirect to after successful registration, on a per-request or per-user basis. If not overridden, will use :attr:`~success_url`. Should return a string containing a (relative) URL, or a string name of a URL pattern, or a 3-tuple of arguments suitable for passing to Django's ``redirect`` shortcut. django-registration-2.2/LICENSE0000644000076700007670000000276312726166473015600 0ustar james00000000000000Copyright (c) 2007-2016, James Bennett All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. * Neither the name of the author nor the names of other contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. django-registration-2.2/MANIFEST.in0000644000076700007670000000024612214057645016313 0ustar james00000000000000include CHANGELOG include INSTALL include LICENSE include MANIFEST.in include README include AUTHORS recursive-include docs * recursive-include registration/locale * django-registration-2.2/PKG-INFO0000644000076700007670000000222613011716531015642 0ustar james00000000000000Metadata-Version: 1.1 Name: django-registration Version: 2.2 Summary: An extensible user-registration application for Django Home-page: https://github.com/ubernostrum/django-registration/ Author: James Bennett Author-email: james@b-list.org License: UNKNOWN Description: UNKNOWN Platform: UNKNOWN Classifier: Development Status :: 5 - Production/Stable Classifier: Environment :: Web Environment Classifier: Framework :: Django Classifier: Framework :: Django :: 1.8 Classifier: Framework :: Django :: 1.9 Classifier: Framework :: Django :: 1.10 Classifier: Intended Audience :: Developers Classifier: License :: OSI Approved :: BSD License Classifier: Operating System :: OS Independent Classifier: Programming Language :: Python Classifier: Topic :: Software Development :: Libraries :: Python Modules Classifier: Programming Language :: Python Classifier: Programming Language :: Python :: 2 Classifier: Programming Language :: Python :: 2.7 Classifier: Programming Language :: Python :: 3 Classifier: Programming Language :: Python :: 3.3 Classifier: Programming Language :: Python :: 3.4 Classifier: Programming Language :: Python :: 3.5 Classifier: Topic :: Utilities django-registration-2.2/README.rst0000644000076700007670000000075313007332734016243 0ustar james00000000000000.. -*-restructuredtext-*- .. image:: https://travis-ci.org/ubernostrum/django-registration.svg?branch=master :target: https://travis-ci.org/ubernostrum/django-registration This is a fairly simple user-registration application for Django, designed to make allowing user signups as painless as possible. It requires a functional installation of Django 1.8 or newer, but has no other dependencies. Full documentation is `available online `_. django-registration-2.2/registration/0000755000076700007670000000000013011716531017255 5ustar james00000000000000django-registration-2.2/registration/__init__.py0000644000076700007670000000123213011716336021367 0ustar james00000000000000VERSION = (2, 2, 0, 'final', 0) def get_version(): """ Returns a PEP 386-compliant version number from VERSION. """ assert len(VERSION) == 5 assert VERSION[3] in ('alpha', 'beta', 'rc', 'final') # Now build the two parts of the version number: # main = X.Y[.Z] # sub = .devN - for pre-alpha releases # | {a|b|c}N - for alpha, beta and rc releases parts = 2 if VERSION[2] == 0 else 3 main = '.'.join(str(x) for x in VERSION[:parts]) sub = '' if VERSION[3] != 'final': mapping = {'alpha': 'a', 'beta': 'b', 'rc': 'c'} sub = mapping[VERSION[3]] + str(VERSION[4]) return str(main + sub) django-registration-2.2/registration/admin.py0000644000076700007670000000342012726166473020736 0ustar james00000000000000""" Admin class for the RegistrationProfile model, providing several conveniences. This is only enabled if 'registration' is in your INSTALLED_APPS setting, which should only occur if you are using the model-based activation workflow. """ from django.apps import apps from django.contrib import admin from django.contrib.sites.shortcuts import get_current_site from django.utils.translation import ugettext_lazy as _ from registration.models import RegistrationProfile class RegistrationAdmin(admin.ModelAdmin): actions = ['activate_users', 'resend_activation_email'] list_display = ('user', 'activation_key_expired') raw_id_fields = ['user'] search_fields = ('user__username', 'user__first_name', 'user__last_name') def activate_users(self, request, queryset): """ Activate the selected users, if they are not alrady activated. """ for profile in queryset: RegistrationProfile.objects.activate_user(profile.activation_key) activate_users.short_description = _(u"Activate users") def resend_activation_email(self, request, queryset): """ Re-send activation emails for the selected users. Note that this will *only* send activation emails for users who are eligible to activate; emails will not be sent to users whose activation keys have expired or who have already activated. """ for profile in queryset: if not profile.activation_key_expired(): profile.send_activation_email( get_current_site(request) ) resend_activation_email.short_description = _(u"Re-send activation emails") if apps.is_installed('registration'): admin.site.register(RegistrationProfile, RegistrationAdmin) django-registration-2.2/registration/auth_urls.py0000644000076700007670000000342112726166473021655 0ustar james00000000000000""" URL patterns for the views included in ``django.contrib.auth``. Including these URLs (via the ``include()`` directive) will set up these patterns based at whatever URL prefix they are included under. The URLconfs in the built-in registration workflows already have an ``include()`` for these URLs, so if you're using one of them it is not necessary to manually include these views. """ from django.conf.urls import url from django.contrib.auth import views as auth_views urlpatterns = [ url(r'^login/$', auth_views.login, {'template_name': 'registration/login.html'}, name='auth_login'), url(r'^logout/$', auth_views.logout, {'template_name': 'registration/logout.html'}, name='auth_logout'), url(r'^password/change/$', auth_views.password_change, {'post_change_redirect': 'auth_password_change_done'}, name='auth_password_change'), url(r'^password/change/done/$', auth_views.password_change_done, name='auth_password_change_done'), url(r'^password/reset/$', auth_views.password_reset, {'post_reset_redirect': 'auth_password_reset_done', 'email_template_name': 'registration/password_reset_email.txt'}, name='auth_password_reset'), url(r'^password/reset/confirm/(?P[0-9A-Za-z_\-]+)/' r'(?P[0-9A-Za-z]{1,13}-[0-9A-Za-z]{1,20})/$', auth_views.password_reset_confirm, {'post_reset_redirect': 'auth_password_reset_complete'}, name='auth_password_reset_confirm'), url(r'^password/reset/complete/$', auth_views.password_reset_complete, name='auth_password_reset_complete'), url(r'^password/reset/done/$', auth_views.password_reset_done, name='auth_password_reset_done'), ] django-registration-2.2/registration/backends/0000755000076700007670000000000013011716531021027 5ustar james00000000000000django-registration-2.2/registration/backends/__init__.py0000644000076700007670000000000012214057645023136 0ustar james00000000000000django-registration-2.2/registration/backends/default/0000755000076700007670000000000013011716531022453 5ustar james00000000000000django-registration-2.2/registration/backends/default/__init__.py0000644000076700007670000000117712575163044024603 0ustar james00000000000000""" Backwards-compatible import location for the model-based activation workflow. Formerly this was the default registration workflow of django-registration, and so was found at registration.backends.default. As of the current release, however, it is no longer the default workflow (there is now no default), and has accordingly been moved to registration.backends.model_activation. Attempting to import the views or include() the URLconf found here will raise deprecation warnings to make users aware of this fact, and remind them to modify imports and include()s, as support for this location will be removed in a future release. """ django-registration-2.2/registration/backends/default/urls.py0000644000076700007670000000115512604633610024017 0ustar james00000000000000""" Backwards-compatible support for include()-ing the model-based activation workflow's URLconf. The new location for that URLconf is registration.backends.model_activation.urls. Using include() with registration.backends.default.urls will raise deprecation warnings, and support for it will be removed in a future release. """ import warnings from registration.backends.model_activation import urls as model_urls warnings.warn( "registration.backends.default.urls is deprecated; " "use registration.backends.model_activation.urls instead.", DeprecationWarning ) urlpatterns = model_urls.urlpatterns django-registration-2.2/registration/backends/default/views.py0000644000076700007670000000123212604633610024163 0ustar james00000000000000""" Backwards-compatible support for importing the model-based activation workflow's views. The new location for those views is registration.backends.model_activation.views. Importing from registration.backends.default will raise deprecation warnings, and support for it will be removed in a future release. """ import warnings from registration.backends.model_activation import views as new_location warnings.warn( "registration.backends.default.views is deprecated; " "use registration.backends.model_activation.views instead.", DeprecationWarning ) ActivationView = new_location.ActivationView RegistrationView = new_location.RegistrationView django-registration-2.2/registration/backends/hmac/0000755000076700007670000000000013011716531021737 5ustar james00000000000000django-registration-2.2/registration/backends/hmac/__init__.py0000644000076700007670000000055413007332734024060 0ustar james00000000000000""" A two-step (signup, then activation) registration workflow, using HMAC-signed tokens. To use, include() the provided URLconf -- registration.backends.hmac.urls -- somewhere in your URL configuration. For more details, see the documentation in the docs/ directory of the source-code distribution, or online at https://django-registration.readthedocs.io/ """ django-registration-2.2/registration/backends/hmac/urls.py0000644000076700007670000000226112726166473023317 0ustar james00000000000000""" URLconf for registration and activation, using django-registration's HMAC activation workflow. """ from django.conf.urls import include, url from django.views.generic.base import TemplateView from . import views urlpatterns = [ url(r'^activate/complete/$', TemplateView.as_view( template_name='registration/activation_complete.html' ), name='registration_activation_complete'), # The activation key can make use of any character from the # URL-safe base64 alphabet, plus the colon as a separator. url(r'^activate/(?P[-:\w]+)/$', views.ActivationView.as_view(), name='registration_activate'), url(r'^register/$', views.RegistrationView.as_view(), name='registration_register'), url(r'^register/complete/$', TemplateView.as_view( template_name='registration/registration_complete.html' ), name='registration_complete'), url(r'^register/closed/$', TemplateView.as_view( template_name='registration/registration_closed.html' ), name='registration_disallowed'), url(r'', include('registration.auth_urls')), ] django-registration-2.2/registration/backends/hmac/views.py0000644000076700007670000001202712726166473023470 0ustar james00000000000000""" A two-step (registration followed by activation) workflow, implemented by emailing an HMAC-verified timestamped activation token to the user on signup. """ from django.conf import settings from django.contrib.auth import get_user_model from django.contrib.sites.shortcuts import get_current_site from django.core import signing from django.template.loader import render_to_string from registration import signals from registration.views import ActivationView as BaseActivationView from registration.views import RegistrationView as BaseRegistrationView REGISTRATION_SALT = getattr(settings, 'REGISTRATION_SALT', 'registration') class RegistrationView(BaseRegistrationView): """ Register a new (inactive) user account, generate an activation key and email it to the user. This is different from the model-based activation workflow in that the activation key is simply the username, signed using Django's TimestampSigner, with HMAC verification on activation. """ email_body_template = 'registration/activation_email.txt' email_subject_template = 'registration/activation_email_subject.txt' def register(self, form): new_user = self.create_inactive_user(form) signals.user_registered.send(sender=self.__class__, user=new_user, request=self.request) return new_user def get_success_url(self, user): return ('registration_complete', (), {}) def create_inactive_user(self, form): """ Create the inactive user account and send an email containing activation instructions. """ new_user = form.save(commit=False) new_user.is_active = False new_user.save() self.send_activation_email(new_user) return new_user def get_activation_key(self, user): """ Generate the activation key which will be emailed to the user. """ return signing.dumps( obj=getattr(user, user.USERNAME_FIELD), salt=REGISTRATION_SALT ) def get_email_context(self, activation_key): """ Build the template context used for the activation email. """ return { 'activation_key': activation_key, 'expiration_days': settings.ACCOUNT_ACTIVATION_DAYS, 'site': get_current_site(self.request) } def send_activation_email(self, user): """ Send the activation email. The activation key is simply the username, signed using TimestampSigner. """ activation_key = self.get_activation_key(user) context = self.get_email_context(activation_key) context.update({ 'user': user }) subject = render_to_string(self.email_subject_template, context) # Force subject to a single line to avoid header-injection # issues. subject = ''.join(subject.splitlines()) message = render_to_string(self.email_body_template, context) user.email_user(subject, message, settings.DEFAULT_FROM_EMAIL) class ActivationView(BaseActivationView): """ Given a valid activation key, activate the user's account. Otherwise, show an error message stating the account couldn't be activated. """ def activate(self, *args, **kwargs): # This is safe even if, somehow, there's no activation key, # because unsign() will raise BadSignature rather than # TypeError on a value of None. username = self.validate_key(kwargs.get('activation_key')) if username is not None: user = self.get_user(username) if user is not None: user.is_active = True user.save() return user return False def get_success_url(self, user): return ('registration_activation_complete', (), {}) def validate_key(self, activation_key): """ Verify that the activation key is valid and within the permitted activation time window, returning the username if valid or ``None`` if not. """ try: username = signing.loads( activation_key, salt=REGISTRATION_SALT, max_age=settings.ACCOUNT_ACTIVATION_DAYS * 86400 ) return username # SignatureExpired is a subclass of BadSignature, so this will # catch either one. except signing.BadSignature: return None def get_user(self, username): """ Given the verified username, look up and return the corresponding user account if it exists, or ``None`` if it doesn't. """ User = get_user_model() lookup_kwargs = { User.USERNAME_FIELD: username, 'is_active': False } try: user = User.objects.get(**lookup_kwargs) return user except User.DoesNotExist: return None django-registration-2.2/registration/backends/model_activation/0000755000076700007670000000000013011716531024350 5ustar james00000000000000django-registration-2.2/registration/backends/model_activation/__init__.py0000644000076700007670000000070713007332734026471 0ustar james00000000000000""" A two-step (signup, then activation) registration workflow, using a model to store the activation key. To use, add 'registration' to your INSTALLED_APPS, run migrations and include() the provided URLconf -- registration.backends.model_activation.urls -- somewhere in your URL configuration. For more details, see the documentation in the docs/ directory of the source-code distribution, or online at https://django-registration.readthedocs.io/ """ django-registration-2.2/registration/backends/model_activation/urls.py0000644000076700007670000000246512726166473025736 0ustar james00000000000000""" URLconf for registration and activation, using django-registration's two-step model-based activation workflow. """ from django.conf.urls import include, url from django.views.generic.base import TemplateView from . import views urlpatterns = [ url(r'^activate/complete/$', TemplateView.as_view( template_name='registration/activation_complete.html' ), name='registration_activation_complete'), # Activation keys get matched by \w+ instead of the more specific # [a-fA-F0-9]{40} because a bad activation key should still get to # the view; that way it can return a sensible "invalid key" # message instead of a confusing 404. url(r'^activate/(?P\w+)/$', views.ActivationView.as_view(), name='registration_activate'), url(r'^register/$', views.RegistrationView.as_view(), name='registration_register'), url(r'^register/complete/$', TemplateView.as_view( template_name='registration/registration_complete.html' ), name='registration_complete'), url(r'^register/closed/$', TemplateView.as_view( template_name='registration/registration_closed.html' ), name='registration_disallowed'), url(r'', include('registration.auth_urls')), ] django-registration-2.2/registration/backends/model_activation/views.py0000644000076700007670000000343212614556316026074 0ustar james00000000000000""" A two-step (registration followed by activation) workflow, implemented by storing an activation key in a model and emailing the key to the user. This workflow is provided primarily for backwards-compatibility with existing installations; new installs of django-registration should look into the HMAC activation workflow in registration.backends.hmac. """ from django.contrib.sites.shortcuts import get_current_site from registration import signals from registration.models import RegistrationProfile from registration.views import ActivationView as BaseActivationView from registration.views import RegistrationView as BaseRegistrationView class RegistrationView(BaseRegistrationView): """ Register a new (inactive) user account, generate and store an activation key, and email it to the user. """ def register(self, form): new_user = RegistrationProfile.objects.create_inactive_user( form, site=get_current_site(self.request) ) signals.user_registered.send(sender=self.__class__, user=new_user, request=self.request) return new_user def get_success_url(self, user): return ('registration_complete', (), {}) class ActivationView(BaseActivationView): """ Given a valid activation key, activate the user's account. Otherwise, show an error message stating the account couldn't be activated. """ def activate(self, *args, **kwargs): activation_key = kwargs.get('activation_key') activated_user = RegistrationProfile.objects.activate_user( activation_key ) return activated_user def get_success_url(self, user): return ('registration_activation_complete', (), {}) django-registration-2.2/registration/backends/simple/0000755000076700007670000000000013011716531022320 5ustar james00000000000000django-registration-2.2/registration/backends/simple/__init__.py0000644000076700007670000000057413007332734024443 0ustar james00000000000000""" A one-step registration workflow, in which a user signs up and is immediately active and logged in. To use, include() the provided URLconf -- registration.backends.simple.urls -- somewhere in your URL configuration. For more details, see the documentation in the docs/ directory of the source-code distribution, or online at https://django-registration.readthedocs.io/ """ django-registration-2.2/registration/backends/simple/urls.py0000644000076700007670000000105412726166473023677 0ustar james00000000000000""" URLconf for registration using django-registration's simple one-step workflow. """ from django.conf.urls import include, url from django.views.generic.base import TemplateView from . import views urlpatterns = [ url(r'^register/$', views.RegistrationView.as_view(), name='registration_register'), url(r'^register/closed/$', TemplateView.as_view( template_name='registration/registration_closed.html' ), name='registration_disallowed'), url(r'', include('registration.auth_urls')), ] django-registration-2.2/registration/backends/simple/views.py0000644000076700007670000000204412614563136024040 0ustar james00000000000000""" A one-step (user signs up and is immediately active and logged in) workflow. """ from django.contrib.auth import authenticate, get_user_model, login from registration import signals from registration.views import RegistrationView as BaseRegistrationView User = get_user_model() class RegistrationView(BaseRegistrationView): """ Registration via the simplest possible process: a user supplies a username, email address and password (the bare minimum for a useful account), and is immediately signed up and logged in). """ def register(self, form): new_user = form.save() new_user = authenticate( username=getattr(new_user, User.USERNAME_FIELD), password=form.cleaned_data['password1'] ) login(self.request, new_user) signals.user_registered.send(sender=self.__class__, user=new_user, request=self.request) return new_user def get_success_url(self, user): return '/' django-registration-2.2/registration/forms.py0000644000076700007670000001163512727400212020762 0ustar james00000000000000""" Forms and validation code for user registration. Note that all of these forms assume your user model is similar in structure to Django's default User class. If your user model is significantly different, you may need to write your own form class; see the documentation for notes on custom user models with django-registration. """ from django import forms from django.contrib.auth import get_user_model from django.contrib.auth.forms import UserCreationForm from django.core.exceptions import ValidationError from django.utils.translation import ugettext_lazy as _ from . import validators User = get_user_model() class RegistrationForm(UserCreationForm): """ Form for registering a new user account. Validates that the requested username is not already in use, and requires the password to be entered twice to catch typos. Subclasses should feel free to add any additional validation they need, but should take care when overriding ``save()`` to respect the ``commit=False`` argument, as several registration workflows will make use of it to create inactive user accounts. """ # Explicitly declared here because Django's default # UserCreationForm, which we subclass, does not require this field # but workflows in django-registration which involve explicit # activation step do require it. If you need an optional email # field, simply subclass and declare the field not required. email = forms.EmailField( help_text=_(u'email address'), required=True ) class Meta(UserCreationForm.Meta): fields = [ User.USERNAME_FIELD, 'email', 'password1', 'password2' ] required_css_class = 'required' def clean(self): """ Apply the reserved-name validator to the username. """ # This is done in clean() because Django does not currently # have a non-ugly way to just add a validator to an existing # field on a form when subclassing; the standard approach is # to re-declare the entire field in order to specify the # validator. That's not an option here because we're dealing # with the user model and we don't know -- given custom users # -- how to declare the username field. # # So defining clean() and attaching the error message (if # there is one) to the username field is the least-ugly # solution. username_value = self.cleaned_data.get(User.USERNAME_FIELD) if username_value is not None: try: if hasattr(self, 'reserved_names'): reserved_names = self.reserved_names else: reserved_names = validators.DEFAULT_RESERVED_NAMES validator = validators.ReservedNameValidator( reserved_names=reserved_names ) validator(username_value) except ValidationError as v: self.add_error(User.USERNAME_FIELD, v) super(RegistrationForm, self).clean() class RegistrationFormTermsOfService(RegistrationForm): """ Subclass of ``RegistrationForm`` which adds a required checkbox for agreeing to a site's Terms of Service. """ tos = forms.BooleanField( widget=forms.CheckboxInput, label=_(u'I have read and agree to the Terms of Service'), error_messages={ 'required': validators.TOS_REQUIRED, } ) class RegistrationFormUniqueEmail(RegistrationForm): """ Subclass of ``RegistrationForm`` which enforces uniqueness of email addresses. """ def clean_email(self): """ Validate that the supplied email address is unique for the site. """ if User.objects.filter(email__iexact=self.cleaned_data['email']): raise forms.ValidationError(validators.DUPLICATE_EMAIL) return self.cleaned_data['email'] class RegistrationFormNoFreeEmail(RegistrationForm): """ Subclass of ``RegistrationForm`` which disallows registration with email addresses from popular free webmail services; moderately useful for preventing automated spam registrations. To change the list of banned domains, pass a list of domains as the keyword argument ``bad_domains`` when initializing the form. """ bad_domains = ['aim.com', 'aol.com', 'email.com', 'gmail.com', 'googlemail.com', 'hotmail.com', 'hushmail.com', 'msn.com', 'mail.ru', 'mailinator.com', 'live.com', 'yahoo.com'] def clean_email(self): """ Check the supplied email address against a list of known free webmail domains. """ email_domain = self.cleaned_data['email'].split('@')[1] if email_domain in self.bad_domains: raise forms.ValidationError(validators.FREE_EMAIL) return self.cleaned_data['email'] django-registration-2.2/registration/locale/0000755000076700007670000000000013011716531020514 5ustar james00000000000000django-registration-2.2/registration/locale/ar/0000755000076700007670000000000013011716531021116 5ustar james00000000000000django-registration-2.2/registration/locale/ar/LC_MESSAGES/0000755000076700007670000000000013011716531022703 5ustar james00000000000000django-registration-2.2/registration/locale/ar/LC_MESSAGES/django.mo0000644000076700007670000000412712214057645024516 0ustar james00000000000000x-y_N6V;') *8ARg}5CQ1l:@+l, "(  2?   I have read and agree to the Terms of ServiceRegistration using free email addresses is prohibited. Please supply a different email address.This email address is already in use. Please supply a different email address.This username is already taken. Please choose another.Usernames can only contain letters, numbers and underscoresYou must agree to the terms to registerYou must type the same password each timeactivation keyemail addresspasswordpassword (again)registration profileregistration profilesuserusernameProject-Id-Version: PACKAGE VERSION Report-Msgid-Bugs-To: POT-Creation-Date: 2007-09-19 19:30-0500 PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE Last-Translator: FULL NAME Language-Team: LANGUAGE MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit أقر بقراءة والموافقة على شروط الخدمةيمنع التسجيل باستخدام عناوين بريد الكترونية مجانية. يرجى تزويد عنوان بريد الكتروني مختلف.عنوان البريد الالكتروني مسجل مسبقا. يرجى تزويد عنوان بريد الكتروني مختلف.اسم المستخدم مسجل مسبقا. يرجى اختيار اسم اخر.يمكن أن يحتوي اسم المستخدم على احرف، ارقام وشرطات سطرية فقطيجب الموافقة على الشروط للتسجيليجب ادخال كلمة المرور مطابقة كل مرةرمز التفعيلعنوان البريد الالكترونيكلمة المرورتأكيد كلمة المرورملف التسجيل الشخصيملفات التسجيل الشخصيةمستخدماسم المستخدمdjango-registration-2.2/registration/locale/ar/LC_MESSAGES/django.po0000644000076700007670000000474312214057645024525 0ustar james00000000000000# SOME DESCRIPTIVE TITLE. # Copyright (C) YEAR THE PACKAGE'S COPYRIGHT HOLDER # This file is distributed under the same license as the PACKAGE package. # FIRST AUTHOR , YEAR. # #, fuzzy msgid "" msgstr "" "Project-Id-Version: PACKAGE VERSION\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2007-09-19 19:30-0500\n" "PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" "Last-Translator: FULL NAME \n" "Language-Team: LANGUAGE \n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=UTF-8\n" "Content-Transfer-Encoding: 8bit\n" #: forms.py:38 msgid "username" msgstr "اسم المستخدم" #: forms.py:41 msgid "email address" msgstr "عنوان البريد الالكتروني" #: forms.py:43 msgid "password" msgstr "كلمة المرور" #: forms.py:45 msgid "password (again)" msgstr "تأكيد كلمة المرور" #: forms.py:54 msgid "Usernames can only contain letters, numbers and underscores" msgstr "يمكن أن يحتوي اسم المستخدم على احرف، ارقام وشرطات سطرية فقط" #: forms.py:59 msgid "This username is already taken. Please choose another." msgstr "اسم المستخدم مسجل مسبقا. يرجى اختيار اسم اخر." #: forms.py:68 msgid "You must type the same password each time" msgstr "يجب ادخال كلمة المرور مطابقة كل مرة" #: forms.py:96 msgid "I have read and agree to the Terms of Service" msgstr "أقر بقراءة والموافقة على شروط الخدمة" #: forms.py:105 msgid "You must agree to the terms to register" msgstr "يجب الموافقة على الشروط للتسجيل" #: forms.py:124 msgid "" "This email address is already in use. Please supply a different email " "address." msgstr "عنوان البريد الالكتروني مسجل مسبقا. يرجى تزويد عنوان بريد الكتروني مختلف." #: forms.py:149 msgid "" "Registration using free email addresses is prohibited. Please supply a " "different email address." msgstr "يمنع التسجيل باستخدام عناوين بريد الكترونية مجانية. يرجى تزويد عنوان بريد الكتروني مختلف." #: models.py:188 msgid "user" msgstr "مستخدم" #: models.py:189 msgid "activation key" msgstr "رمز التفعيل" #: models.py:194 msgid "registration profile" msgstr "ملف التسجيل الشخصي" #: models.py:195 msgid "registration profiles" msgstr "ملفات التسجيل الشخصية" django-registration-2.2/registration/locale/bg/0000755000076700007670000000000013011716531021104 5ustar james00000000000000django-registration-2.2/registration/locale/bg/LC_MESSAGES/0000755000076700007670000000000013011716531022671 5ustar james00000000000000django-registration-2.2/registration/locale/bg/LC_MESSAGES/django.mo0000644000076700007670000000437612214057645024512 0ustar james00000000000000x-y_N6V;') *8ARg}sbbyZ{h_; % CP)p+"   I have read and agree to the Terms of ServiceRegistration using free email addresses is prohibited. Please supply a different email address.This email address is already in use. Please supply a different email address.This username is already taken. Please choose another.Usernames can only contain letters, numbers and underscoresYou must agree to the terms to registerYou must type the same password each timeactivation keyemail addresspasswordpassword (again)registration profileregistration profilesuserusernameProject-Id-Version: PACKAGE VERSION Report-Msgid-Bugs-To: POT-Creation-Date: 2007-09-19 19:30-0500 PO-Revision-Date: 2008-03-05 12:37+0200 Last-Translator: Vladislav Language-Team: LANGUAGE MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit X-Poedit-Bookmarks: -1,-1,-1,-1,10,-1,-1,-1,-1,-1 Прочел съм и съм съгласен с условията за експлоатацияРегистрациите с безплатни адреси е забранен. Моля въведете различен адрес за електронна пощаАдреса на електронната поща е използван. Моля въведете друг адрес.Потребителското име е заето. Моля изберето друго.Потребителските имена могат да съдържат букви, цифри и подчертавкиТрябва да сте съгласни с условията за да се регистрирате.Грешка при проверка на паролата.Ключ за активацияЕлектронна пощаПаролаПарола (проверка)регистрационен профилрегистрационни профилиПотребителПотребителско име django-registration-2.2/registration/locale/bg/LC_MESSAGES/django.po0000644000076700007670000000517212214057645024510 0ustar james00000000000000# SOME DESCRIPTIVE TITLE. # Copyright (C) YEAR THE PACKAGE'S COPYRIGHT HOLDER # This file is distributed under the same license as the PACKAGE package. # FIRST AUTHOR , YEAR. # msgid "" msgstr "" "Project-Id-Version: PACKAGE VERSION\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2007-09-19 19:30-0500\n" "PO-Revision-Date: 2008-03-05 12:37+0200\n" "Last-Translator: Vladislav \n" "Language-Team: LANGUAGE \n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=UTF-8\n" "Content-Transfer-Encoding: 8bit\n" "X-Poedit-Bookmarks: -1,-1,-1,-1,10,-1,-1,-1,-1,-1\n" #: forms.py:38 msgid "username" msgstr "Потребителско име " #: forms.py:41 msgid "email address" msgstr "Електронна поща" #: forms.py:43 msgid "password" msgstr "Парола" #: forms.py:45 msgid "password (again)" msgstr "Парола (проверка)" #: forms.py:54 msgid "Usernames can only contain letters, numbers and underscores" msgstr "Потребителските имена могат да съдържат букви, цифри и подчертавки" #: forms.py:59 msgid "This username is already taken. Please choose another." msgstr "Потребителското име е заето. Моля изберето друго." #: forms.py:68 msgid "You must type the same password each time" msgstr "Грешка при проверка на паролата." #: forms.py:96 msgid "I have read and agree to the Terms of Service" msgstr "Прочел съм и съм съгласен с условията за експлоатация" #: forms.py:105 msgid "You must agree to the terms to register" msgstr "Трябва да сте съгласни с условията за да се регистрирате." #: forms.py:124 msgid "This email address is already in use. Please supply a different email address." msgstr "Адреса на електронната поща е използван. Моля въведете друг адрес." #: forms.py:149 msgid "Registration using free email addresses is prohibited. Please supply a different email address." msgstr "Регистрациите с безплатни адреси е забранен. Моля въведете различен адрес за електронна поща" #: models.py:188 msgid "user" msgstr "Потребител" #: models.py:189 msgid "activation key" msgstr "Ключ за активация" #: models.py:194 msgid "registration profile" msgstr "регистрационен профил" #: models.py:195 msgid "registration profiles" msgstr "регистрационни профили" django-registration-2.2/registration/locale/ca/0000755000076700007670000000000013011716531021077 5ustar james00000000000000django-registration-2.2/registration/locale/ca/LC_MESSAGES/0000755000076700007670000000000013011716531022664 5ustar james00000000000000django-registration-2.2/registration/locale/ca/LC_MESSAGES/django.mo0000644000076700007670000000364112214057645024477 0ustar james00000000000000<)-(9_S%N>(g'pj$Bgw2~ `,RPD >"as     A user with that username already exists.Activate usersE-mailI have read and agree to the Terms of ServicePasswordPassword (again)Re-send activation emailsRegistration using free email addresses is prohibited. Please supply a different email address.The two password fields didn't match.This email address is already in use. Please supply a different email address.This value must contain only letters, numbers and underscores.UsernameYou must agree to the terms to registeractivation keyregistration profileregistration profilesuserProject-Id-Version: django-registration 0.8 Report-Msgid-Bugs-To: POT-Creation-Date: 2011-07-17 11:04+0200 PO-Revision-Date: 2010-09-24 23:21+0100 Last-Translator: Carles Barrobés i Meix Language-Team: Català Language: MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit X-Poedit-Language: Catalan Ja existeix un usuari amb aquest nomActivar usuarisE-mailHe llegit i estic d'acord amb les condicions d'úsContrasenyaContrasenya (de nou)Re-enviar e-mails d'activacióEstà prohibit registrar-se utilitzant adreces d'e-mail gratuïtes. Sisplau entreu-ne una altra.Els dos camps de contrasenya no coincideixenAquesta adreça d'e-mail ja està sent utilitzada. Sisplau, entreu-ne una altra.Aquest valor ha de contenir només lletres, números i guions baixosNom d'usuariHeu d'estar d'acord amb les condicions d'ús per registrar-vosclau d'activacióperfil de registreperfils de registreusuaridjango-registration-2.2/registration/locale/ca/LC_MESSAGES/django.po0000644000076700007670000000462612214057645024506 0ustar james00000000000000# Catalan translation for django-registration. # Copyright (C) 2007-2010, James Bennet # This file is distributed under the same license as the django-registration package. # Carles Barrobés , 2010. # msgid "" msgstr "" "Project-Id-Version: django-registration 0.8\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2011-07-17 11:04+0200\n" "PO-Revision-Date: 2010-09-24 23:21+0100\n" "Last-Translator: Carles Barrobés i Meix \n" "Language-Team: Català\n" "Language: \n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=UTF-8\n" "Content-Transfer-Encoding: 8bit\n" "X-Poedit-Language: Catalan\n" #: admin.py:23 msgid "Activate users" msgstr "Activar usuaris" #: admin.py:43 msgid "Re-send activation emails" msgstr "Re-enviar e-mails d'activació" #: forms.py:35 msgid "Username" msgstr "Nom d'usuari" #: forms.py:36 msgid "This value must contain only letters, numbers and underscores." msgstr "Aquest valor ha de contenir només lletres, números i guions baixos" #: forms.py:39 msgid "E-mail" msgstr "E-mail" #: forms.py:41 msgid "Password" msgstr "Contrasenya" #: forms.py:43 msgid "Password (again)" msgstr "Contrasenya (de nou)" #: forms.py:55 msgid "A user with that username already exists." msgstr "Ja existeix un usuari amb aquest nom" #: forms.py:67 msgid "The two password fields didn't match." msgstr "Els dos camps de contrasenya no coincideixen" #: forms.py:78 msgid "I have read and agree to the Terms of Service" msgstr "He llegit i estic d'acord amb les condicions d'ús" #: forms.py:79 msgid "You must agree to the terms to register" msgstr "Heu d'estar d'acord amb les condicions d'ús per registrar-vos" #: forms.py:95 msgid "" "This email address is already in use. Please supply a different email " "address." msgstr "" "Aquesta adreça d'e-mail ja està sent utilitzada. Sisplau, entreu-ne una " "altra." #: forms.py:122 msgid "" "Registration using free email addresses is prohibited. Please supply a " "different email address." msgstr "" "Està prohibit registrar-se utilitzant adreces d'e-mail gratuïtes. Sisplau " "entreu-ne una altra." #: models.py:168 msgid "user" msgstr "usuari" #: models.py:169 msgid "activation key" msgstr "clau d'activació" #: models.py:174 msgid "registration profile" msgstr "perfil de registre" #: models.py:175 msgid "registration profiles" msgstr "perfils de registre" #~ msgid "Email address" #~ msgstr "Adreça d'e-mail" django-registration-2.2/registration/locale/cs/0000755000076700007670000000000013011716531021121 5ustar james00000000000000django-registration-2.2/registration/locale/cs/LC_MESSAGES/0000755000076700007670000000000013011716531022706 5ustar james00000000000000django-registration-2.2/registration/locale/cs/LC_MESSAGES/django.mo0000644000076700007670000000365312214057645024524 0ustar james00000000000000<) -&/@_Z%N>/'nQ)0Zo4 !aNSmEFNav     A user with that username already exists.Activate usersEmail addressI have read and agree to the Terms of ServicePasswordPassword (again)Re-send activation emailsRegistration using free email addresses is prohibited. Please supply a different email address.The two password fields didn't match.This email address is already in use. Please supply a different email address.This value must contain only letters, numbers and underscores.You must agree to the terms to registeractivation keyregistration profileregistration profilesuserusernameProject-Id-Version: PACKAGE VERSION Report-Msgid-Bugs-To: POT-Creation-Date: 2009-10-12 14:09-0500 PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE Last-Translator: Implayo s.r.o. Language-Team: LANGUAGE Language: cs MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Uživatel s tímto jménem již existuje.Aktivovat uživateleE-mailová adresaPřečetl jsem si a souhlasím s podmínkami službyHesloHeslo (znovu)Znovu odeslat aktivační e-mailyPoužívání volných e-mailových adres je zakázáno. Prosím zadejte jinou e-mailovou adresu.Zadaná 2 hesla se neshodují.Tato e-mailová adresa se již používá. Prosím zadejte jinou e-mailovou adresu.Tato hodnota může obsahovat pouze písmena, čísla a podtržítka.Musíte odsouhlasit podmínky služby pro pokračování v registraci.aktivační klíčregistrační profilregistrační profilyuživateluživatelské jménodjango-registration-2.2/registration/locale/cs/LC_MESSAGES/django.po0000644000076700007670000000453112214057645024523 0ustar james00000000000000# SOME DESCRIPTIVE TITLE. # Copyright (C) YEAR THE PACKAGE'S COPYRIGHT HOLDER # This file is distributed under the same license as the PACKAGE package. # FIRST AUTHOR , 2011. # #, fuzzy msgid "" msgstr "" "Project-Id-Version: PACKAGE VERSION\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2009-10-12 14:09-0500\n" "PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" "Last-Translator: Implayo s.r.o. \n" "Language-Team: LANGUAGE \n" "Language: cs\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=UTF-8\n" "Content-Transfer-Encoding: 8bit\n" #: admin.py:23 msgid "Activate users" msgstr "Aktivovat uživatele" #: admin.py:43 msgid "Re-send activation emails" msgstr "Znovu odeslat aktivační e-maily" #: forms.py:35 msgid "username" msgstr "uživatelské jméno" #: forms.py:36 msgid "This value must contain only letters, numbers and underscores." msgstr "Tato hodnota může obsahovat pouze písmena, čísla a podtržítka." #: forms.py:39 msgid "Email address" msgstr "E-mailová adresa" #: forms.py:41 msgid "Password" msgstr "Heslo" #: forms.py:43 msgid "Password (again)" msgstr "Heslo (znovu)" #: forms.py:55 msgid "A user with that username already exists." msgstr "Uživatel s tímto jménem již existuje." #: forms.py:67 msgid "The two password fields didn't match." msgstr "Zadaná 2 hesla se neshodují." #: forms.py:78 msgid "I have read and agree to the Terms of Service" msgstr "Přečetl jsem si a souhlasím s podmínkami služby" #: forms.py:79 msgid "You must agree to the terms to register" msgstr "Musíte odsouhlasit podmínky služby pro pokračování v registraci." #: forms.py:95 msgid "" "This email address is already in use. Please supply a different email " "address." msgstr "" "Tato e-mailová adresa se již používá. Prosím zadejte jinou e-mailovou " "adresu." #: forms.py:122 msgid "" "Registration using free email addresses is prohibited. Please supply a " "different email address." msgstr "" "Používání volných e-mailových adres je zakázáno. Prosím zadejte " "jinou e-mailovou adresu." #: models.py:165 msgid "user" msgstr "uživatel" #: models.py:166 msgid "activation key" msgstr "aktivační klíč" #: models.py:171 msgid "registration profile" msgstr "registrační profil" #: models.py:172 msgid "registration profiles" msgstr "registrační profily" django-registration-2.2/registration/locale/da/0000755000076700007670000000000013011716531021100 5ustar james00000000000000django-registration-2.2/registration/locale/da/LC_MESSAGES/0000755000076700007670000000000013011716531022665 5ustar james00000000000000django-registration-2.2/registration/locale/da/LC_MESSAGES/django.mo0000644000076700007670000000341312214057645024475 0ustar james00000000000000<) -&/@_Z%N>/n'w3 +(9bk}Z @8T 0     A user with that username already exists.Activate usersEmail addressI have read and agree to the Terms of ServicePasswordPassword (again)Re-send activation emailsRegistration using free email addresses is prohibited. Please supply a different email address.The two password fields didn't match.This email address is already in use. Please supply a different email address.This value must contain only letters, numbers and underscores.UsernameYou must agree to the terms to registeractivation keyregistration profileregistration profilesuserProject-Id-Version: django-registration 0.8 Report-Msgid-Bugs-To: POT-Creation-Date: PO-Revision-Date: Last-Translator: Rune Bromer Language-Team: MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Der findes allerede en bruger med dette brugernavn.Aktiver brugereE-mailadresseI har l¾st og accepterer betingelserne.PasswordPassword (gentag)Gensend aktiveringsemailsRegistrering med gratis emailadresser er ikke muligt. V¾lg venligst en anden emailadresseDe 2 passwordfelter er ikke ens.Denne emailadresse er allerede i brug. Benyt venligst en anden. V¾rdien mŒ kun indeholde bogstaver, tal og underscore.BrugernavnDu skal acceptere betingelserne for at registereAktiveringsn¿gleRegistreringsprofilRegistreringprofilerbrugerdjango-registration-2.2/registration/locale/da/LC_MESSAGES/django.po0000644000076700007670000000426412214057645024505 0ustar james00000000000000# SOME DESCRIPTIVE TITLE. # Copyright (C) YEAR THE PACKAGE'S COPYRIGHT HOLDER # This file is distributed under the same license as the PACKAGE package. # Rune Bromer , 2007-2009. # #, fuzzy msgid "" msgstr "" "Project-Id-Version: django-registration 0.8 \n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: \n" "PO-Revision-Date: \n" "Last-Translator: Rune Bromer \n" "Language-Team: \n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=UTF-8\n" "Content-Transfer-Encoding: 8bit\n" #: admin.py:23 msgid "Activate users" msgstr "Aktiver brugere" #: admin.py:43 msgid "Re-send activation emails" msgstr "Gensend aktiveringsemails" #: forms.py:35 msgid "Username" msgstr "Brugernavn" #: forms.py:36 msgid "This value must contain only letters, numbers and underscores." msgstr "V¾rdien mŒ kun indeholde bogstaver, tal og underscore." #: forms.py:39 msgid "Email address" msgstr "E-mailadresse" #: forms.py:41 msgid "Password" msgstr "Password" #: forms.py:43 msgid "Password (again)" msgstr "Password (gentag)" #: forms.py:55 msgid "A user with that username already exists." msgstr "Der findes allerede en bruger med dette brugernavn." #: forms.py:67 msgid "The two password fields didn't match." msgstr "De 2 passwordfelter er ikke ens." #: forms.py:78 msgid "I have read and agree to the Terms of Service" msgstr "I har l¾st og accepterer betingelserne." #: forms.py:79 msgid "You must agree to the terms to register" msgstr "Du skal acceptere betingelserne for at registere" #: forms.py:95 msgid "" "This email address is already in use. Please supply a different email " "address." msgstr "" "Denne emailadresse er allerede i brug. Benyt venligst en anden. " #: forms.py:122 msgid "" "Registration using free email addresses is prohibited. Please supply a " "different email address." msgstr "" "Registrering med gratis emailadresser er ikke muligt. V¾lg venligst en " "anden emailadresse" #: models.py:165 msgid "user" msgstr "bruger" #: models.py:166 msgid "activation key" msgstr "Aktiveringsn¿gle" #: models.py:171 msgid "registration profile" msgstr "Registreringsprofil" #: models.py:172 msgid "registration profiles" msgstr "Registreringprofiler" django-registration-2.2/registration/locale/de/0000755000076700007670000000000013011716531021104 5ustar james00000000000000django-registration-2.2/registration/locale/de/LC_MESSAGES/0000755000076700007670000000000013011716531022671 5ustar james00000000000000django-registration-2.2/registration/locale/de/LC_MESSAGES/django.mo0000644000076700007670000000371712214057645024510 0ustar james00000000000000<) -&/@_Z%N>/n'wF)%Oc;r!t,eWD /G<     A user with that username already exists.Activate usersEmail addressI have read and agree to the Terms of ServicePasswordPassword (again)Re-send activation emailsRegistration using free email addresses is prohibited. Please supply a different email address.The two password fields didn't match.This email address is already in use. Please supply a different email address.This value must contain only letters, numbers and underscores.UsernameYou must agree to the terms to registeractivation keyregistration profileregistration profilesuserProject-Id-Version: django-registration 0.8 Report-Msgid-Bugs-To: POT-Creation-Date: 2009-10-18 21:32+0200 PO-Revision-Date: 2007-09-29 16:50+0200 Last-Translator: Jannis Leidel Language-Team: Deutsch MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Dieser Benutzername ist bereits vergeben.Benutzer aktivierenE-Mail-AdresseIch habe die Nutzungsvereinbarung gelesen und stimme ihr zuPasswortPasswort (wiederholen)Aktivierungs-E-Mail erneut sendenDie Registrierung mit einer kostenlosen E-Mail-Adresse ist untersagt. Bitte geben Sie eine andere E-Mail-Adresse an.Die beiden Passwörter sind nicht identisch.Diese E-Mail-Adresse wird schon genutzt. Bitte geben Sie eine andere E-Mail-Adresse an.Dieser Wert darf nur Buchstaben, Ziffern und Unterstriche enthalten.BenutzernameSie müssen der Nutzungsvereinbarung zustimmen, um sich zu registrierenAktivierungsschlüsselRegistrierungsprofilRegistrierungsprofileBenutzerdjango-registration-2.2/registration/locale/de/LC_MESSAGES/django.po0000644000076700007670000000457212214057645024513 0ustar james00000000000000# SOME DESCRIPTIVE TITLE. # Copyright (C) YEAR THE PACKAGE'S COPYRIGHT HOLDER # This file is distributed under the same license as the PACKAGE package. # Jannis Leidel , 2007-2009. # #, fuzzy msgid "" msgstr "" "Project-Id-Version: django-registration 0.8 \n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2009-10-18 21:32+0200\n" "PO-Revision-Date: 2007-09-29 16:50+0200\n" "Last-Translator: Jannis Leidel \n" "Language-Team: Deutsch \n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=UTF-8\n" "Content-Transfer-Encoding: 8bit\n" #: admin.py:23 msgid "Activate users" msgstr "Benutzer aktivieren" #: admin.py:43 msgid "Re-send activation emails" msgstr "Aktivierungs-E-Mail erneut senden" #: forms.py:35 msgid "Username" msgstr "Benutzername" #: forms.py:36 msgid "This value must contain only letters, numbers and underscores." msgstr "Dieser Wert darf nur Buchstaben, Ziffern und Unterstriche enthalten." #: forms.py:39 msgid "Email address" msgstr "E-Mail-Adresse" #: forms.py:41 msgid "Password" msgstr "Passwort" #: forms.py:43 msgid "Password (again)" msgstr "Passwort (wiederholen)" #: forms.py:55 msgid "A user with that username already exists." msgstr "Dieser Benutzername ist bereits vergeben." #: forms.py:67 msgid "The two password fields didn't match." msgstr "Die beiden Passwörter sind nicht identisch." #: forms.py:78 msgid "I have read and agree to the Terms of Service" msgstr "Ich habe die Nutzungsvereinbarung gelesen und stimme ihr zu" #: forms.py:79 msgid "You must agree to the terms to register" msgstr "Sie müssen der Nutzungsvereinbarung zustimmen, um sich zu registrieren" #: forms.py:95 msgid "" "This email address is already in use. Please supply a different email " "address." msgstr "" "Diese E-Mail-Adresse wird schon genutzt. Bitte geben Sie eine andere E-Mail-" "Adresse an." #: forms.py:122 msgid "" "Registration using free email addresses is prohibited. Please supply a " "different email address." msgstr "" "Die Registrierung mit einer kostenlosen E-Mail-Adresse ist untersagt. Bitte " "geben Sie eine andere E-Mail-Adresse an." #: models.py:165 msgid "user" msgstr "Benutzer" #: models.py:166 msgid "activation key" msgstr "Aktivierungsschlüssel" #: models.py:171 msgid "registration profile" msgstr "Registrierungsprofil" #: models.py:172 msgid "registration profiles" msgstr "Registrierungsprofile" django-registration-2.2/registration/locale/el/0000755000076700007670000000000013011716531021114 5ustar james00000000000000django-registration-2.2/registration/locale/el/LC_MESSAGES/0000755000076700007670000000000013011716531022701 5ustar james00000000000000django-registration-2.2/registration/locale/el/LC_MESSAGES/django.mo0000644000076700007670000000457012214057645024516 0ustar james00000000000000x-y_N6V;') *8ARg}5WbY'oD! 3 Q `    I have read and agree to the Terms of ServiceRegistration using free email addresses is prohibited. Please supply a different email address.This email address is already in use. Please supply a different email address.This username is already taken. Please choose another.Usernames can only contain letters, numbers and underscoresYou must agree to the terms to registerYou must type the same password each timeactivation keyemail addresspasswordpassword (again)registration profileregistration profilesuserusernameProject-Id-Version: PACKAGE VERSION Report-Msgid-Bugs-To: POT-Creation-Date: 2007-09-19 19:30-0500 PO-Revision-Date: 2007-11-14 21:50+0200 Last-Translator: FULL NAME Language-Team: LANGUAGE MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Διάβασα και συμφωνώ με τους Όρους της ΥπηρεσίαςΗ εγγραφή μέσω δωρεάν διευθύνσεων ηλεκτρονικού ταχυδρομείου απαγορεύεται. Παρακαλώ δώστε κάποια άλλη.Η συγκεκριμένη διεύθυνση ηλεκτρονικού ταχυδρομείου χρησιμοποιείται ήδη. Παρακαλώ δώστε κάποια άλλη.Αυτό το όνομα χρήστη χρησιμοποίειται ήδη. Παρακαλώ διαλέξτε ένα άλλο.Τα ονόματα χρηστών μπορούν να περιλαμβάνουν μόνο γράμματα, αριθμούς και υπογραμμίσειςΠρέπει να συμφωνείται με τους όρους για να εγγραφείτεΠρέπει να εισάγετε το ίδιο συνθηματικό κάθε φοράκλειδί ενεργοποίησηςδιεύθυνση ηλεκτρονικού ταχυδρομείουσυνθηματικόσυνθηματικό (ξανά)προφίλ εγγραφήςπροφίλ εγγραφώνχρήστηςόνομα χρήστηdjango-registration-2.2/registration/locale/el/LC_MESSAGES/django.po0000644000076700007670000000543612214057645024523 0ustar james00000000000000# SOME DESCRIPTIVE TITLE. # Copyright (C) YEAR THE PACKAGE'S COPYRIGHT HOLDER # This file is distributed under the same license as the PACKAGE package. # Panos Laganakos , 2007. # #, fuzzy msgid "" msgstr "" "Project-Id-Version: PACKAGE VERSION\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2007-09-19 19:30-0500\n" "PO-Revision-Date: 2007-11-14 21:50+0200\n" "Last-Translator: FULL NAME \n" "Language-Team: LANGUAGE \n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=UTF-8\n" "Content-Transfer-Encoding: 8bit\n" #: forms.py:38 msgid "username" msgstr "όνομα χρήστη" #: forms.py:41 msgid "email address" msgstr "διεύθυνση ηλεκτρονικού ταχυδρομείου" #: forms.py:43 msgid "password" msgstr "συνθηματικό" #: forms.py:45 msgid "password (again)" msgstr "συνθηματικό (ξανά)" #: forms.py:54 msgid "Usernames can only contain letters, numbers and underscores" msgstr "Τα ονόματα χρηστών μπορούν να περιλαμβάνουν μόνο γράμματα, αριθμούς και υπογραμμίσεις" #: forms.py:59 msgid "This username is already taken. Please choose another." msgstr "Αυτό το όνομα χρήστη χρησιμοποίειται ήδη. Παρακαλώ διαλέξτε ένα άλλο." #: forms.py:68 msgid "You must type the same password each time" msgstr "Πρέπει να εισάγετε το ίδιο συνθηματικό κάθε φορά" #: forms.py:96 msgid "I have read and agree to the Terms of Service" msgstr "Διάβασα και συμφωνώ με τους Όρους της Υπηρεσίας" #: forms.py:105 msgid "You must agree to the terms to register" msgstr "Πρέπει να συμφωνείται με τους όρους για να εγγραφείτε" #: forms.py:124 msgid "" "This email address is already in use. Please supply a different email " "address." msgstr "" "Η συγκεκριμένη διεύθυνση ηλεκτρονικού ταχυδρομείου χρησιμοποιείται ήδη. " "Παρακαλώ δώστε κάποια άλλη." #: forms.py:149 msgid "" "Registration using free email addresses is prohibited. Please supply a " "different email address." msgstr "" "Η εγγραφή μέσω δωρεάν διευθύνσεων ηλεκτρονικού ταχυδρομείου απαγορεύεται. ""Παρακαλώ δώστε κάποια άλλη." #: models.py:188 msgid "user" msgstr "χρήστης" #: models.py:189 msgid "activation key" msgstr "κλειδί ενεργοποίησης" #: models.py:194 msgid "registration profile" msgstr "προφίλ εγγραφής" #: models.py:195 msgid "registration profiles" msgstr "προφίλ εγγραφών" django-registration-2.2/registration/locale/en/0000755000076700007670000000000013011716531021116 5ustar james00000000000000django-registration-2.2/registration/locale/en/LC_MESSAGES/0000755000076700007670000000000013011716531022703 5ustar james00000000000000django-registration-2.2/registration/locale/en/LC_MESSAGES/django.mo0000644000076700007670000000055712214057645024521 0ustar james00000000000000$,859Project-Id-Version: PACKAGE VERSION Report-Msgid-Bugs-To: POT-Creation-Date: 2009-10-12 14:09-0500 PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE Last-Translator: FULL NAME Language-Team: LANGUAGE MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit django-registration-2.2/registration/locale/en/LC_MESSAGES/django.po0000644000076700007670000000327112214057645024520 0ustar james00000000000000# SOME DESCRIPTIVE TITLE. # Copyright (C) YEAR THE PACKAGE'S COPYRIGHT HOLDER # This file is distributed under the same license as the PACKAGE package. # FIRST AUTHOR , YEAR. # #, fuzzy msgid "" msgstr "" "Project-Id-Version: PACKAGE VERSION\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2009-10-12 14:09-0500\n" "PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" "Last-Translator: FULL NAME \n" "Language-Team: LANGUAGE \n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=UTF-8\n" "Content-Transfer-Encoding: 8bit\n" #: admin.py:23 msgid "Activate users" msgstr "" #: admin.py:43 msgid "Re-send activation emails" msgstr "" #: forms.py:35 msgid "username" msgstr "" #: forms.py:36 msgid "This value must contain only letters, numbers and underscores." msgstr "" #: forms.py:39 msgid "Email address" msgstr "" #: forms.py:41 msgid "Password" msgstr "" #: forms.py:43 msgid "Password (again)" msgstr "" #: forms.py:55 msgid "A user with that username already exists." msgstr "" #: forms.py:67 msgid "The two password fields didn't match." msgstr "" #: forms.py:78 msgid "I have read and agree to the Terms of Service" msgstr "" #: forms.py:79 msgid "You must agree to the terms to register" msgstr "" #: forms.py:95 msgid "" "This email address is already in use. Please supply a different email " "address." msgstr "" #: forms.py:122 msgid "" "Registration using free email addresses is prohibited. Please supply a " "different email address." msgstr "" #: models.py:165 msgid "user" msgstr "" #: models.py:166 msgid "activation key" msgstr "" #: models.py:171 msgid "registration profile" msgstr "" #: models.py:172 msgid "registration profiles" msgstr "" django-registration-2.2/registration/locale/es/0000755000076700007670000000000013011716531021123 5ustar james00000000000000django-registration-2.2/registration/locale/es/LC_MESSAGES/0000755000076700007670000000000013011716531022710 5ustar james00000000000000django-registration-2.2/registration/locale/es/LC_MESSAGES/django.mo0000644000076700007670000000356512214057645024530 0ustar james00000000000000x-y_N6V;') *8ARg}T,v a>N%1t3  3F[c   I have read and agree to the Terms of ServiceRegistration using free email addresses is prohibited. Please supply a different email address.This email address is already in use. Please supply a different email address.This username is already taken. Please choose another.Usernames can only contain letters, numbers and underscoresYou must agree to the terms to registerYou must type the same password each timeactivation keyemail addresspasswordpassword (again)registration profileregistration profilesuserusernameProject-Id-Version: django-registration 0.3 Report-Msgid-Bugs-To: POT-Creation-Date: 2008-03-11 00:19-0400 PO-Revision-Date: 2008-03-11 00:19-0400 Last-Translator: Ernesto Rico Schmidt Language-Team: Español MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit He leído y acepto los términos de servicioEl registro usando una dirección de correo electrónico gratis está prohibido.Por favor proporciona otra dirección.La dirección de correo electrónico ya está siendo usada. Por favorproporciona otra dirección.Este nombre de usuario ya está ocupado. Por favor escoge otroLos nombres de usuarios sólo pueden contener letras, números y guiones bajosTienes que aceptar los términos para registrarteTienes que introducir la misma contraseña cada vezclave de activacióndirección de coreo electrónicocontraseñacontraseña (otra vez)perfil de registroperfiles de registrousuarionombre de usuariodjango-registration-2.2/registration/locale/es/LC_MESSAGES/django.po0000644000076700007670000000445212214057645024527 0ustar james00000000000000# Spanish translation for django-registration. # Copyright (C) 2007, James Bennet # This file is distributed under the same license as the registration package. # Ernesto Rico Schmidt , 2008. # #, fuzzy msgid "" msgstr "" "Project-Id-Version: django-registration 0.3 \n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2008-03-11 00:19-0400\n" "PO-Revision-Date: 2008-03-11 00:19-0400\n" "Last-Translator: Ernesto Rico Schmidt \n" "Language-Team: Español \n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=UTF-8\n" "Content-Transfer-Encoding: 8bit\n" #: forms.py:38 msgid "username" msgstr "nombre de usuario" #: forms.py:41 msgid "email address" msgstr "dirección de coreo electrónico" #: forms.py:43 msgid "password" msgstr "contraseña" #: forms.py:45 msgid "password (again)" msgstr "contraseña (otra vez)" #: forms.py:54 msgid "Usernames can only contain letters, numbers and underscores" msgstr "Los nombres de usuarios sólo pueden contener letras, números y guiones bajos" #: forms.py:59 msgid "This username is already taken. Please choose another." msgstr "Este nombre de usuario ya está ocupado. Por favor escoge otro" #: forms.py:71 msgid "You must type the same password each time" msgstr "Tienes que introducir la misma contraseña cada vez" #: forms.py:100 msgid "I have read and agree to the Terms of Service" msgstr "He leído y acepto los términos de servicio" #: forms.py:109 msgid "You must agree to the terms to register" msgstr "Tienes que aceptar los términos para registrarte" #: forms.py:128 msgid "" "This email address is already in use. Please supply a different email " "address." msgstr "" "La dirección de correo electrónico ya está siendo usada. Por favor" "proporciona otra dirección." #: forms.py:153 msgid "" "Registration using free email addresses is prohibited. Please supply a " "different email address." msgstr "" "El registro usando una dirección de correo electrónico gratis está prohibido." "Por favor proporciona otra dirección." #: models.py:188 msgid "user" msgstr "usuario" #: models.py:189 msgid "activation key" msgstr "clave de activación" #: models.py:194 msgid "registration profile" msgstr "perfil de registro" #: models.py:195 msgid "registration profiles" msgstr "perfiles de registro" django-registration-2.2/registration/locale/es_AR/0000755000076700007670000000000013011716531021505 5ustar james00000000000000django-registration-2.2/registration/locale/es_AR/LC_MESSAGES/0000755000076700007670000000000013011716531023272 5ustar james00000000000000django-registration-2.2/registration/locale/es_AR/LC_MESSAGES/django.mo0000644000076700007670000000347112214057645025106 0ustar james00000000000000x-y_N6V;') *8ARg}5<iKh>I@=)~  '   I have read and agree to the Terms of ServiceRegistration using free email addresses is prohibited. Please supply a different email address.This email address is already in use. Please supply a different email address.This username is already taken. Please choose another.Usernames can only contain letters, numbers and underscoresYou must agree to the terms to registerYou must type the same password each timeactivation keyemail addresspasswordpassword (again)registration profileregistration profilesuserusernameProject-Id-Version: PACKAGE VERSION Report-Msgid-Bugs-To: POT-Creation-Date: 2007-09-19 19:30-0500 PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE Last-Translator: FULL NAME Language-Team: LANGUAGE MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit He leído y estoy de acuerdo con las Condiciones de ServicioLa registración con un e-mail gratuito está prohibida. Por favor de una dirección de e-mail diferente.Esa dirección de e-mail ya está en uso. Por favor provea otra dirección.Ese nombre de usuario ya está asignado. Por favor elija otro.El nombre de usuario solo puede contener letras, números y guiones bajosDebe estar de acuerdo con las Condiciones para poder registrarseDebe tipear la misma contraseña cada vezclave de activacióndirección de e-mailcontraseñacontraseña (nuevamente)perfil de registroperfiles de registrousuarionombre de usuariodjango-registration-2.2/registration/locale/es_AR/LC_MESSAGES/django.po0000644000076700007670000000433112214057645025105 0ustar james00000000000000# SOME DESCRIPTIVE TITLE. # Copyright (C) 2008 Leonardo Manuel Rocha # This file is distributed under the same license as the PACKAGE package. # FIRST AUTHOR , YEAR. # #, fuzzy msgid "" msgstr "" "Project-Id-Version: PACKAGE VERSION\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2007-09-19 19:30-0500\n" "PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" "Last-Translator: FULL NAME \n" "Language-Team: LANGUAGE \n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=UTF-8\n" "Content-Transfer-Encoding: 8bit\n" #: forms.py:38 msgid "username" msgstr "nombre de usuario" #: forms.py:41 msgid "email address" msgstr "dirección de e-mail" #: forms.py:43 msgid "password" msgstr "contraseña" #: forms.py:45 msgid "password (again)" msgstr "contraseña (nuevamente)" #: forms.py:54 msgid "Usernames can only contain letters, numbers and underscores" msgstr "El nombre de usuario solo puede contener letras, números y guiones bajos" #: forms.py:59 msgid "This username is already taken. Please choose another." msgstr "Ese nombre de usuario ya está asignado. Por favor elija otro." #: forms.py:68 msgid "You must type the same password each time" msgstr "Debe tipear la misma contraseña cada vez" #: forms.py:96 msgid "I have read and agree to the Terms of Service" msgstr "He leído y estoy de acuerdo con las Condiciones de Servicio" #: forms.py:105 msgid "You must agree to the terms to register" msgstr "Debe estar de acuerdo con las Condiciones para poder registrarse" #: forms.py:124 msgid "" "This email address is already in use. Please supply a different email " "address." msgstr "Esa dirección de e-mail ya está en uso. Por favor provea otra " "dirección." #: forms.py:149 msgid "" "Registration using free email addresses is prohibited. Please supply a " "different email address." msgstr "La registración con un e-mail gratuito está prohibida. Por favor " "de una dirección de e-mail diferente." #: models.py:188 msgid "user" msgstr "usuario" #: models.py:189 msgid "activation key" msgstr "clave de activación" #: models.py:194 msgid "registration profile" msgstr "perfil de registro" #: models.py:195 msgid "registration profiles" msgstr "perfiles de registro" django-registration-2.2/registration/locale/fa/0000755000076700007670000000000013011716531021102 5ustar james00000000000000django-registration-2.2/registration/locale/fa/LC_MESSAGES/0000755000076700007670000000000013011716531022667 5ustar james00000000000000django-registration-2.2/registration/locale/fa/LC_MESSAGES/django.mo0000644000076700007670000000417712214057645024507 0ustar james00000000000000x-y_N6V;') *8ARg}dI{_*fd:V3!#< `k   I have read and agree to the Terms of ServiceRegistration using free email addresses is prohibited. Please supply a different email address.This email address is already in use. Please supply a different email address.This username is already taken. Please choose another.Usernames can only contain letters, numbers and underscoresYou must agree to the terms to registerYou must type the same password each timeactivation keyemail addresspasswordpassword (again)registration profileregistration profilesuserusernameProject-Id-Version: django-registration 0.8 Report-Msgid-Bugs-To: POT-Creation-Date: 2007-09-19 19:30-0500 PO-Revision-Date: 2011-11-18 01:11+0330 Last-Translator: Mohsen Mansouryar Language-Team: erixe MIME-Version: 1.0 Content-Type: text/plain; charset=utf-8 Content-Transfer-Encoding: 8bit X-Poedit-Language: Persian X-Poedit-Country: IRAN, ISLAMIC REPUBLIC OF X-Poedit-SourceCharset: utf-8 من شرایط استفاده از این سرویس را مطالعه کرده و می پذیرم.ثبت نام با استفاده از پست های الکترونیکی رایگان امکان پذیر نمی باشد.این آدرس استفاده شده است. لطفا آدرس دیگری ارائه دهید.این نام کاربری گرفته شده است. لطفا نام دیگری انتخاب کنید.نام های کاربری تنها می توانند شامل حرف، رقم و یا _ باشند.شما باید شرایط عضویت را بپذیرید!دو گذرواژه باید مطابق باشند!کد فعالسازیپست الکترونیکیگذرواژهگذرواژه(تکرار)مشخصات ثبت نامپروفایل های ثبت نامکاربرنام کاربریdjango-registration-2.2/registration/locale/fa/LC_MESSAGES/django.po0000644000076700007670000000502112214057645024477 0ustar james00000000000000# SOME DESCRIPTIVE TITLE. # Copyright (C) YEAR THE PACKAGE'S COPYRIGHT HOLDER # This file is distributed under the same license as the PACKAGE package. # Mohsen Mansouryar , 2011. # msgid "" msgstr "" "Project-Id-Version: django-registration 0.8\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2007-09-19 19:30-0500\n" "PO-Revision-Date: 2011-11-18 01:11+0330\n" "Last-Translator: Mohsen Mansouryar \n" "Language-Team: erixe \n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=utf-8\n" "Content-Transfer-Encoding: 8bit\n" "X-Poedit-Language: Persian\n" "X-Poedit-Country: IRAN, ISLAMIC REPUBLIC OF\n" "X-Poedit-SourceCharset: utf-8\n" #: forms.py:38 msgid "username" msgstr "نام کاربری" #: forms.py:41 msgid "email address" msgstr "پست الکترونیکی" #: forms.py:43 msgid "password" msgstr "گذرواژه" #: forms.py:45 msgid "password (again)" msgstr "گذرواژه(تکرار)" #: forms.py:54 msgid "Usernames can only contain letters, numbers and underscores" msgstr "نام های کاربری تنها می توانند شامل حرف، رقم و یا _ باشند." #: forms.py:59 msgid "This username is already taken. Please choose another." msgstr "این نام کاربری گرفته شده است. لطفا نام دیگری انتخاب کنید." #: forms.py:68 msgid "You must type the same password each time" msgstr "دو گذرواژه باید مطابق باشند!" #: forms.py:96 msgid "I have read and agree to the Terms of Service" msgstr "من شرایط استفاده از این سرویس را مطالعه کرده و می پذیرم." #: forms.py:105 msgid "You must agree to the terms to register" msgstr "شما باید شرایط عضویت را بپذیرید!" #: forms.py:124 msgid "This email address is already in use. Please supply a different email address." msgstr "این آدرس استفاده شده است. لطفا آدرس دیگری ارائه دهید." #: forms.py:149 msgid "Registration using free email addresses is prohibited. Please supply a different email address." msgstr "ثبت نام با استفاده از پست های الکترونیکی رایگان امکان پذیر نمی باشد." #: models.py:188 msgid "user" msgstr "کاربر" #: models.py:189 msgid "activation key" msgstr "کد فعالسازی" #: models.py:194 msgid "registration profile" msgstr "مشخصات ثبت نام" #: models.py:195 msgid "registration profiles" msgstr "پروفایل های ثبت نام" django-registration-2.2/registration/locale/fr/0000755000076700007670000000000013011716531021123 5ustar james00000000000000django-registration-2.2/registration/locale/fr/LC_MESSAGES/0000755000076700007670000000000013011716531022710 5ustar james00000000000000django-registration-2.2/registration/locale/fr/LC_MESSAGES/django.mo0000644000076700007670000000373412214057645024526 0ustar james00000000000000<) -&/@_Z%N>/n'wQ)0Zr< ,d,|LF=CO      A user with that username already exists.Activate usersEmail addressI have read and agree to the Terms of ServicePasswordPassword (again)Re-send activation emailsRegistration using free email addresses is prohibited. Please supply a different email address.The two password fields didn't match.This email address is already in use. Please supply a different email address.This value must contain only letters, numbers and underscores.UsernameYou must agree to the terms to registeractivation keyregistration profileregistration profilesuserProject-Id-Version: django-registration 0.8 alpha-1 Report-Msgid-Bugs-To: POT-Creation-Date: 2010-07-01 14:33+0200 PO-Revision-Date: 2010-07-01 14:30+0200 Last-Translator: Patrick Samson Language-Team: Français MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Un utilisateur avec ce nom existe déjà.Active les utilisateursAdresse courrielJ'ai lu et accepté les Conditions Générales d'UtilisationMot de passeMot de passe (vérification)Envoie à nouveau les courriels d'activationL'inscription avec adresse courriel de compte gratuit est interdite. Veuillez en indiquer une autre.Les deux mots de passe ne correspondent pas.Cette adresse courriel est déjà utilisée. Veuillez en indiquer une autre.Cette valeur ne doit contenir que des lettres, chiffres et tirets bas.Nom d'utilisateurVous devez accepter les conditions d'utilisation pour vous inscrireclé d'activationprofil d'inscriptionprofils d'inscriptionutilisateurdjango-registration-2.2/registration/locale/fr/LC_MESSAGES/django.po0000644000076700007670000000467312214057645024534 0ustar james00000000000000# django-registration French translation. # Copyright (C) YEAR THE PACKAGE'S COPYRIGHT HOLDER # This file is distributed under the same license as the django-registration package. # Samuel Adam , 2007. # #, fuzzy msgid "" msgstr "" "Project-Id-Version: django-registration 0.8 alpha-1 \n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2010-07-01 14:33+0200\n" "PO-Revision-Date: 2010-07-01 14:30+0200\n" "Last-Translator: Patrick Samson \n" "Language-Team: Français \n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=UTF-8\n" "Content-Transfer-Encoding: 8bit\n" #: .\admin.py:23 msgid "Activate users" msgstr "Active les utilisateurs" #: .\admin.py:43 msgid "Re-send activation emails" msgstr "Envoie à nouveau les courriels d'activation" #: .\forms.py:35 msgid "Username" msgstr "Nom d'utilisateur" #: .\forms.py:36 msgid "This value must contain only letters, numbers and underscores." msgstr "Cette valeur ne doit contenir que des lettres, chiffres et tirets bas." #: .\forms.py:39 msgid "Email address" msgstr "Adresse courriel" #: .\forms.py:41 msgid "Password" msgstr "Mot de passe" #: .\forms.py:43 msgid "Password (again)" msgstr "Mot de passe (vérification)" #: .\forms.py:55 msgid "A user with that username already exists." msgstr "Un utilisateur avec ce nom existe déjà." #: .\forms.py:67 msgid "The two password fields didn't match." msgstr "Les deux mots de passe ne correspondent pas." #: .\forms.py:78 msgid "I have read and agree to the Terms of Service" msgstr "J'ai lu et accepté les Conditions Générales d'Utilisation" #: .\forms.py:79 msgid "You must agree to the terms to register" msgstr "Vous devez accepter les conditions d'utilisation pour vous inscrire" #: .\forms.py:95 msgid "" "This email address is already in use. Please supply a different email " "address." msgstr "Cette adresse courriel est déjà utilisée. Veuillez en indiquer une autre." #: .\forms.py:122 msgid "" "Registration using free email addresses is prohibited. Please supply a " "different email address." msgstr "" "L'inscription avec adresse courriel de compte gratuit est interdite. " "Veuillez en indiquer une autre." #: .\models.py:165 msgid "user" msgstr "utilisateur" #: .\models.py:166 msgid "activation key" msgstr "clé d'activation" #: .\models.py:171 msgid "registration profile" msgstr "profil d'inscription" #: .\models.py:172 msgid "registration profiles" msgstr "profils d'inscription" django-registration-2.2/registration/locale/he/0000755000076700007670000000000013011716531021110 5ustar james00000000000000django-registration-2.2/registration/locale/he/LC_MESSAGES/0000755000076700007670000000000013011716531022675 5ustar james00000000000000django-registration-2.2/registration/locale/he/LC_MESSAGES/django.mo0000644000076700007670000000355012214057645024507 0ustar james00000000000000x-y_N6V;') *8ARg}*1tg]:e-f9 3 MX   I have read and agree to the Terms of ServiceRegistration using free email addresses is prohibited. Please supply a different email address.This email address is already in use. Please supply a different email address.This username is already taken. Please choose another.Usernames can only contain letters, numbers and underscoresYou must agree to the terms to registerYou must type the same password each timeactivation keyemail addresspasswordpassword (again)registration profileregistration profilesuserusernameProject-Id-Version: registration Report-Msgid-Bugs-To: POT-Creation-Date: 2008-02-10 02:01+0200 PO-Revision-Date: 2008-02-10 02:05+0200 Last-Translator: Meir Kriheli Language-Team: Hebrew MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bitקראתי והסכמתי לתנאי השימושהרישום בעזרת תיבת דואר אלקטרוני חינמית אסור. נא לספק כתובת אחרת.כתובת הדואר האלקטרוני תפוסה כבר. נא לספק כתובת דואר אחרת.שם המשתמש תפוס כבר. נא לבחור אחר.שמות משתמש יכולים להכיל רק אותיות, ספרות וקווים תחתוניםעליך להסכים לתנאי השימושיש להקליד את אותה הסיסמה פעמייםמפתח הפעלהדואר אלקטרוניסיסמהסיסמה (שוב)פרופיל רישוםפרופילי רישוםמשתמששם משתמשdjango-registration-2.2/registration/locale/he/LC_MESSAGES/django.po0000644000076700007670000000440112214057645024506 0ustar james00000000000000# translation of registration. # Copyright (C) 2008 THE registration'S COPYRIGHT HOLDER # This file is distributed under the same license as the registration package. # <>, 2008. # , fuzzy # <>, 2008. # # msgid "" msgstr "" "Project-Id-Version: registration\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2008-02-10 02:01+0200\n" "PO-Revision-Date: 2008-02-10 02:05+0200\n" "Last-Translator: Meir Kriheli \n" "Language-Team: Hebrew\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=UTF-8\n" "Content-Transfer-Encoding: 8bit" #: forms.py:38 msgid "username" msgstr "שם משתמש" #: forms.py:41 msgid "email address" msgstr "דואר אלקטרוני" #: forms.py:43 msgid "password" msgstr "סיסמה" #: forms.py:45 msgid "password (again)" msgstr "סיסמה (שוב)" #: forms.py:54 msgid "Usernames can only contain letters, numbers and underscores" msgstr "שמות משתמש יכולים להכיל רק אותיות, ספרות וקווים תחתונים" #: forms.py:59 msgid "This username is already taken. Please choose another." msgstr "שם המשתמש תפוס כבר. נא לבחור אחר." #: forms.py:64 msgid "You must type the same password each time" msgstr "יש להקליד את אותה הסיסמה פעמיים" #: forms.py:93 msgid "I have read and agree to the Terms of Service" msgstr "קראתי והסכמתי לתנאי השימוש" #: forms.py:102 msgid "You must agree to the terms to register" msgstr "עליך להסכים לתנאי השימוש" #: forms.py:121 msgid "" "This email address is already in use. Please supply a different email " "address." msgstr "" "כתובת הדואר האלקטרוני תפוסה כבר. נא לספק כתובת דואר אחרת." #: forms.py:146 msgid "" "Registration using free email addresses is prohibited. Please supply a " "different email address." msgstr "" "הרישום בעזרת תיבת דואר אלקטרוני חינמית אסור. נא לספק כתובת אחרת." #: models.py:188 msgid "user" msgstr "משתמש" #: models.py:189 msgid "activation key" msgstr "מפתח הפעלה" #: models.py:194 msgid "registration profile" msgstr "פרופיל רישום" #: models.py:195 msgid "registration profiles" msgstr "פרופילי רישום" django-registration-2.2/registration/locale/hr/0000755000076700007670000000000013011716531021125 5ustar james00000000000000django-registration-2.2/registration/locale/hr/LC_MESSAGES/0000755000076700007670000000000013011716531022712 5ustar james00000000000000django-registration-2.2/registration/locale/hr/LC_MESSAGES/django.mo0000644000076700007670000000362312214057645024525 0ustar james00000000000000<) -&/@_Z%N>/'nU!4V j/w"kPLp?;9Mcz    A user with that username already exists.Activate usersEmail addressI have read and agree to the Terms of ServicePasswordPassword (again)Re-send activation emailsRegistration using free email addresses is prohibited. Please supply a different email address.The two password fields didn't match.This email address is already in use. Please supply a different email address.This value must contain only letters, numbers and underscores.You must agree to the terms to registeractivation keyregistration profileregistration profilesuserusernameProject-Id-Version: 0.8.1beta Report-Msgid-Bugs-To: POT-Creation-Date: 2010-12-01 14:09-0500 PO-Revision-Date: 2010-12-01 15:49+0100 Last-Translator: Enis Afgan Language-Team: MIME-Version: 1.0 Content-Type: text/plain; charset=utf-8 Content-Transfer-Encoding: 8bit X-Poedit-Language: Croatian X-Poedit-Country: CROATIA Ovo korisničko ime već postoji.Aktiviraj korisnikeEmail adresaPročitao sam i slažem se s uvijetima uporabe.LozinkaLozinka (ponovno)Ponovno pošlji aktivacijski emailRegistracija gdje se koristi besplati email servis nije dopuštena. Molimo da koristite drugu email adresu.Oba polja za lozinku nisu ista.Ova email adresa je već korištena. Molimo da koristite drugu email adresu.Ova vrijednost mora sadržavati samo slova, brojeve i podvlake.Morate se složiti sa uvijetima uporabe prije registracije.Aktivacijski ključRegistracijski profilRegistracijski profiliKorisnikKorisničko imedjango-registration-2.2/registration/locale/hr/LC_MESSAGES/django.po0000644000076700007670000000443112214057645024526 0ustar james00000000000000# SOME DESCRIPTIVE TITLE. # Copyright (C) YEAR THE PACKAGE'S COPYRIGHT HOLDER # This file is distributed under the same license as the PACKAGE package. # FIRST AUTHOR , YEAR. # msgid "" msgstr "" "Project-Id-Version: 0.8.1beta\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2010-12-01 14:09-0500\n" "PO-Revision-Date: 2010-12-01 15:49+0100\n" "Last-Translator: Enis Afgan \n" "Language-Team: \n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=utf-8\n" "Content-Transfer-Encoding: 8bit\n" "X-Poedit-Language: Croatian\n" "X-Poedit-Country: CROATIA\n" #: admin.py:23 msgid "Activate users" msgstr "Aktiviraj korisnike" #: admin.py:43 msgid "Re-send activation emails" msgstr "Ponovno pošlji aktivacijski email" #: forms.py:35 msgid "username" msgstr "Korisničko ime" #: forms.py:36 msgid "This value must contain only letters, numbers and underscores." msgstr "Ova vrijednost mora sadržavati samo slova, brojeve i podvlake." #: forms.py:39 msgid "Email address" msgstr "Email adresa" #: forms.py:41 msgid "Password" msgstr "Lozinka" #: forms.py:43 msgid "Password (again)" msgstr "Lozinka (ponovno)" #: forms.py:55 msgid "A user with that username already exists." msgstr "Ovo korisničko ime već postoji." #: forms.py:67 msgid "The two password fields didn't match." msgstr "Oba polja za lozinku nisu ista." #: forms.py:78 msgid "I have read and agree to the Terms of Service" msgstr "Pročitao sam i slažem se s uvijetima uporabe." #: forms.py:79 msgid "You must agree to the terms to register" msgstr "Morate se složiti sa uvijetima uporabe prije registracije." #: forms.py:95 msgid "This email address is already in use. Please supply a different email address." msgstr "Ova email adresa je već korištena. Molimo da koristite drugu email adresu." #: forms.py:122 msgid "Registration using free email addresses is prohibited. Please supply a different email address." msgstr "Registracija gdje se koristi besplati email servis nije dopuštena. Molimo da koristite drugu email adresu." #: models.py:165 msgid "user" msgstr "Korisnik" #: models.py:166 msgid "activation key" msgstr "Aktivacijski ključ" #: models.py:171 msgid "registration profile" msgstr "Registracijski profil" #: models.py:172 msgid "registration profiles" msgstr "Registracijski profili"django-registration-2.2/registration/locale/is/0000755000076700007670000000000013011716531021127 5ustar james00000000000000django-registration-2.2/registration/locale/is/LC_MESSAGES/0000755000076700007670000000000013011716531022714 5ustar james00000000000000django-registration-2.2/registration/locale/is/LC_MESSAGES/django.mo0000644000076700007670000000270412214057645024526 0ustar james00000000000000H-I_wN6&)] 8'0MXG@!/Qa is    I have read and agree to the Terms of ServiceRegistration using free email addresses is prohibited. Please supply a different email address.This email address is already in use. Please supply a different email address.This username is already taken. Please choose another.You must type the same password each timeactivation keyemail addresspasswordpassword (again)registration profileregistration profilesuserusernameProject-Id-Version: PACKAGE VERSION Report-Msgid-Bugs-To: POT-Creation-Date: 2009-01-22 12:49+0100 PO-Revision-Date: 2009-01-22 12:49+0100 Last-Translator: Björn Kristinsson Language-Team: Icelandic MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Ég hef lesið og samþykki skilmálanaÓheimilt er að nota ókeypis netföng. Vinsamlegast notaðu annað netfang.Þetta netfang er þegar á skrá. Vinsamlegast notaðu annað netfang.Þetta notendanafn er þegar á skrá. Vinsamlega reyndu annað.Lykilorðin verða að vera eins einkennislykillnetfanglykilorðlykilorð (aftur)skráningarprófíllskráningarprófílarnotandinotandanafndjango-registration-2.2/registration/locale/is/LC_MESSAGES/django.po0000644000076700007670000000355312214057645024534 0ustar james00000000000000# Icelandic translation of django-registration # Copyright (C) YEAR THE PACKAGE'S COPYRIGHT HOLDER # This file is distributed under the same license as the django-registration # package. # Björn Kristinsson , 2009. # #, fuzzy msgid "" msgstr "" "Project-Id-Version: PACKAGE VERSION\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2009-01-22 12:49+0100\n" "PO-Revision-Date: 2009-01-22 12:49+0100\n" "Last-Translator: Björn Kristinsson \n" "Language-Team: Icelandic\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=UTF-8\n" "Content-Transfer-Encoding: 8bit\n" #: forms.py:36 msgid "username" msgstr "notandanafn" #: forms.py:39 msgid "email address" msgstr "netfang" #: forms.py:41 msgid "password" msgstr "lykilorð" #: forms.py:43 msgid "password (again)" msgstr "lykilorð (aftur)" #: forms.py:55 msgid "This username is already taken. Please choose another." msgstr "Þetta notendanafn er þegar á skrá. Vinsamlega reyndu annað." #: forms.py:67 msgid "You must type the same password each time" msgstr "Lykilorðin verða að vera eins " #: forms.py:90 msgid "I have read and agree to the Terms of Service" msgstr "Ég hef lesið og samþykki skilmálana" #: forms.py:107 msgid "" "This email address is already in use. Please supply a different email " "address." msgstr "Þetta netfang er þegar á skrá. Vinsamlegast notaðu annað netfang." #: forms.py:133 msgid "" "Registration using free email addresses is prohibited. Please supply a " "different email address." msgstr "Óheimilt er að nota ókeypis netföng. Vinsamlegast notaðu annað netfang." #: models.py:218 msgid "user" msgstr "notandi" #: models.py:219 msgid "activation key" msgstr "einkennislykill" #: models.py:224 msgid "registration profile" msgstr "skráningarprófíll" #: models.py:225 msgid "registration profiles" msgstr "skráningarprófílar" django-registration-2.2/registration/locale/it/0000755000076700007670000000000013011716531021130 5ustar james00000000000000django-registration-2.2/registration/locale/it/LC_MESSAGES/0000755000076700007670000000000013011716531022715 5ustar james00000000000000django-registration-2.2/registration/locale/it/LC_MESSAGES/django.mo0000644000076700007670000000375512214057645024536 0ustar james00000000000000<) -&/@_Z%N>/n'w! ?/`M$JC b/n     A user with that username already exists.Activate usersEmail addressI have read and agree to the Terms of ServicePasswordPassword (again)Re-send activation emailsRegistration using free email addresses is prohibited. Please supply a different email address.The two password fields didn't match.This email address is already in use. Please supply a different email address.This value must contain only letters, numbers and underscores.UsernameYou must agree to the terms to registeractivation keyregistration profileregistration profilesuserProject-Id-Version: django-registration 0.8 alpha-1 Report-Msgid-Bugs-To: POT-Creation-Date: 2010-07-01 14:33+0200 PO-Revision-Date: 2011-08-04 12:41-0600 Last-Translator: Flavio Curella Language-Team: Italiano MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Plural-Forms: nplurals=2; plural=(n != 1); X-Poedit-Language: Italian X-Poedit-Country: ITALY Questo nome utente è già usato.Attiva utentiindirizzo emailDichiaro di aver letto e di approvare le Condizioni di ServizioPasswordPassword (di nuovo)Re-invia email di attivazioneLa registrazione con indirizzi email gratis non è permessa. Inserisci un altro indirizzo email.Le password inserite non coincidono.Questo indirizzo email è già in uso. Inserisci un altro indirizzo email.Questo valore può contenere solo lettere, numeri e sottolineature.Nome utentePer registrarsi bisogna approvare le condizionichiave di attivazioneprofilo di registrazioneprofili di registrazioneutentedjango-registration-2.2/registration/locale/it/LC_MESSAGES/django.po0000644000076700007670000000473512214057645024540 0ustar james00000000000000# translation of django.po to Italian # Copyright (C) YEAR THE PACKAGE'S COPYRIGHT HOLDER # This file is distributed under the same license as the PACKAGE package. # # Nicola Larosa , 2008. # Flavio Curella , 2011 msgid "" msgstr "" "Project-Id-Version: django-registration 0.8 alpha-1\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2010-07-01 14:33+0200\n" "PO-Revision-Date: 2011-08-04 12:41-0600\n" "Last-Translator: Flavio Curella \n" "Language-Team: Italiano \n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=UTF-8\n" "Content-Transfer-Encoding: 8bit\n" "Plural-Forms: nplurals=2; plural=(n != 1);\n" "X-Poedit-Language: Italian\n" "X-Poedit-Country: ITALY\n" #: .\admin.py:23 msgid "Activate users" msgstr "Attiva utenti" #: .\admin.py:43 msgid "Re-send activation emails" msgstr "Re-invia email di attivazione" #: .\forms.py:35 msgid "Username" msgstr "Nome utente" #: .\forms.py:36 msgid "This value must contain only letters, numbers and underscores." msgstr "Questo valore può contenere solo lettere, numeri e sottolineature." #: .\forms.py:39 msgid "Email address" msgstr "indirizzo email" #: .\forms.py:41 msgid "Password" msgstr "Password" #: .\forms.py:43 msgid "Password (again)" msgstr "Password (di nuovo)" #: .\forms.py:55 msgid "A user with that username already exists." msgstr "Questo nome utente è già usato." #: .\forms.py:67 msgid "The two password fields didn't match." msgstr "Le password inserite non coincidono." #: .\forms.py:78 msgid "I have read and agree to the Terms of Service" msgstr "Dichiaro di aver letto e di approvare le Condizioni di Servizio" #: .\forms.py:79 msgid "You must agree to the terms to register" msgstr "Per registrarsi bisogna approvare le condizioni" #: .\forms.py:95 msgid "This email address is already in use. Please supply a different email address." msgstr "Questo indirizzo email è già in uso. Inserisci un altro indirizzo email." #: .\forms.py:122 msgid "Registration using free email addresses is prohibited. Please supply a different email address." msgstr "La registrazione con indirizzi email gratis non è permessa. Inserisci un altro indirizzo email." #: .\models.py:165 msgid "user" msgstr "utente" #: .\models.py:166 msgid "activation key" msgstr "chiave di attivazione" #: .\models.py:171 msgid "registration profile" msgstr "profilo di registrazione" #: .\models.py:172 msgid "registration profiles" msgstr "profili di registrazione" django-registration-2.2/registration/locale/ja/0000755000076700007670000000000013011716531021106 5ustar james00000000000000django-registration-2.2/registration/locale/ja/LC_MESSAGES/0000755000076700007670000000000013011716531022673 5ustar james00000000000000django-registration-2.2/registration/locale/ja/LC_MESSAGES/django.mo0000644000076700007670000000376312214057645024513 0ustar james00000000000000x-y_N6V;') *8ARg}F6 uf TqE< !Ik     I have read and agree to the Terms of ServiceRegistration using free email addresses is prohibited. Please supply a different email address.This email address is already in use. Please supply a different email address.This username is already taken. Please choose another.Usernames can only contain letters, numbers and underscoresYou must agree to the terms to registerYou must type the same password each timeactivation keyemail addresspasswordpassword (again)registration profileregistration profilesuserusernameProject-Id-Version: django-registration 0.4 Report-Msgid-Bugs-To: POT-Creation-Date: 2007-09-19 19:30-0500 PO-Revision-Date: 2008-01-31 10:20+0900 Last-Translator: Shinya Okano Language-Team: Japanese MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit サービス利用規約を読み、同意します。自由なメールアドレスを使用した登録は禁止されています。他のメールアドレスを指定してください。このメールアドレスは既に使用されています。他のメールアドレスを指定して下さい。このユーザ名は既に使用されています。他のユーザ名を指定してください。ユーザ名には半角英数とアンダースコアのみが使用できます。登録するためには規約に同意する必要があります。同じパスワードを入力する必要があります。アクティベーションキーメールアドレスパスワードパスワード (確認)登録プロファイル登録プロファイルユーザユーザ名django-registration-2.2/registration/locale/ja/LC_MESSAGES/django.po0000644000076700007670000000457112214057645024514 0ustar james00000000000000# SOME DESCRIPTIVE TITLE. # Copyright (C) YEAR THE PACKAGE'S COPYRIGHT HOLDER # This file is distributed under the same license as the PACKAGE package. # Shinya Okano , YEAR. # #, fuzzy msgid "" msgstr "" "Project-Id-Version: django-registration 0.4 \n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2007-09-19 19:30-0500\n" "PO-Revision-Date: 2008-01-31 10:20+0900\n" "Last-Translator: Shinya Okano \n" "Language-Team: Japanese \n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=UTF-8\n" "Content-Transfer-Encoding: 8bit\n" #: forms.py:38 msgid "username" msgstr "ユーザ名" #: forms.py:41 msgid "email address" msgstr "メールアドレス" #: forms.py:43 msgid "password" msgstr "パスワード" #: forms.py:45 msgid "password (again)" msgstr "パスワード (確認)" #: forms.py:54 msgid "Usernames can only contain letters, numbers and underscores" msgstr "ユーザ名には半角英数とアンダースコアのみが使用できます。" #: forms.py:59 msgid "This username is already taken. Please choose another." msgstr "このユーザ名は既に使用されています。他のユーザ名を指定してください。" #: forms.py:68 msgid "You must type the same password each time" msgstr "同じパスワードを入力する必要があります。" #: forms.py:96 msgid "I have read and agree to the Terms of Service" msgstr "サービス利用規約を読み、同意します。" #: forms.py:105 msgid "You must agree to the terms to register" msgstr "登録するためには規約に同意する必要があります。" #: forms.py:124 msgid "This email address is already in use. Please supply a different email address." msgstr "このメールアドレスは既に使用されています。他のメールアドレスを指定して下さい。" #: forms.py:149 msgid "Registration using free email addresses is prohibited. Please supply a different email address." msgstr "自由なメールアドレスを使用した登録は禁止されています。他のメールアドレスを指定してください。" #: models.py:188 msgid "user" msgstr "ユーザ" #: models.py:189 msgid "activation key" msgstr "アクティベーションキー" #: models.py:194 msgid "registration profile" msgstr "登録プロファイル" #: models.py:195 msgid "registration profiles" msgstr "登録プロファイル" django-registration-2.2/registration/locale/ko/0000755000076700007670000000000013011716531021125 5ustar james00000000000000django-registration-2.2/registration/locale/ko/LC_MESSAGES/0000755000076700007670000000000013011716531022712 5ustar james00000000000000django-registration-2.2/registration/locale/ko/LC_MESSAGES/django.mo0000644000076700007670000000363312214057645024526 0ustar james00000000000000<) -&/@_Z%N>/'n>B`q2d1`P:( GUi }    A user with that username already exists.Activate usersEmail addressI have read and agree to the Terms of ServicePasswordPassword (again)Re-send activation emailsRegistration using free email addresses is prohibited. Please supply a different email address.The two password fields didn't match.This email address is already in use. Please supply a different email address.This value must contain only letters, numbers and underscores.You must agree to the terms to registeractivation keyregistration profileregistration profilesuserusernameProject-Id-Version: PACKAGE VERSION Report-Msgid-Bugs-To: POT-Creation-Date: 2009-10-12 14:09-0500 PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE Last-Translator: Young Gyu Park Language-Team: LANGUAGE MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 이미 같은 아이디로 사용자가 등록되어 있습니다.활동 사용자이메일 주소약관을 읽었고 그 내용에 동의합니다.사용자 패스워드패스워드 (재입력)이 메일 제 전송무료 이메일 계정으로 등록하실 수 없습니다. 다른 이메일을 등록해 주세요패스워드가 서로 일치하지 않습니다.이메일이 이미 사용중입니다. 다른 이메일을 등록해 주세요.이 곳에는 숫자, _, 영문 글자만 가능합니다.약관에 동의 하셔야만 합니다.활성화 키등록 프로파일등록 프로파일사용자사용자 아이디django-registration-2.2/registration/locale/ko/LC_MESSAGES/django.po0000644000076700007670000000446512214057645024535 0ustar james00000000000000# SOME DESCRIPTIVE TITLE. # Copyright (C) YEAR THE PACKAGE'S COPYRIGHT HOLDER # This file is distributed under the same license as the PACKAGE package. # Young Gyu Park , 2009. # #, fuzzy msgid "" msgstr "" "Project-Id-Version: PACKAGE VERSION\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2009-10-12 14:09-0500\n" "PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" "Last-Translator: Young Gyu Park \n" "Language-Team: LANGUAGE \n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=UTF-8\n" "Content-Transfer-Encoding: 8bit\n" #: admin.py:23 msgid "Activate users" msgstr "활동 사용자" #: admin.py:43 msgid "Re-send activation emails" msgstr "이 메일 제 전송" #: forms.py:35 msgid "username" msgstr "사용자 아이디" #: forms.py:36 msgid "This value must contain only letters, numbers and underscores." msgstr "이 곳에는 숫자, _, 영문 글자만 가능합니다." #: forms.py:39 msgid "Email address" msgstr "이메일 주소" #: forms.py:41 msgid "Password" msgstr "사용자 패스워드" #: forms.py:43 msgid "Password (again)" msgstr "패스워드 (재입력)" #: forms.py:55 msgid "A user with that username already exists." msgstr "이미 같은 아이디로 사용자가 등록되어 있습니다." #: forms.py:67 msgid "The two password fields didn't match." msgstr "패스워드가 서로 일치하지 않습니다." #: forms.py:78 msgid "I have read and agree to the Terms of Service" msgstr "약관을 읽었고 그 내용에 동의합니다." #: forms.py:79 msgid "You must agree to the terms to register" msgstr "약관에 동의 하셔야만 합니다." #: forms.py:95 msgid "" "This email address is already in use. Please supply a different email " "address." msgstr "이메일이 이미 사용중입니다. 다른 이메일을 등록해 주세요." #: forms.py:122 msgid "" "Registration using free email addresses is prohibited. Please supply a " "different email address." msgstr "무료 이메일 계정으로 등록하실 수 없습니다. 다른 이메일을 등록해 주세요" #: models.py:165 msgid "user" msgstr "사용자" #: models.py:166 msgid "activation key" msgstr "활성화 키" #: models.py:171 msgid "registration profile" msgstr "등록 프로파일" #: models.py:172 msgid "registration profiles" msgstr "등록 프로파일" django-registration-2.2/registration/locale/nb/0000755000076700007670000000000013011716531021113 5ustar james00000000000000django-registration-2.2/registration/locale/nb/LC_MESSAGES/0000755000076700007670000000000013011716531022700 5ustar james00000000000000django-registration-2.2/registration/locale/nb/LC_MESSAGES/django.mo0000644000076700007670000000354312214057645024514 0ustar james00000000000000<) -&/@_Z%N>/n'wB9![ k#y^"-PPB /2F\     A user with that username already exists.Activate usersEmail addressI have read and agree to the Terms of ServicePasswordPassword (again)Re-send activation emailsRegistration using free email addresses is prohibited. Please supply a different email address.The two password fields didn't match.This email address is already in use. Please supply a different email address.This value must contain only letters, numbers and underscores.UsernameYou must agree to the terms to registeractivation keyregistration profileregistration profilesuserProject-Id-Version: django-registration 0.8 Report-Msgid-Bugs-To: POT-Creation-Date: 2010-12-15 21:37+0100 PO-Revision-Date: 2010-12-15 21:37+0100 Last-Translator: jonklo Language-Team: LANGUAGE MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Det eksisterer allerede en bruker med dette brukernavnet.Aktiver brukereE-postadresseJeg har lest og godtar betingelsenePassordPassord (gjenta)Send ny aktiveringsmailRegistrering med gratis e-postadresse er ikke tillatt. Vennligst oppgi en annen e-postadresse.De to passordfeltene er ikke like.Denne e-postadressen er allerede i bruk. Vennligst oppgi en annen e-postadresse.Dette feltet kan bare inneholde bokstaver, nummer og understreker.BrukernavnDu må godta betingelsene for å registrere degaktiveringsnøkkelregistrasjonsprofilregistrasjonsprofilerbrukerdjango-registration-2.2/registration/locale/nb/LC_MESSAGES/django.po0000644000076700007670000000437712214057645024525 0ustar james00000000000000# SOME DESCRIPTIVE TITLE. # Copyright (C) YEAR THE PACKAGE'S COPYRIGHT HOLDER # This file is distributed under the same license as the PACKAGE package. # jonklo , 2010. # #, fuzzy msgid "" msgstr "" "Project-Id-Version: django-registration 0.8\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2010-12-15 21:37+0100\n" "PO-Revision-Date: 2010-12-15 21:37+0100\n" "Last-Translator: jonklo \n" "Language-Team: LANGUAGE \n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=UTF-8\n" "Content-Transfer-Encoding: 8bit\n" #: admin.py:23 msgid "Activate users" msgstr "Aktiver brukere" #: admin.py:43 msgid "Re-send activation emails" msgstr "Send ny aktiveringsmail" #: forms.py:35 msgid "Username" msgstr "Brukernavn" #: forms.py:36 msgid "This value must contain only letters, numbers and underscores." msgstr "Dette feltet kan bare inneholde bokstaver, nummer og understreker." #: forms.py:39 msgid "Email address" msgstr "E-postadresse" #: forms.py:41 msgid "Password" msgstr "Passord" #: forms.py:43 msgid "Password (again)" msgstr "Passord (gjenta)" #: forms.py:55 msgid "A user with that username already exists." msgstr "Det eksisterer allerede en bruker med dette brukernavnet." #: forms.py:67 msgid "The two password fields didn't match." msgstr "De to passordfeltene er ikke like." #: forms.py:78 msgid "I have read and agree to the Terms of Service" msgstr "Jeg har lest og godtar betingelsene" #: forms.py:79 msgid "You must agree to the terms to register" msgstr "Du må godta betingelsene for å registrere deg" #: forms.py:95 msgid "" "This email address is already in use. Please supply a different email " "address." msgstr "Denne e-postadressen er allerede i bruk. Vennligst oppgi en annen " "e-postadresse." #: forms.py:122 msgid "" "Registration using free email addresses is prohibited. Please supply a " "different email address." msgstr "Registrering med gratis e-postadresse er ikke tillatt. Vennligst " "oppgi en annen e-postadresse." #: models.py:168 msgid "user" msgstr "bruker" #: models.py:169 msgid "activation key" msgstr "aktiveringsnøkkel" #: models.py:174 msgid "registration profile" msgstr "registrasjonsprofil" #: models.py:175 msgid "registration profiles" msgstr "registrasjonsprofiler" django-registration-2.2/registration/locale/nl/0000755000076700007670000000000013011716531021125 5ustar james00000000000000django-registration-2.2/registration/locale/nl/LC_MESSAGES/0000755000076700007670000000000013011716531022712 5ustar james00000000000000django-registration-2.2/registration/locale/nl/LC_MESSAGES/django.mo0000644000076700007670000000355212214057645024526 0ustar james00000000000000x-y_N6V;') *8ARg}c3b#QWM0B~,   )< Q[   I have read and agree to the Terms of ServiceRegistration using free email addresses is prohibited. Please supply a different email address.This email address is already in use. Please supply a different email address.This username is already taken. Please choose another.Usernames can only contain letters, numbers and underscoresYou must agree to the terms to registerYou must type the same password each timeactivation keyemail addresspasswordpassword (again)registration profileregistration profilesuserusernameProject-Id-Version: registration Report-Msgid-Bugs-To: POT-Creation-Date: 2008-08-14 13:25+0200 PO-Revision-Date: 2008-08-14 13:25+0200 Last-Translator: Joost Cassee Language-Team: LANGUAGE MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Plural-Forms: nplurals=2; plural=(n != 1); Ik heb de servicevoorwaarden gelezen en ga akkoord.U kunt u niet registreren met een gratis e-mail adres. Kiest u alstublieft een ander e-mail adres.Dit e-mail adres is reeds in gebruik. Kiest u alstublieft een ander e-mail adres.Deze gebruikersnaam is reeds in gebruik. Kiest u alstublieft een andere gebruikersnaam.Gebruikersnamen kunnen alleen letters, nummer en liggende streepjes bevatten.U moet akkoord gaan met de servicevoorwaarden om u te registreren.U moet twee maal hetzelfde wachtwoord typen.activatiecodee-mail adreswachtwoordwachtwoord (opnieuw)registratieprofielregistratieprofielengebruikergebruikersnaamdjango-registration-2.2/registration/locale/nl/LC_MESSAGES/django.po0000644000076700007670000000434712214057645024534 0ustar james00000000000000# SOME DESCRIPTIVE TITLE. # Copyright (C) YEAR THE PACKAGE'S COPYRIGHT HOLDER # This file is distributed under the same license as the PACKAGE package. # FIRST AUTHOR , YEAR. # msgid "" msgstr "" "Project-Id-Version: registration\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2008-08-14 13:25+0200\n" "PO-Revision-Date: 2008-08-14 13:25+0200\n" "Last-Translator: Joost Cassee \n" "Language-Team: LANGUAGE \n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=UTF-8\n" "Content-Transfer-Encoding: 8bit\n" "Plural-Forms: nplurals=2; plural=(n != 1);\n" #: forms.py:38 msgid "username" msgstr "gebruikersnaam" #: forms.py:41 msgid "email address" msgstr "e-mail adres" #: forms.py:43 msgid "password" msgstr "wachtwoord" #: forms.py:45 msgid "password (again)" msgstr "wachtwoord (opnieuw)" #: forms.py:54 msgid "Usernames can only contain letters, numbers and underscores" msgstr "Gebruikersnamen kunnen alleen letters, nummer en liggende streepjes bevatten." #: forms.py:59 msgid "This username is already taken. Please choose another." msgstr "Deze gebruikersnaam is reeds in gebruik. Kiest u alstublieft een andere gebruikersnaam." #: forms.py:71 msgid "You must type the same password each time" msgstr "U moet twee maal hetzelfde wachtwoord typen." #: forms.py:100 msgid "I have read and agree to the Terms of Service" msgstr "Ik heb de servicevoorwaarden gelezen en ga akkoord." #: forms.py:109 msgid "You must agree to the terms to register" msgstr "U moet akkoord gaan met de servicevoorwaarden om u te registreren." #: forms.py:125 msgid "This email address is already in use. Please supply a different email address." msgstr "Dit e-mail adres is reeds in gebruik. Kiest u alstublieft een ander e-mail adres." #: forms.py:151 msgid "Registration using free email addresses is prohibited. Please supply a different email address." msgstr "U kunt u niet registreren met een gratis e-mail adres. Kiest u alstublieft een ander e-mail adres." #: models.py:191 msgid "user" msgstr "gebruiker" #: models.py:192 msgid "activation key" msgstr "activatiecode" #: models.py:197 msgid "registration profile" msgstr "registratieprofiel" #: models.py:198 msgid "registration profiles" msgstr "registratieprofielen" django-registration-2.2/registration/locale/pl/0000755000076700007670000000000013011716531021127 5ustar james00000000000000django-registration-2.2/registration/locale/pl/LC_MESSAGES/0000755000076700007670000000000013011716531022714 5ustar james00000000000000django-registration-2.2/registration/locale/pl/LC_MESSAGES/django.mo0000644000076700007670000000335112214057645024525 0ustar james00000000000000x-y_N6V;') *8ARg}1'_>E7L7 *Al ~    I have read and agree to the Terms of ServiceRegistration using free email addresses is prohibited. Please supply a different email address.This email address is already in use. Please supply a different email address.This username is already taken. Please choose another.Usernames can only contain letters, numbers and underscoresYou must agree to the terms to registerYou must type the same password each timeactivation keyemail addresspasswordpassword (again)registration profileregistration profilesuserusernameProject-Id-Version: 0.4 Report-Msgid-Bugs-To: POT-Creation-Date: 2007-09-19 19:30-0500 PO-Revision-Date: 2007-12-15 12:45+0100 Last-Translator: Jarek Zgoda Language-Team: Polish MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Przeczytałem regulamin i akceptuję goNie ma możliwości rejestracji przy użyciu darmowego adresu email. Użyj innego adresu email.Ten adres email jest już używany. Użyj innego adresu email.Ta nazwa użytkownika jest już zajęta. Wybierz inną.Nazwa użytkownika może zawierać tylko litery, cyfry i znaki podkreśleniaMusisz zaakceptować regulamin, aby się zarejestrowaćMusisz wpisać to samo hasło w obu polachklucz aktywacyjnyadres emailhasłohasło (ponownie)profil rejestracjiprofile rejestracjiużytkowniknazwa użytkownikadjango-registration-2.2/registration/locale/pl/LC_MESSAGES/django.po0000644000076700007670000000424512214057645024533 0ustar james00000000000000# Polish translation for django-registration. # Copyright (C) YEAR THE PACKAGE'S COPYRIGHT HOLDER # This file is distributed under the same license as the django-registration package. # Jarek Zgoda , 2007. # #, fuzzy msgid "" msgstr "" "Project-Id-Version: 0.4\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2007-09-19 19:30-0500\n" "PO-Revision-Date: 2007-12-15 12:45+0100\n" "Last-Translator: Jarek Zgoda \n" "Language-Team: Polish \n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=UTF-8\n" "Content-Transfer-Encoding: 8bit\n" #: forms.py:38 msgid "username" msgstr "nazwa użytkownika" #: forms.py:41 msgid "email address" msgstr "adres email" #: forms.py:43 msgid "password" msgstr "hasło" #: forms.py:45 msgid "password (again)" msgstr "hasło (ponownie)" #: forms.py:54 msgid "Usernames can only contain letters, numbers and underscores" msgstr "" "Nazwa użytkownika może zawierać tylko litery, cyfry i znaki podkreślenia" #: forms.py:59 msgid "This username is already taken. Please choose another." msgstr "Ta nazwa użytkownika jest już zajęta. Wybierz inną." #: forms.py:68 msgid "You must type the same password each time" msgstr "Musisz wpisać to samo hasło w obu polach" #: forms.py:96 msgid "I have read and agree to the Terms of Service" msgstr "Przeczytałem regulamin i akceptuję go" #: forms.py:105 msgid "You must agree to the terms to register" msgstr "Musisz zaakceptować regulamin, aby się zarejestrować" #: forms.py:124 msgid "" "This email address is already in use. Please supply a different email " "address." msgstr "Ten adres email jest już używany. Użyj innego adresu email." #: forms.py:149 msgid "" "Registration using free email addresses is prohibited. Please supply a " "different email address." msgstr "" "Nie ma możliwości rejestracji przy użyciu darmowego adresu email. Użyj " "innego adresu email." #: models.py:188 msgid "user" msgstr "użytkownik" #: models.py:189 msgid "activation key" msgstr "klucz aktywacyjny" #: models.py:194 msgid "registration profile" msgstr "profil rejestracji" #: models.py:195 msgid "registration profiles" msgstr "profile rejestracji" django-registration-2.2/registration/locale/pt/0000755000076700007670000000000013011716531021137 5ustar james00000000000000django-registration-2.2/registration/locale/pt/LC_MESSAGES/0000755000076700007670000000000013011716531022724 5ustar james00000000000000django-registration-2.2/registration/locale/pt/LC_MESSAGES/django.mo0000644000076700007670000000354712214057645024544 0ustar james00000000000000<) -&/@_Z%N>/n'wB9![o.uR!3LU@ 5$8J \     A user with that username already exists.Activate usersEmail addressI have read and agree to the Terms of ServicePasswordPassword (again)Re-send activation emailsRegistration using free email addresses is prohibited. Please supply a different email address.The two password fields didn't match.This email address is already in use. Please supply a different email address.This value must contain only letters, numbers and underscores.UsernameYou must agree to the terms to registeractivation keyregistration profileregistration profilesuserProject-Id-Version: PACKAGE VERSION Report-Msgid-Bugs-To: POT-Creation-Date: 2010-03-26 10:54+0000 PO-Revision-Date: 2011-01-24 12:20+0000 Last-Translator: Nuno Mariz Language-Team: Nuno Mariz MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Um utilizador com o mesmo nome já se encontra registado.Ativar utilizadoresEmailEu li e concordo com as Condiçoes de ServiçoPasswordPassword (novamente)Reenviar emails de ativaçãoO registo com emails gratuitos é proibido. Por favor forneça um email diferente.As duas passwords não coincidem.Este email já se encontra registado. Por favor forneça um email diferente.Este valor apenas deverá conter letras, números e underscores.UtilizadorDeverá concordar com as condições para se registarchave de ativaçãoperfil de registoperfis de registoutilizadordjango-registration-2.2/registration/locale/pt/LC_MESSAGES/django.po0000644000076700007670000000436212214057645024543 0ustar james00000000000000# SOME DESCRIPTIVE TITLE. # Copyright (C) YEAR THE PACKAGE'S COPYRIGHT HOLDER # This file is distributed under the same license as the PACKAGE package. # FIRST AUTHOR , YEAR. # msgid "" msgstr "" "Project-Id-Version: PACKAGE VERSION\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2010-03-26 10:54+0000\n" "PO-Revision-Date: 2011-01-24 12:20+0000\n" "Last-Translator: Nuno Mariz \n" "Language-Team: Nuno Mariz \n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=UTF-8\n" "Content-Transfer-Encoding: 8bit\n" #: admin.py:23 msgid "Activate users" msgstr "Ativar utilizadores" #: admin.py:43 msgid "Re-send activation emails" msgstr "Reenviar emails de ativação" #: forms.py:35 msgid "Username" msgstr "Utilizador" #: forms.py:36 msgid "This value must contain only letters, numbers and underscores." msgstr "Este valor apenas deverá conter letras, números e underscores." #: forms.py:39 msgid "Email address" msgstr "Email" #: forms.py:41 msgid "Password" msgstr "Password" #: forms.py:43 msgid "Password (again)" msgstr "Password (novamente)" #: forms.py:55 msgid "A user with that username already exists." msgstr "Um utilizador com o mesmo nome já se encontra registado." #: forms.py:67 msgid "The two password fields didn't match." msgstr "As duas passwords não coincidem." #: forms.py:78 msgid "I have read and agree to the Terms of Service" msgstr "Eu li e concordo com as Condiçoes de Serviço" #: forms.py:79 msgid "You must agree to the terms to register" msgstr "Deverá concordar com as condições para se registar" #: forms.py:95 msgid "" "This email address is already in use. Please supply a different email " "address." msgstr "Este email já se encontra registado. Por favor forneça um email diferente." #: forms.py:122 msgid "" "Registration using free email addresses is prohibited. Please supply a " "different email address." msgstr "O registo com emails gratuitos é proibido. Por favor forneça um email diferente." #: models.py:168 msgid "user" msgstr "utilizador" #: models.py:169 msgid "activation key" msgstr "chave de ativação" #: models.py:174 msgid "registration profile" msgstr "perfil de registo" #: models.py:175 msgid "registration profiles" msgstr "perfis de registo" django-registration-2.2/registration/locale/pt_BR/0000755000076700007670000000000013011716531021522 5ustar james00000000000000django-registration-2.2/registration/locale/pt_BR/LC_MESSAGES/0000755000076700007670000000000013011716531023307 5ustar james00000000000000django-registration-2.2/registration/locale/pt_BR/LC_MESSAGES/django.mo0000644000076700007670000000340412214057645025117 0ustar james00000000000000 h-i_N6F;}')  (9Ndi5r2n]J;D4)1^  I have read and agree to the Terms of ServiceRegistration using free email addresses is prohibited. Please supply a different email address.This email address is already in use. Please supply a different email address.This username is already taken. Please choose another.Usernames can only contain letters, numbers and underscoresYou must agree to the terms to registerYou must type the same password each timeactivation keyemail addresspassword (again)registration profileregistration profilesuserusernameProject-Id-Version: PACKAGE VERSION Report-Msgid-Bugs-To: POT-Creation-Date: 2007-09-19 19:30-0500 PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE Last-Translator: FULL NAME Language-Team: LANGUAGE MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Eu lí e concordo com os Termos de Uso do serviçoRegistrar-se com contas de email gratuitos está proibido. Por favor, informe um endereço de email diferente.Este endereço de email já está em uso. Por favor, informe um endereço de email diferente.Este nome de usuário já existe. Por favor, escolha outro.Nomes de usuário apenas podem conter letras, números, e underscoreVocê deve concordar com os termos para registrar-seVocê deve escrever a mesma senha nos dois camposchave de ativaçãoendereço de emailsenha (novamente)profile de registroprofiles de registrousuáriousuáriodjango-registration-2.2/registration/locale/pt_BR/LC_MESSAGES/django.po0000644000076700007670000000425112604331402025110 0ustar james00000000000000# SOME DESCRIPTIVE TITLE. # Copyright (C) YEAR THE PACKAGE'S COPYRIGHT HOLDER # This file is distributed under the same license as the PACKAGE package. # FIRST AUTHOR , YEAR. # #, fuzzy msgid "" msgstr "" "Project-Id-Version: PACKAGE VERSION\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2007-09-19 19:30-0500\n" "PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" "Last-Translator: FULL NAME \n" "Language-Team: LANGUAGE \n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=UTF-8\n" "Content-Transfer-Encoding: 8bit\n" #: forms.py:38 msgid "username" msgstr "usuário" #: forms.py:41 msgid "email address" msgstr "endereço de email" #: forms.py:43 msgid "password" msgstr "senha" #: forms.py:45 msgid "password (again)" msgstr "senha (novamente)" #: forms.py:54 msgid "Usernames can only contain letters, numbers and underscores" msgstr "Nomes de usuário apenas podem conter letras, números, e underscore" #: forms.py:59 msgid "This username is already taken. Please choose another." msgstr "Este nome de usuário já existe. Por favor, escolha outro." #: forms.py:68 msgid "You must type the same password each time" msgstr "Você deve escrever a mesma senha nos dois campos" #: forms.py:96 msgid "I have read and agree to the Terms of Service" msgstr "Eu lí e concordo com os Termos de Uso do serviço" #: forms.py:105 msgid "You must agree to the terms to register" msgstr "Você deve concordar com os termos para registrar-se" #: forms.py:124 msgid "" "This email address is already in use. Please supply a different email " "address." msgstr "Este endereço de email já está em uso. Por favor, informe um endereço de email diferente." #: forms.py:149 msgid "" "Registration using free email addresses is prohibited. Please supply a " "different email address." msgstr "Registrar-se com contas de email gratuitos é proibido. Por favor, informe um endereço de email diferente." #: models.py:188 msgid "user" msgstr "usuário" #: models.py:189 msgid "activation key" msgstr "chave de ativação" #: models.py:194 msgid "registration profile" msgstr "perfil de registro" #: models.py:195 msgid "registration profiles" msgstr "perfis de registro" django-registration-2.2/registration/locale/ru/0000755000076700007670000000000013011716531021142 5ustar james00000000000000django-registration-2.2/registration/locale/ru/LC_MESSAGES/0000755000076700007670000000000013011716531022727 5ustar james00000000000000django-registration-2.2/registration/locale/ru/LC_MESSAGES/django.mo0000644000076700007670000000464612214057645024550 0ustar james00000000000000<) -&/@_Z%N>/n'w5P4e,] %29L8fo4\! '= 'e       A user with that username already exists.Activate usersEmail addressI have read and agree to the Terms of ServicePasswordPassword (again)Re-send activation emailsRegistration using free email addresses is prohibited. Please supply a different email address.The two password fields didn't match.This email address is already in use. Please supply a different email address.This value must contain only letters, numbers and underscores.UsernameYou must agree to the terms to registeractivation keyregistration profileregistration profilesuserProject-Id-Version: PACKAGE VERSION Report-Msgid-Bugs-To: POT-Creation-Date: 2009-10-21 20:12+0600 PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE Last-Translator: FULL NAME Language-Team: LANGUAGE MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Пользователь с таким именем уже существует.Активировать учетные записиАдрес электронной почтыЯ прочитал Правила Использования и согласен с нимиПарольПароль (снова)Выслать ключи активации зановоРегистрация с использованием свободных почтовых серверов запрещена. Пожалуйста, введите другой адрес электронной почты.Введенные пароли не совпадают.Этот адрес электронной почты уже используется. Пожалуйста, введите другой адрес.Это поле может содержать только буквы, цифры и подчеркиванияИмя пользователяДля регистрации Вы должны согласиться с Правиламиключ активациикарточка регистрациикарточки регистрациипользовательdjango-registration-2.2/registration/locale/ru/LC_MESSAGES/django.po0000644000076700007670000000547512214057645024554 0ustar james00000000000000# SOME DESCRIPTIVE TITLE. # Copyright (C) YEAR THE PACKAGE'S COPYRIGHT HOLDER # This file is distributed under the same license as the PACKAGE package. # FIRST AUTHOR , YEAR. # msgid "" msgstr "" "Project-Id-Version: PACKAGE VERSION\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2009-10-21 20:12+0600\n" "PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" "Last-Translator: FULL NAME \n" "Language-Team: LANGUAGE \n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=UTF-8\n" "Content-Transfer-Encoding: 8bit\n" #: admin.py:23 msgid "Activate users" msgstr "Активировать учетные записи" #: admin.py:43 msgid "Re-send activation emails" msgstr "Выслать ключи активации заново" #: forms.py:35 msgid "Username" msgstr "Имя пользователя" #: forms.py:36 msgid "This value must contain only letters, numbers and underscores." msgstr "Это поле может содержать только буквы, цифры и подчеркивания" #: forms.py:39 msgid "Email address" msgstr "Адрес электронной почты" #: forms.py:41 msgid "Password" msgstr "Пароль" #: forms.py:43 msgid "Password (again)" msgstr "Пароль (снова)" #: forms.py:55 msgid "A user with that username already exists." msgstr "Пользователь с таким именем уже существует." #: forms.py:67 msgid "The two password fields didn't match." msgstr "Введенные пароли не совпадают." #: forms.py:78 msgid "I have read and agree to the Terms of Service" msgstr "Я прочитал Правила Использования и согласен с ними" #: forms.py:79 msgid "You must agree to the terms to register" msgstr "Для регистрации Вы должны согласиться с Правилами" #: forms.py:95 msgid "" "This email address is already in use. Please supply a different email " "address." msgstr "" "Этот адрес электронной почты уже используется. Пожалуйста, введите другой " "адрес." #: forms.py:122 msgid "" "Registration using free email addresses is prohibited. Please supply a " "different email address." msgstr "" "Регистрация с использованием свободных почтовых серверов запрещена. " "Пожалуйста, введите другой адрес электронной почты." #: models.py:165 msgid "user" msgstr "пользователь" #: models.py:166 msgid "activation key" msgstr "ключ активации" #: models.py:171 msgid "registration profile" msgstr "карточка регистрации" #: models.py:172 msgid "registration profiles" msgstr "карточки регистрации" django-registration-2.2/registration/locale/sl/0000755000076700007670000000000013011716531021132 5ustar james00000000000000django-registration-2.2/registration/locale/sl/LC_MESSAGES/0000755000076700007670000000000013011716531022717 5ustar james00000000000000django-registration-2.2/registration/locale/sl/LC_MESSAGES/django.mo0000644000076700007670000000354112214057645024531 0ustar james00000000000000<) -&/@_Z%N>/'nm1L~%QG3d74/ FP    A user with that username already exists.Activate usersEmail addressI have read and agree to the Terms of ServicePasswordPassword (again)Re-send activation emailsRegistration using free email addresses is prohibited. Please supply a different email address.The two password fields didn't match.This email address is already in use. Please supply a different email address.This value must contain only letters, numbers and underscores.You must agree to the terms to registeractivation keyregistration profileregistration profilesuserusernameProject-Id-Version: 0.8.1beta Report-Msgid-Bugs-To: POT-Creation-Date: 2009-10-12 14:09-0500 PO-Revision-Date: 2011-11-05 21:20+0100 Last-Translator: Marko Mrdjenovic Language-Team: Slovenian MIME-Version: 1.0 Content-Type: text/plain; charset=utf-8 Content-Transfer-Encoding: 8bit X-Poedit-Language: Slovenian X-Poedit-Country: SLOVENIA Uporabnik s tem uporabniškim imenom že obstaja.Aktiviraj uporabnikeE-naslovStrinjam se s pogoji uporabeGesloGeslo (ponovno)Ponovno pošlji aktivacijsko e-poštoRegistracija ni mogoča z brezplačnimi e-naslovi. Prosimo vnesite drug e-naslov.Polji z gesli se ne ujemata.E-naslov je že v uporabi, prosimo vnesite drugega.Vrednost lahko vsebuje samo črke, cifre in podčrtaje.Za registracijo se morate strinjati s pogoji uporabeAktivacijski ključRegistracijski profilRegistracijski profiliUporabnikuporabniško imedjango-registration-2.2/registration/locale/sl/LC_MESSAGES/django.po0000644000076700007670000000435112214057645024534 0ustar james00000000000000# SOME DESCRIPTIVE TITLE. # Copyright (C) YEAR THE PACKAGE'S COPYRIGHT HOLDER # This file is distributed under the same license as the PACKAGE package. # FIRST AUTHOR , YEAR. # msgid "" msgstr "" "Project-Id-Version: 0.8.1beta\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2009-10-12 14:09-0500\n" "PO-Revision-Date: 2011-11-05 21:20+0100\n" "Last-Translator: Marko Mrdjenovic \n" "Language-Team: Slovenian \n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=utf-8\n" "Content-Transfer-Encoding: 8bit\n" "X-Poedit-Language: Slovenian\n" "X-Poedit-Country: SLOVENIA\n" #: admin.py:23 msgid "Activate users" msgstr "Aktiviraj uporabnike" #: admin.py:43 msgid "Re-send activation emails" msgstr "Ponovno pošlji aktivacijsko e-pošto" #: forms.py:35 msgid "username" msgstr "uporabniško ime" #: forms.py:36 msgid "This value must contain only letters, numbers and underscores." msgstr "Vrednost lahko vsebuje samo črke, cifre in podčrtaje." #: forms.py:39 msgid "Email address" msgstr "E-naslov" #: forms.py:41 msgid "Password" msgstr "Geslo" #: forms.py:43 msgid "Password (again)" msgstr "Geslo (ponovno)" #: forms.py:55 msgid "A user with that username already exists." msgstr "Uporabnik s tem uporabniškim imenom že obstaja." #: forms.py:67 msgid "The two password fields didn't match." msgstr "Polji z gesli se ne ujemata." #: forms.py:78 msgid "I have read and agree to the Terms of Service" msgstr "Strinjam se s pogoji uporabe" #: forms.py:79 msgid "You must agree to the terms to register" msgstr "Za registracijo se morate strinjati s pogoji uporabe" #: forms.py:95 msgid "This email address is already in use. Please supply a different email address." msgstr "E-naslov je že v uporabi, prosimo vnesite drugega." #: forms.py:122 msgid "Registration using free email addresses is prohibited. Please supply a different email address." msgstr "Registracija ni mogoča z brezplačnimi e-naslovi. Prosimo vnesite drug e-naslov." #: models.py:165 msgid "user" msgstr "Uporabnik" #: models.py:166 msgid "activation key" msgstr "Aktivacijski ključ" #: models.py:171 msgid "registration profile" msgstr "Registracijski profil" #: models.py:172 msgid "registration profiles" msgstr "Registracijski profili" django-registration-2.2/registration/locale/sr/0000755000076700007670000000000013011716531021140 5ustar james00000000000000django-registration-2.2/registration/locale/sr/LC_MESSAGES/0000755000076700007670000000000013011716531022725 5ustar james00000000000000django-registration-2.2/registration/locale/sr/LC_MESSAGES/django.mo0000644000076700007670000000365612214057645024546 0ustar james00000000000000x-y_N6V;') *8ARg}3ndK1SME3 FSZj   I have read and agree to the Terms of ServiceRegistration using free email addresses is prohibited. Please supply a different email address.This email address is already in use. Please supply a different email address.This username is already taken. Please choose another.Usernames can only contain letters, numbers and underscoresYou must agree to the terms to registerYou must type the same password each timeactivation keyemail addresspasswordpassword (again)registration profileregistration profilesuserusernameProject-Id-Version: django-registration trunk Report-Msgid-Bugs-To: POT-Creation-Date: 2008-04-05 13:51+0200 PO-Revision-Date: 2008-04-05 14:00+0100 Last-Translator: Nebojsa Djordjevic Language-Team: MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Plural-Forms: nplurals=3; plural=n%10==1 && n%100!=11 ? 0 : n%10>=2 && n%10<=4 && (n%100<10 || n%100>=20) ? 1 : 2; X-Poedit-Language: Serbian X-Poedit-Country: YUGOSLAVIA Pročitao sam i slažem se sa uslovima korišćenjaRegistracija korišćenjem besplatnig e-mail adresa je zabranjena. Morate uneti drugu e-mail adresu.Ova e-mail adresa je već u upotrebi. Morate koristiti drugu e-mail adresu.Korisničko ime je već zauzeto. Izaberite drugo.Korisničko ime može da se sastoji samo od slova, brojeva i donje crte ("_")Morate se složiti sa uslovima korišćenja da bi ste se registrovaliUnete šifre se ne slažuaktivacioni ključemail adresašifrašifra (ponovo)registracioni profilregistracioni profilikorisnikkorisničko imedjango-registration-2.2/registration/locale/sr/LC_MESSAGES/django.po0000644000076700007670000000446512214057645024550 0ustar james00000000000000# SOME DESCRIPTIVE TITLE. # Copyright (C) YEAR THE PACKAGE'S COPYRIGHT HOLDER # This file is distributed under the same license as the PACKAGE package. # FIRST AUTHOR , YEAR. # msgid "" msgstr "" "Project-Id-Version: django-registration trunk\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2008-04-05 13:51+0200\n" "PO-Revision-Date: 2008-04-05 14:00+0100\n" "Last-Translator: Nebojsa Djordjevic \n" "Language-Team: \n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=UTF-8\n" "Content-Transfer-Encoding: 8bit\n" "Plural-Forms: nplurals=3; plural=n%10==1 && n%100!=11 ? 0 : n%10>=2 && n%10<=4 && (n%100<10 || n%100>=20) ? 1 : 2;\n" "X-Poedit-Language: Serbian\n" "X-Poedit-Country: YUGOSLAVIA\n" #: forms.py:38 msgid "username" msgstr "korisničko ime" #: forms.py:41 msgid "email address" msgstr "email adresa" #: forms.py:43 msgid "password" msgstr "šifra" #: forms.py:45 msgid "password (again)" msgstr "šifra (ponovo)" #: forms.py:54 msgid "Usernames can only contain letters, numbers and underscores" msgstr "Korisničko ime može da se sastoji samo od slova, brojeva i donje crte (\"_\")" #: forms.py:59 msgid "This username is already taken. Please choose another." msgstr "Korisničko ime je već zauzeto. Izaberite drugo." #: forms.py:71 msgid "You must type the same password each time" msgstr "Unete šifre se ne slažu" #: forms.py:100 msgid "I have read and agree to the Terms of Service" msgstr "Pročitao sam i slažem se sa uslovima korišćenja" #: forms.py:109 msgid "You must agree to the terms to register" msgstr "Morate se složiti sa uslovima korišćenja da bi ste se registrovali" #: forms.py:128 msgid "This email address is already in use. Please supply a different email address." msgstr "Ova e-mail adresa je već u upotrebi. Morate koristiti drugu e-mail adresu." #: forms.py:153 msgid "Registration using free email addresses is prohibited. Please supply a different email address." msgstr "Registracija korišćenjem besplatnig e-mail adresa je zabranjena. Morate uneti drugu e-mail adresu." #: models.py:188 msgid "user" msgstr "korisnik" #: models.py:189 msgid "activation key" msgstr "aktivacioni ključ" #: models.py:194 msgid "registration profile" msgstr "registracioni profil" #: models.py:195 msgid "registration profiles" msgstr "registracioni profili" django-registration-2.2/registration/locale/sv/0000755000076700007670000000000013011716531021144 5ustar james00000000000000django-registration-2.2/registration/locale/sv/LC_MESSAGES/0000755000076700007670000000000013011716531022731 5ustar james00000000000000django-registration-2.2/registration/locale/sv/LC_MESSAGES/django.mo0000644000076700007670000000322712214057645024544 0ustar james00000000000000x-y_N6V;') *8ARg}7$B9+2eF3 4 F S]nu ~    I have read and agree to the Terms of ServiceRegistration using free email addresses is prohibited. Please supply a different email address.This email address is already in use. Please supply a different email address.This username is already taken. Please choose another.Usernames can only contain letters, numbers and underscoresYou must agree to the terms to registerYou must type the same password each timeactivation keyemail addresspasswordpassword (again)registration profileregistration profilesuserusernameProject-Id-Version: PACKAGE VERSION Report-Msgid-Bugs-To: POT-Creation-Date: 2008-03-23 18:59+0100 PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE Last-Translator: Emil Stenström Language-Team: LANGUAGE MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Jag har läst och accepterar avtaletGratis e-postadresser är inte tillåtna, använd en annan adress.Den e-postadressen är upptagen, använd an annan adress.Det användarnamnet är upptaget. Prova ett annat.Användarnamn får bara innehålla bokstäver, siffror och understreckDu måste acceptera avtalet för att registrera digBåda lösenord måste vara likaAktiveringsnyckelE-postadressLösenordLösenord (igen)ProfilProfilerAnvändareAnvändarnamndjango-registration-2.2/registration/locale/sv/LC_MESSAGES/django.po0000644000076700007670000000412112214057645024541 0ustar james00000000000000# SOME DESCRIPTIVE TITLE. # Copyright (C) YEAR THE PACKAGE'S COPYRIGHT HOLDER # This file is distributed under the same license as the PACKAGE package. # FIRST AUTHOR , YEAR. # #, fuzzy msgid "" msgstr "" "Project-Id-Version: PACKAGE VERSION\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2008-03-23 18:59+0100\n" "PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" "Last-Translator: Emil Stenström \n" "Language-Team: LANGUAGE \n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=UTF-8\n" "Content-Transfer-Encoding: 8bit\n" #: .\forms.py:38 msgid "username" msgstr "Användarnamn" #: .\forms.py:41 msgid "email address" msgstr "E-postadress" #: .\forms.py:43 msgid "password" msgstr "Lösenord" #: .\forms.py:45 msgid "password (again)" msgstr "Lösenord (igen)" #: .\forms.py:54 msgid "Usernames can only contain letters, numbers and underscores" msgstr "Användarnamn får bara innehålla bokstäver, siffror och understreck" #: .\forms.py:59 msgid "This username is already taken. Please choose another." msgstr "Det användarnamnet är upptaget. Prova ett annat." #: .\forms.py:71 msgid "You must type the same password each time" msgstr "Båda lösenord måste vara lika" #: .\forms.py:100 msgid "I have read and agree to the Terms of Service" msgstr "Jag har läst och accepterar avtalet" #: .\forms.py:109 msgid "You must agree to the terms to register" msgstr "Du måste acceptera avtalet för att registrera dig" #: .\forms.py:128 msgid "" "This email address is already in use. Please supply a different email " "address." msgstr "Den e-postadressen är upptagen, använd an annan adress." #: .\forms.py:153 msgid "" "Registration using free email addresses is prohibited. Please supply a " "different email address." msgstr "Gratis e-postadresser är inte tillåtna, använd en annan adress." #: .\models.py:188 msgid "user" msgstr "Användare" #: .\models.py:189 msgid "activation key" msgstr "Aktiveringsnyckel" #: .\models.py:194 msgid "registration profile" msgstr "Profil" #: .\models.py:195 msgid "registration profiles" msgstr "Profiler" django-registration-2.2/registration/locale/tr_TR/0000755000076700007670000000000013011716531021546 5ustar james00000000000000django-registration-2.2/registration/locale/tr_TR/LC_MESSAGES/0000755000076700007670000000000013011716531023333 5ustar james00000000000000django-registration-2.2/registration/locale/tr_TR/LC_MESSAGES/django.mo0000644000076700007670000000363112214057645025145 0ustar james00000000000000<) -&/@_Z%N>/n'wI7(` {0*f#cHD0&Wl{      A user with that username already exists.Activate usersEmail addressI have read and agree to the Terms of ServicePasswordPassword (again)Re-send activation emailsRegistration using free email addresses is prohibited. Please supply a different email address.The two password fields didn't match.This email address is already in use. Please supply a different email address.This value must contain only letters, numbers and underscores.UsernameYou must agree to the terms to registeractivation keyregistration profileregistration profilesuserProject-Id-Version: PACKAGE VERSION Report-Msgid-Bugs-To: POT-Creation-Date: 2010-11-11 12:48+0200 PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE Last-Translator: RECEP KIRMIZI Language-Team: LANGUAGE Language: MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Bu kullanıcı adına sahip bir kullanıcı bulunmakta.Kullanıcıları aktive etEposta adresiAnlaşma kurallarını okudum ve kabul ediyorum.ParolaParola (tekrar)Aktivasyon e-postalarını yeniden gönderÜcretsiz eposta adresleri ile kayıt kabul edilmemektedir. Lütfen farklı bir eposta adresi veriniz.İki parola birbiri ile uyuşmadı.Bu eposta adresi kullanımda. Lütfen farklı bir eposta adresi veriniz.Bu alan sadece harfler, numaralar ve alt çizgiler barındırabilir.Kullanıcı adıKayıt olmak için kuralları kabul etmelisiniz.aktivasyon anahtarıkayıt profilikayıt profillerikullanıcıdjango-registration-2.2/registration/locale/tr_TR/LC_MESSAGES/django.po0000644000076700007670000000446712214057645025160 0ustar james00000000000000# SOME DESCRIPTIVE TITLE. # Copyright (C) YEAR THE PACKAGE'S COPYRIGHT HOLDER # This file is distributed under the same license as the PACKAGE package. # FIRST AUTHOR , YEAR. # #, fuzzy msgid "" msgstr "" "Project-Id-Version: PACKAGE VERSION\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2010-11-11 12:48+0200\n" "PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" "Last-Translator: RECEP KIRMIZI \n" "Language-Team: LANGUAGE \n" "Language: \n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=UTF-8\n" "Content-Transfer-Encoding: 8bit\n" #: admin.py:23 msgid "Activate users" msgstr "Kullanıcıları aktive et" #: admin.py:43 msgid "Re-send activation emails" msgstr "Aktivasyon e-postalarını yeniden gönder" #: forms.py:35 msgid "Username" msgstr "Kullanıcı adı" #: forms.py:36 msgid "This value must contain only letters, numbers and underscores." msgstr "Bu alan sadece harfler, numaralar ve alt çizgiler barındırabilir." #: forms.py:39 msgid "Email address" msgstr "Eposta adresi" #: forms.py:41 msgid "Password" msgstr "Parola" #: forms.py:43 msgid "Password (again)" msgstr "Parola (tekrar)" #: forms.py:55 msgid "A user with that username already exists." msgstr "Bu kullanıcı adına sahip bir kullanıcı bulunmakta." #: forms.py:67 msgid "The two password fields didn't match." msgstr "İki parola birbiri ile uyuşmadı." #: forms.py:78 msgid "I have read and agree to the Terms of Service" msgstr "Anlaşma kurallarını okudum ve kabul ediyorum." #: forms.py:79 msgid "You must agree to the terms to register" msgstr "Kayıt olmak için kuralları kabul etmelisiniz." #: forms.py:95 msgid "" "This email address is already in use. Please supply a different email " "address." msgstr "Bu eposta adresi kullanımda. Lütfen farklı bir eposta adresi veriniz." #: forms.py:122 msgid "" "Registration using free email addresses is prohibited. Please supply a " "different email address." msgstr "" "Ücretsiz eposta adresleri ile kayıt kabul edilmemektedir. Lütfen farklı bir " "eposta adresi veriniz." #: models.py:168 msgid "user" msgstr "kullanıcı" #: models.py:169 msgid "activation key" msgstr "aktivasyon anahtarı" #: models.py:174 msgid "registration profile" msgstr "kayıt profili" #: models.py:175 msgid "registration profiles" msgstr "kayıt profilleri" django-registration-2.2/registration/locale/zh_CN/0000755000076700007670000000000013011716531021515 5ustar james00000000000000django-registration-2.2/registration/locale/zh_CN/LC_MESSAGES/0000755000076700007670000000000013011716531023302 5ustar james00000000000000django-registration-2.2/registration/locale/zh_CN/LC_MESSAGES/django.mo0000644000076700007670000000320512214057645025111 0ustar james00000000000000x-y_N6V;') *8ARg}9$PJ;-0$ & 3@G Z gt {   I have read and agree to the Terms of ServiceRegistration using free email addresses is prohibited. Please supply a different email address.This email address is already in use. Please supply a different email address.This username is already taken. Please choose another.Usernames can only contain letters, numbers and underscoresYou must agree to the terms to registerYou must type the same password each timeactivation keyemail addresspasswordpassword (again)registration profileregistration profilesuserusernameProject-Id-Version: PACKAGE VERSION Report-Msgid-Bugs-To: POT-Creation-Date: 2007-09-19 19:30-0500 PO-Revision-Date: 2008-03-20 23:22+0800 Last-Translator: hutuworm Language-Team: LANGUAGE MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 我已阅读并同意该服务条款禁止使用免费 Email 地址注册，请提供一个另外的 Email 地址。该 Email 地址已有人使用，请提供一个另外的 Email 地址。该用户名已被占用，请另选一个。用户名只能包含字母、数字和下划线您必须同意注册条款您必须输入两遍同样的密码激活密钥Email 地址密码密码（重复）注册信息注册信息用户用户名django-registration-2.2/registration/locale/zh_CN/LC_MESSAGES/django.po0000644000076700007670000000377512214057645025130 0ustar james00000000000000# SOME DESCRIPTIVE TITLE. # Copyright (C) YEAR THE PACKAGE'S COPYRIGHT HOLDER # This file is distributed under the same license as the PACKAGE package. # FIRST AUTHOR , YEAR. # msgid "" msgstr "" "Project-Id-Version: PACKAGE VERSION\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2007-09-19 19:30-0500\n" "PO-Revision-Date: 2008-03-20 23:22+0800\n" "Last-Translator: hutuworm \n" "Language-Team: LANGUAGE \n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=UTF-8\n" "Content-Transfer-Encoding: 8bit\n" #: forms.py:38 msgid "username" msgstr "用户名" #: forms.py:41 msgid "email address" msgstr "Email 地址" #: forms.py:43 msgid "password" msgstr "密码" #: forms.py:45 msgid "password (again)" msgstr "密码（重复）" #: forms.py:54 msgid "Usernames can only contain letters, numbers and underscores" msgstr "用户名只能包含字母、数字和下划线" #: forms.py:59 msgid "This username is already taken. Please choose another." msgstr "该用户名已被占用，请另选一个。" #: forms.py:68 msgid "You must type the same password each time" msgstr "您必须输入两遍同样的密码" #: forms.py:96 msgid "I have read and agree to the Terms of Service" msgstr "我已阅读并同意该服务条款" #: forms.py:105 msgid "You must agree to the terms to register" msgstr "您必须同意注册条款" #: forms.py:124 msgid "This email address is already in use. Please supply a different email address." msgstr "该 Email 地址已有人使用，请提供一个另外的 Email 地址。" #: forms.py:149 msgid "Registration using free email addresses is prohibited. Please supply a different email address." msgstr "禁止使用免费 Email 地址注册，请提供一个另外的 Email 地址。" #: models.py:188 msgid "user" msgstr "用户" #: models.py:189 msgid "activation key" msgstr "激活密钥" #: models.py:194 msgid "registration profile" msgstr "注册信息" #: models.py:195 msgid "registration profiles" msgstr "注册信息" django-registration-2.2/registration/locale/zh_TW/0000755000076700007670000000000013011716531021547 5ustar james00000000000000django-registration-2.2/registration/locale/zh_TW/LC_MESSAGES/0000755000076700007670000000000013011716531023334 5ustar james00000000000000django-registration-2.2/registration/locale/zh_TW/LC_MESSAGES/django.mo0000644000076700007670000000320512214057645025143 0ustar james00000000000000x-y_N6V;') *8ARg}9$PJ;-0$ & 3@G Z gt {   I have read and agree to the Terms of ServiceRegistration using free email addresses is prohibited. Please supply a different email address.This email address is already in use. Please supply a different email address.This username is already taken. Please choose another.Usernames can only contain letters, numbers and underscoresYou must agree to the terms to registerYou must type the same password each timeactivation keyemail addresspasswordpassword (again)registration profileregistration profilesuserusernameProject-Id-Version: PACKAGE VERSION Report-Msgid-Bugs-To: POT-Creation-Date: 2007-09-19 19:30-0500 PO-Revision-Date: 2008-03-20 23:22+0800 Last-Translator: hutuworm Language-Team: LANGUAGE MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 我已閱讀並同意該服務條款禁止使用免費 Email 地址注冊，請提供一個另外的 Email 地址。該 Email 地址已有人使用，請提供一個另外的 Email 地址。該用戶名已被佔用，請另選一個。用戶名只能包含字母、數字和下劃線您必須同意注冊條款您必須輸入兩遍同樣的密碼激活密鑰Email 地址密碼密碼（重復）注冊信息注冊信息用戶用戶名django-registration-2.2/registration/locale/zh_TW/LC_MESSAGES/django.po0000644000076700007670000000377512214057645025162 0ustar james00000000000000# SOME DESCRIPTIVE TITLE. # Copyright (C) YEAR THE PACKAGE'S COPYRIGHT HOLDER # This file is distributed under the same license as the PACKAGE package. # FIRST AUTHOR , YEAR. # msgid "" msgstr "" "Project-Id-Version: PACKAGE VERSION\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2007-09-19 19:30-0500\n" "PO-Revision-Date: 2008-03-20 23:22+0800\n" "Last-Translator: hutuworm \n" "Language-Team: LANGUAGE \n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=UTF-8\n" "Content-Transfer-Encoding: 8bit\n" #: forms.py:38 msgid "username" msgstr "用戶名" #: forms.py:41 msgid "email address" msgstr "Email 地址" #: forms.py:43 msgid "password" msgstr "密碼" #: forms.py:45 msgid "password (again)" msgstr "密碼（重復）" #: forms.py:54 msgid "Usernames can only contain letters, numbers and underscores" msgstr "用戶名只能包含字母、數字和下劃線" #: forms.py:59 msgid "This username is already taken. Please choose another." msgstr "該用戶名已被佔用，請另選一個。" #: forms.py:68 msgid "You must type the same password each time" msgstr "您必須輸入兩遍同樣的密碼" #: forms.py:96 msgid "I have read and agree to the Terms of Service" msgstr "我已閱讀並同意該服務條款" #: forms.py:105 msgid "You must agree to the terms to register" msgstr "您必須同意注冊條款" #: forms.py:124 msgid "This email address is already in use. Please supply a different email address." msgstr "該 Email 地址已有人使用，請提供一個另外的 Email 地址。" #: forms.py:149 msgid "Registration using free email addresses is prohibited. Please supply a different email address." msgstr "禁止使用免費 Email 地址注冊，請提供一個另外的 Email 地址。" #: models.py:188 msgid "user" msgstr "用戶" #: models.py:189 msgid "activation key" msgstr "激活密鑰" #: models.py:194 msgid "registration profile" msgstr "注冊信息" #: models.py:195 msgid "registration profiles" msgstr "注冊信息" django-registration-2.2/registration/management/0000755000076700007670000000000013011716531021371 5ustar james00000000000000django-registration-2.2/registration/management/__init__.py0000644000076700007670000000000012214057645023500 0ustar james00000000000000django-registration-2.2/registration/management/commands/0000755000076700007670000000000013011716531023172 5ustar james00000000000000django-registration-2.2/registration/management/commands/__init__.py0000644000076700007670000000000012214057645025301 0ustar james00000000000000django-registration-2.2/registration/management/commands/cleanupregistration.py0000644000076700007670000000106612726166473027651 0ustar james00000000000000""" A management command which deletes expired accounts (e.g., accounts which signed up but never activated) from the database. Calls ``RegistrationProfile.objects.delete_expired_users()``, which contains the actual logic for determining which accounts are deleted. """ from django.core.management.base import BaseCommand from registration.models import RegistrationProfile class Command(BaseCommand): help = "Delete expired user registrations from the database" def handle(self, **options): RegistrationProfile.objects.delete_expired_users() django-registration-2.2/registration/migrations/0000755000076700007670000000000013011716531021431 5ustar james00000000000000django-registration-2.2/registration/migrations/0001_initial.py0000644000076700007670000000213012604633610024073 0ustar james00000000000000# -*- coding: utf-8 -*- from __future__ import unicode_literals from django.conf import settings from django.db import migrations, models class Migration(migrations.Migration): dependencies = [ migrations.swappable_dependency(settings.AUTH_USER_MODEL), ] operations = [ migrations.CreateModel( name='RegistrationProfile', fields=[ ('id', models.AutoField( primary_key=True, serialize=False, auto_created=True, verbose_name='ID')), ('activation_key', models.CharField( verbose_name='activation key', max_length=40)), ('user', models.OneToOneField( to=settings.AUTH_USER_MODEL, verbose_name='user')), ], options={ 'verbose_name': 'registration profile', 'verbose_name_plural': 'registration profiles', }, ), ] django-registration-2.2/registration/migrations/__init__.py0000644000076700007670000000000012561320613023531 0ustar james00000000000000django-registration-2.2/registration/models.py0000644000076700007670000001362413011525254021120 0ustar james00000000000000""" Model and manager used by the model-based activation workflow. If you're not using that workflow, you should not have 'registration' in your INSTALLED_APPS. This is provided primarily for backwards-compatibility with existing installations; new installs of django-registration should look into the HMAC activation workflow in registration.backends.hmac, which also provides a two-step process but requires no models or storage of the activation key. """ import datetime import hashlib import re from django.conf import settings from django.contrib.auth import get_user_model from django.db import models, transaction from django.template.loader import render_to_string from django.utils.crypto import get_random_string from django.utils.encoding import python_2_unicode_compatible from django.utils import timezone from django.utils.translation import ugettext_lazy as _ SHA1_RE = re.compile('^[a-f0-9]{40}$') class RegistrationManager(models.Manager): """ Custom manager for the ``RegistrationProfile`` model. The methods defined here provide shortcuts for account creation and activation (including generation and emailing of activation keys), and for cleaning out expired inactive accounts. """ def activate_user(self, activation_key): """ Validate an activation key and activate the corresponding user if valid. Returns the user account on success, ``False`` on failure. """ # Make sure the key we're trying conforms to the pattern of a # SHA1 hash; if it doesn't, no point trying to look it up in # the database. if SHA1_RE.search(activation_key.lower()): try: profile = self.get(activation_key=activation_key) except self.model.DoesNotExist: return False if not profile.activation_key_expired(): user = profile.user user.is_active = True user.save() profile.activation_key = self.model.ACTIVATED profile.save() return user return False def expired(self): """ Query for all profiles which are expired and correspond to non-active users. """ if settings.USE_TZ: now = timezone.now() else: now = datetime.datetime.now() return self.exclude( models.Q(user__is_active=True) | models.Q(activation_key=self.model.ACTIVATED) ).filter( user__date_joined__lt=now - datetime.timedelta( settings.ACCOUNT_ACTIVATION_DAYS ) ) @transaction.atomic def create_inactive_user(self, form, site, send_email=True): """ Create a new, inactive user, generate a ``RegistrationProfile`` and email its activation key to the user, returning the new user. """ new_user = form.save(commit=False) new_user.is_active = False new_user.save() registration_profile = self.create_profile(new_user) if send_email: registration_profile.send_activation_email(site) return new_user def create_profile(self, user): """ Create a ``RegistrationProfile`` for a given user, and return the ``RegistrationProfile``. """ User = get_user_model() username = str(getattr(user, User.USERNAME_FIELD)) hash_input = (get_random_string(5) + username).encode('utf-8') activation_key = hashlib.sha1(hash_input).hexdigest() return self.create(user=user, activation_key=activation_key) @transaction.atomic def delete_expired_users(self): """ Remove expired instances of ``RegistrationProfile`` and their associated users. """ for profile in self.expired(): user = profile.user profile.delete() user.delete() @python_2_unicode_compatible class RegistrationProfile(models.Model): """ A simple model which stores an activation key for use during user account registration. """ ACTIVATED = "ALREADY_ACTIVATED" user = models.OneToOneField(settings.AUTH_USER_MODEL, verbose_name=_(u'user')) activation_key = models.CharField(_(u'activation key'), max_length=40) objects = RegistrationManager() class Meta: verbose_name = _(u'registration profile') verbose_name_plural = _(u'registration profiles') def __str__(self): return "Registration information for %s" % self.user def activation_key_expired(self): """ Determine whether this ``RegistrationProfile``'s activation key has expired, returning a boolean -- ``True`` if the key has expired, ``False`` otherwise. """ expiration_date = datetime.timedelta( days=settings.ACCOUNT_ACTIVATION_DAYS ) return self.activation_key == self.ACTIVATED or \ (self.user.date_joined + expiration_date <= timezone.now()) activation_key_expired.boolean = True def send_activation_email(self, site): """ Send an activation email to the user associated with this ``RegistrationProfile``. """ ctx_dict = {'activation_key': self.activation_key, 'expiration_days': settings.ACCOUNT_ACTIVATION_DAYS, 'user': self.user, 'site': site} subject = render_to_string('registration/activation_email_subject.txt', ctx_dict) # Force subject to a single line to avoid header-injection # issues. subject = ''.join(subject.splitlines()) message = render_to_string('registration/activation_email.txt', ctx_dict) self.user.email_user(subject, message, settings.DEFAULT_FROM_EMAIL) django-registration-2.2/registration/runtests.py0000644000076700007670000000537012756210220021522 0ustar james00000000000000""" A standalone test runner script, configuring the minimum settings required for tests to execute. Re-use at your own risk: many Django applications will require different settings and/or templates to run their tests. """ import os import sys # Make sure the app is (at least temporarily) on the import path. APP_DIR = os.path.abspath(os.path.dirname(__file__)) sys.path.insert(0, APP_DIR) # Minimum settings required for the app's tests. SETTINGS_DICT = { 'BASE_DIR': APP_DIR, 'INSTALLED_APPS': ( 'django.contrib.auth', 'django.contrib.contenttypes', 'django.contrib.sessions', 'django.contrib.sites', # This is only needed by the model-based activation workflow. 'registration', ), # Test cases will override this liberally. 'ROOT_URLCONF': 'registration.backends.default.urls', 'DATABASES': { 'default': { 'ENGINE': 'django.db.backends.sqlite3', 'NAME': os.path.join(APP_DIR, 'db.sqlite3'), }, }, 'MIDDLEWARE_CLASSES': ( 'django.middleware.common.CommonMiddleware', 'django.middleware.csrf.CsrfViewMiddleware', 'django.contrib.sessions.middleware.SessionMiddleware', 'django.contrib.auth.middleware.AuthenticationMiddleware', ), 'SITE_ID': 1, 'TEMPLATES': [{ 'BACKEND': 'django.template.backends.django.DjangoTemplates', 'DIRS': [os.path.join(APP_DIR, 'tests/templates')], 'OPTIONS': { 'context_processors': [ 'django.contrib.auth.context_processors.auth', 'django.template.context_processors.debug', 'django.template.context_processors.i18n', 'django.template.context_processors.media', 'django.template.context_processors.static', 'django.template.context_processors.tz', 'django.contrib.messages.context_processors.messages', ], }, }], } def run_tests(): # Making Django run this way is a two-step process. First, call # settings.configure() to give Django settings to work with: from django.conf import settings settings.configure(**SETTINGS_DICT) # Then, call django.setup() to initialize the application cache # and other bits: import django if hasattr(django, 'setup'): django.setup() # Now we instantiate a test runner... from django.test.utils import get_runner TestRunner = get_runner(settings) # And then we run tests and return the results. test_runner = TestRunner(verbosity=1, interactive=True) failures = test_runner.run_tests(['registration.tests']) sys.exit(bool(failures)) if __name__ == '__main__': # pragma: no cover run_tests() # pragma: no cover django-registration-2.2/registration/signals.py0000644000076700007670000000046712604633610021301 0ustar james00000000000000""" Custom signals sent during the registration and activation processes. """ from django.dispatch import Signal # A new user has registered. user_registered = Signal(providing_args=["user", "request"]) # A user has activated his or her account. user_activated = Signal(providing_args=["user", "request"]) django-registration-2.2/registration/tests/0000755000076700007670000000000013011716531020417 5ustar james00000000000000django-registration-2.2/registration/tests/__init__.py0000644000076700007670000000000012560036423022521 0ustar james00000000000000django-registration-2.2/registration/tests/base.py0000644000076700007670000002055213011530142021677 0ustar james00000000000000""" Base classes for other test cases to inherit from. """ from contextlib import contextmanager from django.contrib.auth import get_user_model from django.core import mail from django.core.urlresolvers import reverse from django.http import HttpRequest from django.test import TestCase, override_settings from ..forms import RegistrationForm from .. import signals User = get_user_model() # django-registration needs to test that signals are sent at # registration and activation. Django -- as of 1.10 -- does not have a # test assertion built in to test whether a signal was or was not # sent. The code below is from a pull request submitted upstream to # Django to add assertSignalSent and assertSignalNotSent assertions to # Django's base test case class, and will be removed once it's been # integrated into Django and django-registration is only supporting # versions of Django which include it. class _AssertSignalSentContext(object): def __init__(self, test_case, signal, required_kwargs=None): self.test_case = test_case self.signal = signal self.required_kwargs = required_kwargs def _listener(self, sender, **kwargs): self.signal_sent = True self.received_kwargs = kwargs self.sender = sender def __enter__(self): self.signal_sent = False self.received_kwargs = {} self.sender = None self.signal.connect(self._listener) return self def __exit__(self, exc_type, exc_value, traceback): self.signal.disconnect(self._listener) if not self.signal_sent: self.test_case.fail('Signal was not sent.') return if self.required_kwargs is not None: missing_kwargs = [] for k in self.required_kwargs: if k not in self.received_kwargs: missing_kwargs.append(k) if missing_kwargs: self.test_case.fail( "Signal missing required arguments: " "%s" % ','.join(missing_kwargs) ) class _AssertSignalNotSentContext(_AssertSignalSentContext): def __exit__(self, exc_type, exc_value, traceback): self.signal.disconnect(self._listener) if self.signal_sent: self.test_case.fail('Signal was unexpectedly sent.') @override_settings( ACCOUNT_ACTIVATION_DAYS=7, REGISTRATION_OPEN=True ) class RegistrationTestCase(TestCase): """ Base class for test cases, defining valid data for registering a user account and looking up the account after creation. """ user_model = User valid_data = { User.USERNAME_FIELD: 'alice', 'email': 'alice@example.com', 'password1': 'swordfish', 'password2': 'swordfish', } user_lookup_kwargs = { User.USERNAME_FIELD: 'alice', } @contextmanager def assertSignalSent(self, signal, required_kwargs=None): with _AssertSignalSentContext(self, signal, required_kwargs) as cm: yield cm @contextmanager def assertSignalNotSent(self, signal): with _AssertSignalNotSentContext(self, signal) as cm: yield cm class WorkflowTestCase(RegistrationTestCase): """ Base class for the test cases which exercise the built-in workflows, including logic common to all of them (and which needs to be tested for each one). """ def test_registration_open(self): """ ``REGISTRATION_OPEN``, when ``True``, permits registration. """ resp = self.client.get(reverse('registration_register')) self.assertEqual(200, resp.status_code) @override_settings(REGISTRATION_OPEN=False) def test_registration_closed(self): """ ``REGISTRATION_OPEN``, when ``False``, disallows registration. """ resp = self.client.get( reverse('registration_register') ) self.assertRedirects(resp, reverse('registration_disallowed')) resp = self.client.post( reverse('registration_register'), data=self.valid_data ) self.assertRedirects(resp, reverse('registration_disallowed')) def test_registration_get(self): """ HTTP ``GET`` to the registration view uses the appropriate template and populates a registration form into the context. """ resp = self.client.get(reverse('registration_register')) self.assertEqual(200, resp.status_code) self.assertTemplateUsed( resp, 'registration/registration_form.html' ) self.assertTrue( isinstance( resp.context['form'], RegistrationForm ) ) def test_registration(self): """ Registration creates a new account. """ with self.assertSignalSent(signals.user_registered): resp = self.client.post( reverse('registration_register'), data=self.valid_data ) self.assertRedirects(resp, reverse('registration_complete')) new_user = self.user_model.objects.get(**self.user_lookup_kwargs) self.assertTrue( new_user.check_password( self.valid_data['password1'] ) ) self.assertEqual(new_user.email, self.valid_data['email']) def test_registration_failure(self): """ Registering with invalid data fails. """ data = self.valid_data.copy() data.update(password2='notsecret') with self.assertSignalNotSent(signals.user_registered): resp = self.client.post( reverse('registration_register'), data=data ) self.assertEqual(200, resp.status_code) self.assertFalse(resp.context['form'].is_valid()) self.assertTrue(resp.context['form'].has_error('password2')) def test_registration_signal(self): with self.assertSignalSent(signals.user_registered) as cm: self.client.post( reverse('registration_register'), data=self.valid_data ) self.assertEqual( getattr(cm.received_kwargs['user'], self.user_model.USERNAME_FIELD), self.valid_data[User.USERNAME_FIELD] ) self.assertTrue( isinstance(cm.received_kwargs['request'], HttpRequest) ) class ActivationTestCase(WorkflowTestCase): """ Base class for testing the built-in workflows which involve an activation step. """ # First few methods repeat parent class, but with added checks for # is_active status and sending of activation emails. def test_registration(self): """ Registration creates a new inactive account and sends an activation email. """ with self.assertSignalSent(signals.user_registered): super(ActivationTestCase, self).test_registration() new_user = self.user_model.objects.get(**self.user_lookup_kwargs) # New user must not be active. self.assertFalse(new_user.is_active) # An activation email was sent. self.assertEqual(len(mail.outbox), 1) def test_registration_failure(self): """ Registering with invalid data fails. """ with self.assertSignalNotSent(signals.user_registered): super(ActivationTestCase, self).test_registration_failure() # Activation email was not sent. self.assertEqual(0, len(mail.outbox)) def test_registration_no_sites(self): """ Registration still functions properly when ``django.contrib.sites`` is not installed; the fallback will be a ``RequestSite`` instance. """ with self.modify_settings(INSTALLED_APPS={ 'remove': ['django.contrib.sites'] }): with self.assertSignalSent(signals.user_registered): resp = self.client.post( reverse('registration_register'), data=self.valid_data ) self.assertEqual(302, resp.status_code) new_user = self.user_model.objects.get(**self.user_lookup_kwargs) self.assertTrue( new_user.check_password( self.valid_data['password1'] ) ) self.assertEqual(new_user.email, self.valid_data['email']) django-registration-2.2/registration/tests/templates/0000755000076700007670000000000013011716531022415 5ustar james00000000000000django-registration-2.2/registration/tests/templates/registration/0000755000076700007670000000000013011716531025127 5ustar james00000000000000django-registration-2.2/registration/tests/templates/registration/activate.html0000644000076700007670000000000012561322725027612 0ustar james00000000000000django-registration-2.2/registration/tests/templates/registration/activation_complete.html0000644000076700007670000000000012561322700032034 0ustar james00000000000000django-registration-2.2/registration/tests/templates/registration/activation_email.txt0000644000076700007670000000000012561323004031164 0ustar james00000000000000django-registration-2.2/registration/tests/templates/registration/activation_email_subject.txt0000644000076700007670000000000012561322771032715 0ustar james00000000000000django-registration-2.2/registration/tests/templates/registration/registration_closed.html0000644000076700007670000000000012561322631032051 0ustar james00000000000000django-registration-2.2/registration/tests/templates/registration/registration_complete.html0000644000076700007670000000000012561322671032414 0ustar james00000000000000django-registration-2.2/registration/tests/templates/registration/registration_form.html0000644000076700007670000000000012561322324031542 0ustar james00000000000000django-registration-2.2/registration/tests/test_forms.py0000644000076700007670000001131013011530044023143 0ustar james00000000000000""" Exercise django-registration's built-in form classes. """ from django.test import modify_settings from django.utils.six import text_type from .. import forms from .. import validators from .base import RegistrationTestCase @modify_settings(INSTALLED_APPS={'remove': 'registration'}) class RegistrationFormTests(RegistrationTestCase): """ Test the built-in form classes. """ def test_email_required(self): """ The email address field is required. """ form = forms.RegistrationForm() self.assertTrue( form.fields['email'].required ) def test_username_uniqueness(self): """ Username uniqueness is enforced. This test is necessary as of 2.1.x to ensure the base UserCreationForm clean() continues to be called from the overridden clean() in RegistrationForm. """ user_data = self.valid_data.copy() del user_data['password1'] del user_data['password2'] user_data['password'] = 'swordfish' existing_user = self.user_model(**user_data) existing_user.save() form = forms.RegistrationForm(data=self.valid_data.copy()) self.assertFalse(form.is_valid()) self.assertTrue(form.has_error(self.user_model.USERNAME_FIELD)) def test_reserved_names(self): """ Reserved names are disallowed. """ for reserved_name in validators.DEFAULT_RESERVED_NAMES: data = self.valid_data.copy() data[self.user_model.USERNAME_FIELD] = reserved_name form = forms.RegistrationForm(data=data) self.assertFalse(form.is_valid()) self.assertTrue(form.has_error(self.user_model.USERNAME_FIELD)) self.assertTrue( text_type(validators.RESERVED_NAME) in form.errors[self.user_model.USERNAME_FIELD] ) def test_custom_reserved_names(self): """ Reserved names can be overridden by an attribute. """ custom_reserved_names = ['foo', 'bar', 'eggs', 'spam'] class CustomReservedNamesForm(forms.RegistrationForm): reserved_names = custom_reserved_names for reserved_name in custom_reserved_names: data = self.valid_data.copy() data[self.user_model.USERNAME_FIELD] = reserved_name form = CustomReservedNamesForm(data=data) self.assertFalse(form.is_valid()) self.assertTrue(form.has_error(self.user_model.USERNAME_FIELD)) self.assertTrue( text_type(validators.RESERVED_NAME) in form.errors[self.user_model.USERNAME_FIELD] ) def test_tos_field(self): """ The terms-of-service field on RegistrationFormTermsOfService is required. """ form = forms.RegistrationFormTermsOfService( data=self.valid_data.copy() ) self.assertFalse(form.is_valid()) self.assertTrue(form.has_error('tos')) self.assertEqual( form.errors['tos'], [text_type(validators.TOS_REQUIRED)] ) def test_email_uniqueness(self): """ Email uniqueness is enforced by RegistrationFormUniqueEmail. """ self.user_model.objects.create( username='bob', email=self.valid_data['email'], password=self.valid_data['password1'] ) form = forms.RegistrationFormUniqueEmail( data=self.valid_data.copy() ) self.assertFalse(form.is_valid()) self.assertTrue(form.has_error('email')) self.assertEqual( form.errors['email'], [text_type(validators.DUPLICATE_EMAIL)] ) data = self.valid_data.copy() data.update(email='bob@example.com') form = forms.RegistrationFormUniqueEmail( data=data ) self.assertTrue(form.is_valid()) def test_no_free_email(self): """ Free email domains are disallowed by RegistrationFormNoFreeEmail. """ for domain in forms.RegistrationFormNoFreeEmail.bad_domains: data = self.valid_data.copy() data.update( email='testuser@%s' % domain ) form = forms.RegistrationFormNoFreeEmail( data=data ) self.assertFalse(form.is_valid()) self.assertTrue(form.has_error('email')) self.assertEqual( form.errors['email'], [text_type(validators.FREE_EMAIL)] ) form = forms.RegistrationFormNoFreeEmail( data=self.valid_data.copy() ) self.assertTrue(form.is_valid()) django-registration-2.2/registration/tests/test_hmac_workflow.py0000644000076700007670000001505613010735414024701 0ustar james00000000000000""" Tests for the HMAC signed-token registration workflow. """ import datetime import time from django.conf import settings from django.core import signing from django.core.urlresolvers import reverse from django.http import HttpRequest from django.test import modify_settings, override_settings from .. import signals from registration.backends.hmac.views import REGISTRATION_SALT from .base import ActivationTestCase @modify_settings(INSTALLED_APPS={'remove': 'registration'}) @override_settings(ROOT_URLCONF='registration.backends.hmac.urls') class HMACViewTests(ActivationTestCase): """ Tests for the signed-token registration workflow. """ def test_activation(self): """ Activation of an account functions properly. """ resp = self.client.post( reverse('registration_register'), data=self.valid_data ) activation_key = signing.dumps( obj=self.valid_data[self.user_model.USERNAME_FIELD], salt=REGISTRATION_SALT ) with self.assertSignalSent(signals.user_activated): resp = self.client.get( reverse( 'registration_activate', args=(), kwargs={'activation_key': activation_key} ) ) self.assertRedirects(resp, reverse('registration_activation_complete')) def test_repeat_activation(self): """ Once activated, attempting to re-activate an account (even with a valid key) does nothing. """ resp = self.client.post( reverse('registration_register'), data=self.valid_data ) activation_key = signing.dumps( obj=self.valid_data[self.user_model.USERNAME_FIELD], salt=REGISTRATION_SALT ) with self.assertSignalSent(signals.user_activated): resp = self.client.get( reverse( 'registration_activate', args=(), kwargs={'activation_key': activation_key} ) ) # First activation redirects to success. self.assertRedirects(resp, reverse('registration_activation_complete')) with self.assertSignalNotSent(signals.user_activated): resp = self.client.get( reverse( 'registration_activate', args=(), kwargs={'activation_key': activation_key} ) ) # Second activation fails. self.assertEqual(200, resp.status_code) self.assertTemplateUsed(resp, 'registration/activate.html') # The timestamp calculation will error if USE_TZ=True, due to # trying to subtract a naive from an aware datetime. Since time # zones aren't relevant to the test, we just temporarily disable # time-zone support rather than do the more complex dance of # checking the setting and forcing everything to naive or aware. @override_settings(USE_TZ=False) def test_activation_expired(self): """ An expired account can't be activated. """ self.client.post( reverse('registration_register'), data=self.valid_data ) # We need to create an activation key valid for the username, # but with a timestamp > ACCOUNT_ACTIVATION_DAYS days in the # past. This requires monkeypatching time.time() to return # that timestamp, since TimestampSigner uses time.time(). # # On Python 3.3+ this is much easier because of the # timestamp() method of datetime objects, but since # django-registration has to run on Python 2.7, we manually # calculate it using a timedelta between the signup date and # the UNIX epoch, and patch time.time() temporarily to return # a date (ACCOUNT_ACTIVATION_DAYS + 1) days in the past. user = self.user_model.objects.get(**self.user_lookup_kwargs) joined_timestamp = ( user.date_joined - datetime.datetime.fromtimestamp(0) ).total_seconds() expired_timestamp = ( joined_timestamp - (settings.ACCOUNT_ACTIVATION_DAYS + 1) * 86400 ) _old_time = time.time try: time.time = lambda: expired_timestamp activation_key = signing.dumps( obj=self.valid_data[self.user_model.USERNAME_FIELD], salt=REGISTRATION_SALT ) finally: time.time = _old_time with self.assertSignalNotSent(signals.user_activated): resp = self.client.get( reverse( 'registration_activate', args=(), kwargs={'activation_key': activation_key} ) ) self.assertEqual(200, resp.status_code) self.assertTemplateUsed(resp, 'registration/activate.html') def test_nonexistent_activation(self): """ A nonexistent username in an activation key will fail to activate. """ activation_key = signing.dumps( obj='parrot', salt=REGISTRATION_SALT ) with self.assertSignalNotSent(signals.user_activated): resp = self.client.get( reverse( 'registration_activate', args=(), kwargs={'activation_key': activation_key} ) ) self.assertEqual(200, resp.status_code) self.assertTemplateUsed(resp, 'registration/activate.html') def test_activation_signal(self): self.client.post( reverse('registration_register'), data=self.valid_data ) activation_key = signing.dumps( obj=self.valid_data[self.user_model.USERNAME_FIELD], salt=REGISTRATION_SALT ) with self.assertSignalSent(signals.user_activated, required_kwargs=['user', 'request']) as cm: self.client.get( reverse( 'registration_activate', args=(), kwargs={'activation_key': activation_key} ) ) self.assertEqual( getattr(cm.received_kwargs['user'], self.user_model.USERNAME_FIELD), self.valid_data[self.user_model.USERNAME_FIELD] ) self.assertTrue( isinstance(cm.received_kwargs['request'], HttpRequest) ) django-registration-2.2/registration/tests/test_model_workflow.py0000644000076700007670000000771013010470761025070 0ustar james00000000000000""" Tests for the model-based activation workflow. """ import datetime from django.conf import settings from django.core.urlresolvers import reverse from django.http import HttpRequest from django.test import override_settings from ..models import RegistrationProfile from .. import signals from .base import ActivationTestCase @override_settings(ROOT_URLCONF='registration.backends.model_activation.urls') class ModelActivationViewTests(ActivationTestCase): """ Tests for the model-based activation workflow. """ def test_activation(self): """ Activation of an account functions properly. """ resp = self.client.post( reverse('registration_register'), data=self.valid_data ) profile = RegistrationProfile.objects.get( user__username=self.valid_data[self.user_model.USERNAME_FIELD] ) with self.assertSignalSent(signals.user_activated): resp = self.client.get( reverse( 'registration_activate', args=(), kwargs={'activation_key': profile.activation_key} ) ) self.assertRedirects(resp, reverse('registration_activation_complete')) def test_activation_expired(self): """ An expired account can't be activated. """ resp = self.client.post( reverse('registration_register'), data=self.valid_data ) profile = RegistrationProfile.objects.get( user__username=self.valid_data[self.user_model.USERNAME_FIELD] ) user = profile.user user.date_joined -= datetime.timedelta( days=settings.ACCOUNT_ACTIVATION_DAYS + 1 ) user.save() with self.assertSignalNotSent(signals.user_activated): resp = self.client.get( reverse( 'registration_activate', args=(), kwargs={'activation_key': profile.activation_key} ) ) self.assertEqual(200, resp.status_code) self.assertTemplateUsed(resp, 'registration/activate.html') def test_activation_signal(self): self.client.post( reverse('registration_register'), data=self.valid_data ) profile = RegistrationProfile.objects.get( user__username=self.valid_data[self.user_model.USERNAME_FIELD] ) with self.assertSignalSent(signals.user_activated, required_kwargs=['user', 'request']) as cm: self.client.get( reverse( 'registration_activate', args=(), kwargs={'activation_key': profile.activation_key} ) ) self.assertEqual( getattr(cm.received_kwargs['user'], self.user_model.USERNAME_FIELD), self.valid_data[self.user_model.USERNAME_FIELD] ) self.assertTrue( isinstance(cm.received_kwargs['request'], HttpRequest) ) class ModelActivationCompatibilityTests(ModelActivationViewTests): """ Re-run the model-activation workflow tests, but using the 'registration.backends.default' import compatibility support, to ensure that it works. """ def test_view_imports(self): """ Importing the views from the old location works, and returns the correct view classes. """ from registration.backends.default import views as old_views from registration.backends.model_activation import views as new_views self.assertEqual( old_views.ActivationView.__class__, new_views.ActivationView.__class__ ) self.assertEqual( old_views.RegistrationView.__class__, new_views.RegistrationView.__class__ ) django-registration-2.2/registration/tests/test_models.py0000644000076700007670000003153713011525346023326 0ustar james00000000000000""" Tests for the model and manager in the model-based workflow. """ import datetime import hashlib from django.conf import settings from django.contrib.auth import get_user_model from django.contrib.sites.shortcuts import get_current_site from django.core import mail, management from django.db import models from django.test import RequestFactory, TestCase, override_settings from django.utils.six import text_type from ..forms import RegistrationForm from ..models import SHA1_RE, RegistrationProfile User = get_user_model() @override_settings(ACCOUNT_ACTIVATION_DAYS=7) class RegistrationModelTests(TestCase): """ Test the model and manager used in the model-based activation workflow. """ user_info = { User.USERNAME_FIELD: 'alice', 'password': 'swordfish', 'email': 'alice@example.com' } user_lookup_kwargs = { User.USERNAME_FIELD: 'alice' } def get_form(self): """ Create and return a RegistrationForm filled with valid data. """ form = RegistrationForm( data={ User.USERNAME_FIELD: 'alice', 'password1': 'swordfish', 'password2': 'swordfish', 'email': 'alice@example.com', } ) return form def get_site(self): """ Return a Site or RequestSite instance for use in registration. """ factory = RequestFactory() return get_current_site(factory.get('/')) def test_profile_creation(self): """ Creating a registration profile for a user populates the profile with the correct user and a SHA1 hash to use as activation key. """ new_user = User.objects.create_user(**self.user_info) profile = RegistrationProfile.objects.create_profile(new_user) self.assertEqual(RegistrationProfile.objects.count(), 1) self.assertEqual(profile.user.id, new_user.id) self.assertTrue(SHA1_RE.match(profile.activation_key)) self.assertEqual( text_type(profile), "Registration information for %s" % ( self.user_info[User.USERNAME_FIELD] ) ) def test_activation_email(self): """ RegistrationProfile.send_activation_email sends an email. """ new_user = User.objects.create_user(**self.user_info) profile = RegistrationProfile.objects.create_profile(new_user) profile.send_activation_email(self.get_site()) self.assertEqual(len(mail.outbox), 1) self.assertEqual(mail.outbox[0].to, [self.user_info['email']]) def test_user_creation(self): """ Creating a new user populates the correct data, and sets the user's account inactive. """ new_user = RegistrationProfile.objects.create_inactive_user( self.get_form(), site=self.get_site() ) self.assertEqual( getattr(new_user, User.USERNAME_FIELD), self.user_info[User.USERNAME_FIELD] ) self.assertEqual( new_user.email, self.user_info['email'] ) self.assertTrue( new_user.check_password(self.user_info['password']) ) self.assertFalse(new_user.is_active) def test_user_creation_email(self): """ By default, creating a new user sends an activation email. """ RegistrationProfile.objects.create_inactive_user( self.get_form(), site=self.get_site() ) self.assertEqual(len(mail.outbox), 1) def test_user_creation_no_email(self): """ Passing send_email=False when creating a new user doesn't send an activation email. """ RegistrationProfile.objects.create_inactive_user( form=self.get_form(), site=self.get_site(), send_email=False, ) self.assertEqual(len(mail.outbox), 0) def test_unexpired_account(self): """ RegistrationProfile.activation_key_expired() is False within the activation window. """ new_user = RegistrationProfile.objects.create_inactive_user( self.get_form(), site=self.get_site() ) profile = RegistrationProfile.objects.get(user=new_user) self.assertFalse(profile.activation_key_expired()) def test_expired_account(self): """ RegistrationProfile.activation_key_expired() is True outside the activation window. """ new_user = RegistrationProfile.objects.create_inactive_user( self.get_form(), site=self.get_site() ) new_user.date_joined -= datetime.timedelta( days=settings.ACCOUNT_ACTIVATION_DAYS + 1 ) new_user.save() profile = RegistrationProfile.objects.get(user=new_user) self.assertTrue(profile.activation_key_expired()) def test_valid_activation(self): """ Activating a user within the permitted window makes the account active, and resets the activation key. """ new_user = RegistrationProfile.objects.create_inactive_user( form=self.get_form(), site=self.get_site() ) profile = RegistrationProfile.objects.get(user=new_user) activated = RegistrationProfile.objects.activate_user( profile.activation_key ) self.assertTrue(isinstance(activated, User)) self.assertEqual(activated.id, new_user.id) self.assertTrue(activated.is_active) profile = RegistrationProfile.objects.get(user=new_user) self.assertEqual(profile.activation_key, RegistrationProfile.ACTIVATED) def test_expired_activation(self): """ Attempting to activate outside the permitted window doesn't activate the account. """ new_user = RegistrationProfile.objects.create_inactive_user( form=self.get_form(), site=self.get_site() ) new_user.date_joined -= datetime.timedelta( days=settings.ACCOUNT_ACTIVATION_DAYS + 1 ) new_user.save() profile = RegistrationProfile.objects.get(user=new_user) activated = RegistrationProfile.objects.activate_user( profile.activation_key ) self.assertFalse(isinstance(activated, User)) self.assertFalse(activated) new_user = User.objects.get(**self.user_lookup_kwargs) self.assertFalse(new_user.is_active) profile = RegistrationProfile.objects.get(user=new_user) self.assertNotEqual( profile.activation_key, RegistrationProfile.ACTIVATED ) def test_activation_invalid_key(self): """ Attempting to activate with a key which is not a SHA1 hash fails. """ self.assertFalse(RegistrationProfile.objects.activate_user('foo')) def test_activation_already_activated(self): """ Attempting to re-activate an already-activated account fails. """ new_user = RegistrationProfile.objects.create_inactive_user( form=self.get_form(), site=self.get_site() ) profile = RegistrationProfile.objects.get(user=new_user) RegistrationProfile.objects.activate_user(profile.activation_key) profile = RegistrationProfile.objects.get(user=new_user) self.assertFalse( RegistrationProfile.objects.activate_user( profile.activation_key ) ) def test_activation_nonexistent_key(self): """ Attempting to activate with a non-existent key (i.e., one not associated with any account) fails. """ # Due to the way activation keys are constructed during # registration, this will never be a valid key. invalid_key = hashlib.sha1('foo'.encode('utf-8')).hexdigest() self.assertFalse( RegistrationProfile.objects.activate_user( invalid_key ) ) def test_expired_user_deletion(self): """ RegistrationProfile.objects.delete_expired_users() only deletes inactive users whose activation window has expired. """ RegistrationProfile.objects.create_inactive_user( form=self.get_form(), site=self.get_site() ) expired_form = RegistrationForm( data={ User.USERNAME_FIELD: 'bob', 'password1': 'swordfish', 'password2': 'swordfish', 'email': 'bob@example.com', } ) expired_user = RegistrationProfile.objects.create_inactive_user( form=expired_form, site=self.get_site() ) expired_user.date_joined -= datetime.timedelta( days=settings.ACCOUNT_ACTIVATION_DAYS + 1 ) expired_user.save() RegistrationProfile.objects.delete_expired_users() self.assertEqual(1, RegistrationProfile.objects.count()) with self.assertRaises(User.DoesNotExist): User.objects.get(**{ User.USERNAME_FIELD: 'bob' }) def test_management_command(self): """ The cleanupregistration management command properly deletes expired accounts. """ RegistrationProfile.objects.create_inactive_user( form=self.get_form(), site=self.get_site() ) expired_form = RegistrationForm( data={ User.USERNAME_FIELD: 'bob', 'password1': 'swordfish', 'password2': 'swordfish', 'email': 'bob@example.com', } ) expired_user = RegistrationProfile.objects.create_inactive_user( form=expired_form, site=self.get_site() ) expired_user.date_joined -= datetime.timedelta( days=settings.ACCOUNT_ACTIVATION_DAYS + 1 ) expired_user.save() management.call_command('cleanupregistration') self.assertEqual(RegistrationProfile.objects.count(), 1) with self.assertRaises(User.DoesNotExist): User.objects.get(**{ User.USERNAME_FIELD: 'bob' }) def test_expired_query(self): """ The expired() method of RegistrationManager correctly returns only expired registration profiles. """ form = RegistrationForm( data={ User.USERNAME_FIELD: 'test_expired_query', 'password1': 'swordfish', 'password2': 'swordfish', 'email': 'test_expired_query@example.com' } ) user = RegistrationProfile.objects.create_inactive_user( form=form, site=self.get_site() ) profile = RegistrationProfile.objects.get(user=user) original_date_joined = user.date_joined original_activation_key = profile.activation_key # Test matrix for expired() is as follows: # # * User with is_active=False, activation_key != ACTIVATED, # date_joined in the activation window is not expired. self.assertEqual(0, len(RegistrationProfile.objects.expired())) # * User with is_active=False, activation_key != ACTIVATED, # date_joined too old to be in activation window is expired. User.objects.filter(username=user.username).update( date_joined=models.F('date_joined') - datetime.timedelta( settings.ACCOUNT_ACTIVATION_DAYS + 1 ) ) self.assertEqual(1, len(RegistrationProfile.objects.expired())) self.assertEqual( [user.username], list(RegistrationProfile.objects.expired().values_list( 'user__username', flat=True )) ) # * User with is_active=True, activation_key=ACTIVATED, # date_joined too old to be in activation window is not # expired. user.is_active = True user.save() self.assertEqual(0, len(RegistrationProfile.objects.expired())) # * User with is_active=True, activation_key != ACTIVATED, # date_joined too old to be in activation window is not # expired. profile.activation_key = original_activation_key profile.save() self.assertEqual(0, len(RegistrationProfile.objects.expired())) # * User with is_active=True, activation_key != ACTIVATED, # date_joined in the activation window is not expired. user.date_joined = original_date_joined user.save() self.assertEqual(0, len(RegistrationProfile.objects.expired())) @override_settings(USE_TZ=True) def test_expired_query_tz(self): """ The expired() method still functions with time zones enabled. """ self.test_expired_query() django-registration-2.2/registration/tests/test_simple_workflow.py0000644000076700007670000000356313010470420025253 0ustar james00000000000000""" Tests for the simple one-step registration workflow. """ from django.core.urlresolvers import reverse from django.test import modify_settings, override_settings from .. import signals from .base import WorkflowTestCase @modify_settings(INSTALLED_APPS={'remove': 'registration'}) @override_settings(ROOT_URLCONF='registration.backends.simple.urls') class SimpleWorkflowViewTests(WorkflowTestCase): """ Tests for the simple one-step workflow. """ def test_registration(self): """ Registration creates a new account and logs the user in. """ with self.assertSignalSent(signals.user_registered, required_kwargs=['user', 'request']) as cm: resp = self.client.post( reverse('registration_register'), data=self.valid_data ) self.assertEqual( getattr(cm.received_kwargs['user'], self.user_model.USERNAME_FIELD), self.valid_data[self.user_model.USERNAME_FIELD] ) # fetch_redirect_response=False because the URLConf we're # using in these tests does not define a URL pattern for '/', # so allowing the default behavior would fail the test when # that URL 404s. self.assertRedirects(resp, '/', fetch_redirect_response=False) new_user = self.user_model.objects.get(**self.user_lookup_kwargs) self.assertTrue( new_user.check_password( self.valid_data['password1'] ) ) self.assertEqual(new_user.email, self.valid_data['email']) # New user must be active. self.assertTrue(new_user.is_active) # New user must be logged in. resp = self.client.get(reverse('registration_register')) self.assertTrue(resp.context['user'].is_authenticated()) django-registration-2.2/registration/tests/test_views.py0000644000076700007670000000223712660450502023173 0ustar james00000000000000""" Tests for django-registration's built-in views. """ from django.core.urlresolvers import reverse from django.test import override_settings from ..models import RegistrationProfile from .base import RegistrationTestCase @override_settings(ROOT_URLCONF='registration.tests.urls') class ActivationViewTests(RegistrationTestCase): """ Tests for aspects of the activation view not currently exercised by any built-in workflow. """ @override_settings(ACCOUNT_ACTIVATION_DAYS=7) def test_activation(self): """ Activation of an account functions properly when using a simple string URL as the success redirect. """ resp = self.client.post( reverse('registration_register'), data=self.valid_data ) profile = RegistrationProfile.objects.get( user__username=self.valid_data[self.user_model.USERNAME_FIELD] ) resp = self.client.get( reverse( 'registration_activate', args=(), kwargs={'activation_key': profile.activation_key} ) ) self.assertRedirects(resp, '/') django-registration-2.2/registration/tests/urls.py0000644000076700007670000000314012604633610021757 0ustar james00000000000000""" URLs used in the unit tests for django-registration. You should not attempt to use these URLs in any sort of real or development environment. """ from django.conf.urls import include, url from django.views.generic.base import TemplateView from registration.backends.model_activation.views import RegistrationView from .views import ActivateWithSimpleRedirect urlpatterns = [ url(r'^$', TemplateView.as_view( template_name='registration/activation_complete.html' ), name='simple_activation_redirect'), url(r'^activate/complete/$', TemplateView.as_view( template_name='registration/activation_complete.html' ), name='registration_activation_complete'), # Activation keys get matched by \w+ instead of the more specific # [a-fA-F0-9]{40} because a bad activation key should still get to # the view; that way it can return a sensible "invalid key" # message instead of a confusing 404. url(r'^activate/(?P\w+)/$', ActivateWithSimpleRedirect.as_view(), name='registration_activate'), url(r'^register/$', RegistrationView.as_view(), name='registration_register'), url(r'^register/complete/$', TemplateView.as_view( template_name='registration/registration_complete.html' ), name='registration_complete'), url(r'^register/closed/$', TemplateView.as_view( template_name='registration/registration_closed.html' ), name='registration_disallowed'), url(r'', include('registration.auth_urls')), ] django-registration-2.2/registration/tests/views.py0000644000076700007670000000073212604633610022133 0ustar james00000000000000""" Viw classes to exercise options of the registration view behavior not covered by the built-in workflows. """ from registration.backends.model_activation.views import ActivationView class ActivateWithSimpleRedirect(ActivationView): def get_success_url(self, user): """ Returns a simple string URL to redirect to on success, rather than a (view, args, kwargs) 3-tuple, to test handling of that case. """ return '/' django-registration-2.2/registration/urls.py0000644000076700007670000000114012616070230020607 0ustar james00000000000000""" Backwards-compatible URLconf for existing django-registration installs; this allows the standard ``include('registration.urls')`` to continue working, but that usage is deprecated and will be removed in a future release. For new installs, use ``include('registration.backends.model_activation.urls')``. """ import warnings from registration.backends.model_activation import urls as model_urls warnings.warn( "include('registration.urls') is deprecated; use " "include('registration.backends.model_activation.urls') instead.", DeprecationWarning ) urlpatterns = model_urls.urlpatterns django-registration-2.2/registration/validators.py0000644000076700007670000001013312746061647022014 0ustar james00000000000000""" Error messages, data and custom validation code used in django-registration's various user-registration form classes. """ from django.core.exceptions import ValidationError from django.utils.translation import ugettext_lazy as _ DUPLICATE_EMAIL = _(u"This email address is already in use. " u"Please supply a different email address.") FREE_EMAIL = _(u"Registration using free email addresses is prohibited. " u"Please supply a different email address.") RESERVED_NAME = _(u"This value is reserved and cannot be registered.") TOS_REQUIRED = _(u"You must agree to the terms to register") # Below we construct a large but non-exhaustive list of names which # users probably should not be able to register with, due to various # risks: # # * For a site which creates email addresses from username, important # common addresses must be reserved. # # * For a site which creates subdomains from usernames, important # common hostnames/domain names must be reserved. # # * For a site which uses the username to generate a URL to the user's # profile, common well-known filenames must be reserved. # # etc., etc. # # Credit for basic idea and most of the list to Geoffrey Thomas's blog # post about names to reserve: # https://ldpreload.com/blog/names-to-reserve SPECIAL_HOSTNAMES = [ # Hostnames with special/reserved meaning. 'autoconfig', # Thunderbird autoconfig 'autodiscover', # MS Outlook/Exchange autoconfig 'broadcasthost', # Network broadcast hostname 'isatap', # IPv6 tunnel autodiscovery 'localdomain', # Loopback 'localhost', # Loopback 'wpad', # Proxy autodiscovery ] PROTOCOL_HOSTNAMES = [ # Common protocol hostnames. 'ftp', 'imap', 'mail', 'news', 'pop', 'pop3', 'smtp', 'usenet', 'uucp', 'webmail', 'www', ] CA_ADDRESSES = [ # Email addresses known used by certificate authorities during # verification. 'admin', 'administrator', 'hostmaster', 'info', 'is', 'it', 'mis', 'postmaster', 'root', 'ssladmin', 'ssladministrator', 'sslwebmaster', 'sysadmin', 'webmaster', ] RFC_2142 = [ # RFC-2142-defined names not already covered. 'abuse', 'marketing', 'noc', 'sales', 'security', 'support', ] NOREPLY_ADDRESSES = [ # Common no-reply email addresses. 'mailer-daemon', 'nobody', 'noreply', 'no-reply', ] SENSITIVE_FILENAMES = [ # Sensitive filenames. 'clientaccesspolicy.xml', # Silverlight cross-domain policy file. 'crossdomain.xml', # Flash cross-domain policy file. 'favicon.ico', 'humans.txt', 'robots.txt', '.htaccess', '.htpasswd', ] OTHER_SENSITIVE_NAMES = [ # Other names which could be problems depending on URL/subdomain # structure. 'account', 'accounts', 'blog', 'buy', 'clients', 'contact', 'contactus', 'contact-us', 'copyright', 'dashboard', 'doc', 'docs', 'download', 'downloads', 'enquiry', 'faq', 'help', 'inquiry', 'license', 'login', 'logout', 'me', 'myaccount', 'payments', 'plans', 'portfolio', 'preferences', 'pricing', 'privacy', 'profile', 'register' 'secure', 'settings', 'signin', 'signup', 'ssl', 'status', 'subscribe', 'terms', 'tos', 'user', 'users' 'weblog', 'work', ] DEFAULT_RESERVED_NAMES = (SPECIAL_HOSTNAMES + PROTOCOL_HOSTNAMES + CA_ADDRESSES + RFC_2142 + NOREPLY_ADDRESSES + SENSITIVE_FILENAMES + OTHER_SENSITIVE_NAMES) class ReservedNameValidator(object): """ Validator which disallows many reserved names as form field values. """ def __init__(self, reserved_names=DEFAULT_RESERVED_NAMES): self.reserved_names = reserved_names def __call__(self, value): if value in self.reserved_names or \ value.startswith('.well-known'): raise ValidationError( RESERVED_NAME, code='invalid' ) django-registration-2.2/registration/views.py0000644000076700007670000001055013011014670020760 0ustar james00000000000000""" Base view classes for all registration workflows. """ from django.conf import settings from django.shortcuts import redirect from django.views.generic.base import TemplateView from django.views.generic.edit import FormView from registration import signals from registration.forms import RegistrationForm class RegistrationView(FormView): """ Base class for user registration views. """ disallowed_url = 'registration_disallowed' form_class = RegistrationForm success_url = None template_name = 'registration/registration_form.html' def dispatch(self, *args, **kwargs): """ Check that user signup is allowed before even bothering to dispatch or do other processing. """ if not self.registration_allowed(): return redirect(self.disallowed_url) return super(RegistrationView, self).dispatch(*args, **kwargs) def form_valid(self, form): new_user = self.register(form) success_url = self.get_success_url(new_user) # success_url may be a simple string, or a tuple providing the # full argument set for redirect(). Attempting to unpack it # tells us which one it is. try: to, args, kwargs = success_url return redirect(to, *args, **kwargs) except ValueError: return redirect(success_url) def form_invalid(self, form): # tl;dr -- this method is implemented to work around Django # ticket #25548, which is present in the Django 1.9 release # (but not in Django 1.8 or 1.10). # # The longer explanation is that in Django 1.9, # FormMixin.form_invalid() does not pass the form instance to # get_context_data(). This causes get_context_data() to # construct a new form instance with the same data in order to # put it into the template context, and then any access to # that form's ``errors`` or ``cleaned_data`` runs that form # instance's validation. The end result is that validation # gets run twice on an invalid form submission, which is # undesirable for performance reasons. # # Manually implementing this method, and passing the form # instance to get_context_data(), solves this issue (which was # fixed in Django 1.9.1 and so is not present in Django # 1.10). return self.render_to_response(self.get_context_data(form=form)) def registration_allowed(self): """ Override this to enable/disable user registration, either globally or on a per-request basis. """ return getattr(settings, 'REGISTRATION_OPEN', True) def register(self, form): """ Implement user-registration logic here. Access to both the request and the registration form is available here. """ raise NotImplementedError class ActivationView(TemplateView): """ Base class for user activation views. """ template_name = 'registration/activate.html' def get(self, *args, **kwargs): """ The base activation logic; subclasses should leave this method alone and implement activate(), which is called from this method. """ activated_user = self.activate(*args, **kwargs) if activated_user: signals.user_activated.send( sender=self.__class__, user=activated_user, request=self.request ) success_url = self.get_success_url(activated_user) try: to, args, kwargs = success_url return redirect(to, *args, **kwargs) except ValueError: return redirect(success_url) return super(ActivationView, self).get(*args, **kwargs) def activate(self, *args, **kwargs): """ Implement account-activation logic here. """ raise NotImplementedError def get_success_url(self, user): """ Implement this to return the URL (either a 3-tuple for redirect(), or a simple string name of a URL pattern) to redirect to after successful activation. This differs from most get_success_url() methods of Django views in that it receives an extra argument: the user whose account was activated. """ raise NotImplementedError django-registration-2.2/setup.cfg0000644000076700007670000000065013011716531016365 0ustar james00000000000000[coverage:run] include = registration/* omit = registration/tests/* [coverage:report] fail_under = 100 exclude_lines = pragma: no cover def __str__ raise NotImplementedError omit = registration/runtests.py,registration/__init__.py,registration/tests/* [flake8] exclude = locale,__pycache__,.pyc,templates max-complexity = 10 [isort] lines_after_imports = 2 [egg_info] tag_build = tag_date = 0 tag_svn_revision = 0 django-registration-2.2/setup.py0000644000076700007670000000443113007322606016260 0ustar james00000000000000import os from setuptools import setup from registration import get_version # Compile the list of packages available, because distutils doesn't have # an easy way to do this. packages, data_files = [], [] root_dir = os.path.dirname(__file__) if root_dir: os.chdir(root_dir) for dirpath, dirnames, filenames in os.walk('registration'): # Ignore dirnames that start with '.' for i, dirname in enumerate(dirnames): if dirname.startswith('.') or '__pycache__' in dirname: del dirnames[i] if '__init__.py' in filenames: pkg = dirpath.replace(os.path.sep, '.') if os.path.altsep: pkg = pkg.replace(os.path.altsep, '.') packages.append(pkg) elif filenames: prefix = dirpath[13:] # Strip "registration/" or "registration\" for f in filenames: data_files.append(os.path.join(prefix, f)) setup(name='django-registration', zip_safe=False, # eggs are the devil. version=get_version().replace(' ', '-'), description='An extensible user-registration application for Django', author='James Bennett', author_email='james@b-list.org', url='https://github.com/ubernostrum/django-registration/', package_dir={'registration': 'registration'}, packages=packages, package_data={'registration': data_files}, test_suite='registration.runtests.run_tests', classifiers=[ 'Development Status :: 5 - Production/Stable', 'Environment :: Web Environment', 'Framework :: Django', 'Framework :: Django :: 1.8', 'Framework :: Django :: 1.9', 'Framework :: Django :: 1.10', 'Intended Audience :: Developers', 'License :: OSI Approved :: BSD License', 'Operating System :: OS Independent', 'Programming Language :: Python', 'Topic :: Software Development :: Libraries :: Python Modules', 'Programming Language :: Python', 'Programming Language :: Python :: 2', 'Programming Language :: Python :: 2.7', 'Programming Language :: Python :: 3', 'Programming Language :: Python :: 3.3', 'Programming Language :: Python :: 3.4', 'Programming Language :: Python :: 3.5', 'Topic :: Utilities'], )