Merge branch 'hotfix/another_fix_for_comparison' into dev

[auf_rh_dae.git] / project / rh / managers.py

# -*- encoding: utf-8 -*-

from datetime import date

from django.db import models
from django.db.models import Q
from django.db.models.query import QuerySet

from project import groups


class SecurityManager(models.Manager):

    prefixe_service = None
    prefixe_implantation = None

    def ma_region_ou_service(self, user):
        """
        Filtrage des postes en fonction du user connecté (region / service)
        On s'intéresse aussi au groupe auquel appartient le user car
        certains groupes peuvent tout voir.
        """
        employe = groups.get_employe_from_user(user)
        groupes = [g.name for g in user.groups.all()]

        ############################################
        # TRAITEMENT NORMAL
        ############################################
        # REGION

        # Zones administratives attribuées au profil.
        zones = groups.get_zones_from_user(user)
        q = Q(**{'%s__in' % self.prefixe_implantation: zones })

        # SERVICE
        if self.prefixe_service \
           and groups.SERVICE_UTILISATEURS in groupes:
            q = q | Q(**{self.prefixe_service: employe.service})

        liste = self.get_query_set().filter(q)

        ############################################
        # TRAITEMENT ACCIOR
        ############################################
        if groups.ACCIOR in groupes:
            liste = self.get_query_set().all()

        ############################################
        # TRAITEMENT ABF
        ############################################
        if groups.ABF in groupes:
            liste = self.get_query_set().all()

        ############################################
        # TRAITEMENT FINANCE
        ############################################
        if groups.FINANCE in groupes:
            liste = self.get_query_set().all()

        ############################################
        # TRAITEMENT HAUTE DIRECTION
        ############################################
        if groups.HAUTE_DIRECTION in groupes:
            liste = self.get_query_set().all()

        ############################################
        # TRAITEMENT DRH
        ############################################
        if groups.DRH_NIVEAU_1 in groupes or groups.DRH_NIVEAU_2 in groupes:
            liste = self.get_query_set().all()

        if user.is_superuser:
            liste = self.get_query_set().all()

        return liste


class ActifsQuerySet(QuerySet):
    debut_field = 'date_debut'
    fin_field = 'date_fin'

    def _actifs(self, debut_field, fin_field, date_min=None, date_max=None,
            annee=None):
        q = Q()
        if annee:
            janvier = date(annee, 1, 1)
            decembre = date(annee, 12, 31)
            date_min = max(janvier, date_min) if date_min else janvier
            date_max = min(decembre, date_max) if date_max else decembre
        if not date_min and not date_max:
            date_min = date_max = date.today()
        if date_min:
            q = q & (
                Q(**{fin_field + '__gte': date_min}) |
                Q(**{fin_field: None}))
        if date_max:
            q = q & (
                Q(**{debut_field + '__lte': date_max}) |
                Q(**{debut_field: None}))

        q_inconnus = self._inconnus(debut_field, fin_field)
        return q & ~q_inconnus

    def _inconnus(self, debut_field, fin_field):
        q = Q(**{
            debut_field + '__isnull': True,
            fin_field + '__isnull': True,
            })
        return q

    def get_q_actifs(self, date_min=None, date_max=None, annee=None):
        return self._actifs(self.debut_field, self.fin_field,
                date_min, date_max, annee)

    def actifs(self, date_min=None, date_max=None, annee=None):
        qs = self
        q = self.get_q_actifs(date_min, date_max, annee)
        return qs.filter(q)

    def get_q_inconnus(self, date_min=None, date_max=None, annee=None):
        return self._inconnus(self.debut_field, self.fin_field)

    def inconnus(self):
        qs = self
        q = self.get_q_inconnus()
        return qs.filter(q)

    def get_q_inactifs(self, date_min=None, date_max=None, annee=None):
        actifs_ids = [e['id'] for e in self.actifs(date_min, date_max,
            annee).values('id')]
        q_non_actifs = ~Q(id__in=actifs_ids)
        q_inconnus = self.get_q_inconnus()
        q_futurs = self.get_q_futurs(date_min, date_max, annee)
        return q_non_actifs & ~q_inconnus & ~q_futurs

    def inactifs(self, date_min=None, date_max=None, annee=None):
        return self.get_q_inactifs(date_min, date_max, annee)

    def get_q_futurs(self, date_min=None, date_max=None, annee=None):
        q = Q()
        if annee:
            janvier = date(annee, 1, 1)
            decembre = date(annee, 12, 31)
            date_min = max(janvier, date_min) if date_min else janvier
            date_max = min(decembre, date_max) if date_max else decembre
        if not date_min and not date_max:
            date_min = date_max = date.today()
        if date_min:
            q = q & Q(**{self.debut_field + '__gt': date_min})
        if date_max:
            q = q & Q(**{self.debut_field + '__gt': date_max})
        return q

    def futurs(self, date_min=None, date_max=None, annee=None):
        return self.get_q_futurs(date_min, date_max, annee)


class PosteQuerySet(ActifsQuerySet):
    pass


class PosteManager(SecurityManager):
    prefixe_service = "service"
    prefixe_implantation = "implantation__zone_administrative"

    def get_query_set(self):
        return PosteQuerySet(self.model).select_related('type_poste')

    def ma_region_ou_service(self, user):
        return super(PosteManager, self).ma_region_ou_service(user)

    def actifs(self, *args, **kwargs):
        return self.get_query_set().actifs(*args, **kwargs)

class DossierQuerySet(ActifsQuerySet):
    pass


class DossierManager(SecurityManager):
    prefixe_service = "poste__service"
    prefixe_implantation = "poste__implantation__zone_administrative"

    def get_query_set(self):
        return DossierQuerySet(self.model) \
                .select_related('poste', 'employe')

    def actifs(self, *args, **kwargs):
        return self.get_query_set().actifs(*args, **kwargs)

    def sans_contrats_ou_echus(self, *args, **kwargs):
        app = self.model._meta.app_label
        sql = """
        SELECT D.id FROM %(app)s_dossier AS D
        LEFT JOIN %(app)s_contrat AS C ON D.id = C.dossier AND C.date_debut =
            (SELECT MAX(date_debut) FROM %(app)s_contrat WHERE dossier=D.id)
        WHERE (D.date_fin > '%(today)s' OR D.date_fin IS NULL)
        AND (C.id IS NULL OR C.date_fin < '%(today)s')
        """ % {'today': date.today(), 'app': app}
        ids = [d.id for d in self.raw(sql)]
        return self.get_query_set().filter(id__in=ids).filter(*args, **kwargs)


class RemunerationQuerySet(ActifsQuerySet):

    def actifs(self, *args, **kwargs):
        remun_q = self._actifs('date_debut', 'date_fin', *args, **kwargs)
        dossier_q = self._actifs('dossier__date_debut', 'dossier__date_fin',
                *args, **kwargs)
        return self.filter(remun_q & dossier_q)


class RemunerationManager(models.Manager):

    def get_query_set(self):
        return RemunerationQuerySet(self.model)

    def actifs(self, *args, **kwargs):
        return self.get_query_set().actifs(*args, **kwargs)


class EmployeQuerySet(ActifsQuerySet):
    debut_field = 'rh_dossiers__date_debut'
    fin_field = 'rh_dossiers__date_fin'


class EmployeManager(models.Manager):

    def get_query_set(self):
        return EmployeQuerySet(self.model)

    def actifs(self, *args, **kwargs):
        return self.get_query_set().actifs(*args, **kwargs)


class ContratQuerySet(ActifsQuerySet):
    pass

class ContratManager(models.Manager):

    def get_query_set(self):
        return ContratQuerySet(self.model)\
                .select_related('dossier', 'dossier__poste')


class PosteComparaisonManager(SecurityManager):
    use_for_related_fields = True
    prefixe_implantation = "implantation__zone_administrative"


class DossierComparaisonManager(SecurityManager):
    use_for_related_fields = True
    prefixe_implantation = "implantation__zone_administrative"


class ArchivableManager(models.Manager):

    def get_query_set(self):
        return super(ArchivableManager, self).get_query_set() \
                .filter(archive=False)