Synnefo

from django.utils.importlib import import_module

from django.core.exceptions import ImproperlyConfigured

from django.utils.translation import ugettext as _

from astakos.im.util import get_invitation

from astakos.im.functions import send_verification, send_activation, \

import logging

import re

    try:

        backend_class = getattr(mod, backend_class_name)

    except AttributeError:

    return backend_class(request)

class ActivationBackend(object):

    def _is_preaccepted(self, user):

        # return True if user email matches specific patterns

        for pattern in RE_USER_EMAIL_PATTERNS:

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

    administrator activates his/her account.

    """

    def get_signup_form(self, provider='local', instance=None):

        """

    supplies the necessary registation information, an incative user account is

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

    """

    def _is_preaccepted(self, user):

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

            return True

from django.core.urlresolvers import reverse

from astakos.im.models import AstakosUser, GroupKind, Service, Resource

from astakos.im.settings import INVITATIONS_ENABLED, COOKIE_NAME, EMAILCHANGE_ENABLED

import logging

def _get_user_by_username(user_id):

    try:

        user = AstakosUser.objects.get(username = user_id)

        raise ItemNotFound('Invalid userid')

    else:

        response = HttpResponse()

        raise BadRequest('Email missing')

    try:

        user = AstakosUser.objects.get(email = email)

        raise ItemNotFound('Invalid email')

    if not user.is_active:

from functools import wraps

from time import time, mktime

from django.http import HttpResponse

from django.utils import simplejson as json

from astakos.im.util import epoch

logger = logging.getLogger(__name__)

format = ('%a, %d %b %Y %H:%M:%S GMT')

from functools import wraps

from time import time, mktime

from django.http import HttpResponse

from django.views.decorators.csrf import csrf_exempt

from astakos.im.models import AstakosUser, Service

from astakos.im.forms import FeedbackForm

logger = logging.getLogger(__name__)

# or implied, of GRNET S.A.

from astakos.im.settings import IM_MODULES, INVITATIONS_ENABLED, IM_STATIC_URL, \

        GLOBAL_MESSAGES, PROFILE_EXTRA_LINKS

from astakos.im.api import get_menu

from astakos.im.util import get_query

from astakos.im.models import GroupKind

from django.utils import simplejson as json

def im_modules(request):

# interpreted as representing official policies, either expressed

# or implied, of GRNET S.A.

from urlparse import urljoin

from django import forms

from django.utils.translation import ugettext as _

    PasswordResetForm, PasswordChangeForm

from django.core.mail import send_mail

from django.contrib.auth.tokens import default_token_generator

from django.template import Context, loader

from django.utils.http import int_to_base36

from django.core.urlresolvers import reverse

from django.utils.safestring import mark_safe

from django.utils.encoding import smart_str

from django.forms.extras.widgets import SelectDateWidget

    RECAPTCHA_ENABLED, LOGGING_LEVEL

from astakos.im.widgets import DummyWidget, RecaptchaWidget

from astakos.im.functions import send_change_email

import logging

import hashlib

        user.renew_token()

        if commit:

            user.save()

        return user

class InvitedLocalUserCreationForm(LocalUserCreationForm):

        user.provider = get_query(self.request).get('provider')

        if commit:

            user.save()

        return user

class InvitedThirdPartyUserCreationForm(ThirdPartyUserCreationForm):

            user = AstakosUser.objects.get(email=email, is_active=True)

            if not user.has_usable_password():

                raise forms.ValidationError(_("This account has not a usable password."))

            raise forms.ValidationError(_('That e-mail address doesn\'t have an associated user account. Are you sure you\'ve registered?'))

        return email

from astakos.im.settings import DEFAULT_CONTACT_EMAIL, DEFAULT_FROM_EMAIL, \

    SITENAME, BASEURL, DEFAULT_ADMIN_EMAIL, LOGGING_LEVEL

logger = logging.getLogger(__name__)

        email = user.email if user and user.is_authenticated() else ''

        r = func(*args, **kwargs)

        if LOGGING_LEVEL:

        return r

    return with_logging

        raise SendVerificationError()

    else:

        msg = 'Sent activation %s' % user.email

def send_activation(user, template_name='im/activation_email.txt'):

    send_verification(user, template_name)

    user.save()

def send_admin_notification(template_name,

    subject='alpha2 testing notification',

):

    """

    """

    if not DEFAULT_ADMIN_EMAIL:

        return

    message = render_to_string(template_name, dictionary)

    sender = DEFAULT_FROM_EMAIL

    try:

        raise SendNotificationError()

    else:

        msg = 'Sent admin notification for user %s' % dictionary

def send_helpdesk_notification(user, template_name='im/account_notification.txt'):

    """

        raise SendNotificationError()

    else:

        msg = 'Sent helpdesk admin notification for %s' % user.email

def send_invitation(invitation, template_name='im/invitation.txt'):

    """

    """

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

    url = '%s?code=%d' % (urljoin(BASEURL, reverse('index')), invitation.code)

                'invitation': invitation,

                'url': url,

                'baseurl': BASEURL,

        raise SendInvitationError()

    else:

        msg = 'Sent invitation %s' % invitation

def send_greeting(user, email_template_name='im/welcome_email.txt'):

    """

        raise SendGreetingError()

    else:

        msg = 'Sent greeting %s' % user.email

def send_feedback(msg, data, user, email_template_name='im/feedback_mail.txt'):

    subject = _("Feedback from %s alpha2 testing" % SITENAME)

        raise SendFeedbackError()

    else:

        msg = 'Sent feedback from %s' % user.email

def send_change_email(ec, request, email_template_name='registration/email_change_email.txt'):

    try:

        raise ChangeEmailError()

    else:

        msg = 'Sent change email for %s' % ec.user.email

def activate(user, email_template_name='im/welcome_email.txt',

                helpdesk_email_template_name='im/helpdesk_notification.txt', verify_email=False):

                                    content_type=content_type)

        user.user_permissions.remove(p)

        return 1

        return -1

def remove_group_permission(group, pname):

                                    content_type=content_type)

        group.permissions.remove(p)

        return 1

        return -1

# interpreted as representing official policies, either expressed

# or implied, of GRNET S.A.

from django.core.management.base import BaseCommand, CommandError

from astakos.im.models import AstakosGroup

from django.core.management.base import BaseCommand, CommandError

from ._common import format_bool

from optparse import make_option

from django.core.management.base import BaseCommand, CommandError

class Command(BaseCommand):

    args = "<groupname>"

            raise CommandError("Invalid group")

        try:

            pname = options.get('add-permission')

            if pname:

                r, created = add_group_permission(group, pname)

# interpreted as representing official policies, either expressed

# or implied, of GRNET S.A.

from django.core.management.base import BaseCommand, CommandError

from django.db.utils import IntegrityError

class Command(BaseCommand):

    args = "<service> <resource> [<key>=<value>...]"

# interpreted as representing official policies, either expressed

# or implied, of GRNET S.A.

from os.path import abspath

from django.core.management.base import BaseCommand, CommandError

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

        try:

        except IOError:

            raise CommandError("Invalid location")

import socket

from optparse import make_option

from uuid import uuid4

from datetime import datetime

# interpreted as representing official policies, either expressed

# or implied, of GRNET S.A.

from django.core.management.base import BaseCommand, CommandError

from django.db.utils import IntegrityError

from django.db import transaction

from datetime import datetime

from django.core.management.base import BaseCommand, CommandError

from django.core.exceptions import ValidationError

from django.db.utils import IntegrityError

from django.contrib.auth import authenticate

from astakos.im.settings import COOKIE_NAME

from astakos.im.functions import login

class CookieAuthenticationMiddleware(object):

# encoding: utf-8

from south.db import db

from south.v2 import SchemaMigration

class Migration(SchemaMigration):

# encoding: utf-8

from south.db import db

from south.v2 import SchemaMigration

class Migration(SchemaMigration):

# encoding: utf-8

from south.db import db

from south.v2 import SchemaMigration

class Migration(SchemaMigration):

# encoding: utf-8

from south.db import db

from south.v2 import SchemaMigration

class Migration(SchemaMigration):

# encoding: utf-8

from south.db import db

from south.v2 import SchemaMigration

class Migration(SchemaMigration):

import datetime

from south.db import db

from south.v2 import SchemaMigration

class Migration(SchemaMigration):

# encoding: utf-8

from south.db import db

from south.v2 import SchemaMigration

class Migration(SchemaMigration):

import datetime

from south.db import db

from south.v2 import SchemaMigration

class Migration(SchemaMigration):

# encoding: utf-8

from south.db import db

from south.v2 import SchemaMigration

class Migration(SchemaMigration):

# encoding: utf-8

from south.db import db

from south.v2 import SchemaMigration

class Migration(SchemaMigration):

# encoding: utf-8

import datetime

from south.v2 import DataMigration

class Migration(DataMigration):

# encoding: utf-8

from south.db import db

from south.v2 import SchemaMigration

class Migration(SchemaMigration):

# encoding: utf-8

from south.db import db

from south.v2 import SchemaMigration

class Migration(SchemaMigration):

# encoding: utf-8

from south.db import db

from south.v2 import SchemaMigration

class Migration(SchemaMigration):

# encoding: utf-8

import datetime

from south.v2 import DataMigration

from django.db.models import Count

class Migration(DataMigration):

# encoding: utf-8

from south.v2 import DataMigration

d = {

        'cyclades' : { 'vm' : 2 },

import hashlib

import uuid

import logging

from time import asctime

from datetime import datetime, timedelta

from base64 import b64encode

from random import randint

from collections import defaultdict

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

from django.utils.translation import ugettext as _

from django.core.exceptions import ValidationError

from django.db import transaction

from django.db.models.signals import post_save, post_syncdb

from astakos.im.settings import DEFAULT_USER_LEVEL, INVITATIONS_PER_LEVEL, \

    EMAILCHANGE_ACTIVATION_DAYS, LOGGING_LEVEL

QUEUE_CLIENT_ID = 3 # Astakos.

                username =  uuid.uuid4().hex[:30]

                try:

                    AstakosUser.objects.get(username = username)

                    self.username = username

            if not self.provider:

                self.provider = 'local'

        self.auth_token_expires = self.auth_token_created + \

                                  timedelta(hours=AUTH_TOKEN_DURATION)

        msg = 'Token renewed for %s' % self.email

    def __unicode__(self):

        return '%s (%s)' % (self.realname, self.email)

# or implied, of GRNET S.A.

import logging

from astakos.im.functions import set_user_credibility

from time import time

from hashlib import sha1

class UserEvent(object):

        self.eventVersion = '1'

        self.occurredMillis = int(time() * 1000)

        self.receivedMillis = self.occurredMillis

        self.isActive = user.is_active

        self.role = 'default'

        self.eventType = eventType

        hash = sha1()

        self.id = hash.hexdigest()

    def format(self):

# interpreted as representing official policies, either expressed

# or implied, of GRNET S.A.

from django.shortcuts import render_to_response

from django.template import RequestContext

from django.contrib import messages

from django.utils.translation import ugettext as _

from django.views.decorators.csrf import csrf_exempt

from astakos.im.util import prepare_response, get_query

from astakos.im.views import requires_anonymous

from astakos.im.forms import LoginForm

from astakos.im.settings import RATELIMIT_RETRIES_ALLOWED

    on_failure: the template name to render on login failure

    """

    was_limited = getattr(request, 'limited', False)

    next = get_query(request).get('next', '')

    if not form.is_valid():

        return render_to_response(on_failure,

# or implied, of GRNET S.A.

from django.core.urlresolvers import reverse

from django.utils.translation import ugettext as _

from django.utils.http import urlencode

from django.contrib.auth import authenticate

from django.http import HttpResponse, HttpResponseBadRequest

from django.core.exceptions import ValidationError

from astakos.im.settings import COOKIE_NAME, COOKIE_DOMAIN

from astakos.im.util import set_cookie

            except ValidationError, e:

                return HttpResponseBadRequest(e)

            # authenticate before login

            auth_login(request, user)

            set_cookie(response, user)

            logger.info('Token reset for %s' % request.user.email)

        parts = list(urlsplit(next))

        url = urlunsplit(parts)

        response['Location'] = url

        response.status_code = 302

from django.contrib import messages

from django.template import RequestContext

from astakos.im.views import requires_anonymous, render_response

from astakos.im.forms import LoginForm

from astakos.im.activation_backends import get_backend, SimpleBackend

    SHIB_MAIL = "HTTP_SHIB_MAIL"

@requires_anonymous

    tokens = request.META

    try:

    email = tokens.get(Tokens.SHIB_MAIL, None)

    try:

        if user.is_active:

            return prepare_response(request,

                                    user,

                backend = get_backend(request)

            form = backend.get_signup_form(provider='shibboleth', instance=user)

        except Exception, e:

            messages.error(request, e)

        return render_response(on_creation_template,

# interpreted as representing official policies, either expressed

# or implied, of GRNET S.A.

from astakos.im.forms import ExtendedPasswordResetForm, ExtendedPasswordChangeForm, LoginForm

from astakos.im.settings import IM_MODULES, INVITATIONS_ENABLED, EMAILCHANGE_ENABLED

import time

from urllib import quote

from datetime import tzinfo, timedelta

from django.http import HttpResponse, HttpResponseBadRequest, urlencode

from django.core.urlresolvers import reverse

from django.core.exceptions import ValidationError

    COOKIE_DOMAIN, COOKIE_SECURE, FORCE_PROFILE_UPDATE, LOGGING_LEVEL

from astakos.im.functions import login

logger = logging.getLogger(__name__)

class UTC(tzinfo):

def isoformat(d):

def epoch(datetime):

    return int(time.mktime(datetime.timetuple())*1000)

    extra_context.update(kwargs)

    return RequestContext(request, extra_context)

                        expires=expire_fmt, path='/',

                        domain=COOKIE_DOMAIN, secure=COOKIE_SECURE)

    msg = 'Cookie [expiring %s] set for %s' % (user.auth_token_expires, user.email)

class lazy_string(object):

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

# or implied, of GRNET S.A.

import logging

from urllib import quote

from functools import wraps

from django.contrib import messages

from django.contrib.auth.decorators import login_required

from django.contrib.auth.views import password_change

from django.core.urlresolvers import reverse

from django.db import transaction

from django.db.models import Q

from django.http import HttpResponse, HttpResponseBadRequest, HttpResponseForbidden, \

    HttpResponseRedirect, HttpResponseBadRequest

from django.shortcuts import redirect

from django.utils.http import urlencode

from django.utils.translation import ugettext as _

from astakos.im.activation_backends import get_backend, SimpleBackend

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

    switch_account_to_shibboleth, send_admin_notification, SendNotificationError

logger = logging.getLogger(__name__)

    if tab is None:

        tab = template.partition('_')[0].partition('.html')[0]

    kwargs.setdefault('tab', tab)

    response = HttpResponse(html, status=status)

    if reset_cookie:

        set_cookie(response, context_instance['request'].user)

    return wrapper

@signed_terms_required

    """

    If there is logged on user renders the profile page otherwise renders login page.

@login_required

@signed_terms_required

@transaction.commit_manually

    """

    Allows a user to invite somebody else.

@login_required

@signed_terms_required

    """

    Allows a user to edit his/her profile.

    * LOGIN_URL: login uri

    """

    form = ProfileForm(instance=request.user)

    extra_context['next'] = request.GET.get('next')

    reset_cookie = False

                           context_instance = get_context(request,

                                                          extra_context))

    """

    Allows a user to create a local account.

                    if additional_email != user.email:

                        user.additionalmail_set.create(email=additional_email)

                        msg = 'Additional email: %s saved for user %s.' % (additional_email, user.email)

                if user and user.is_active:

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

                    return prepare_response(request, user, next=next)

@login_required

@signed_terms_required

    """

    Allows a user to send feedback.

            try:

                send_feedback(msg, data, request.user, email_template_name)

            except SendMailError, e:

                messages.error(request, message)

            else:

                message = _('Feedback successfully sent')

    return render_response(template_name,

                           feedback_form = form,

                           context_instance = get_context(request, extra_context))

@signed_terms_required

    """

    Wraps `django.contrib.auth.logout` and delete the cookie.

    """

        auth_logout(request)

        response.delete_cookie(COOKIE_NAME, path='/', domain=COOKIE_DOMAIN)

        msg = 'Cookie deleted for %s' % email

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

    if next:

        response['Location'] = next

        return response

    messages.success(request, _('You have successfully logged out.'))

    context = get_context(request, extra_context)

    return response

@transaction.commit_manually

            transaction.rollback()

            return index(request)

    term = None

    terms = None

    if not term_id:

            pass

    else:

        try:

            pass

    if not term:

                 email_template_name='registration/email_change_email.txt',

                 form_template_name='registration/email_change_form.html',

                 confirm_template_name='registration/email_change_done.html',

    if activation_key:

        try:

            user = EmailChange.objects.change_email(activation_key)

                )

            except SendNotificationError, e:

                messages.error(request, e, fail_silently=True)

    else:

        now = datetime.now()

        data = {

from django import forms

from django.utils.safestring import mark_safe

from django.utils import simplejson as json

from django.template.loader import render_to_string

from astakos.im.settings import RECAPTCHA_PUBLIC_KEY, RECAPTCHA_OPTIONS, \