ajouté des inlines dans l'admin (#1555)

[auf_rh_dae.git] / project / budget / models.py

# -=- encoding: utf-8 -=-

from django.db import models
from rh import models as rh


class Simulation(models.Model):
    nom = models.CharField(max_length=255,
                            verbose_name=u'Nom de la simulation')

    def initialize(self):
        """ Copie les données nécessaires à une simulation. """
        if not self.is_empty():
            raise ValueError(u'Cette simulation a déjà été initialisée.')

        self.seen_models = {}

        for model in [rh.Poste, rh.Dossier, rh.Remuneration, rh.Evenement,
                      rh.EvenementRemuneration, rh.Classement, rh.ValeurPoint,
                      rh.TauxChange]:
            self.seen_models[model.__class__.__name__.lower()] = \
                    self.copy_rh_models(model)

    def is_empty(self):
        for attr in ['classement_set', 'dossier_set', 'evenement_set',
                     'evenementremuneration_set', 'poste_set',
                     'remuneration_set', 'valeurpoint_set', 'tauxchange_set']:
            if not getattr(self, attr).all().count() == 0:
                return False
        return True

    def reset(self):
        for attr in ['classement_set', 'dossier_set', 'evenement_set',
                     'evenementremuneration_set', 'poste_set',
                     'remuneration_set', 'valeurpoint_set', 'tauxchange_set']:
            getattr(self, attr).all().delete()

    def copy_rh_models(self, model):
        """ Crée une copie de simulation de tous les enregistrements d'un
        modèle donné et en retourne la liste indexée dans un dictionnaire.

        Opère une translation des id si nécessaire. """
        xlate = getattr(self, 'xlate_%s' % model.__class__.__name__.lower(),
                        None)
        seen = {}
        for orig in model.objects.all():
            sim = self.copy_rh_model(orig)
            if xlate is not None:
                xlate(sim)
            sim.save()
            seen[orig.id] = sim
        return seen

    def copy_rh_model(self, obj):
        """ Crée une copie de simulation d'un modèle rh. """
        initial = dict([('simulation', self)] +
                       [(f.name, getattr(obj, f.name))
                        for f in obj._meta.fields
                        if not isinstance(f, models.AutoField) and
                           not f in obj._meta.parents.values()])
        return globals()[obj.__class__.__name__](**initial)

    def initialize(self):
        """ Copie les données nécessaires à une simulation. """
        if (self.poste_set.all().count() > 0 or
          self.dossier_set.all().count() > 0):
            raise ValueError(u'Cette simulation a déjà été initialisée.')

        postes = {}
        for rh_p in rh.Poste.objects.all():
            sim_p = self.copy_rh_model(rh_p)
            sim_p.save()
            postes[rh_p.id] = sim_p

        dossiers = {}
        for rh_d in rh.Dossier.objects.all():
            sim_d = self.copy_rh_model(rh_d)
            if not sim_d.poste.id in postes:
                self.poste_set.all().delete()
                self.dossier_set.all().delete()
                raise ValueError(u'Données inconsistantes.')
            sim_d.poste = postes[sim_d.poste.id]
            sim_d.save()
            dossiers[rh_d.id] = sim_d

    def xlate_dossier(self, d):
        if not d.poste.id in self.seen_models['poste']:
            raise ValueError(u'Données inconsistantes.')
        d.poste = self.seen_models['poste'][d.poste.id]
        if not d.classement.id in self.seen_models['classement']:
            raise ValueError(u'Données inconsistantes.')
        d.classement = self.seen_models['classement'] [d.classement.id]

    def xlate_evenement(self, e):
        if not e.dossier.id in self.seen_models['dossier']:
            raise ValueError(u'Données inconsistantes.')
        e.dossier = self.seen_models['dossier'][e.dossier.id]

    def xlate_remuneration(self, r):
        if not r.dossier.id in self.seen_models['dossier']:
            raise ValueError(u'Données inconsistantes.')
        r.dossier = self.seen_models['dossier'] [r.dossier.id]

    def xlate_evenementremuneration(self, er):
        if not er.dossier.id in self.seen_models['dossier']:
            raise ValueError(u'Données inconsistantes.')
        er.dossier = self.seen_models['dossier'] [er.dossier.id]
        if not er.evenement.id in self.seen_models['evenement']:
            raise ValueError(u'Données inconsistantes.')
        er.evenement = self.seen_models['evenement'] [er.evenement.id]


class Classement(rh.Classement_):
    __doc__ = rh.Classement_.__doc__
    simulation = models.ForeignKey(Simulation)


class Dossier(rh.Dossier_):
    __doc__ = rh.Dossier_.__doc__
    simulation = models.ForeignKey(Simulation)


class Evenement(rh.Evenement_):
    __doc__ = rh.Evenement_.__doc__
    simulation = models.ForeignKey(Simulation)


class EvenementRemuneration(rh.EvenementRemuneration_):
    __doc__ = rh.EvenementRemuneration_.__doc__
    simulation = models.ForeignKey(Simulation)


class Poste(rh.Poste_):
    __doc__ = rh.Poste_.__doc__
    simulation = models.ForeignKey(Simulation)


class PosteFinancement(rh.PosteFinancement_):
    __doc__ = rh.PosteFinancement_.__doc__
    simulation = models.ForeignKey(Simulation)


class Remuneration(rh.Remuneration_):
    __doc__ = rh.Remuneration_.__doc__
    simulation = models.ForeignKey(Simulation)


class TauxChange(rh.TauxChange_):
    __doc__ = rh.TauxChange_.__doc__
    simulation = models.ForeignKey(Simulation)


class ValeurPoint(rh.ValeurPoint_):
    __doc__ = rh.ValeurPoint_.__doc__
    simulation = models.ForeignKey(Simulation)