Skip to content
GitLab
Menu
Projects
Groups
Snippets
Help
Help
Support
Community forum
Keyboard shortcuts
?
Submit feedback
Contribute to GitLab
Sign in
Toggle navigation
Menu
Open sidebar
etch
nuages
Commits
22720d0c
Commit
22720d0c
authored
May 12, 2013
by
Christophe Siraut
Browse files
Do not include dependencies. List them in README.
parent
9b45de72
Changes
127
Hide whitespace changes
Inline
Side-by-side
README
View file @
22720d0c
...
...
@@ -6,7 +6,11 @@ Nuages - Easy poll sharing
The project uses the following django applications:
- django-registration: https://bitbucket.org/ubernostrum/django-registration
- django-request: https://github.com/kylef/django-request
- django-voting: https://github.com/brosner/django-voting.git
On debian they can be installed as follow:
# aptitude install python-django-registration python-django-voting
The project uses the following javascripts:
- jquery, jquery-ui: http://www.jquery.com/
...
...
registration/__init__.py
deleted
100644 → 0
View file @
9b45de72
VERSION
=
(
0
,
9
,
0
,
'beta'
,
1
)
def
get_version
():
from
django.utils.version
import
get_version
as
django_get_version
return
django_get_version
(
VERSION
)
# pragma: no cover
registration/admin.py
deleted
100644 → 0
View file @
9b45de72
from
django.contrib
import
admin
from
django.contrib.sites.models
import
RequestSite
from
django.contrib.sites.models
import
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
):
"""
Activates the selected users, if they are not alrady
activated.
"""
for
profile
in
queryset
:
RegistrationProfile
.
objects
.
activate_user
(
profile
.
activation_key
)
activate_users
.
short_description
=
_
(
"Activate users"
)
def
resend_activation_email
(
self
,
request
,
queryset
):
"""
Re-sends 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.
"""
if
Site
.
_meta
.
installed
:
site
=
Site
.
objects
.
get_current
()
else
:
site
=
RequestSite
(
request
)
for
profile
in
queryset
:
if
not
profile
.
activation_key_expired
():
profile
.
send_activation_email
(
site
)
resend_activation_email
.
short_description
=
_
(
"Re-send activation emails"
)
admin
.
site
.
register
(
RegistrationProfile
,
RegistrationAdmin
)
registration/auth_urls.py
deleted
100644 → 0
View file @
9b45de72
"""
URL patterns for the views included in ``django.contrib.auth``.
Including these URLs (via the ``include()`` directive) will set up the
following patterns based at whatever URL prefix they are included
under:
* User login at ``login/``.
* User logout at ``logout/``.
* The two-step password change at ``password/change/`` and
``password/change/done/``.
* The four-step password reset at ``password/reset/``,
``password/reset/confirm/``, ``password/reset/complete/`` and
``password/reset/done/``.
The default registration backend already has an ``include()`` for
these URLs, so under the default setup it is not necessary to manually
include these views. Other backends may or may not include them;
consult a specific backend's documentation for details.
"""
from
django.conf.urls
import
include
from
django.conf.urls
import
patterns
from
django.conf.urls
import
url
from
django.contrib.auth
import
views
as
auth_views
urlpatterns
=
patterns
(
''
,
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
,
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
,
name
=
'auth_password_reset'
),
url
(
r
'^password/reset/confirm/(?P<uidb36>[0-9A-Za-z]+)-(?P<token>.+)/$'
,
auth_views
.
password_reset_confirm
,
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'
),
)
registration/backends/__init__.py
deleted
100644 → 0
View file @
9b45de72
registration/backends/default/__init__.py
deleted
100644 → 0
View file @
9b45de72
registration/backends/default/urls.py
deleted
100644 → 0
View file @
9b45de72
"""
URLconf for registration and activation, using django-registration's
default backend.
If the default behavior of these views is acceptable to you, simply
use a line like this in your root URLconf to set up the default URLs
for registration::
(r'^accounts/', include('registration.backends.default.urls')),
This will also automatically set up the views in
``django.contrib.auth`` at sensible default locations.
If you'd like to customize registration behavior, feel free to set up
your own URL patterns for these views instead.
"""
from
django.conf.urls
import
patterns
from
django.conf.urls
import
include
from
django.conf.urls
import
url
from
django.views.generic.base
import
TemplateView
from
registration.backends.default.views
import
ActivationView
from
registration.backends.default.views
import
RegistrationView
urlpatterns
=
patterns
(
''
,
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<activation_key>\w+)/$'
,
ActivationView
.
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'
),
(
r
''
,
include
(
'registration.auth_urls'
)),
)
registration/backends/default/views.py
deleted
100644 → 0
View file @
9b45de72
from
django.conf
import
settings
from
django.contrib.sites.models
import
RequestSite
from
django.contrib.sites.models
import
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
):
"""
A registration backend which follows a simple workflow:
1. User signs up, inactive account is created.
2. Email is sent to user with activation link.
3. User clicks activation link, account is now active.
Using this backend requires that
* ``registration`` be listed in the ``INSTALLED_APPS`` setting
(since this backend makes use of models defined in this
application).
* The setting ``ACCOUNT_ACTIVATION_DAYS`` be supplied, specifying
(as an integer) the number of days from registration during
which a user may activate their account (after that period
expires, activation will be disallowed).
* The creation of the templates
``registration/activation_email_subject.txt`` and
``registration/activation_email.txt``, which will be used for
the activation email. See the notes for this backends
``register`` method for details regarding these templates.
Additionally, registration can be temporarily closed by adding the
setting ``REGISTRATION_OPEN`` and setting it to
``False``. Omitting this setting, or setting it to ``True``, will
be interpreted as meaning that registration is currently open and
permitted.
Internally, this is accomplished via storing an activation key in
an instance of ``registration.models.RegistrationProfile``. See
that model and its custom manager for full documentation of its
fields and supported operations.
"""
def
register
(
self
,
request
,
**
cleaned_data
):
"""
Given a username, email address and password, register a new
user account, which will initially be inactive.
Along with the new ``User`` object, a new
``registration.models.RegistrationProfile`` will be created,
tied to that ``User``, containing the activation key which
will be used for this account.
An email will be sent to the supplied email address; this
email should contain an activation link. The email will be
rendered using two templates. See the documentation for
``RegistrationProfile.send_activation_email()`` for
information about these templates and the contexts provided to
them.
After the ``User`` and ``RegistrationProfile`` are created and
the activation email is sent, the signal
``registration.signals.user_registered`` will be sent, with
the new ``User`` as the keyword argument ``user`` and the
class of this backend as the sender.
"""
username
,
email
,
password
=
cleaned_data
[
'username'
],
cleaned_data
[
'email'
],
cleaned_data
[
'password1'
]
if
Site
.
_meta
.
installed
:
site
=
Site
.
objects
.
get_current
()
else
:
site
=
RequestSite
(
request
)
new_user
=
RegistrationProfile
.
objects
.
create_inactive_user
(
username
,
email
,
password
,
site
)
signals
.
user_registered
.
send
(
sender
=
self
.
__class__
,
user
=
new_user
,
request
=
request
)
return
new_user
def
registration_allowed
(
self
,
request
):
"""
Indicate whether account registration is currently permitted,
based on the value of the setting ``REGISTRATION_OPEN``. This
is determined as follows:
* If ``REGISTRATION_OPEN`` is not specified in settings, or is
set to ``True``, registration is permitted.
* If ``REGISTRATION_OPEN`` is both specified and set to
``False``, registration is not permitted.
"""
return
getattr
(
settings
,
'REGISTRATION_OPEN'
,
True
)
def
get_success_url
(
self
,
request
,
user
):
"""
Return the name of the URL to redirect to after successful
user registration.
"""
return
(
'registration_complete'
,
(),
{})
class
ActivationView
(
BaseActivationView
):
def
activate
(
self
,
request
,
activation_key
):
"""
Given an an activation key, look up and activate the user
account corresponding to that key (if possible).
After successful activation, the signal
``registration.signals.user_activated`` will be sent, with the
newly activated ``User`` as the keyword argument ``user`` and
the class of this backend as the sender.
"""
activated_user
=
RegistrationProfile
.
objects
.
activate_user
(
activation_key
)
if
activated_user
:
signals
.
user_activated
.
send
(
sender
=
self
.
__class__
,
user
=
activated_user
,
request
=
request
)
return
activated_user
def
get_success_url
(
self
,
request
,
user
):
return
(
'registration_activation_complete'
,
(),
{})
registration/backends/simple/__init__.py
deleted
100644 → 0
View file @
9b45de72
registration/backends/simple/urls.py
deleted
100644 → 0
View file @
9b45de72
"""
URLconf for registration and activation, using django-registration's
one-step backend.
If the default behavior of these views is acceptable to you, simply
use a line like this in your root URLconf to set up the default URLs
for registration::
(r'^accounts/', include('registration.backends.simple.urls')),
This will also automatically set up the views in
``django.contrib.auth`` at sensible default locations.
If you'd like to customize registration behavior, feel free to set up
your own URL patterns for these views instead.
"""
from
django.conf.urls
import
include
from
django.conf.urls
import
patterns
from
django.conf.urls
import
url
from
django.views.generic.base
import
TemplateView
from
registration.backends.simple.views
import
RegistrationView
urlpatterns
=
patterns
(
''
,
url
(
r
'^register/$'
,
RegistrationView
.
as_view
(),
name
=
'registration_register'
),
url
(
r
'^register/closed/$'
,
TemplateView
.
as_view
(
template_name
=
'registration/registration_closed.html'
),
name
=
'registration_disallowed'
),
(
r
''
,
include
(
'registration.auth_urls'
)),
)
registration/backends/simple/views.py
deleted
100644 → 0
View file @
9b45de72
from
django.conf
import
settings
from
django.contrib.auth
import
authenticate
from
django.contrib.auth
import
login
from
django.contrib.auth.models
import
User
from
registration
import
signals
from
registration.views
import
RegistrationView
as
BaseRegistrationView
class
RegistrationView
(
BaseRegistrationView
):
"""
A registration backend which implements the simplest possible
workflow: 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
,
request
,
**
cleaned_data
):
username
,
email
,
password
=
cleaned_data
[
'username'
],
cleaned_data
[
'email'
],
cleaned_data
[
'password1'
]
User
.
objects
.
create_user
(
username
,
email
,
password
)
new_user
=
authenticate
(
username
=
username
,
password
=
password
)
login
(
request
,
new_user
)
signals
.
user_registered
.
send
(
sender
=
self
.
__class__
,
user
=
new_user
,
request
=
request
)
return
new_user
def
registration_allowed
(
self
,
request
):
"""
Indicate whether account registration is currently permitted,
based on the value of the setting ``REGISTRATION_OPEN``. This
is determined as follows:
* If ``REGISTRATION_OPEN`` is not specified in settings, or is
set to ``True``, registration is permitted.
* If ``REGISTRATION_OPEN`` is both specified and set to
``False``, registration is not permitted.
"""
return
getattr
(
settings
,
'REGISTRATION_OPEN'
,
True
)
def
get_success_url
(
self
,
request
,
user
):
return
(
user
.
get_absolute_url
(),
(),
{})
registration/forms.py
deleted
100644 → 0
View file @
9b45de72
"""
Forms and validation code for user registration.
Note that all of these forms assume Django's bundle default ``User``
model; since it's not possible for a form to anticipate in advance the
needs of custom user models, you will need to write your own forms if
you're using a custom model.
"""
from
django.contrib.auth.models
import
User
from
django
import
forms
from
django.utils.translation
import
ugettext_lazy
as
_
class
RegistrationForm
(
forms
.
Form
):
"""
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 avoid defining a ``save()`` method -- the actual
saving of collected user data is delegated to the active
registration backend.
"""
required_css_class
=
'required'
username
=
forms
.
RegexField
(
regex
=
r
'^[\w.@+-]+$'
,
max_length
=
30
,
label
=
_
(
"Username"
),
error_messages
=
{
'invalid'
:
_
(
"This value may contain only letters, numbers and @/./+/-/_ characters."
)})
email
=
forms
.
EmailField
(
label
=
_
(
"E-mail"
))
password1
=
forms
.
CharField
(
widget
=
forms
.
PasswordInput
,
label
=
_
(
"Password"
))
password2
=
forms
.
CharField
(
widget
=
forms
.
PasswordInput
,
label
=
_
(
"Password (again)"
))
def
clean_username
(
self
):
"""
Validate that the username is alphanumeric and is not already
in use.
"""
existing
=
User
.
objects
.
filter
(
username__iexact
=
self
.
cleaned_data
[
'username'
])
if
existing
.
exists
():
raise
forms
.
ValidationError
(
_
(
"A user with that username already exists."
))
else
:
return
self
.
cleaned_data
[
'username'
]
def
clean
(
self
):
"""
Verifiy that the values entered into the two password fields
match. Note that an error here will end up in
``non_field_errors()`` because it doesn't apply to a single
field.
"""
if
'password1'
in
self
.
cleaned_data
and
'password2'
in
self
.
cleaned_data
:
if
self
.
cleaned_data
[
'password1'
]
!=
self
.
cleaned_data
[
'password2'
]:
raise
forms
.
ValidationError
(
_
(
"The two password fields didn't match."
))
return
self
.
cleaned_data
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'
:
_
(
"You must agree to the terms to register"
)})
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
(
_
(
"This email address is already in use. Please supply a different email address."
))
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, subclass this form and
override the attribute ``bad_domains``.
"""
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
(
_
(
"Registration using free email addresses is prohibited. Please supply a different email address."
))
return
self
.
cleaned_data
[
'email'
]
registration/locale/ar/LC_MESSAGES/django.mo
deleted
100644 → 0
View file @
9b45de72
File deleted
registration/locale/ar/LC_MESSAGES/django.po
deleted
100644 → 0
View file @
9b45de72
# 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 <EMAIL@ADDRESS>, 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 <EMAIL@ADDRESS>\n"
"Language-Team: LANGUAGE <LL@li.org>\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 "ملفات التسجيل الشخصية"
registration/locale/bg/LC_MESSAGES/django.mo
deleted
100644 → 0
View file @
9b45de72
File deleted
registration/locale/bg/LC_MESSAGES/django.po
deleted
100644 → 0
View file @
9b45de72
# 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 <EMAIL@ADDRESS>, 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 <vladislav.mitov@gmail.com>\n"