# coding: utf-8 from __future__ import unicode_literals from django.db import models from django.db.models.signals import post_save from django.contrib.auth.models import User from django.contrib.gis.db import models as geomodels from django.template.defaultfilters import slugify from django.forms.widgets import DateInput from django.urls import reverse from django.utils import timezone from django.utils.html import strip_tags from taggit_autosuggest.managers import TaggableManager from tinymce.models import HTMLField as RichTextField from .utils import choices_length from .statics import DEPARTEMENTS_DEFAUT, PAYS_OPTIONS, TYPE_LIEU_OPTIONS, TYPE_STAGE_OPTIONS, TYPE_LIEU_DICT, TYPE_STAGE_DICT, NIVEAU_SCOL_OPTIONS, NIVEAU_SCOL_DICT import ldap # # Profil Normalien (extension du modèle User) # class Normalien(models.Model): user = models.OneToOneField(User, related_name="profil") # Infos spécifiques nom = models.CharField(u"Nom complet", max_length=255, blank=True) promotion = models.CharField(u"Promotion", max_length=40, blank=True) mail = models.EmailField(u"Adresse e-mail permanente", max_length=200, blank=True) contactez_moi = models.BooleanField(u"Inviter les visiteurs à me contacter", default=True) bio = models.TextField(u"À propos de moi", blank=True, default=""); class Meta: verbose_name = u"Profil élève" verbose_name_plural = u"Profils élèves" def __unicode__(self): return u"%s (%s)" % (self.nom, self.user.username) # Liste des stages publiés def stages_publics(self): return self.stages.filter(public=True).order_by('-date_debut') # Hook à la création d'un nouvel utilisateur : récupération de ses infos par LDAP def create_user_profile(sender, instance, created, **kwargs): if created: profil, created = Normalien.objects.get_or_create(user=instance) try: ldap.set_option(ldap.OPT_X_TLS_REQUIRE_CERT, ldap.OPT_X_TLS_NEVER) l = ldap.initialize("ldaps://ldap.spi.ens.fr:636") l.set_option(ldap.OPT_REFERRALS, 0) l.set_option(ldap.OPT_PROTOCOL_VERSION, 3) l.set_option(ldap.OPT_X_TLS,ldap.OPT_X_TLS_DEMAND) l.set_option(ldap.OPT_X_TLS_DEMAND, True) l.set_option(ldap.OPT_DEBUG_LEVEL, 255) l.set_option(ldap.OPT_NETWORK_TIMEOUT, 10) l.set_option(ldap.OPT_TIMEOUT, 10) info = l.search_s('dc=spi,dc=ens,dc=fr', ldap.SCOPE_SUBTREE, ('(uid=%s)' % (instance.username,)), [str("cn"), str("mailRoutingAddress"), str("homeDirectory")]) # Si des informations sont disponibles if len(info) > 0: infos = info[0][1] # Nom profil.nom = infos.get('cn', [''])[0] # Parsing du homeDirectory pour la promotion if 'homeDirectory' in infos: dirs = infos['homeDirectory'][0].split('/') if dirs[1] == 'users': annee = dirs[2] dep = dirs[3] dep = dict(DEPARTEMENTS_DEFAUT).get(dep.lower(), '') profil.promotion = u'%s %s' % (dep, annee) # Mail pmail = infos.get('mailRoutingAddress', ['%s@clipper.ens.fr'%instance.username]) if len(pmail) > 0: profil.mail = pmail[0] profil.save() except ldap.LDAPError: pass post_save.connect(create_user_profile, sender=User) # # Lieu de stage # class Lieu(models.Model): # Général nom = models.CharField(u"Nom de l'institution d'accueil", max_length=250) type_lieu = models.CharField(u"Type de structure d'accueil", default="universite", choices=TYPE_LIEU_OPTIONS, max_length=choices_length(TYPE_LIEU_OPTIONS)) # Infos géographiques ville = models.CharField(u"Ville", max_length=200) pays = models.CharField(u"Pays", choices=PAYS_OPTIONS, max_length=choices_length(PAYS_OPTIONS)) # Coordonnées objects = geomodels.GeoManager() # Requis par GeoDjango coord = geomodels.PointField(u"Coordonnées", geography=True, srid = 4326) # Type du lieu en plus joli @property def type_lieu_fancy(self): return TYPE_LIEU_DICT.get(self.type_lieu, ("lieu", False))[0] @property def type_lieu_fem(self): return TYPE_LIEU_DICT.get(self.type_lieu, ("lieu", False))[1] def __unicode__(self): return u"%s (%s)" % (self.nom, self.ville) class Meta: verbose_name = "Lieu" verbose_name_plural = "Lieux" # # Matières des stages # class StageMatiere(models.Model): nom = models.CharField(u"Nom", max_length=30) slug = models.SlugField() class Meta: verbose_name = "Matière des stages" verbose_name_plural = "Matières des stages" def __unicode__(self): return self.nom # # Un stage # class Stage(models.Model): # Misc auteur = models.ForeignKey(Normalien, related_name="stages") public = models.BooleanField(u"Visible publiquement", default=False) date_creation = models.DateTimeField(u"Créé le", default=timezone.now) date_maj = models.DateTimeField(u"Mis à jour le", default=timezone.now) len_avis_stage = models.IntegerField(u"Longueur des avis de stage", default=0) len_avis_lieux = models.IntegerField(u"Longueur des avis de lieu", default=0) # Caractéristiques du stage sujet = models.CharField(u"Sujet", max_length=500) date_debut = models.DateField(u"Date de début", null=True) date_fin = models.DateField(u"Date de fin", null=True) type_stage = models.CharField(u"Type", default="stage", choices=TYPE_STAGE_OPTIONS, max_length=choices_length(TYPE_STAGE_OPTIONS)) niveau_scol = models.CharField(u"Année de scolarité", default="", choices=NIVEAU_SCOL_OPTIONS, max_length=choices_length(NIVEAU_SCOL_OPTIONS), blank=True) thematiques = TaggableManager(u"Thématiques", blank=True) matieres = models.ManyToManyField(StageMatiere, verbose_name=u"Matière(s)", related_name="stages") encadrants = models.CharField(u"Encadrant⋅e⋅s", max_length=500, blank=True) structure = models.CharField(u"Structure d'accueil", max_length=500, blank=True) # Avis lieux = models.ManyToManyField(Lieu, related_name="stages", through="AvisLieu", blank=True) # Affichage des avis ordonnés @property def avis_lieux(self): return self.avislieu_set.order_by('order') # Shortcut pour affichage rapide @property def lieu_principal(self): avis_lieux = self.avis_lieux if len(avis_lieux) == 0: return None return self.avis_lieux[0].lieu # Type du stage en plus joli @property def type_stage_fancy(self): return TYPE_STAGE_DICT.get(self.type_stage, ("stage", False))[0] @property def type_stage_fem(self): return TYPE_STAGE_DICT.get(self.type_stage, ("stage", False))[1] # Niveau scolaire en plus joli @property def niveau_scol_fancy(self): return NIVEAU_SCOL_DICT.get(self.niveau_scol, "") def get_absolute_url(self): return reverse('avisstage:stage', self) def __unicode__(self): return u"%s (par %s)" % (self.sujet, self.auteur.user.username) def update_stats(self, save=True): def get_len(obj): length = 0 avis = obj.avis_all for k, av in avis: length += len(av.split()) length += len(obj.chapo.split()) length += len(obj.les_plus.split()) length += len(obj.les_moins.split()) return length if self.avis_stage: self.len_avis_stage = get_len(self.avis_stage) self.len_avis_lieux = 0 for avis in self.avislieu_set.all(): self.len_avis_lieux += get_len(avis) if save: self.save() class Meta: verbose_name = "Stage" # # Les avis # class AvisStage(models.Model): stage = models.OneToOneField(Stage, related_name="avis_stage") chapo = models.TextField(u"En quelques mots", blank=True) avis_ambiance = RichTextField(u"L'ambiance de travail", blank=True) avis_sujet = RichTextField(u"La mission", blank=True) avis_admin = RichTextField(u"Formalités et administration", blank=True) avis_prestage = RichTextField(u"Avant le stage", blank=True, default="") les_plus = models.TextField(u"Les plus de cette expérience", blank=True) les_moins = models.TextField(u"Les moins de cette expérience", blank=True) def __unicode__(self): return u"Avis sur {%s} par %s" % (self.stage.sujet, self.stage.auteur.user.username) # Liste des champs d'avis, couplés à leur nom (pour l'affichage) @property def avis_all(self): fields = ['avis_sujet', 'avis_ambiance', 'avis_admin', 'avis_prestage'] return [(AvisStage._meta.get_field(field).verbose_name, getattr(self, field, '')) for field in fields] class AvisLieu(models.Model): stage = models.ForeignKey(Stage) lieu = models.ForeignKey(Lieu) order = models.IntegerField("Ordre", default=0) chapo = models.TextField(u"En quelques mots", blank=True) avis_lieustage = RichTextField(u"Les lieux de travail", blank=True) avis_pratique = RichTextField(u"S'installer - conseils pratiques", blank=True) avis_tourisme = RichTextField(u"Dans les parages", blank=True) les_plus = models.TextField(u"Les plus du lieu", blank=True) les_moins = models.TextField(u"Les moins du lieu", blank=True) class Meta: verbose_name = "Avis sur un lieu de stage" verbose_name_plural = "Avis sur un lieu de stage" def __unicode__(self): return u"Avis sur {%s} par %s" % (self.lieu.nom, self.stage.auteur.user_id) # Liste des champs d'avis, couplés à leur nom (pour l'affichage) @property def avis_all(self): fields = ['avis_lieustage', 'avis_pratique', 'avis_tourisme'] return [(AvisLieu._meta.get_field(field).verbose_name, getattr(self, field, '')) for field in fields]