Update while working on Django 1.5 upgrade

gestioncof/admin.py

@@ -1,13 +1,17 @@
 # coding: utf-8
 
 from django.contrib import admin
-from gestioncof.models import Survey, SurveyQuestion, SurveyQuestionAnswer
-from gestioncof.models import Event, EventOption, EventOptionChoice
-from gestioncof.models import CofProfile
+from gestioncof.models import *
+from gestioncof.petits_cours_models import *
 from django.contrib.auth.models import User
 from django.contrib.auth.admin import UserAdmin
 from django.core.urlresolvers import reverse
 from django.utils.safestring import mark_safe
+import django.forms as forms
+#import eav.admin
+from django.utils.translation import ugettext_lazy as _
+from django.contrib.admin import SimpleListFilter
+from django.db.models import Q
 
 def add_link_field(target_model = '', field = '', link_text = unicode, desc_text = unicode):
     def add_link(cls):
@@ -61,36 +65,170 @@ class EventAdmin(admin.ModelAdmin):
                 EventOptionInline,
               ]
 
+#from eav.forms import BaseDynamicEntityForm
+
+#class CofProfileInline(eav.admin.BaseEntityInline, admin.StackedInline):
 class CofProfileInline(admin.StackedInline):
     model = CofProfile
+    #form = BaseDynamicEntityForm
     inline_classes = ("collapse open",)
 
-class UserProfileAdmin(UserAdmin):
-    def login_clipper(self, obj):
+class FkeyLookup(object):
+    def __init__(self, fkeydecl, short_description=None, admin_order_field=None):
+        self.fk, fkattrs = fkeydecl.split('__', 1)
+        self.fkattrs = fkattrs.split('__')
+ 
+        self.short_description = short_description or self.fkattrs[-1]
+        self.admin_order_field = admin_order_field or fkeydecl
+ 
+    def __get__(self, obj, klass):
+        if obj is None:
+            return self  # hack required to make Django validate (if obj is None, then we're a class, and classes are callable <wink>)
+ 
+        item = getattr(obj, self.fk)
+        for attr in self.fkattrs:
+            item = getattr(item, attr)
+        return item
+
+def ProfileInfo(field, short_description, boolean = False):
+    def getter(self):
         try:
-            return obj.get_profile().login_clipper
-        except UserProfile.DoesNotExist:
+            return getattr(self.get_profile(), field)
+        except CofProfile.DoesNotExist:
             return ""
+    getter.short_description = short_description
+    getter.boolean = boolean
+    return getter
+
+User.profile_login_clipper = FkeyLookup("profile__login_clipper", "Login clipper")
+User.profile_num = FkeyLookup("profile__num", "Numéro")
+User.profile_phone = ProfileInfo("phone", "Téléphone")
+User.profile_occupation = ProfileInfo("occupation", "Occupation")
+User.profile_departement = ProfileInfo("departement", "Departement")
+User.profile_mailing_cof = ProfileInfo("mailing_cof", "ML COF", True)
+User.profile_mailing_bda = ProfileInfo("mailing_bda", "ML BDA", True)
+User.profile_mailing_bda_revente = ProfileInfo("mailing_bda_revente", "ML BDA-R", True)
+
+class UserProfileAdmin(UserAdmin):
     def is_buro(self, obj):
         try:
             return obj.get_profile().is_buro
-        except UserProfile.DoesNotExist:
+        except CofProfile.DoesNotExist:
             return False
     is_buro.short_description = 'Membre du Buro'
     is_buro.boolean = True
     def is_cof(self, obj):
         try:
             return obj.get_profile().is_cof
-        except UserProfile.DoesNotExist:
+        except CofProfile.DoesNotExist:
             return False
     is_cof.short_description = 'Membre du COF'
     is_cof.boolean = True
-    list_display = UserAdmin.list_display + ('login_clipper','is_cof','is_buro',)
-    list_filter = UserAdmin.list_filter + ('profile__is_cof', 'profile__is_buro')
+    list_display = ('profile_num',) + UserAdmin.list_display + ('profile_login_clipper','profile_phone','profile_occupation','profile_mailing_cof','profile_mailing_bda','profile_mailing_bda_revente','is_cof','is_buro',)
+    list_display_links = ('username','email','first_name','last_name')
+    list_filter = UserAdmin.list_filter + ('profile__is_cof', 'profile__is_buro', 'profile__mailing_cof', 'profile__mailing_bda')
     inlines = [
                 CofProfileInline,
               ]
 
+import autocomplete_light
+def user_unicode(self):
+    if self.first_name and self.last_name:
+        return u"%s %s (%s)" % (self.first_name, self.last_name, self.username)
+    else:
+        return self.username
+User.__unicode__ = user_unicode
+class EventRegistrationAdmin(admin.ModelAdmin):
+    form = autocomplete_light.modelform_factory(EventRegistration)
+    list_display = ('__unicode__','event','user','paid')
+    list_filter = ('paid',)
+    search_fields = ('user__username', 'user__first_name', 'user__last_name', 'user__email', 'event__title')
+
+"""
+class VoterProfileInlineForm(BaseDynamicEntityForm):
+    def __init__(self, data=None, *args, **kwargs):
+        super(BaseDynamicEntityForm, self).__init__(data, *args, **kwargs)
+        config_cls = self.instance._eav_config_cls
+        self.entity = getattr(self.instance, config_cls.eav_attr)
+        self.base_fields = {}
+        self._build_dynamic_fields()
+
+class VoterProfileInline(eav.admin.BaseEntityInline, admin.StackedInline):
+    model = CofProfile
+    form = VoterProfileInlineForm
+    inline_classes = ("collapse open",)
+    fields = None
+    fieldsets = None
+
+    def get_fieldsets(self, request, obj=None):
+        formset = self.get_formset(request)
+        fk_name = self.fk_name or formset.fk.name
+        kw = {fk_name: obj} if obj else {}
+        instance = self.model(**kw)
+        form = formset.form(request.POST, instance=instance)
+
+        return [(None, {'fields': form.fields.keys()})]
+
+class VotedListFilter(SimpleListFilter):
+    # Human-readable title which will be displayed in the
+    # right admin sidebar just above the filter options.
+    title = _(u'A voté')
+
+    # Parameter for the filter that will be used in the URL query.
+    parameter_name = 'voted'
+
+    def lookups(self, request, model_admin):
+        return (
+            ('1', _('Yes')),
+            ('0', _('No')),
+        )
+
+    def queryset(self, request, queryset):
+        # Returns the filtered queryset based on the value
+        # provided in the query string and retrievable via
+        # `self.value()`.
+        #
+        # Compare the requested value (either '80s' or '90s')
+        # to decide how to filter the queryset.
+        if self.value() == '1':
+            qs2 = User.objects.filter(profile__eav__a_vot = True)
+            return queryset.filter(pk__in = qs2.values_list('id', flat = True))
+            return voters
+        if self.value() == '0':
+            qs2 = User.objects.filter(profile__eav__a_vot = False)
+            return queryset.filter(pk__in = qs2.values_list('id', flat = True))
+
+class VoterAdmin(UserProfileAdmin):
+
+    form = forms.ModelForm
+    fields = ('username','first_name','last_name')
+    readonly_fields = ('username','first_name','last_name')
+    fieldsets = None
+
+    def is_cof(self, obj):
+        try:
+            return obj.get_profile().is_cof
+        except CofProfile.DoesNotExist:
+            return False
+    is_cof.short_description = 'Membre du COF'
+    is_cof.boolean = True
+    def a_vote(self, obj):
+        try:
+            if not obj.get_profile().eav.a_vot:
+                return False
+            else:
+                return True
+        except CofProfile.DoesNotExist:
+            return False
+    a_vote.short_description = 'A voté'
+    a_vote.boolean = True
+    list_display = ('profile_num',) + UserAdmin.list_display + ('is_cof','a_vote')
+    list_filter = ('profile__is_cof', 'profile__is_buro', VotedListFilter)
+    inlines = [
+                VoterProfileInline,
+              ]
+"""
+
 admin.site.register(Survey, SurveyAdmin)
 admin.site.register(SurveyQuestion, SurveyQuestionAdmin)
 admin.site.register(Event, EventAdmin)
@@ -98,3 +236,8 @@ admin.site.register(EventOption, EventOptionAdmin)
 admin.site.unregister(User)
 admin.site.register(User, UserProfileAdmin)
 admin.site.register(CofProfile)
+admin.site.register(PetitCoursSubject)
+admin.site.register(PetitCoursAbility)
+admin.site.register(PetitCoursDemande)
+#admin.site.register(Voter, VoterAdmin)
+admin.site.register(EventRegistration, EventRegistrationAdmin)

gestioncof/decorators.py

@@ -7,8 +7,7 @@ def is_cof(user):
     except:
         return False
 
-def cof_required(login_url = None):
-    return user_passes_test(lambda u: is_cof(u), login_url=login_url)
+cof_required = user_passes_test(lambda u: is_cof(u))
 
 def is_buro(user):
     try:
@@ -17,5 +16,4 @@ def is_buro(user):
     except:
         return False
 
-def buro_required(login_url = None):
-    return user_passes_test(lambda u: is_buro(u), login_url=login_url)
+buro_required = user_passes_test(lambda u: is_buro(u))

gestioncof/models.py

@@ -5,6 +5,8 @@ from django.contrib.auth.models import User
 from django.utils.translation import ugettext_lazy as _
 from django.db.models.signals import post_save
 
+from petits_cours_models import *
+
 OCCUPATION_CHOICES = (
     ('exterieur', _(u"Extérieur")),
     ('1A', _(u"1A")),
@@ -29,19 +31,23 @@ class CofProfile(models.Model):
     user = models.OneToOneField(User, related_name = "profile")
     login_clipper = models.CharField("Login clipper", max_length = 8, blank = True)
     is_cof = models.BooleanField("Membre du COF", default = False)
-    num = models.IntegerField ("Numéro d'adhérent", blank = True, default = 0),
+    num = models.IntegerField ("Numéro d'adhérent", blank = True, default = 0)
     phone = models.CharField("Téléphone", max_length = 20, blank = True)
     occupation = models.CharField (_(u"Occupation"),
                              default = "1A",
                              choices = OCCUPATION_CHOICES,
                              max_length = choices_length (OCCUPATION_CHOICES))
+    departement = models.CharField (_(u"Département"), max_length = 50, blank = True)
     type_cotiz = models.CharField (_(u"Type de cotisation"),
                              default = "normalien",
                              choices = TYPE_COTIZ_CHOICES,
                              max_length = choices_length (TYPE_COTIZ_CHOICES))
     mailing_cof = models.BooleanField("Recevoir les mails COF", default = False)
-    mailing_bda_revente = models.BooleanField("Recevoir les mails de revente de places BDA", default = False)
+    mailing_bda = models.BooleanField("Recevoir les mails BdA", default = False)
+    mailing_bda_revente = models.BooleanField("Recevoir les mails de revente de places BdA", default = False)
     is_buro = models.BooleanField("Membre du Burô", default = False)
+    petits_cours_accept = models.BooleanField("Recevoir des petits cours", default = False)
+    petits_cours_sent = models.IntegerField("Nombre de propositions petits cours reçues", default = 0)
 
     class Meta:
         verbose_name = "Profil COF"
@@ -62,6 +68,7 @@ class Event(models.Model):
     end_date = models.DateField("Date de fin", blank = True, null = True)
     description = models.TextField("Description", blank = True)
     registration_open = models.BooleanField("Inscriptions ouvertes", default = True)
+    old = models.BooleanField("Archiver (événement fini)", default = False)
 
     class Meta:
         verbose_name = "Événement"
@@ -100,10 +107,14 @@ class EventRegistration(models.Model):
         verbose_name = "Inscription"
         unique_together = ("user", "event")
 
+    def __unicode__(self):
+        return u"Inscription de %s à %s" % (unicode(self.user), unicode(self.event.title))
+
 class Survey(models.Model):
     title = models.CharField("Titre", max_length = 200)
     details = models.TextField("Détails", blank = True)
     survey_open = models.BooleanField("Sondage ouvert", default = True)
+    old = models.BooleanField("Archiver (sondage fini)", default = False)
 
     class Meta:
         verbose_name = "Sondage"
@@ -140,3 +151,24 @@ class SurveyAnswer(models.Model):
     class Meta:
         verbose_name = "Réponses"
         unique_together = ("user", "survey")
+
+class Clipper(models.Model):
+    username = models.CharField("Identifiant", max_length = 20)
+    fullname = models.CharField("Nom complet", max_length = 200)
+
+"""
+class Voter(User):
+    class Meta:
+        proxy = True
+        verbose_name = "voteur"
+    def __unicode__(self):
+        return u"%s %s" % (self.first_name, self.last_name)
+
+import eav
+eav.register(CofProfile)
+
+class ManagerOnlyEavConfig(eav.registry.EavConfig):
+    manager_only = True
+
+eav.register(User, ManagerOnlyEavConfig)
+"""

gestioncof/shared.py

@@ -1,16 +1,10 @@
 from django.contrib.sites.models import Site
 from django.conf import settings
 from django_cas.backends import CASBackend
-from django.template import RequestContext, loader
-from django.http import HttpResponse
+from django.db import models, connection
 
 from gestioncof.models import CofProfile
 
-def render_page (request, data, template):
-    template = loader.get_template (template)
-    context = RequestContext (request, data)
-    return HttpResponse (template.render (context))
-
 class COFCASBackend(CASBackend):
     def authenticate(self, ticket, service):
         """Authenticates CAS ticket and retrieves user data"""
@@ -39,3 +33,16 @@ def context_processor (request):
             "site": Site.objects.get_current(),
            }
     return data
+
+def lock_table(model):
+    cursor = connection.cursor()
+    table = model._meta.db_table
+    cursor.execute("LOCK TABLES %s WRITE" % table)
+    row = cursor.fetchone()
+    return row
+
+def unlock_table(model):
+    cursor = connection.cursor()
+    cursor.execute("UNLOCK TABLES")
+    row = cursor.fetchone()
+    return row

gestioncof/templatetags/utils.py

@@ -1,7 +1,11 @@
 from django import template
+from django.utils.safestring import mark_safe
+
+import re
 
 register = template.Library()
 
+@register.filter
 def key(d, key_name):
     try:
         value = d[key_name]
@@ -9,4 +13,24 @@ def key(d, key_name):
         from django.conf import settings
         value = settings.TEMPLATE_STRING_IF_INVALID
     return value
-key = register.filter('key', key)
+
+def highlight_text(text, q):
+    q2 = "|".join(q.split())
+    pattern = re.compile(r"(?P<filter>%s)" % q2, re.IGNORECASE)
+    return mark_safe(re.sub(pattern, r"<span class='highlight'>\g<filter></span>", text))
+
+@register.filter
+def highlight_user(user, q):
+    if user.first_name and user.last_name:
+        text = u"%s %s (<tt>%s</tt>)" % (user.first_name, user.last_name, user.username)
+    else:
+        text = user.username
+    return highlight_text(text, q)
+
+@register.filter
+def highlight_clipper(clipper, q):
+    if clipper.fullname:
+        text = u"%s (<tt>%s</tt>)" % (clipper.fullname, clipper.username)
+    else:
+        text = clipper.username
+    return highlight_text(text, q)

gestioncof/views.py

@@ -1,29 +1,51 @@
 # coding: utf-8
-from django.shortcuts import redirect, get_object_or_404
-from django.http import Http404
+
+import unicodecsv
+
+from django.shortcuts import redirect, get_object_or_404, render
+from django.http import Http404, HttpResponse
 from django.core.urlresolvers import reverse
+from django.contrib.auth.models import User
 from django.contrib.auth.decorators import login_required
 from django import forms
 from django.forms.widgets import RadioSelect, CheckboxSelectMultiple
 from django.utils.translation import ugettext_lazy as _
+from django.db.models import Max
+from django.contrib.auth.views import login as django_login_view
 
 from gestioncof.models import Survey, SurveyQuestion, SurveyQuestionAnswer, SurveyAnswer
 from gestioncof.models import Event, EventOption, EventOptionChoice, EventRegistration
-from gestioncof.models import CofProfile
-from gestioncof.shared import render_page
+from gestioncof.models import CofProfile, Clipper
 from gestioncof.decorators import buro_required, cof_required
 from gestioncof.widgets import TriStateCheckbox
+from gestioncof.shared import lock_table, unlock_table
 
 @login_required
 def home(request):
-    data = {"surveys": Survey.objects.filter(survey_open = True).all(),
-            "events": Event.objects.filter(registration_open = True).all()}
-    return render_page(request, data, "home.html")
+    data = {"surveys": Survey.objects.filter(old = False).all(),
+            "events": Event.objects.filter(old = False).all(),
+            "open_surveys": Survey.objects.filter(survey_open = True, old = False).all(),
+            "open_events": Event.objects.filter(registration_open = True, old = False).all()}
+    return render(request, "home.html", data)
 
 def login(request):
     if request.user.is_authenticated():
         return redirect("gestioncof.views.home")
-    return render_page(request, {}, "login_switch.html")
+    return render(request, "login_switch.html", {})
+
+def login_ext(request):
+    if request.method == "POST" and "username" in request.POST:
+        try:
+            user = User.objects.get(username = request.POST["username"])
+            if not user.has_usable_password() or user.password in ("","!"):
+                profile, created = CofProfile.objects.get_or_create(user = user)
+                if profile.login_clipper:
+                    return render(request, "error.html", {"error_type": "use_clipper_login"})
+                else:
+                    return render(request, "error.html", {"error_type": "no_password"})
+        except User.DoesNotExist:
+            pass
+    return django_login_view(request, template_name = 'login.html')
 
 @login_required
 def logout(request):
@@ -124,11 +146,12 @@ def survey(request, survey_id):
         except SurveyAnswer.DoesNotExist:
             current_answer = None
             form = SurveyForm(survey = survey)
-    return render_page(request, {"survey": survey, "form": form, "success": success, "deleted": deleted, "current_answer": current_answer}, "survey.html")
+    return render(request, "survey.html", {"survey": survey, "form": form, "success": success, "deleted": deleted, "current_answer": current_answer})
 
 class EventForm(forms.Form):
     def __init__(self, *args, **kwargs):
         event = kwargs.pop("event")
+        self.event = event
         current_choices = kwargs.pop("current_choices", None)
         super(EventForm, self).__init__(*args, **kwargs)
         choices = {}
@@ -163,6 +186,25 @@ class EventForm(forms.Form):
             if name.startswith('option_'):
                 yield (self.fields[name].option_id, value)
 
+def get_event_form_choices(event, form):
+    all_choices = []
+    for option_id, choices_ids in form.choices():
+        option = get_object_or_404(EventOption, id = option_id,
+                                   event = event)
+        if type(choices_ids) != list:
+            choices_ids = [choices_ids]
+        if not option.multi_choices and len(choices_ids) > 1:
+            raise Http404
+        for choice_id in choices_ids:
+            if not choice_id:
+                continue
+            choice_id = int(choice_id)
+            choice = EventOptionChoice.objects.get(
+                                       id = choice_id,
+                                       event_option = option)
+            all_choices.append(choice)
+    return all_choices
+
 @login_required
 def event(request, event_id):
     event = get_object_or_404(Event, id = event_id)
@@ -172,27 +214,8 @@ def event(request, event_id):
     if request.method == "POST":
         form = EventForm(request.POST, event = event)
         if form.is_valid():
-            all_choices = []
-            for option_id, choices_ids in form.choices():
-                option = get_object_or_404(EventOption, id = option_id,
-                                             event = event)
-                if type(choices_ids) != list:
-                    choices_ids = [choices_ids]
-                if not option.multi_choices and len(choices_ids) > 1:
-                    raise Http404
-                for choice_id in choices_ids:
-                    if not choice_id:
-                        continue
-                    choice_id = int(choice_id)
-                    choice = EventOptionChoice.objects.get(
-                                               id = choice_id,
-                                               event_option = option)
-                    all_choices.append(choice)
-            try:
-                current_registration = EventRegistration.objects.get(user = request.user, event = event)
-            except EventRegistration.DoesNotExist:
-                current_registration = EventRegistration(user = request.user, event = event)
-                current_registration.save()
+            all_choices = get_event_form_choices(event, form)
+            (current_registration, _) = EventRegistration.objects.get_or_create(user = request.user, event = event)
             current_registration.options = all_choices
             current_registration.save()
             success = True
@@ -202,13 +225,7 @@ def event(request, event_id):
             form = EventForm(event = event, current_choices = current_registration.options)
         except EventRegistration.DoesNotExist:
             form = EventForm(event = event)
-    return render_page(request, {"event": event, "form": form, "success": success}, "event.html")
-
-@buro_required()
-def event_status(request, event_id):
-    event = get_object_or_404(Event, id = event_id)
-    registrants = EventRegistration.objects.filter(event = event).all()
-    return render_page(request, {"event": event, "registrants": registrants}, "event_status.html")
+    return render(request, "event.html", {"event": event, "form": form, "success": success})
 
 class SurveyStatusFilterForm(forms.Form):
     def __init__(self, *args, **kwargs):
@@ -240,7 +257,6 @@ class EventStatusFilterForm(forms.Form):
     def __init__(self, *args, **kwargs):
         event = kwargs.pop("event")
         super(EventStatusFilterForm, self).__init__(*args, **kwargs)
-        choices = {}
         for option in event.options.all():
             for choice in option.choices.all():
                 name = "option_%d_choice_%d" % (option.id, choice.id)
@@ -256,24 +272,35 @@ class EventStatusFilterForm(forms.Form):
                 field.option_id = option.id
                 field.choice_id = choice.id
                 self.fields[name] = field
+        # has_paid
+        name = "event_has_paid"
+        if self.is_bound and self.data.get(self.add_prefix(name), None):
+            initial = self.data.get(self.add_prefix(name), None)
+        else:
+            initial = "none"
+        field = forms.ChoiceField(label = "Événement payé",
+                                  choices = [("yes", "yes"),("no","no"),("none","none")],
+                                  widget = TriStateCheckbox,
+                                  required = False,
+                                  initial = initial)
+        self.fields[name] = field
 
     def filters(self):
         for name, value in self.cleaned_data.items():
             if name.startswith('option_'):
                 yield (self.fields[name].option_id, self.fields[name].choice_id, value)
+            elif name == "event_has_paid":
+                yield ("has_paid", None, value)
 
 def clean_post_for_status(initial):
-    d = dict(initial)
+    d = initial.copy()
     for k, v in d.items():
         if k.startswith("id_"):
             del d[k]
-            if type(v) == list and len(v) >= 1:
-                d[k[3:]] = v[0]
-            else:
-                d[k[3:]] = v
+            d[k[3:]] = v
     return d
 
-@buro_required()
+@buro_required
 def event_status(request, event_id):
     event = get_object_or_404(Event, id = event_id)
     registrations_query = EventRegistration.objects.filter(event = event)
@@ -281,6 +308,12 @@ def event_status(request, event_id):
     form = EventStatusFilterForm(post_data or None, event = event)
     if form.is_valid():
         for option_id, choice_id, value in form.filters():
+            if option_id == "has_paid":
+                if value == "yes":
+                    registrations_query = registrations_query.filter(paid = True)
+                elif value == "no":
+                    registrations_query = registrations_query.filter(paid = False)
+                continue
             choice = get_object_or_404(EventOptionChoice, id = choice_id, event_option__id = option_id)
             if value == "none":
                 continue
@@ -297,9 +330,9 @@ def event_status(request, event_id):
     for user_choice in user_choices:
         for choice in user_choice.options.all():
             choices_count[choice.id] += 1
-    return render_page(request, {"event": event, "user_choices": user_choices, "options": options, "choices_count": choices_count, "form": form}, "event_status.html")
+    return render(request, "event_status.html", {"event": event, "user_choices": user_choices, "options": options, "choices_count": choices_count, "form": form})
 
-@buro_required()
+@buro_required
 def survey_status(request, survey_id):
     survey = get_object_or_404(Survey, id = survey_id)
     answers_query = SurveyAnswer.objects.filter(survey = survey)
@@ -323,7 +356,7 @@ def survey_status(request, survey_id):
     for user_answer in user_answers:
         for answer in user_answer.answers.all():
             answers_count[answer.id] += 1
-    return render_page(request, {"survey": survey, "user_answers": user_answers, "questions": questions, "answers_count": answers_count, "form": form}, "survey_status.html")
+    return render(request, "survey_status.html", {"survey": survey, "user_answers": user_answers, "questions": questions, "answers_count": answers_count, "form": form})
 
 class UserProfileForm(forms.ModelForm):
     first_name = forms.CharField(label=_(u'Prénom'), max_length=30)
@@ -339,6 +372,7 @@ class UserProfileForm(forms.ModelForm):
             'last_name',
             'phone',
             'mailing_cof',
+            'mailing_bda',
             'mailing_bda_revente',
             ]
 
@@ -350,7 +384,7 @@ class UserProfileForm(forms.ModelForm):
 
     class Meta:
         model = CofProfile
-        fields = ("phone", "mailing_cof", "mailing_bda_revente",)
+        fields = ("phone", "mailing_cof", "mailing_bda", "mailing_bda_revente",)
 
 @login_required
 def profile(request):
@@ -362,10 +396,312 @@ def profile(request):
             success = True
     else:
         form = UserProfileForm(instance = request.user.get_profile())
-    return render_page(request, {"form": form, "success": success}, "profile.html")
+    return render(request, "profile.html", {"form": form, "success": success})
 
-@login_required
+class RegistrationUserForm(forms.ModelForm):
+    def __init__(self, *args, **kw):
+        super(RegistrationUserForm, self).__init__(*args, **kw)
+        self.fields['username'].help_text = ""
+
+    class Meta:
+        model = User
+        fields = ("username", "first_name", "last_name", "email")
+
+class RegistrationProfileForm(forms.ModelForm):
+    def __init__(self, *args, **kw):
+        super(RegistrationProfileForm, self).__init__(*args, **kw)
+        self.fields['mailing_cof'].initial = True
+        self.fields['mailing_bda'].initial = True
+        self.fields['mailing_bda_revente'].initial = True
+        self.fields['num'].widget.attrs['readonly'] = True
+
+        self.fields.keyOrder = [
+            'login_clipper',
+            'phone',
+            'occupation',
+            'departement',
+            'is_cof',
+            'num',
+            'type_cotiz',
+            'mailing_cof',
+            'mailing_bda',
+            'mailing_bda_revente',
+            ]
+
+    def save(self, *args, **kw):
+        instance = super(RegistrationProfileForm, self).save(*args, **kw)
+        if instance.is_cof and not instance.num:
+            # Generate new number
+            try:
+                lock_table(CofProfile)
+                aggregate = CofProfile.objects.aggregate(Max('num'))
+                instance.num = aggregate['num__max'] + 1
+                instance.save()
+                self.cleaned_data['num'] = instance.num
+                self.data['num'] = instance.num
+            finally:
+                unlock_table(CofProfile)
+        return instance
+
+    class Meta:
+        model = CofProfile
+        fields = ("login_clipper", "num", "phone", "occupation", "departement", "is_cof", "type_cotiz", "mailing_cof", "mailing_bda", "mailing_bda_revente",)
+
+def registration_set_ro_fields(user_form, profile_form):
+    user_form.fields['username'].widget.attrs['readonly'] = True
+    profile_form.fields['login_clipper'].widget.attrs['readonly'] = True
+
+@buro_required
+def registration_form(request, login_clipper = None, username = None):
+    member = None
+    if login_clipper:
+        clipper = get_object_or_404(Clipper, username = login_clipper)
+        try: # check if the given user is already registered
+            member = User.objects.filter(username = login_clipper).get()
+            username = member.username
+            login_clipper = None
+        except User.DoesNotExist:
+            # new user, but prefill
+            user_form = RegistrationUserForm()
+            profile_form = RegistrationProfileForm()
+            user_form.fields['username'].initial = login_clipper
+            user_form.fields['email'].initial = login_clipper + "@clipper.ens.fr"
+            profile_form.fields['login_clipper'].initial = login_clipper
+            if clipper.fullname:
+                bits = clipper.fullname.split(" ")
+                user_form.fields['first_name'].initial = bits[0]
+                if len(bits) > 1:
+                    user_form.fields['last_name'].initial = " ".join(bits[1:])
+            registration_set_ro_fields(user_form, profile_form)
+    if username:
+        member = get_object_or_404(User, username = username)
+        (profile, _) = CofProfile.objects.get_or_create(user = member)
+        # already existing, prefill
+        user_form = RegistrationUserForm(instance = member)
+        profile_form = RegistrationProfileForm(instance = profile)
+        registration_set_ro_fields(user_form, profile_form)
+    elif not login_clipper:
+        # new user
+        user_form = RegistrationUserForm()
+        profile_form = RegistrationProfileForm()
+    return render(request, "registration_form.html", {"user_form": user_form, "profile_form": profile_form, "member": member, "login_clipper": login_clipper})
+
+STATUS_CHOICES = (('no','Non'),
+                  ('wait','Attente paiement'),
+                  ('paid','Payé'),)
+class AdminEventForm(forms.Form):
+    status = forms.ChoiceField(label = "Inscription", choices = STATUS_CHOICES, widget = RadioSelect)
+
+    def __init__(self, *args, **kwargs):
+        event = kwargs.pop("event")
+        self.event = event
+        current_choices = kwargs.pop("current_choices", None)
+        paid = kwargs.pop("paid", None)
+        if paid == True:
+            kwargs["initial"] = {"status":"paid"}
+        elif paid == False:
+            kwargs["initial"] = {"status":"wait"}
+        else:
+            kwargs["initial"] = {"status":"no"}
+        super(AdminEventForm, self).__init__(*args, **kwargs)
+        choices = {}
+        if current_choices:
+            for choice in current_choices.all():
+                if choice.event_option.id not in choices:
+                    choices[choice.event_option.id] = [choice.id]
+                else:
+                    choices[choice.event_option.id].append(choice.id)
+        all_choices = choices
+        for option in event.options.all():
+            choices = [(choice.id, choice.value) for choice in option.choices.all()]
+            if option.multi_choices:
+                initial = [] if option.id not in all_choices else all_choices[option.id]
+                field = forms.MultipleChoiceField(label = option.name,
+                                                  choices = choices,
+                                                  widget = CheckboxSelectMultiple,
+                                                  required = False,
+                                                  initial = initial)
+            else:
+                initial = None if option.id not in all_choices else all_choices[option.id][0]
+                field = forms.ChoiceField(label = option.name,
+                                          choices = choices,
+                                          widget = RadioSelect,
+                                          required = False,
+                                          initial = initial)
+            field.option_id = option.id
+            self.fields["option_%d" % option.id] = field
+
+    def choices(self):
+        for name, value in self.cleaned_data.items():
+            if name.startswith('option_'):
+                yield (self.fields[name].option_id, value)
+
+@buro_required
+def registration_form2(request, login_clipper = None, username = None):
+    events = Event.objects.filter(old = False).all()
+    member = None
+    if login_clipper:
+        clipper = get_object_or_404(Clipper, username = login_clipper)
+        try: # check if the given user is already registered
+            member = User.objects.filter(username = login_clipper).get()
+            username = member.username
+            login_clipper = None
+        except User.DoesNotExist:
+            # new user, but prefill
+            user_form = RegistrationUserForm()
+            profile_form = RegistrationProfileForm()
+            event_forms = [AdminEventForm(event = event) for event in events]
+            user_form.fields['username'].initial = login_clipper
+            user_form.fields['email'].initial = login_clipper + "@clipper.ens.fr"
+            profile_form.fields['login_clipper'].initial = login_clipper
+            if clipper.fullname:
+                bits = clipper.fullname.split(" ")
+                user_form.fields['first_name'].initial = bits[0]
+                if len(bits) > 1:
+                    user_form.fields['last_name'].initial = " ".join(bits[1:])
+            registration_set_ro_fields(user_form, profile_form)
+    if username:
+        member = get_object_or_404(User, username = username)
+        (profile, _) = CofProfile.objects.get_or_create(user = member)
+        # already existing, prefill
+        user_form = RegistrationUserForm(instance = member)
+        profile_form = RegistrationProfileForm(instance = profile)
+        registration_set_ro_fields(user_form, profile_form)
+        event_forms = []
+        for event in events:
+            try:
+                current_registration = EventRegistration.objects.get(user = member, event = event)
+                form = AdminEventForm(event = event, current_choices = current_registration.options, paid = current_registration.paid)
+            except EventRegistration.DoesNotExist:
+                form = AdminEventForm(event = event)
+            event_forms.append(form)
+    elif not login_clipper:
+        # new user
+        user_form = RegistrationUserForm()
+        profile_form = RegistrationProfileForm()
+        event_forms = [AdminEventForm(event = event) for event in events]
+    return render(request, "registration_form.html", {"user_form": user_form, "profile_form": profile_form, "member": member, "login_clipper": login_clipper, "event_forms": event_forms})
+
+@buro_required
 def registration(request):
-    data = {"surveys": Survey.objects.filter(survey_open = True).all(),
-            "events": Event.objects.filter(registration_open = True).all()}
-    return render_page(request, data, "registration.html")
+    if request.POST:
+        request_dict = request.POST.copy()
+        if "num" in request_dict:
+            del request_dict["num"]
+        success = False
+        user_form = RegistrationUserForm(request_dict)
+        profile_form = RegistrationProfileForm(request_dict)
+        events = Event.objects.filter(old = False).all()
+        event_forms = [AdminEventForm(request_dict, event = event) for event in events]
+        user_form.is_valid()
+        profile_form.is_valid()
+        for event_form in event_forms: event_form.is_valid()
+        member = None
+        login_clipper = None
+        if "user_exists" in request_dict and request_dict["user_exists"]:
+            username = request_dict["username"]
+            try:
+                member = User.objects.filter(username = username).get()
+                (profile, _) = CofProfile.objects.get_or_create(user = member)
+                user_form = RegistrationUserForm(request_dict, instance = member)
+                profile_form = RegistrationProfileForm(request_dict, instance = profile)
+            except User.DoesNotExist:
+                try:
+                    clipper = Clipper.objects.filter(username = username).get()
+                    login_clipper = clipper.username
+                except Clipper.DoesNotExist:
+                    pass
+        for form in event_forms:
+            if not form.is_valid(): break
+            if form.cleaned_data['status'] == 'no': continue
+            all_choices = get_event_form_choices(form.event, form)
+        if user_form.is_valid() and profile_form.is_valid() and not any([not form.is_valid() for form in event_forms]):
+            member = user_form.save()
+            (profile, _) = CofProfile.objects.get_or_create(user = member)
+            request_dict["num"] = profile.num
+            profile_form = RegistrationProfileForm(request_dict, instance = profile)
+            profile_form.is_valid()
+            profile_form.save()
+            for form in event_forms:
+                if form.cleaned_data['status'] == 'no':
+                    try:
+                        current_registration = EventRegistration.objects.get(user = member, event = form.event)
+                        current_registration.delete()
+                    except EventRegistration.DoesNotExist:
+                        pass
+                    continue
+                all_choices = get_event_form_choices(form.event, form)
+                (current_registration, _) = EventRegistration.objects.get_or_create(user = member, event = form.event)
+                current_registration.options = all_choices
+                current_registration.paid = (form.cleaned_data['status'] == 'paid')
+                current_registration.save()
+            success = True
+        return render(request, "registration_post.html", {"success": success, "user_form": user_form, "profile_form": profile_form, "member": member, "login_clipper": login_clipper, "event_forms": event_forms})
+    else:
+        return render(request, "registration.html")
+
+@buro_required
+def export_members(request):
+    response = HttpResponse(mimetype = 'text/csv')
+    response['Content-Disposition'] = 'attachment; filename=membres_cof.csv'
+
+    writer = unicodecsv.UnicodeWriter(response)
+    for profile in CofProfile.objects.filter(is_cof = True).all():
+        user = profile.user
+        bits = [profile.num, user.username, user.first_name, user.last_name, user.email, profile.phone, profile.occupation, profile.departement, profile.type_cotiz]
+        writer.writerow([unicode(bit) for bit in bits])
+
+    return response
+
+@buro_required
+def export_mega_orgas(request):
+    response = HttpResponse(mimetype = 'text/csv')
+    response['Content-Disposition'] = 'attachment; filename=participants_mega.csv'
+
+    writer = unicodecsv.UnicodeWriter(response)
+    event = Event.objects.filter(title = "MEGA")
+    for reg in EventRegistration.objects.filter(event = event).exclude(options__id__exact = 3).all():
+        user = reg.user
+        profile = user.get_profile()
+        bits = [user.username, user.first_name, user.last_name, user.email, profile.phone, profile.num]
+        writer.writerow([unicode(bit) for bit in bits])
+
+    return response
+
+@buro_required
+def export_mega_participants(request):
+    response = HttpResponse(mimetype = 'text/csv')
+    response['Content-Disposition'] = 'attachment; filename=participants_mega.csv'
+
+    writer = unicodecsv.UnicodeWriter(response)
+    event = Event.objects.filter(title = "MEGA")
+    for reg in EventRegistration.objects.filter(event = event).filter(options__id__exact = 3).all():
+        user = reg.user
+        profile = user.get_profile()
+        bits = [user.username, user.first_name, user.last_name, user.email, profile.phone, profile.num]
+        writer.writerow([unicode(bit) for bit in bits])
+
+    return response
+
+@buro_required
+def export_mega(request):
+    response = HttpResponse(mimetype = 'text/csv')
+    response['Content-Disposition'] = 'attachment; filename=all_mega.csv'
+
+    writer = unicodecsv.UnicodeWriter(response)
+    event = Event.objects.filter(title = "MEGA")
+    for reg in EventRegistration.objects.filter(event = event).order_by("user__username").all():
+        user = reg.user
+        profile = user.get_profile()
+        bits = [user.username, user.first_name, user.last_name, user.email, profile.phone, profile.num]
+        writer.writerow([unicode(bit) for bit in bits])
+
+    return response
+
+@buro_required
+def utile_cof(request):
+   return render(request, "utile_cof.html", {})
+
+@buro_required
+def utile_bda(request):
+   return render(request, "utile_bda.html", {})