Synnefo » astakos

Αγαπητέ/η {{ user.realname }},

φάση λειτουργίας της έχει ενεργοποιηθεί.

Για να συνδεθείτε, χρησιμοποιήστε τον παρακάτω σύνδεσμο:

    If the ``request.user`` is not a superuser redirects to login page.

    """

    if form.is_valid():

        form.save()

        return redirect(users_info, user.id, template_name, extra_context)

                            context_instance = get_context(request, extra_context,**kwargs))

def _send_greeting(request, user, template_name):

    subject = _('Welcome to %s' %settings.SERVICE_NAME)

    site = Site.objects.get_current()

    baseurl = request.build_absolute_uri('/').rstrip('/')

    message = render_to_string(template_name, {

                'user': user,

                'baseurl': baseurl,

                'site_name': site.name,

                'support': settings.DEFAULT_CONTACT_EMAIL})

        response = HttpResponse()

        response.status=204

        user_info = {'uniq':user.username,

                     'auth_token':user.auth_token,

                     'auth_token_created':user.auth_token_created.isoformat(),

                     'auth_token_expires':user.auth_token_expires.isoformat()}

from django.conf import settings

from django.contrib.auth.backends import ModelBackend

from astakos.im.models import AstakosUser

    """

    """

        try:

                return user

        except AstakosUser.DoesNotExist:

            return None

            return AstakosUser.objects.get(pk=user_id)

        except AstakosUser.DoesNotExist:

            return None

    """

    """

    def get_user(self, user_id):

        try:

            return AstakosUser.objects.get(pk=user_id)

from django.contrib.auth.forms import UserCreationForm

from django.contrib.sites.models import Site

from django.contrib import messages

from smtplib import SMTPException

from urllib import quote

from astakos.im.models import AstakosUser, Invitation

from astakos.im.forms import ExtendedUserCreationForm, InvitedExtendedUserCreationForm

    """

    Return an instance of a registration backend,

    according to the INVITATIONS_ENABLED setting

        backend_class = getattr(mod, backend_class_name)

    except AttributeError:

        raise ImproperlyConfigured('Module "%s" does not define a registration backend named "%s"' % (module, attr))

class InvitationsBackend(object):

    """

    account is created and the user is going to receive an email as soon as an

    administrator activates his/her account.

    """

        """

        Returns the necassary registration form depending the user is invited or not

        Throws Invitation.DoesNotExist in case ``code`` is not valid.

        """

        formclass = 'ExtendedUserCreationForm'

        initial_data = None

        if request.method == 'GET':

                formclass = 'Invited%s' %formclass

                initial_data = {'username':self.invitation.username,

                                'email':self.invitation.username,

                                'realname':self.invitation.realname}

                inviter = AstakosUser.objects.get(username=self.invitation.inviter)

                initial_data['inviter'] = inviter.realname

        else:

            initial_data = request.POST

        return globals()[formclass](initial_data)

        It should be called after ``get_signup_form`` which sets invitation if exists.

        """

        if not invitation:

            return False

            return True

        return False

        """

        In any other case the method returns the action status and a message.

        """

        kwargs = {}

        user = form.save()

        try:

            if self._is_preaccepted(user):

                user.is_active = True

                user.save()

                message = _('Registration completed. You can now login.')

            else:

                message = _('Registration completed. You will receive an email upon your account\'s activation')

            status = messages.SUCCESS

    supplies the necessary registation information, an incative user account is

    created and receives an email in order to activate his/her account.

    """

        """

        Returns the UserCreationForm

        """

        initial_data = request.POST if request.method == 'POST' else None

        """

        Creates an inactive user account and sends a verification email.

        * DEFAULT_FROM_EMAIL: from email

        """

        kwargs = {}

        user = form.save()

        status = messages.SUCCESS

        try:

            message = _('Verification sent to %s' % user.email)

        except (SMTPException, socket.error) as e:

            status = messages.ERROR

            message = getattr(e, name) if hasattr(e, name) else e

        return status, message

        "fields": {

            "level": 1,

            "invitations": 2,

   	}

    }

]

from django import forms

from django.utils.translation import ugettext as _

from django.conf import settings

from hashlib import new as newhasher

from astakos.im.models import AstakosUser

from astakos.im.util import get_or_create_user

import logging

class UniqueUserEmailField(forms.EmailField):

    """

    Extends the built in UserCreationForm in several ways:

    * Adds an email field, which uses the custom UniqueUserEmailField.

    * first_name and last_name fields are added.

    """

    class Meta:

        model = AstakosUser

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

        """

        self.fields.keyOrder = ['email', 'first_name', 'last_name',

                                'password1', 'password2']

    def save(self, commit=True):

        """

        Saves the email, first_name and last_name properties, after the normal

        save behavior is complete.

        """

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

        user.renew_token()

        user.save()

        logging.info('Created user %s', user)

        return user

    """

    """

    inviter = forms.CharField(widget=forms.TextInput(), label=_('Inviter Real Name'))

    class Meta:

        model = AstakosUser

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

        """

        Changes the order of fields, and removes the username field.

        """

        super(InvitedExtendedUserCreationForm, 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

class ProfileForm(forms.ModelForm):

    """

    """

    class Meta:

        model = AstakosUser

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

        super(ProfileForm, self).__init__(*args, **kwargs)

        instance = getattr(self, 'instance', None)

        ro_fields = ('username','date_joined', 'updated', 'auth_token',

                     'auth_token_created', 'auth_token_expires', 'invitations',

        if instance and instance.id:

            for field in ro_fields:

                if isinstance(self.fields[field].widget, forms.CheckboxInput):

                                label=u'Message', required=False)

    feedback_data = forms.CharField(widget=forms.Textarea(),

                                label=u'Data', required=False)

from django.conf import settings

from django.db import models

from django.contrib.auth.models import User, UserManager

from astakos.im.interface import get_quota, set_quota

    # Use UserManager to get the create_user method, etc.

    objects = UserManager()

    #for invitations

    level = models.IntegerField('Inviter level', default=4)

                              invitation.inviter.level + 1)

    # in order to login the user we must call authenticate first 

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

    return prepare_response(request, user, next, 'renew' in request.GET)

from django.shortcuts import render_to_response

from django.template import RequestContext

from django.contrib.auth import authenticate

from django.contrib import messages

from django.utils.translation import ugettext as _

from astakos.im.target.util import prepare_response

from astakos.im.models import AstakosUser

from urllib import unquote

from hashlib import new as newhasher

    """

    on_failure: whatever redirect accepts as to

    """

    if not form.is_valid():

        return render_to_response(on_failure,

                                  {'form':form},

    user.is_active = True

    user.save()

      <div class="span4">

        <h4>Local account</h4>

        <form action="{% url astakos.im.target.local.login %}" method="post" class="form-stacked">{% csrf_token %}

         <div>

            <a href="{% url django.contrib.auth.views.password_reset %}">Forgot your password?</a>

         </div>

<div class="container">

  <h3>You have {{ user.invitations }} invitation{{ user.invitations|pluralize }} left.</h3>

  {% if user.invitations %}

  <br />

  <h4>Invite someone else:</h4>

from django.utils.http import urlencode

from django.utils.translation import ugettext as _

from django.core.urlresolvers import reverse

from django.contrib.auth.models import AnonymousUser

from django.contrib.auth.decorators import login_required

from django.contrib.sites.models import Site

from astakos.im.models import AstakosUser, Invitation

from astakos.im.util import isoformat, get_or_create_user, get_context

from astakos.im.backends import get_backend

def render_response(template, tab=None, status=200, context_instance=None, **kwargs):

    """

    """

    return render_response(template_name,

                           context_instance = get_context(request, extra_context))

def _generate_invitation_code():

    """

    status = None

    message = None

    if request.method == 'POST':

        username = request.POST.get('uniq')

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

    signup.html or ``template_name`` keyword argument.

    """

    if not backend:

    try:

        if request.method == 'POST':

            if form.is_valid():

                # rollback incase of error

                if status == messages.ERROR:

                    transaction.rollback()

                else:

                    transaction.commit()

                messages.add_message(request, status, message)

        messages.add_message(request, messages.ERROR, e)

    return render_response(template_name,

                           form = form if 'form' in locals() else UserCreationForm(),

                               'astakos.im.context_processors.code',

                               'astakos.im.context_processors.invitations')

CUSTOM_USER_MODEL = 'astakos.im.AstakosUser'