Synnefo » astakos

has_credits                  Whether user has credits

has_signed_terms             Whether user has aggred on terms

  "auth_token_created": "Sun, 11-Sep-2011 09:17:14 ",

  "has_credits": false,

  "has_signed_terms": true}

401 (Unauthorized)          Missing token or inactive user or penging approval terms

addterms         Add new approval terms

from astakos.im.util import has_signed_terms

        if not has_signed_terms(user):

            return render_fault(request, Unauthorized('Pending approval terms'))

                     'has_credits':user.has_credits,

                     'has_signed_terms':has_signed_terms(user)}

    query_dict = request.__getattribute__(request.method)

    return {'next' : query_dict.get('next', '')}

from datetime import datetime

from django.utils.functional import lazy

from astakos.im.widgets import DummyWidget, RecaptchaWidget, ApprovalTermsWidget

# since Django 1.4 use django.core.urlresolvers.reverse_lazy instead

from astakos.im.util import reverse_lazy

        fields = ("email", "first_name", "last_name", "has_signed_terms")

        widgets = {"has_signed_terms":ApprovalTermsWidget(terms_uri=reverse_lazy('latest_terms'))}

                                'has_signed_terms',

                                'recaptcha_response_field',]

    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

        user.date_signed_terms = datetime.now()

        fields = ("email", "first_name", "last_name", "has_signed_terms")

        widgets = {"has_signed_terms":ApprovalTermsWidget(terms_uri=reverse_lazy('latest_terms'))}

                                'has_signed_terms',

class SignApprovalTermsForm(forms.ModelForm):

    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):

        """

        Saves the , after the normal

        save behavior is complete.

        """

        user = super(SignApprovalTermsForm, self).save(commit=False)

        user.date_signed_terms = datetime.now()

        if commit:

            user.save()

        return user

# 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 django.core.management.base import BaseCommand, CommandError

from astakos.im.models import ApprovalTerms

class Command(BaseCommand):

    args = "<location>"

    help = "Insert approval terms"

    def handle(self, *args, **options):

        if len(args) != 1:

            raise CommandError("Invalid number of arguments")

        location = args[0].decode('utf8')

        try:

            f = open(location, 'r')

        except IOError:

            raise CommandError("Invalid location")

        terms = ApprovalTerms(location=location)

        terms.save()

        msg = "Created term id %d" % (terms.id,)

        self.stdout.write(msg + '\n')

            '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)

            line = '%s: %s\n' % (key.rjust(17), val)

# encoding: utf-8

import datetime

from south.db import db

from south.v2 import SchemaMigration

from django.db import models

class Migration(SchemaMigration):

    def forwards(self, orm):

        # Adding model 'ApprovalTerms'

        db.create_table('im_approvalterms', (

            ('id', self.gf('django.db.models.fields.AutoField')(primary_key=True)),

            ('date', self.gf('django.db.models.fields.DateTimeField')(default=datetime.datetime(2012, 3, 20, 14, 24, 30, 616341), db_index=True)),

            ('location', self.gf('django.db.models.fields.CharField')(max_length=255)),

        ))

        db.send_create_signal('im', ['ApprovalTerms'])

        # Adding field 'AstakosUser.has_signed_terms'

        db.add_column('im_astakosuser', 'has_signed_terms', self.gf('django.db.models.fields.BooleanField')(default=False), keep_default=False)

        # Adding field 'AstakosUser.date_signed_terms'

        db.add_column('im_astakosuser', 'date_signed_terms', self.gf('django.db.models.fields.DateTimeField')(null=True), keep_default=False)

    def backwards(self, orm):

        # Deleting model 'ApprovalTerms'

        db.delete_table('im_approvalterms')

        # Deleting field 'AstakosUser.has_signed_terms'

        db.delete_column('im_astakosuser', 'has_signed_terms')

        # Deleting field 'AstakosUser.date_signed_terms'

        db.delete_column('im_astakosuser', 'date_signed_terms')

    models = {

        'auth.group': {

            'Meta': {'object_name': 'Group'},

            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),

            'name': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '80'}),

            'permissions': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['auth.Permission']", 'symmetrical': 'False', 'blank': 'True'})

        },

        'auth.permission': {

            'Meta': {'ordering': "('content_type__app_label', 'content_type__model', 'codename')", 'unique_together': "(('content_type', 'codename'),)", 'object_name': 'Permission'},

            'codename': ('django.db.models.fields.CharField', [], {'max_length': '100'}),

            'content_type': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['contenttypes.ContentType']"}),

            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),

            'name': ('django.db.models.fields.CharField', [], {'max_length': '50'})

        },

        'auth.user': {

            'Meta': {'object_name': 'User'},

            'date_joined': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}),

            'email': ('django.db.models.fields.EmailField', [], {'max_length': '75', 'blank': 'True'}),

            'first_name': ('django.db.models.fields.CharField', [], {'max_length': '30', 'blank': 'True'}),

            'groups': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['auth.Group']", 'symmetrical': 'False', 'blank': 'True'}),

            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),

            'is_active': ('django.db.models.fields.BooleanField', [], {'default': 'True'}),

            'is_staff': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),

            'is_superuser': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),

            'last_login': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}),

            'last_name': ('django.db.models.fields.CharField', [], {'max_length': '30', 'blank': 'True'}),

            'password': ('django.db.models.fields.CharField', [], {'max_length': '128'}),

            'user_permissions': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['auth.Permission']", 'symmetrical': 'False', 'blank': 'True'}),

            'username': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '30'})

        },

        'contenttypes.contenttype': {

            'Meta': {'ordering': "('name',)", 'unique_together': "(('app_label', 'model'),)", 'object_name': 'ContentType', 'db_table': "'django_content_type'"},

            'app_label': ('django.db.models.fields.CharField', [], {'max_length': '100'}),

            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),

            'model': ('django.db.models.fields.CharField', [], {'max_length': '100'}),

            'name': ('django.db.models.fields.CharField', [], {'max_length': '100'})

        },

        'im.approvalterms': {

            'Meta': {'object_name': 'ApprovalTerms'},

            'date': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime(2012, 3, 20, 14, 24, 30, 616341)', 'db_index': 'True'}),

            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),

            'location': ('django.db.models.fields.CharField', [], {'max_length': '255'})

        },

        'im.astakosuser': {

            'Meta': {'object_name': 'AstakosUser', '_ormbases': ['auth.User']},

            'affiliation': ('django.db.models.fields.CharField', [], {'max_length': '255', 'blank': 'True'}),

            'auth_token': ('django.db.models.fields.CharField', [], {'max_length': '32', 'null': 'True', 'blank': 'True'}),

            'auth_token_created': ('django.db.models.fields.DateTimeField', [], {'null': 'True'}),

            'auth_token_expires': ('django.db.models.fields.DateTimeField', [], {'null': 'True'}),

            'date_signed_terms': ('django.db.models.fields.DateTimeField', [], {'null': 'True'}),

            'email_verified': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),

            'has_credits': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),

            'has_signed_terms': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),

            'invitations': ('django.db.models.fields.IntegerField', [], {'default': '0'}),

            'is_verified': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),

            'level': ('django.db.models.fields.IntegerField', [], {'default': '4'}),

            'provider': ('django.db.models.fields.CharField', [], {'max_length': '255', 'blank': 'True'}),

            'third_party_identifier': ('django.db.models.fields.CharField', [], {'max_length': '255', 'null': 'True', 'blank': 'True'}),

            'updated': ('django.db.models.fields.DateTimeField', [], {}),

            'user_ptr': ('django.db.models.fields.related.OneToOneField', [], {'to': "orm['auth.User']", 'unique': 'True', 'primary_key': 'True'})

        },

        'im.invitation': {

            'Meta': {'object_name': 'Invitation'},

            'accepted': ('django.db.models.fields.DateTimeField', [], {'null': 'True', 'blank': 'True'}),

            'code': ('django.db.models.fields.BigIntegerField', [], {'db_index': 'True'}),

            'consumed': ('django.db.models.fields.DateTimeField', [], {'null': 'True', 'blank': 'True'}),

            'created': ('django.db.models.fields.DateTimeField', [], {'auto_now_add': 'True', 'blank': 'True'}),

            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),

            'inviter': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'invitations_sent'", 'null': 'True', 'to': "orm['im.AstakosUser']"}),

            'is_accepted': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),

            'is_consumed': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),

            'realname': ('django.db.models.fields.CharField', [], {'max_length': '255'}),

            'username': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '255'})

        }

    }

    complete_apps = ['im']

    has_signed_terms = models.BooleanField('Agree with the terms?', default=False)

    date_signed_terms = models.DateTimeField('Signed terms date', null=True)

class ApprovalTerms(models.Model):

    """

    Model for approval terms

    """

    date = models.DateTimeField('Issue date', db_index=True, default=datetime.now())

    location = models.CharField('Terms location', max_length=255)

        parts = urlparse(exchange)

        exchange = parts.path[1:]

        routing_key = '%s.user' % exchange

{% block body %}

{{ terms }}

{% if form %}

<div class="section">

    <form action="{% url latest_terms %}" method="post" class="login innerlabels">{% csrf_token %}

                {% include "im/form_render.html" %}

                <input type="hidden" name="next" value="{{ next }}">

                <div class="form-row submit">

                    <input type="submit" class="submit altcol" value="SUBMIT" />

                </div>

        </form>

{% endif %}

{% endblock body %}

from django.contrib.auth.views import password_change

from astakos.im.views import signed_terms_required

    url(r'^activate/?$', 'activate'),

    url(r'^approval_terms/?$', 'approval_terms', {}, name='latest_terms'),

    url(r'^approval_terms/(?P<term_id>\d+)?$', 'approval_terms'),

    url(r'^password/?$', 'change_password', {}, name='password_change')

        url(r'^password_change/?$', 'password_change', {'post_change_redirect':'profile'})

from astakos.im.models import AstakosUser, Invitation, ApprovalTerms

class lazy_string(object):

    def __init__(self, function, *args, **kwargs):

        self.function=function

        self.args=args

        self.kwargs=kwargs

    def __str__(self):

        if not hasattr(self, 'str'):

            self.str=self.function(*self.args, **self.kwargs)

        return self.str

def reverse_lazy(*args, **kwargs):

    return lazy_string(reverse, *args, **kwargs)

def has_signed_terms(user):

    if not user.has_signed_terms:

        return False

    try:

        term = ApprovalTerms.objects.order_by('-id')[0]

        if user.date_signed_terms < term.date:

            return False

    except IndexError:

        pass

    return True

from django.contrib.auth.views import password_change

from astakos.im.models import AstakosUser, Invitation, ApprovalTerms

from astakos.im.util import get_context, prepare_response, set_cookie, has_signed_terms

    Decorator checkes whether the request.user is not Anonymous and in that case

            logout_uri = reverse(logout) + '?' + next

            return HttpResponseRedirect(logout_uri)

def signed_terms_required(func):

    """

    Decorator checkes whether the request.user is Anonymous and in that case

    redirects to `logout`.

    """

    @wraps(func)

    def wrapper(request, *args, **kwargs):

        if request.user.is_authenticated() and not has_signed_terms(request.user):

            params = urlencode({'next': request.build_absolute_uri(),

                              'show_form':''})

            terms_uri = reverse('latest_terms') + '?' + params

            return HttpResponseRedirect(terms_uri)

        return func(request, *args, **kwargs)

    return wrapper

@signed_terms_required

@signed_terms_required

@signed_terms_required

@signed_terms_required

def approval_terms(request, term_id=None, template_name='im/approval_terms.html', extra_context={}):

    term = None

    terms = None

    if not term_id:

        try:

            term = ApprovalTerms.objects.order_by('-id')[0]

        except IndexError:

            pass

    else:

        try:

             term = ApprovalTerms.objects.get(id=term_id)

        except ApprovalTermDoesNotExist, e:

            pass

    if not term:

        return HttpResponseBadRequest(_('No approval terms found.'))

    f = open(term.location, 'r')

    terms = f.read()

    if request.method == 'POST':

        next = request.POST.get('next')

        if not next:

            return HttpResponseBadRequest(_('No next param.'))

        form = SignApprovalTermsForm(request.POST, instance=request.user)

        if not form.is_valid():

            return render_response(template_name,

                           terms = terms,

                           form = form,

                           context_instance = get_context(request, extra_context))

        user = form.save()

        return HttpResponseRedirect(next)

    else:

        form = SignApprovalTermsForm(instance=request.user) if request.user.is_authenticated() else None

        return render_response(template_name,

                               terms = terms,

                               form = form,

                               context_instance = get_context(request, extra_context))

@signed_terms_required

def change_password(request):

    return password_change(request, post_change_redirect=reverse('astakos.im.views.edit_profile'))

from django.utils.translation import ugettext as _

class ApprovalTermsWidget(forms.CheckboxInput):

    """

    A CheckboxInput class with a link to the approval terms.

    """

    def __init__(self, attrs=None, check_test=bool, terms_uri='', terms_label=_('Read the terms')):

        super(ApprovalTermsWidget, self).__init__(attrs, check_test)

        self.uri = terms_uri

        self.label = terms_label

    def render(self, name, value, attrs=None):

        html = super(ApprovalTermsWidget, self).render(name, value, attrs)

        return html + mark_safe('<a href=%s target="_blank">%s</a>' % (self.uri, self.label))