Synnefo

from django.http import HttpResponse, HttpResponseRedirect, HttpResponseBadRequest

from django import forms

from django_authopenid.forms import *

    kwargs = {'im_modules':settings.IM_MODULES,

              'other_modules':settings.IM_MODULES[1:]}

    stats['pending'] = User.objects.filter(state = 'PENDING').count()

    stats['invitations_consumed'] = invitations.filter(is_consumed=True).count()

@requires_admin

def pending_users(request):

    users = User.objects.order_by('id')

    users = users.filter(state = 'PENDING')

    try:

        page = int(request.GET.get('page', 1))

    except ValueError:

        page = 1

    offset = max(0, page - 1) * settings.ADMIN_PAGE_LIMIT

    limit = offset + settings.ADMIN_PAGE_LIMIT

    npages = int(ceil(1.0 * users.count() / settings.ADMIN_PAGE_LIMIT))

    prev = page - 1 if page > 1 else None

    next = page + 1 if page < npages else None

    return render_response('pending_users.html',

                            users=users[offset:limit],

                            filter=filter,

                            pages=range(1, npages + 1),

                            page=page,

                            prev=prev,

                            next=next)

def send_greeting(baseurl, user):

    url = baseurl

    subject = _('Welcome to Pithos')

    message = render_to_string('welcome.txt', {

                'user': user,

                'url': url,

                'baseurl': baseurl,

                'service': settings.SERVICE_NAME,

                'support': settings.DEFAULT_CONTACT_EMAIL})

    sender = settings.DEFAULT_FROM_EMAIL

    send_mail(subject, message, sender, [user.email])

    logging.info('Sent greeting %s', user)

@requires_admin

def users_activate(request, user_id):

    user = User.objects.get(id=user_id)

    user.state = 'ACTIVE'

    status = 'success'

    try:

        send_greeting(request.build_absolute_uri('/').rstrip('/'), user)

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

        user.save()

    except (SMTPException, socket.error) as e:

        status = 'error'

        name = 'strerror'

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

    users = User.objects.order_by('id')

    users = users.filter(state = 'PENDING')

    try:

        page = int(request.POST.get('page', 1))

    except ValueError:

        page = 1

    offset = max(0, page - 1) * settings.ADMIN_PAGE_LIMIT

    limit = offset + settings.ADMIN_PAGE_LIMIT

    npages = int(ceil(1.0 * users.count() / settings.ADMIN_PAGE_LIMIT))

    prev = page - 1 if page > 1 else None

    next = page + 1 if page < npages else None

    return render_response('pending_users.html',

                            users=users[offset:limit],

                            filter=filter,

                            pages=range(1, npages + 1),

                            page=page,

                            prev=prev,

                            next=next,

                            message=message)

    url = settings.SIGNUP_TARGET % (baseurl, inv.code, quote(baseurl))

        provider = request.GET.get('provider', None)

        if not provider:

            return HttpResponseBadRequest('No provider')

        code = request.GET.get('code', None)

        kwargs = {'provider':provider}

        if code:

            try:

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

                kwargs['inv']=invitation

            except Invitation.DoesNotExist:

                return HttpResponseBadRequest('Wrong invitation code')

        return render_response('local_create.html', **kwargs)

        retype_password = request.POST.get('retype_passwords')

        elif not retype_password:

            status = 'error'

            message = 'Need to enter password twice'

        elif password != retype_password:

            status = 'error'

            message = 'Passwords do not match'

                user.state = 'ACTIVE' if is_preaccepted(user) else 'PENDING'

                if user.invitation:

                    user.invitation.is_consumed = True

                    print e

        return render_response('users_local_create.html')

        user.provider = 'local'

def is_preaccepted(user):

    return True if settings.INVITATIONS_ENABLED and user.invitation else False

def signup(request):

    if request.method == 'GET':

        kwargs = {'im_modules':settings.IM_MODULES}

        if settings.INVITATIONS_ENABLED:

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

            if not code:

                return HttpResponseBadRequest('No code')

            try:

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

                if invitation.is_consumed:

                    return HttpResponseBadRequest('Invitation has beeen used')

            except Invitation.DoesNotExist:

                return HttpResponseBadRequest('Wrong invitation code')

            kwargs['inv'] = invitation

        return render_response('signup.html', **kwargs)    

    elif request.method == 'POST':

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

        if not choice:

            return HttpResponseBadRequest('No provider selected')

        provider = choice

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

        if provider == 'local':

            url = reverse('pithos.im.views.local.create')

            if settings.INVITATIONS_ENABLED and code:

                url = '%s?code=%s&provider=%s' % (url, code, provider)

            return redirect(url)

        elif provider == 'twitter':

            url = reverse('pithos.im.views.openid_create')

            return redirect(url)

def openid_create(request):

    form1 = OpenidSigninForm()

    kwargs = {'form1':form1}  

    return render_response('openid_create.html')