Synnefo » astakos

            if user.has_usable_password() and user.provider in ('local', ''):

            l.append(dict(url=absolute(reverse('group_list')), name="Groups"))

from django.db.models.query import EmptyQuerySet

class AstakosGroupSearchForm(forms.Form):

    q = forms.CharField(max_length=200, label='')

class MembershipCreationForm(forms.ModelForm):

    # TODO check not to hit the db

    group = forms.ModelChoiceField(queryset=AstakosGroup.objects.all(), widget=forms.HiddenInput())

    person = forms.ModelChoiceField(queryset=AstakosUser.objects.all(), widget=forms.HiddenInput())

    date_requested = forms.DateField(widget=forms.HiddenInput(), input_formats="%d/%m/%Y")

    class Meta:

        model = Membership

        exclude = ('date_joined',)

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

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

        return len(self.approved_members)

    def approve_member(self, person):

        try:

            self.membership_set.create(person=person, date_joined=datetime.now())

        except IntegrityError:

            m = self.membership_set.get(person=person)

            m.date_joined = datetime.now()

            m.save()

    def disapprove_member(self, person):

        self.membership_set.remove(person=person)

    @property

    def members(self):

        return map(lambda m:m.person, self.membership_set.all())

    @property

    def approved_members(self):

        f = filter(lambda m:m.is_approved, self.membership_set.all())

        return map(lambda m:m.person, f)

    @property

    def policies(self):

        return self.astakosgroupquota_set.all()

    @property

    date_requested = models.DateField(default=datetime.now(), blank=True)

    date_joined = models.DateField(null=True, db_index=True, blank=True)

    def approve(self):

        self.date_joined = datetime.now()

        self.save()

    def disapprove(self):

        self.delete()

              <tr>

                <th>Type: {{object.kind}}</th>

              </tr>

              <tr>

                <th>Issue date: {{object.issue_date}}</th>

              </tr>

              <tr>

                <th>Expiration date: {{object.expiration_date}}</th>

              </tr>

              <tr>

                <th>Owner: {% for o in object.owner.all %}

                                {% if user == o %}

                                    Me!

                                {% else%}

                                    {{o.realname}} ({{o.email}})

                                {% endif %}

                            {% endfor %}

                </th>

              </tr>

        {% if object.members %}

                <th>Email</th>

            {% for m in object.membership_set.all %}

                <td>{{m.person.email}}</td>

                <td>{{m.person.realname}}</td>

                {% if m.person in m.group.owner.all %}

                <td>Owner</td>

                {% else %}

                    {% if m.is_approved %}

                    <td>Approved</td>

                    {% else %}

                    <td>Pending</td>

                        {% if user in m.group.owner.all %}

                            <td><a href="{% url approve_member m.id %}">Approve</a></td>

                            <td><a href="{% url disapprove_member m.id %}">Disapprove</a></td>

                        {% endif %}

                    {% endif %}

                {% endif %}

                    <td>{{q.resource.name}}</td>

                    <td>{{q.limit}}</td>

{% load filters %}

    {% if form %}

    <form action="{% url group_search %}" method="post" class="innerlabels signup">{% csrf_token %}

        <h2><span>Search group:</span></h2>

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

            <div class="form-row submit">

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

            </div>

    </form>

    {% else %}

        <p class="submit-rt">

            <a href="{% url group_add %}" class="submit">Create a group</a>

            <a href="{% url group_search %}" class="submit">Join a group</a>

        </p>

    {% endif %}

                <th>Type</th>

                <th>Issue date</th>

                <th>Expiration date</th>

                <th>Owner?</th>

                <th>Participants</th>

                <th>Enrollment status</th>

                <td><a class="extra-link" href="{% url group_detail o.id %}">{{o.name}}</a></td>

                <td>{{o.kind}}</td>

                <td>{{o.issue_date|date:"D d M Y"}}</td>

                <td>{{o.expiration_date|date:"D d M Y"}}</td>

                <td>{% if user in o.owner.all %}Yes{% else %}No{% endif %}</td>

                <td>{{ o.approved_members|length }}/{{ o.members|length }}</td>

                {% if user in o.approved_members %}

                    <td>Active</td>

                    {% if user not in o.owner.all %}

                    <td>

                        <form action="{% url group_leave o.id %}" method="post"class="login innerlabels">{% csrf_token %}

                            <div class="form-row submit clearfix">

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

                            </div>

                        </form>

                    </td>

                    {% endif %}

                {% else %}

                    {% if user in o.members %}

                        <td>Pending</td>

                    {% else %}

                        <td>Not member</td>

                        {% if join_forms %}

                        <td>

                            <form action="{% url group_join o.id %}" method="post"class="login innerlabels">{% csrf_token %}

                                {% with join_forms|lookup:o.name as form %}

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

                                {% endwith %}

                                <div class="form-row submit clearfix">

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

                                </div>

                            </form>

                        </td>

                        {% endif %}

                    {% endif %}

                {% endif %}

    url(r'^group/search/?$', 'group_search', {}, name='group_search'),

    url(r'^group/(?P<group_id>\d+)/join/?$', 'group_join', {}, name='group_join'),

    url(r'^group/(?P<group_id>\d+)/leave/?$', 'group_leave', {}, name='group_leave'),

    url(r'^group/(?P<membership_id>\d+)/approve/?$', 'approve_member', {}, name='approve_member'),

    url(r'^group/(?P<membership_id>\d+)/disapprove/?$', 'disapprove_member', {}, name='disapprove_member'),

from django.contrib.auth.decorators import login_required

from django.core.mail import send_mail

from django.core.urlresolvers import reverse

from django.db import transaction

from django.db.utils import IntegrityError

from django.forms.fields import URLField

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

    HttpResponseRedirect, HttpResponseBadRequest

from django.shortcuts import redirect

from django.template.loader import render_to_string

from django.utils.http import urlencode

from django.utils.translation import ugettext as _

@login_required

                         form_class=get_astakos_group_creation_form(request),

                         post_save_redirect = '/im/group/%(id)s/')

    list = AstakosGroup.objects.filter(membership__person=request.user)

                         AstakosGroup.objects.all(),

                         object_id=group_id,

                         extra_context = {'form':get_astakos_group_policy_creation_form(group),

                                          'quota':group.policies,

                                          'more_policies':group.has_undefined_policies})

@login_required

                         form_class=get_astakos_group_policy_creation_form(group),

                         template_name = 'im/astakosgroup_detail.html',

                         post_save_redirect = reverse('group_detail', kwargs=dict(group_id=group_id)),

                         extra_context = {'group':group,

                                          'quota':group.policies,

                                          'more_policies':group.has_undefined_policies})

@signed_terms_required

@login_required

def group_search(request, queryset=EmptyQuerySet(), extra_context={}, **kwargs):

    join_forms = {}

    if request.method == 'GET':

        form = AstakosGroupSearchForm()

    else:

        form = AstakosGroupSearchForm(get_query(request))

        if form.is_valid():

            q = form.cleaned_data['q'].strip()

            q = URLField().to_python(q)

            queryset = AstakosGroup.objects.select_related().filter(name=q)

            f = MembershipCreationForm

            for g in queryset:

                join_forms[g.name] = f(dict(group=g,

                                            person=request.user,

                                            date_requested=datetime.now().strftime("%d/%m/%Y")))

    return object_list(request,

                        queryset,

                        template_name='im/astakosgroup_list.html',

                        extra_context=dict(form=form, is_search=True, join_forms=join_forms))

@signed_terms_required

@login_required

def group_join(request, group_id):

    return create_object(request,

                         model=Membership,

                         template_name='im/astakosgroup_list.html',

                         post_save_redirect = reverse('group_detail', kwargs=dict(group_id=group_id)))

@signed_terms_required

@login_required

def group_leave(request, group_id):

    try:

        m = Membership.objects.select_related().get(group__id=group_id, person=request.user)

    except Membership.DoesNotExist:

        return HttpResponseBadRequest(_('Invalid membership.'))

    if request.user in m.group.owner.all():

        return HttpResponseForbidden(_('Owner can not leave the group.'))

    return delete_object(request,

                         model=Membership,

                         object_id = m.id,

                         template_name='im/astakosgroup_list.html',

                         post_delete_redirect = reverse('group_detail', kwargs=dict(group_id=group_id)))

def handle_membership():

    def decorator(func):

        @wraps(func)

        def wrapper(request, membership_id):

            try:

                m = Membership.objects.select_related().get(id=membership_id)

            except Membership.DoesNotExist:

                return HttpResponseBadRequest(_('Invalid membership.'))

            else:

                if request.user not in m.group.owner.all():

                    return HttpResponseForbidden(_('User is not a group owner.'))

                func(request, m)

                return render_response(template='im/astakosgroup_detail.html',

                                       context_instance=get_context(request),

                                       object=m.group,

                                       quota=m.group.policies,

                                       more_policies=m.group.has_undefined_policies)

        return wrapper

    return decorator

@signed_terms_required

@login_required

@handle_membership()

def approve_member(request, membership):

    try:

        membership.approve()

        realname = membership.person.realname

        msg = _('%s has been successfully joined the group.' % realname)

        messages.success(request, msg)

    except BaseException, e:

        logger.exception(e)

        msg = _('Something went wrong during %s\'s approval.' % realname)

        messages.error(request, msg)

@signed_terms_required

@login_required

@handle_membership()

def disapprove_member(request, membership):

    try:

        membership.disapprove()

        realname = membership.person.realname

        msg = _('%s has been successfully removed from the group.' % realname)

        messages.success(request, msg)

    except BaseException, e:

        logger.exception(e)

        msg = _('Something went wrong during %s\'s disapproval.' % realname)

        messages.error(request, msg)