Synnefo

from astakos.im.forms import *

from astakos.im.util import get_invitation

from astakos.im.functions import send_verification, send_admin_notification, activate

import socket

import logging

        or invitation username is reserved.

        """

        self.request = request

        super(InvitationsBackend, self).__init__()

        """

        Returns the form class name

        """

    def get_signup_initial_data(self, provider):

        """

                initial_data = {'email':invitation.username,

                                'inviter':invitation.inviter.realname,

                                'first_name':u.first_name,

        else:

            if provider == request.POST.get('provider', ''):

                initial_data = request.POST

        self.request = request

        super(SimpleBackend, self).__init__()

        """

        Returns the form class name

        """

                initial_data = request.POST

        ip = self.request.META.get('REMOTE_ADDR',

                self.request.META.get('HTTP_X_REAL_IP', None))

    def _is_preaccepted(self, user):

        if super(SimpleBackend, self)._is_preaccepted(user):

from django.utils.safestring import mark_safe

from astakos.im.models import AstakosUser, Invitation

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

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

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

        #set readonly form fields

    def save(self, commit=True):

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

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

        return user

class InvitedThirdPartyUserCreationForm(ThirdPartyUserCreationForm):

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

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

        #set readonly form fields

class ShibbolethUserCreationForm(ThirdPartyUserCreationForm):

    def clean_email(self):

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

                'url': url,

                'site_name': SITENAME,

                'user': user,

                'support': DEFAULT_CONTACT_EMAIL

            }

            from_email = DEFAULT_FROM_EMAIL

    Raises SendInvitationError

    """

    subject = _('Invitation to %s alpha2 testing' % SITENAME)

    message = render_to_string('im/invitation.txt', {

                'invitation': invitation,

                'url': url,

            dest='inactive',

            default=False,

            help="Change user's state to inactive"),

        )

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

        if invitations is not None:

            user.invitations = int(invitations)

        if groupname is not None:

            try:

                group = Group.objects.get(name=groupname)

            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)

from astakos.im.util import get_or_create_user, prepare_response, get_context, get_invitation

from astakos.im.views import requires_anonymous, render_response

from astakos.im.settings import DEFAULT_USER_LEVEL

class Tokens:

    # these are mapped by the Shibboleth SP software

@requires_anonymous

def login(request,  backend=None, on_login_template='im/login.html', on_creation_template='im/signup.html', extra_context={}):

    try:

        user = AstakosUser.objects.get(provider='shibboleth', third_party_identifier=eppn)

        if user.is_active:

                                   context_instance=RequestContext(request))

    except AstakosUser.DoesNotExist, e:

        user = AstakosUser(third_party_identifier=eppn, realname=realname,

        return render_response(on_creation_template,

                               context_instance=get_context(request, extra_context))

              {% for o in im_modules %}

              <div>

            {% if o != 'local' %}

                alt="{{ o|title }}">{{ o }}</a>

            {% endif %}

            </div>

        {% endfor %}

        <div class="bottom">

            {% block body.login.signup %}

            {% endblock %}

            </div>

        </div>

    if not code:

        return

    invitation = Invitation.objects.get(code = code)

    if invitation.is_consumed:

        raise ValueError(_('Invitation is used'))

    try:

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

from astakos.im.forms import *

from astakos.im.functions import send_greeting, send_feedback, SendMailError

from astakos.im.functions import invite as invite_func

logger = logging.getLogger(__name__)

    """

    if request.user.is_authenticated():

        return HttpResponseRedirect(reverse('astakos.im.views.index'))

    try:

        if not backend:

            backend = get_backend(request)

        form = backend.get_signup_form(provider)

    except (Invitation.DoesNotExist, ValueError), e:

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

    if request.method == 'POST':

        if form.is_valid():