cleaned Maraudeur model, created MaraudeurManager, created some tests

maraudes/models.py

@@ -5,7 +5,7 @@ from django.utils import timezone
 from django.db import models
 from django.core.urlresolvers import reverse
 
-from utilisateurs.models import Maraudeur, ReferentMaraude
+from utilisateurs.models import Maraudeur
 
 from . import managers
 
@@ -13,7 +13,7 @@ from . import managers
 
 def get_referent_maraude():
     """ Retourne l'administrateur et référent de la Maraude """
-    return Maraudeur.objects.filter(is_superuser=True).first()
+    return Maraudeur.objects.get_referent()
 
 
 ## Modèles

maraudes/tests.py

@@ -4,7 +4,7 @@ import random
 from calendar import monthrange
 from django.test import TestCase
 
-from .models import Maraude, Maraudeur, ReferentMaraude
+from .models import Maraude, Maraudeur
 # Create your tests here.
 
 from maraudes_project.base_data import MARAUDEURS
@@ -41,15 +41,13 @@ class MaraudeManagerTestCase(TestCase):
         self.maraudeurs = Maraudeur.objects.all()
         #Set up Référent de la Maraude
         ref = self.maraudeurs[0]
-        ReferentMaraude.objects.create(
+        Maraudeur.objects.set_referent(ref.first_name, ref.last_name)
-            maraudeur=ref
-        )
 
         l = len(self.maraudeurs)
         today = datetime.date.today()
-        start_date = today.replace(month=today.month - 1,
+        start_date = today.replace(month=today.month - 1 if today.month > 1 else 12,
                                    day=1)
-        end_date = today.replace(month=today.month + 1,
+        end_date = today.replace(month=today.month + 1 if today.month < 12 else 1,
                                  day=28)
         for i, date in enumerate(get_maraude_days(start_date, end_date)):
             i = i % l

utilisateurs/admin.py

@@ -12,12 +12,9 @@ class MaraudeurAdmin(admin.ModelAdmin):
         ('Informations', {'fields': [('first_name', 'last_name')]}),
     ]
 
-    list_display = ('first_name', 'last_name', 'is_superuser')
+    list_display = ('first_name', 'last_name', 'is_active')
 
 
-@admin.register(ReferentMaraude)
-class ReferentMaraudeAdmin(admin.ModelAdmin):
-    fields = ['maraudeur']
 
 @admin.register(Organisme)
 class OrganismeAdmin(admin.ModelAdmin):

utilisateurs/models.py

@@ -2,23 +2,9 @@ import datetime
 
 from django.db import models
 
-from django.contrib.auth.models import User, AnonymousUser
+from django.contrib.auth.models import User, UserManager, AnonymousUser
 # Create your models here.
 
-class SingletonModel(models.Model):
-    class Meta:
-        abstract = True
-
-    def save(self, *args, **kwargs):
-        self.__class__.objects.exclude(id=self.id).delete()
-        super(SingletonModel, self).save(*args, **kwargs)
-
-    @classmethod
-    def load(cls):
-        try:
-            return cls.objects.get()
-        except cls.DoesNotExist:
-            return cls()
 
 ## Visiteur
 
@@ -53,78 +39,60 @@ class Professionnel(User):
 
 
 
+class MaraudeurManager(UserManager):
+    """ Manager for Maraudeurs objects.
+
+    Updates `create`, `get_or_create` methods signatures : 'first_name', 'last_name'.
+    Add `set_referent` method (same signature).
+    """
+
+    def create(self, first_name, last_name):
+        username = "%s.%s" % (first_name[0].lower(), last_name.lower())
+        data = {
+            'first_name': first_name,
+            'last_name': last_name,
+            'email': "%s@alsa68.org" % username,
+            }
+
+        return super().create_user(username, **data)
+
+    def get_or_create(self, first_name, last_name):
+        try:
+            maraudeur = self.get(first_name=first_name, last_name=last_name)
+            created = False
+        except self.model.DoesNotExist:
+            created = True
+            maraudeur = self.create(first_name, last_name)
+
+        return (maraudeur, created)
+
+    def get_referent(self):
+        try:
+            return self.get(is_superuser=True)
+        except self.model.DoesNotExist:
+            return None
+
+    def set_referent(self, first_name, last_name):
+        maraudeur, created = self.get_or_create(first_name, last_name)
+        for previous in self.get_queryset().filter(is_superuser=True):
+            previous.is_superuser = False
+            previous.save()
+        maraudeur.is_superuser = True
+        maraudeur.save()
+        return maraudeur
+
+
+
 class Maraudeur(Professionnel):
     """ Professionnels qui participent aux maraudes   """
 
-    auto_fields = ['username', 'email', 'organisme']
-
     # Donne accès aux vues "maraudes" et "suivi"
 
-    DEFAULT_ORGANISME = "ALSA"
+    objects = MaraudeurManager()
 
     class Meta:
         verbose_name = "Maraudeur"
 
-    def _fill_fields(self):
-        for field in self.auto_fields:
-            filling_func = "fill_%s" % field
-            try:
-                val = getattr(self, filling_func)()
-            except AttributeError:
-                raise ValueError("'%s' is not defined on %s" % (filling_func, self))
-            setattr(self, field, val)
-
-    def fill_email(self):
-        return "%s@alsa68.org" % self.username
-
-    def fill_username(self):
-        return "%s.%s" % (self.first_name[0].lower(), self.last_name.lower())
-
-    def fill_organisme(self):
-        try:
-            return Organisme.objects.get(nom=self.DEFAULT_ORGANISME)
-        except Organisme.DoesNotExist:
-            return None
-
-    def save(self, *args, **kwargs):
-        if not self.pk or not self.username or not self.email:
-            self._fill_fields()
-            self.is_staff = True
-
-        return super(Maraudeur, self).save(*args, **kwargs)
-
     def __str__(self):
         return "%s %s" % (self.first_name, self.last_name[0])
 
-
-
-class ReferentMaraude(SingletonModel):
-    """ Référent de la maraude """
-    maraudeur = models.ForeignKey(Maraudeur)
-
-    class Meta:
-        verbose_name = "Référent de la maraude"
-
-    def __str__(self):
-        return 'Referent: %s' % self.maraudeur
-
-    def set_unique_referent(self):
-        """ Ensure 'is_referent' has only one 'True' value """
-        for maraudeur in Maraudeur.objects.all():
-            if maraudeur == self.maraudeur:
-                maraudeur.is_superuser= True
-                maraudeur.save()
-            else:
-                if maraudeur.is_superuser:
-                    maraudeur.is_superuser = False
-                    maraudeur.save()
-
-    def save(self, *args, **kwargs):
-        # On s'assure que le référent (administrateur) est unique
-        self.set_unique_referent()
-        return super().save(*args, **kwargs)
-
-    @classmethod
-    def get_referent(cls):
-        instance = cls.load()
-        return instance.maraudeur

utilisateurs/tests.py

@@ -1,5 +1,50 @@
 from django.test import TestCase
 
+from .models import Maraudeur, Professionnel
 # Create your tests here.
 
 #TODO: Un seul objet Maraudeur peut avoir la propriété vraie 'is_referent'
+
+class MaraudeurTestCase(TestCase):
+
+    names = [
+        ('Arthur', 'Gerbaud'),
+        ('Thibault', 'Huet'),
+        ('Jacqueline', 'Julien'),
+    ]
+
+
+    def setUp(self):
+        for name in self.names:
+            Maraudeur.objects.create(*name)
+
+    def test_get_or_create_from_first_and_last_name(self):
+        # Existing Maraudeur
+        get_maraudeur = Maraudeur.objects.get(first_name="Thibault", last_name="Huet")
+        maraudeur, created = Maraudeur.objects.get_or_create('Thibault','Huet')
+        self.assertEqual(created, False)
+        self.assertEqual(maraudeur, get_maraudeur)
+        # Non-existing Maraudeur
+        with self.assertRaises(Maraudeur.DoesNotExist):
+            Maraudeur.objects.get(first_name="Thierry", last_name="Lhermitte")
+        maraudeur, created = Maraudeur.objects.get_or_create('Thierry', 'Lhermitte')
+        self.assertEqual(created, True)
+        self.assertEqual(maraudeur, Maraudeur.objects.get(username="t.lhermitte"))
+
+    def test_set_referent_maraude(self):
+        # Set a first referent, non-existing Maraudeur
+        referent1 = Maraudeur.objects.set_referent("Claudine", "Henry")
+        self.assertEqual(referent1.is_superuser, True)
+        self.assertEqual(referent1, Maraudeur.objects.get_referent())
+        # Set a new referent, existing Maraudeur
+        referent2 = Maraudeur.objects.set_referent("Arthur", "Gerbaud")
+        self.assertEqual(referent2.is_superuser, True)
+        self.assertEqual(referent2, Maraudeur.objects.get_referent())
+        self.test_referent_is_unique()
+
+    def test_referent_is_unique(self):
+        superusers = []
+        for m in Maraudeur.objects.all():
+            if m.is_superuser:
+                superusers.append(m)
+        self.assertLess(len(superusers), 2)