/ - Diff - Synnefo - Greek Research and Technology Network's projects

     ::
       {"username": "4ad9f34d6e7a4992b34502d40f40cb",
       "uniq": "papagian@example.com"
       "auth_token": "0000",
       "auth_token_expires": "Tue, 11-Sep-2012 09:17:14 ",
       "auth_token_created": "Sun, 11-Sep-2011 09:17:14 ",
       "has_credits": false,
       "has_signed_terms": true}
       {"userid": "270d191e09834408b7af65885f46a3",
       "email": ["user111@example.com"],
       "name": "user1 User1",
       "auth_token_created": 1333372365000,
       "auth_token_expires": 1335964365000,
       "auth_token": "uiWDLAgtJOGW4mI4q9R/8w==",
       "has_credits": true}
+    |

     ===============  ===========================
     Name             Description
     ===============  ===========================
     activateuser     Activates one or more users
     addgroup         Add new group
     addterms         Add new approval terms
     createuser       Create a user
     inviteuser       Invite a user
     listgroups       List groups
     listinvitations  List invitations
     listusers        List users
     modifyuser       Modify a user's attributes
     sendactivation   Send activation email
     showinvitation   Show invitation info
     showuser         Show user info
     addterms         Add new approval terms
     ===============  ===========================
     To update user credibility from the billing system (Aquarium), enable the queue, install snf-pithos-tools and use ``pithos-dispatcher``::
         pithos-dispatcher --exchange=aquarium --callback=astakos.im.queue.listener.on_creditevent
     Load groups:
     ------------
     To set the initial user groups load the followind fixture:
         snf-manage loaddata groups

     from django.core.exceptions import ImproperlyConfigured
     from django.core.mail import send_mail
     from django.template.loader import render_to_string
     from django.utils.translation import ugettext as _
     from django.contrib.sites.models import Site
     from django.contrib import messages
     from django.db import transaction
     from django.core.urlresolvers import reverse
     from django.utils.translation import ugettext as _
     from django.db import transaction
     from urlparse import urljoin
-...
     def get_backend(request):
         """
         Returns an instance of a registration backend,
         Returns an instance of an activation backend,
         according to the INVITATIONS_ENABLED setting
         (if True returns ``astakos.im.activation_backends.InvitationsBackend`` and if False
         returns ``astakos.im.activation_backends.SimpleBackend``).
-...
         try:
             mod = import_module(module)
         except ImportError, e:
             raise ImproperlyConfigured('Error loading registration backend %s: "%s"' % (module, e))
             raise ImproperlyConfigured('Error loading activation backend %s: "%s"' % (module, e))
         try:
             backend_class = getattr(mod, backend_class_name)
         except AttributeError:
             raise ImproperlyConfigured('Module "%s" does not define a registration backend named "%s"' % (module, attr))
             raise ImproperlyConfigured('Module "%s" does not define a activation backend named "%s"' % (module, attr))
         return backend_class(request)
     class SignupBackend(object):
-...
     class InvitationsBackend(SignupBackend):
         """
         A registration backend which implements the following workflow: a user
         A activation backend which implements the following workflow: a user
         supplies the necessary registation information, if the request contains a valid
         inivation code the user is automatically activated otherwise an inactive user
         account is created and the user is going to receive an email as soon as an
-...
             invitation = self.invitation
             initial_data = self.get_signup_initial_data(provider)
             prefix = 'Invited' if invitation else ''
             main = provider.capitalize() if provider == 'local' else 'ThirdParty'
             main = provider.capitalize()
             suffix  = 'UserCreationForm'
             formclass = '%s%s%s' % (prefix, main, suffix)
             ip = self.request.META.get('REMOTE_ADDR',
-...
         def get_signup_initial_data(self, provider):
             """
             Returns the necassary registration form depending the user is invited or not
             Returns the necassary activation form depending the user is invited or not
             Throws Invitation.DoesNotExist in case ``code`` is not valid.
             """
-...
                     # create a tmp user with the invitation realname
                     # to extract first and last name
                     u = AstakosUser(realname = invitation.realname)
                     print '>>>', invitation, invitation.inviter
                     initial_data = {'email':invitation.username,
                                     'inviter':invitation.inviter.realname,
                                     'first_name':u.first_name,
-...
                 return True
             return False
         @transaction.commit_manually
         def handle_activation(self, user, verification_template_name='im/activation_email.txt', greeting_template_name='im/welcome_email.txt', admin_email_template_name='im/admin_notification.txt'):
             """
             Initially creates an inactive user account. If the user is preaccepted
-...
             The method uses commit_manually decorator in order to ensure the user
             will be created only if the procedure has been completed successfully.
             """
             result = None
             try:
                 if user.is_active:
                     return RegistationCompleted()
                 if self._is_preaccepted(user):
                     if user.email_verified:
                         activate(user, greeting_template_name)
                         result = RegistationCompleted()
                         return RegistationCompleted()
                     else:
                         send_verification(user, verification_template_name)
                         result = VerificationSent()
                         return VerificationSent()
                 else:
                     send_admin_notification(user, admin_email_template_name)
                     result = NotificationSent()
                     return NotificationSent()
             except Invitation.DoesNotExist, e:
                 raise InvitationCodeError()
             else:
                 return result
             except BaseException, e:
                 logger.exception(e)
                 raise e
     class SimpleBackend(SignupBackend):
         """
         A registration backend which implements the following workflow: a user
         A activation backend which implements the following workflow: a user
         supplies the necessary registation information, an incative user account is
         created and receives an email in order to activate his/her account.
         """
-...
             * DEFAULT_CONTACT_EMAIL: service support email
             * DEFAULT_FROM_EMAIL: from email
             """
             result = None
             if not self._is_preaccepted(user):
                 send_admin_notification(user, admin_email_template_name)
                 result = NotificationSent()
             try:
                 if user.is_active:
                     return RegistrationCompeted()
                 if not self._is_preaccepted(user):
                     send_admin_notification(user, admin_email_template_name)
                     return NotificationSent()
                 else:
                     send_verification(user, email_template_name)
                     return VerificationSend()
             except SendEmailError, e:
                 transaction.rollback()
                 raise e
             except BaseException, e:
                 logger.exception(e)
                 raise e
             else:
                 send_verification(user, email_template_name)
                 result = VerificationSend()
             return result
                 transaction.commit()
     class ActivationResult(object):
         def __init__(self, message):
-...
     class RegistationCompleted(ActivationResult):
         def __init__(self):
             message = _('Registration completed. You can now login.')
             super(RegistationCompleted, self).__init__(message)
             super(RegistationCompleted, self).__init__(message)

     import logging
     from functools import wraps
     from traceback import format_exc
     from time import time, mktime
     from urllib import quote
-...
     from django.utils import simplejson as json
     from django.core.urlresolvers import reverse
     from astakos.im.faults import BadRequest, Unauthorized, InternalServerError
     from astakos.im.faults import BadRequest, Unauthorized, InternalServerError, Fault
     from astakos.im.models import AstakosUser
     from astakos.im.settings import CLOUD_SERVICES, INVITATIONS_ENABLED
     from astakos.im.util import has_signed_terms
     from astakos.im.util import has_signed_terms, epoch
     logger = logging.getLogger(__name__)
-...
         response['Content-Length'] = len(response.content)
         return response
     def authenticate(request):
     def api_method(http_method=None, token_required=False, perms=[]):
         """Decorator function for views that implement an API method."""
         def decorator(func):
             @wraps(func)
             def wrapper(request, *args, **kwargs):
                 try:
                     if http_method and request.method != http_method:
                         raise BadRequest('Method not allowed.')
                     x_auth_token = request.META.get('HTTP_X_AUTH_TOKEN')
                     if token_required:
                         if not x_auth_token:
                             raise Unauthorized('Access denied')
                         try:
                             user = AstakosUser.objects.get(auth_token=x_auth_token)
                             if not user.has_perms(perms):
                                 raise Unauthorized('Unauthorized request')
                         except AstakosUser.DoesNotExist, e:
                             raise Unauthorized('Invalid X-Auth-Token')
                         kwargs['user'] = user
                     response = func(request, *args, **kwargs)
                     return response
                 except Fault, fault:
                     return render_fault(request, fault)
                 except BaseException, e:
                     logger.exception('Unexpected error: %s' % e)
                     fault = InternalServerError('Unexpected error')
                     return render_fault(request, fault)
             return wrapper
         return decorator
     @api_method(http_method='GET', token_required=True)
     def authenticate_old(request, user=None):
         # Normal Response Codes: 204
         # Error Response Codes: internalServerError (500)
         #                       badRequest (400)
         #                       unauthorised (401)
         try:
             if request.method != 'GET':
                 raise BadRequest('Method not allowed.')
             x_auth_token = request.META.get('HTTP_X_AUTH_TOKEN')
             if not x_auth_token:
                 return render_fault(request, BadRequest('Missing X-Auth-Token'))
             try:
                 user = AstakosUser.objects.get(auth_token=x_auth_token)
             except AstakosUser.DoesNotExist, e:
                 return render_fault(request, Unauthorized('Invalid X-Auth-Token'))
             # Check if the is active.
             if not user.is_active:
                 return render_fault(request, Unauthorized('User inactive'))
             # Check if the token has expired.
             if (time() - mktime(user.auth_token_expires.timetuple())) > 0:
                 return render_fault(request, Unauthorized('Authentication expired'))
             if not has_signed_terms(user):
                 return render_fault(request, Unauthorized('Pending approval terms'))
             response = HttpResponse()
             response.status=204
             user_info = {'username':user.username,
                          'uniq':user.email,
                          'auth_token':user.auth_token,
                          'auth_token_created':user.auth_token_created.isoformat(),
                          'auth_token_expires':user.auth_token_expires.isoformat(),
                          'has_credits':user.has_credits,
                          'has_signed_terms':has_signed_terms(user)}
             response.content = json.dumps(user_info)
             response['Content-Type'] = 'application/json; charset=UTF-8'
             response['Content-Length'] = len(response.content)
             return response
         except BaseException, e:
             logger.exception(e)
             fault = InternalServerError('Unexpected error')
             return render_fault(request, fault)
         if not user:
             raise BadRequest('No user')
         # Check if the is active.
         if not user.is_active:
             raise Unauthorized('User inactive')
     def get_services(request):
         if request.method != 'GET':
             raise BadRequest('Method not allowed.')
         # Check if the token has expired.
         if (time() - mktime(user.auth_token_expires.timetuple())) > 0:
             raise Unauthorized('Authentication expired')
         if not has_signed_terms(user):
             raise Unauthorized('Pending approval terms')
         response = HttpResponse()
         response.status=204
         user_info = {'username':user.username,
                      'uniq':user.email,
                      'auth_token':user.auth_token,
                      'auth_token_created':user.auth_token_created.isoformat(),
                      'auth_token_expires':user.auth_token_expires.isoformat(),
                      'has_credits':user.has_credits,
                      'has_signed_terms':has_signed_terms(user)}
         response.content = json.dumps(user_info)
         response['Content-Type'] = 'application/json; charset=UTF-8'
         response['Content-Length'] = len(response.content)
         return response
     @api_method(http_method='GET', token_required=True)
     def authenticate(request, user=None):
         # Normal Response Codes: 204
         # Error Response Codes: internalServerError (500)
         #                       badRequest (400)
         #                       unauthorised (401)
         if not user:
             raise BadRequest('No user')
         # Check if the is active.
         if not user.is_active:
             raise Unauthorized('User inactive')
         # Check if the token has expired.
         if (time() - mktime(user.auth_token_expires.timetuple())) > 0:
             raise Unauthorized('Authentication expired')
         if not has_signed_terms(user):
             raise Unauthorized('Pending approval terms')
         response = HttpResponse()
         response.status=204
         user_info = {'userid':user.username,
                      'email':[user.email],
                      'name':user.realname,
                      'auth_token':user.auth_token,
                      'auth_token_created':epoch(user.auth_token_created),
                      'auth_token_expires':epoch(user.auth_token_expires),
                      'has_credits':user.has_credits,
                      'is_active':user.is_active,
                      'groups':[g.name for g in user.groups.all()]}
         response.content = json.dumps(user_info)
         response['Content-Type'] = 'application/json; charset=UTF-8'
         response['Content-Length'] = len(response.content)
         return response
     @api_method(http_method='GET')
     def get_services(request):
         callback = request.GET.get('callback', None)
         data = json.dumps(CLOUD_SERVICES)
         mimetype = 'application/json'
-...
         return HttpResponse(content=data, mimetype=mimetype)
     @api_method()
     def get_menu(request, with_extra_links=False, with_signout=True):
         location = request.GET.get('location', '')
         exclude = []
-...
             l.append({ 'url': absolute(reverse('astakos.im.views.edit_profile')),
                       'name': "My account" })
             if with_extra_links:
                 if request.user.password:
                 if request.user.has_usable_password():
                     l.append({ 'url': absolute(reverse('password_change')),
                               'name': "Change password" })
                 if INVITATIONS_ENABLED:
-...
             data = '%s(%s)' % (callback, data)
         return HttpResponse(content=data, mimetype=mimetype)
     @api_method(http_method='GET', token_required=True, perms=['astakos.im.can_find_userid'])
     def find_userid(request):
         # Normal Response Codes: 204
         # Error Response Codes: internalServerError (500)
         #                       badRequest (400)
         #                       unauthorised (401)
         email = request.GET.get('email')
         if not email:
             raise BadRequest('Email missing')
         try:
             user = AstakosUser.objects.get(email = email)
         except AstakosUser.DoesNotExist, e:
             raise BadRequest('Invalid email')
         else:
             response = HttpResponse()
             response.status=204
             user_info = {'userid':user.username}
             response.content = json.dumps(user_info)
             response['Content-Type'] = 'application/json; charset=UTF-8'
             response['Content-Length'] = len(response.content)
             return response
     @api_method(http_method='GET', token_required=True, perms=['astakos.im.can_find_email'])
     def find_email(request):
         # Normal Response Codes: 204
         # Error Response Codes: internalServerError (500)
         #                       badRequest (400)
         #                       unauthorised (401)
         userid = request.GET.get('userid')
         if not userid:
             raise BadRequest('Userid missing')
         try:
             user = AstakosUser.objects.get(username = userid)
         except AstakosUser.DoesNotExist, e:
             raise BadRequest('Invalid userid')
         else:
             response = HttpResponse()
             response.status=204
             user_info = {'userid':user.email}
             response.content = json.dumps(user_info)
             response['Content-Type'] = 'application/json; charset=UTF-8'
             response['Content-Length'] = len(response.content)
             return response

+    [
+        {
             "model": "auth.group",
             "pk": 1,
             "fields": {
                 "name": "default"
+            }
         },
+        {
             "model": "auth.group",
             "pk": 2,
             "fields": {
                 "name": "academic"
+            }
         },
+        {
             "model": "auth.group",
             "pk": 3,
             "fields": {
                 "name": "shibboleth"
+            }
+        }
+    ]

     # Copyright 2011-2012 GRNET S.A. All rights reserved.
+    #
+    #
     # Redistribution and use in source and binary forms, with or
     # without modification, are permitted provided that the following
     # conditions are met:
+    #
+    #
     #   1. Redistributions of source code must retain the above
     #      copyright notice, this list of conditions and the following
     #      disclaimer.
+    #
+    #
     #   2. 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.
+    #
+    #
     # THIS SOFTWARE IS PROVIDED BY GRNET S.A. ``AS IS'' AND ANY EXPRESS
     # OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
     # WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-...
     # 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.
+    #
+    #
     # The views and conclusions contained in the software and
     # documentation are those of the authors and should not be
     # interpreted as representing official policies, either expressed
-...
     from django.utils.http import int_to_base36
     from django.core.urlresolvers import reverse
     from django.utils.functional import lazy
     from django.utils.safestring import mark_safe
     from astakos.im.models import AstakosUser, Invitation
     from astakos.im.settings import INVITATIONS_PER_LEVEL, DEFAULT_FROM_EMAIL, BASEURL, SITENAME, RECAPTCHA_PRIVATE_KEY, DEFAULT_CONTACT_EMAIL, RECAPTCHA_ENABLED
-...
     class LocalUserCreationForm(UserCreationForm):
         """
         Extends the built in UserCreationForm in several ways:
         * Adds email, first_name, last_name, recaptcha_challenge_field, recaptcha_response_field field.
         * The username field isn't visible and it is assigned a generated id.
         * User created is not active.
         * User created is not active.
         """
         recaptcha_challenge_field = forms.CharField(widget=DummyWidget)
         recaptcha_response_field = forms.CharField(widget=RecaptchaWidget, label='')
         class Meta:
             model = AstakosUser
             fields = ("email", "first_name", "last_name", "has_signed_terms")
             widgets = {"has_signed_terms":ApprovalTermsWidget(terms_uri=reverse_lazy('latest_terms'))}
         def __init__(self, *args, **kwargs):
             """
             Changes the order of fields, and removes the username field.
-...
             if RECAPTCHA_ENABLED:
                 self.fields.keyOrder.extend(['recaptcha_challenge_field',
                                              'recaptcha_response_field',])
             if 'has_signed_terms' in self.fields:
                 # Overriding field label since we need to apply a link
                 # to the terms within the label
                 terms_link_html = '<a href="%s" target="_blank">%s</a>' \
                         % (reverse('latest_terms'), _("the terms"))
                 self.fields['has_signed_terms'].label = \
                         mark_safe("I agree with %s" % terms_link_html)
         def clean_email(self):
             email = self.cleaned_data['email']
             if not email:
-...
                 raise forms.ValidationError(_("This email is already used"))
             except AstakosUser.DoesNotExist:
                 return email
         def clean_has_signed_terms(self):
             has_signed_terms = self.cleaned_data['has_signed_terms']
             if not has_signed_terms:
                 raise forms.ValidationError(_('You have to agree with the terms'))
             return has_signed_terms
         def clean_recaptcha_response_field(self):
             if 'recaptcha_challenge_field' in self.cleaned_data:
                 self.validate_captcha()
-...
             check = captcha.submit(rcf, rrf, RECAPTCHA_PRIVATE_KEY, self.ip)
             if not check.is_valid:
                 raise forms.ValidationError(_('You have not entered the correct words'))
         def save(self, commit=True):
             """
             Saves the email, first_name and last_name properties, after the normal
-...
             """
             user = super(LocalUserCreationForm, self).save(commit=False)
             user.renew_token()
             user.date_signed_terms = datetime.now()
             if commit:
                 user.save()
             logger.info('Created user %s', user)
-...
         """
         Extends the LocalUserCreationForm: adds an inviter readonly field.
         """
         inviter = forms.CharField(widget=forms.TextInput(), label=_('Inviter Real Name'))
         class Meta:
             model = AstakosUser
             fields = ("email", "first_name", "last_name", "has_signed_terms")
             widgets = {"has_signed_terms":ApprovalTermsWidget(terms_uri=reverse_lazy('latest_terms'))}
         def __init__(self, *args, **kwargs):
             """
             Changes the order of fields, and removes the username field.
             """
             super(InvitedLocalUserCreationForm, self).__init__(*args, **kwargs)
             #set readonly form fields
             self.fields['inviter'].widget.attrs['readonly'] = True
             self.fields['email'].widget.attrs['readonly'] = True
             self.fields['username'].widget.attrs['readonly'] = True
         def save(self, commit=True):
             user = super(InvitedLocalUserCreationForm, self).save(commit=False)
             level = user.invitation.inviter.level + 1
-...
                 user.save()
             return user
     class ThirdPartyUserCreationForm(UserCreationForm):
     class ThirdPartyUserCreationForm(forms.ModelForm):
         class Meta:
             model = AstakosUser
             fields = ("email", "has_signed_terms")
             fields = ("email", "first_name", "last_name", "third_party_identifier",
                       "has_signed_terms", "provider")
             widgets = {"has_signed_terms":ApprovalTermsWidget(terms_uri=reverse_lazy('latest_terms'))}
         def __init__(self, *args, **kwargs):
-...
             Changes the order of fields, and removes the username field.
             """
             if 'ip' in kwargs:
                 self.ip = kwargs['ip']
                 kwargs.pop('ip')
             super(ThirdPartyUserCreationForm, self).__init__(*args, **kwargs)
             self.fields.keyOrder = ['email']
             self.fields.keyOrder = ['email', 'first_name', 'last_name',
                                     'provider', 'third_party_identifier']
             if get_latest_terms():
                 self.fields.keyOrder.append('has_signed_terms')
             #set readonly form fields
             ro = ["provider", "third_party_identifier", "first_name", "last_name"]
             for f in ro:
                 self.fields[f].widget.attrs['readonly'] = True
             if 'has_signed_terms' in self.fields:
                 # Overriding field label since we need to apply a link
                 # to the terms within the label
                 terms_link_html = '<a href="%s" target="_blank">%s</a>' \
                         % (reverse('latest_terms'), _("the terms"))
                 self.fields['has_signed_terms'].label = \
                         mark_safe("I agree with %s" % terms_link_html)
         def clean_email(self):
             email = self.cleaned_data['email']
             if not email:
                 raise forms.ValidationError(_("This field is required"))
             try:
                 AstakosUser.objects.get(email = email)
                 raise forms.ValidationError(_("This email is already used"))
             except AstakosUser.DoesNotExist:
                 return email
         def clean_has_signed_terms(self):
             has_signed_terms = self.cleaned_data['has_signed_terms']
             if not has_signed_terms:
                 raise forms.ValidationError(_('You have to agree with the terms'))
             return has_signed_terms
         def save(self, commit=True):
             user = super(ThirdPartyUserCreationForm, self).save(commit=False)
             user.set_unusable_password()
             user.renew_token()
             if commit:
                 user.save()
             logger.info('Created user %s', user)
-...
             #set readonly form fields
             self.fields['email'].widget.attrs['readonly'] = True
     class ShibbolethUserCreationForm(ThirdPartyUserCreationForm):
         def clean_email(self):
             email = self.cleaned_data['email']
             if not email:
                 raise forms.ValidationError(_("This field is required"))
             try:
                 user = AstakosUser.objects.get(email = email)
                 if user.provider == 'local':
                     self.instance = user
                     return email
                 else:
                     raise forms.ValidationError(_("This email is already associated with another shibboleth account."))
             except AstakosUser.DoesNotExist:
                 return email
     class LoginForm(AuthenticationForm):
         username = forms.EmailField(label=_("Email"))
-...
         """
         Subclass of ``ModelForm`` for permiting user to edit his/her profile.
         Most of the fields are readonly since the user is not allowed to change them.
         The class defines a save method which sets ``is_verified`` to True so as the user
         during the next login will not to be redirected to profile page.
         """
         renew = forms.BooleanField(label='Renew token', required=False)
         class Meta:
             model = AstakosUser
             fields = ('email', 'first_name', 'last_name', 'auth_token', 'auth_token_expires')
             fields = ('email', 'first_name', 'last_name', 'auth_token', 'auth_token_expires', 'groups')
         def __init__(self, *args, **kwargs):
             super(ProfileForm, self).__init__(*args, **kwargs)
             instance = getattr(self, 'instance', None)
             ro_fields = ('auth_token', 'auth_token_expires', 'email')
             ro_fields = ('auth_token', 'auth_token_expires', 'groups')
             if instance and instance.id:
                 for field in ro_fields:
                     self.fields[field].widget.attrs['readonly'] = True
         def save(self, commit=True):
             user = super(ProfileForm, self).save(commit=False)
             user.is_verified = True
-...
         """
         Form for sending an invitations
         """
         email = forms.EmailField(required = True, label = 'Email address')
         first_name = forms.EmailField(label = 'First name')
         last_name = forms.EmailField(label = 'Last name')
-...
         """
         Extends PasswordResetForm by overriding save method:
         passes a custom from_email in send_mail.
         Since Django 1.3 this is useless since ``django.contrib.auth.views.reset_password``
         accepts a from_email argument.
         """
-...
             Generates a one-use only link for resetting password and sends to the user.
             """
             for user in self.users_cache:
                 url = urljoin(BASEURL,
                               '/im/local/reset/confirm/%s-%s' %(int_to_base36(user.id),
                                                                 token_generator.make_token(user)))
                 url = reverse('django.contrib.auth.views.password_reset_confirm',
                               kwargs={'uidb36':int_to_base36(user.id),
                                       'token':token_generator.make_token(user)})
                 url = request.build_absolute_uri(url)
                 t = loader.get_template(email_template_name)
                 c = {
                     'email': user.email,
-...
         class Meta:
             model = AstakosUser
             fields = ("has_signed_terms",)
         def __init__(self, *args, **kwargs):
             super(SignApprovalTermsForm, self).__init__(*args, **kwargs)
         def clean_has_signed_terms(self):
             has_signed_terms = self.cleaned_data['has_signed_terms']
             if not has_signed_terms:
                 raise forms.ValidationError(_('You have to agree with the terms'))
             return has_signed_terms
         def save(self, commit=True):
             """
             Updates date_signed_terms & has_signed_terms fields.
             """
             user = super(SignApprovalTermsForm, self).save(commit=False)
             user.date_signed_terms = datetime.now()
             if commit:
                 user.save()
             return user
     class InvitationForm(forms.ModelForm):
         username = forms.EmailField(label=_("Email"))
         def __init__(self, *args, **kwargs):
             super(InvitationForm, self).__init__(*args, **kwargs)
         class Meta:
             model = Invitation
             fields = ('username', 'realname')
-...
                 raise forms.ValidationError(_('There is already invitation for this email.'))
             except Invitation.DoesNotExist:
                 pass
             return username
             return username

         Raises SendInvitationError
         """
         invitation.inviter = inviter
         invitation.save()
         send_invitation(invitation, email_template_name)
         inviter.invitations = max(0, inviter.invitations - 1)
         inviter.save()
-...
             logger.exception(e)
     class SendMailError(Exception):
         def __init__(self, message):
             Exception.__init__(self)
         pass
     class SendAdminNotificationError(SendMailError):
         def __init__(self):
             self.message = _('Failed to send notification')
             SendMailError.__init__(self)
             super(SendAdminNotificationError, self).__init__()
     class SendVerificationError(Exception):
     class SendVerificationError(SendMailError):
         def __init__(self):
             self.message = _('Failed to send verification')
             SendMailError.__init__(self)
             super(SendVerificationError, self).__init__()
     class SendInvitationError(Exception):
     class SendInvitationError(SendMailError):
         def __init__(self):
             self.message = _('Failed to send invitation')
             SendMailError.__init__(self)
             super(SendInvitationError, self).__init__()
     class SendGreetingError(Exception):
     class SendGreetingError(SendMailError):
         def __init__(self):
             self.message = _('Failed to send greeting')
             SendMailError.__init__(self)
             super(SendGreetingError, self).__init__()
     class SendFeedbackError(Exception):
     class SendFeedbackError(SendMailError):
         def __init__(self):
             self.message = _('Failed to send feedback')
             SendMailError.__init__(self)
             super(SendFeedbackError, self).__init__()

     # Copyright 2012 GRNET S.A. All rights reserved.
+    #
     # Redistribution and use in source and binary forms, with or
     # without modification, are permitted provided that the following
     # conditions are met:
+    #
     #   1. Redistributions of source code must retain the above
     #      copyright notice, this list of conditions and the following
     #      disclaimer.
+    #
     #   2. 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.
+    #
     # THIS SOFTWARE IS PROVIDED BY GRNET S.A. ``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 GRNET S.A 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.
+    #
     # The views and conclusions contained in the software and
     # documentation are those of the authors and should not be
     # interpreted as representing official policies, either expressed
     # or implied, of GRNET S.A.
     from optparse import make_option
     from random import choice
     from string import digits, lowercase, uppercase
     from uuid import uuid4
     from time import time
     from os.path import abspath
     from django.core.management.base import BaseCommand, CommandError
     from django.contrib.auth.models import Group
     class Command(BaseCommand):
         args = "<name>"
         help = "Insert group"
         def handle(self, *args, **options):
             if len(args) != 1:
                 raise CommandError("Invalid number of arguments")
             name = args[0].decode('utf8')
             try:
                 Group.objects.get(name=name)
                 raise CommandError("A group with this name already exists")
             except Group.DoesNotExist, e:
                 group = Group(name=name)
                 group.save()
             msg = "Created group id %d" % (group.id,)
             self.stdout.write(msg + '\n')

     # interpreted as representing official policies, either expressed
     # or implied, of GRNET S.A.
     import socket
     from optparse import make_option
     from random import choice
     from string import digits, lowercase, uppercase
-...
             if options['admin']:
                 user.is_admin = True
             user.save()
             msg = "Created user id %d" % (user.id,)
             if options['password'] is None:
                 msg += " with password '%s'" % (password,)
             self.stdout.write(msg + '\n')
             try:
                 user.save()
             except socket.error, e:
                 raise CommandError(e)
             else:
                 msg = "Created user id %d" % (user.id,)
                 if options['password'] is None:
                     msg += " with password '%s'" % (password,)
                 self.stdout.write(msg + '\n')

     from django.core.management.base import BaseCommand, CommandError
     from django.db.utils import IntegrityError
     from django.db import transaction
     from astakos.im.functions import invite, SendMailError
     from astakos.im.models import Invitation
     from ._common import get_user
     @transaction.commit_manually
     class Command(BaseCommand):
         args = "<inviter id or email> <email> <real name>"
         help = "Invite a user"
-...
                     invite(invitation, inviter)
                     self.stdout.write("Invitation sent to '%s'\n" % (email,))
                 except SendMailError, e:
                     transaction.rollback()
                     raise CommandError(e.message)
                 except IntegrityError, e:
                     transaction.rollback()
                     raise CommandError("There is already an invitation for %s" % (email,))
                 else:
                     transaction.commit()
             else:
                 raise CommandError("No invitations left")

     # Copyright 2012 GRNET S.A. All rights reserved.
+    #
     # Redistribution and use in source and binary forms, with or
     # without modification, are permitted provided that the following
     # conditions are met:
+    #
     #   1. Redistributions of source code must retain the above
     #      copyright notice, this list of conditions and the following
     #      disclaimer.
+    #
     #   2. 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.
+    #
     # THIS SOFTWARE IS PROVIDED BY GRNET S.A. ``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 GRNET S.A 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.
+    #
     # The views and conclusions contained in the software and
     # documentation are those of the authors and should not be
     # interpreted as representing official policies, either expressed
     # or implied, of GRNET S.A.
     from optparse import make_option
     from django.core.management.base import BaseCommand, CommandError
     from django.contrib.auth.models import Group
     from astakos.im.models import AstakosUser
     from ._common import format_bool
     class Command(BaseCommand):
         help = "List g"
         option_list = BaseCommand.option_list + (
             make_option('-c',
                 action='store_true',
                 dest='csv',
                 default=False,
                 help="Use pipes to separate values"),
+        )
         def handle(self, *args, **options):
             if args:
                 raise CommandError("Command doesn't accept any arguments")
             groups = Group.objects.all()
             labels = ('id', 'name')
             columns = (1, 2)
             if not options['csv']:
                 line = ' '.join(l.rjust(w) for l, w in zip(labels, columns))
                 self.stdout.write(line + '\n')
                 sep = '-' * len(line)
                 self.stdout.write(sep + '\n')
             for group in groups:
                 fields = (str(group.id), group.name)
                 if options['csv']:
                     line = '|'.join(fields)
                 else:
                     line = ' '.join(f.rjust(w) for f, w in zip(fields, columns))
                 self.stdout.write(line.encode('utf8') + '\n')

             invitations = Invitation.objects.all()
             labels = ('id', 'email', 'real name', 'code', 'used', 'consumed')
             columns = (3, 24, 24, 20, 4, 8)
             labels = ('id', 'inviter', 'email', 'real name', 'code', 'used', 'consumed')
             columns = (3, 24, 24, 24, 20, 4, 8)
             if not options['csv']:
                 line = ' '.join(l.rjust(w) for l, w in zip(labels, columns))
-...
                 code = str(invitation.code)
                 used = format_bool(invitation.is_accepted)
                 consumed = format_bool(invitation.is_consumed)
                 fields = (id, invitation.username, invitation.realname,
                 fields = (id, invitation.inviter.email, invitation.username, invitation.realname,
                           code, used, consumed)
                 if options['csv']:

             if options['pending']:
                 users = users.filter(is_active=False)
             labels = ('id', 'email', 'real name', 'affiliation', 'active', 'admin')
             columns = (3, 24, 24, 12, 6, 5)
             labels = ('id', 'email', 'real name', 'affiliation', 'active', 'admin', 'provider')
             columns = (3, 24, 24, 12, 6, 5, 12)
             if not options['csv']:
                 line = ' '.join(l.rjust(w) for l, w in zip(labels, columns))
-...
                 active = format_bool(user.is_active)
                 admin = format_bool(user.is_superuser)
                 fields = (id, user.email, user.realname, user.affiliation, active,
                           admin)
                           admin, user.provider)
                 if options['csv']:
                     line = '|'.join(fields)

     from optparse import make_option
     from django.core.management.base import BaseCommand, CommandError
     from django.contrib.auth.models import Group
     from ._common import get_user
-...
                 dest='inactive',
                 default=False,
                 help="Change user's state to inactive"),
             make_option('--group',
                 dest='group',
                 help="Extend user groups"),
+            )
         def handle(self, *args, **options):
-...
             if invitations is not None:
                 user.invitations = int(invitations)
             groupname = options.get('group')
             if groupname is not None:
                 try:
                     group = Group.objects.get(name=groupname)
                     user.groups.add(group)
                 except Group.DoesNotExist, e:
                     raise CommandError("Group named %s does not exist." % groupname)
             level = options.get('level')
             if level is not None:
                 user.level = int(level)

     # or implied, of GRNET S.A.
     from django.core.management.base import BaseCommand, CommandError
     from django.db import transaction
     from astakos.im.functions import send_verification
-...
                     self.stderr.write(msg)
                     continue
                 send_verification(user)
                 try:
                     send_verification(user)
                 except SendMailError, e:
                     raise CommandError(e.message)
                 self.stdout.write("Activated '%s'\n" % (user.email,))

                 'verified': format_bool(user.is_verified),
                 'has_credits': format_bool(user.has_credits),
                 'has_signed_terms': format_bool(user.has_signed_terms),
                 'date_signed_terms': format_date(user.date_signed_terms)
                 'date_signed_terms': format_date(user.date_signed_terms),
                 'groups': [elem.name for elem in user.groups.all()],
                 'third_party_identifier': user.third_party_identifier
+            }
             for key, val in sorted(kv.items()):
                 line = '%s: %s\n' % (key.rjust(17), val)
                 line = '%s: %s\n' % (key.rjust(22), val)
                 self.stdout.write(line.encode('utf8'))

     import hashlib
     import uuid
     import logging
     from time import asctime
     from datetime import datetime, timedelta
-...
     from random import randint
     from django.db import models
     from django.contrib.auth.models import User, UserManager
     from django.contrib.auth.models import User, UserManager, Group
     from astakos.im.settings import DEFAULT_USER_LEVEL, INVITATIONS_PER_LEVEL, AUTH_TOKEN_DURATION, BILLING_FIELDS, QUEUE_CONNECTION
     from astakos.im.queue.userevent import UserEvent
-...
     QUEUE_CLIENT_ID = 3 # Astakos.
     logger = logging.getLogger(__name__)
     class AstakosUser(User):
         """
         Extends ``django.contrib.auth.models.User`` by defining additional fields.
-...
         has_signed_terms = models.BooleanField('Agree with the terms?', default=False)
         date_signed_terms = models.DateTimeField('Signed terms date', null=True)
         __has_signed_terms = False
         __groupnames = []
         def __init__(self, *args, **kwargs):
             super(AstakosUser, self).__init__(*args, **kwargs)
             self.__has_signed_terms = self.has_signed_terms
             if self.id:
                 self.__groupnames = [g.name for g in self.groups.all()]
             else:
                 self.is_active = False
         @property
         def realname(self):
             return '%s %s' %(self.first_name, self.last_name)
-...
                 if not self.id:
                     self.date_joined = datetime.now()
                 self.updated = datetime.now()
             # update date_signed_terms if necessary
             if self.__has_signed_terms != self.has_signed_terms:
                 self.date_signed_terms = datetime.now()
             if not self.id:
                 # set username
                 while not self.username:
-...
                         AstakosUser.objects.get(username = username)
                     except AstakosUser.DoesNotExist, e:
                         self.username = username
                 self.is_active = False
                 if not self.provider:
                     self.provider = 'local'
             report_user_event(self)
             super(AstakosUser, self).save(**kwargs)
             # set group if does not exist
             groupname = 'shibboleth' if self.provider == 'shibboleth' else 'default'
             if groupname not in self.__groupnames:
                 try:
                     group = Group.objects.get(name = groupname)
                     self.groups.add(group)
                 except Group.DoesNotExist, e:
                     logger.exception(e)
         def renew_token(self):
             md5 = hashlib.md5()
-...
         accepted = models.DateTimeField('Acceptance date', null=True, blank=True)
         consumed = models.DateTimeField('Consumption date', null=True, blank=True)
         def save(self, **kwargs):
         def __init__(self, *args, **kwargs):
             super(Invitation, self).__init__(*args, **kwargs)
             if not self.id:
                 self.code = _generate_invitation_code()
             super(Invitation, self).save(**kwargs)
         def consume(self):
             self.is_consumed = True

     .navigation {
         min-width: 660px;
+    }
     .mainnav.inline {
         position: absolute;
         right: -10px;
+    }
     .mainnav.inline.subnav {
         position: relative;
         top: 50px;
+    }

       background-color: #3582ac;
+    }
     .rightcol {
       margin-left: 511px;
       display: inline;
       float: left;
       margin-left: 22px;
       width: 306px;
       margin-left: 102px;
+    }
     .rightcol.narrow {
       margin-left: 593px;
       display: inline;
       float: left;
       margin-left: 22px;
       width: 224px;
       margin-left: 102px;
+    }
     .rightcol input[type=text], .rightcol input[type=password] {
       width: 273px;
-...
+    }
     form .form-row.submit {
       margin-top: 22px;
       z-index: 10;
+    }
     form .form-row.with-checkbox {
       margin-top: 7px;
+    }
     form .form-row .extra-link {
       color: #808080;
-...
       color: #aaa;
+    }
     form.innerlabels p {
       display: table;
       position: relative;
+    }
     form textarea,
-...
       color: inherit;
       font-weight: bold;
+    }
     form.innerlabels label.checkbox-label {
       position: relative !important;
       margin-left: 10px !important;
       padding-top: 1em !important;
       top: 11px !important;
       left: 10px;
       cursor: pointer;
+    }
     .service-desc {
       margin-top: 4em;
+    }
-...
       margin-bottom: 2em;
       font-size: 0.8em;
+    }
     .initial_hidden {
     .initially-hidden {
       display: none;
+    }
     /* recaptcha */
-...
       cursor: pointer;
       margin-top: 5.333333333333333px;
+    }
     .textcontent h1, .terms-content h1 {
       font-size: 1.9em;
       margin-bottom: 0.2em;
       margin-top: 1.2em;
       color: #3582ac;
+    }
     .textcontent h1:first-child, .terms-content h1:first-child {
       margin-top: 0;
+    }
     .textcontent h2, .terms-content h2 {
       font-size: 1.6em;
       margin-bottom: 1.1em;
       margin-top: 1.1em;
       color: #3b91bf;
+    }
     .textcontent h2:first-child, .terms-content h2:first-child {
       margin-top: 0;
+    }
     .textcontent h3, .terms-content h3 {
       font-size: 1.3em;
       margin-bottom: 1em;
       margin-top: 1em;
       color: #3b91bf;
+    }
     .textcontent h3:first-child, .terms-content h3:first-child {
       margin-top: 0;
+    }
     .textcontent p, .terms-content p {
       margin-bottom: 1em;
       line-height: 1.5em;
+    }
     .textcontent .date, .terms-content .date {
       margin: 1em 0;
       font-size: 0.9em;
       margin-bottom: 2em;
       color: #808080;
+    }

+    }
     .rightcol {
         .offset(6.5);
         .columns(4);
         .makeColumn(4);
         margin-left: 4*@gridGutterWidth + 14;
         &.narrow {
             .offset(7.5);
             .columns(3);
             .makeColumn(3);
             margin-left: 4*@gridGutterWidth + 14;
+        }
         input[type=text], input[type=password] {
             width: 3*@gridColumnWidth + 4*@gridGutterWidth + 5;
+        }
-...
             position: relative;
             &.submit {
                 margin-top: 1.5*@verticalSpacing;
                 z-index: 10;
+            }
             &.with-checkbox {
                 margin-top: 7px;
+            }
             .extra-link {
-...
+        }
         &.innerlabels p {
             display: table;
             position: relative;
+        }

Synnefo

Revision 18ffbee1