axes.py

   1 #-*- coding: utf8 -*-
   2 '''
   3 '''
   4
   5 from openerp.osv import osv, fields
   6 from datetime import date, timedelta, datetime
   7
   8
   9 # ================================ MESURABLE ================================ #
  10 class Mesurable(osv.Model):
  11     _name = "cmmi.axes.mesurable"
  12
  13     _description = "Table de reference des mesusrables."
  14
  15     _states = [("cree", "Crée"), ("encours", "En cours"),
  16                 ("termine", "Terminé"), ("abandonne", "Abandonné"),
  17                 ("suspendu", "Suspendu"), ("generique", "Générique")]
  18
  19     def _nb_jours_init(self, cr, uid, ids, field, arg, context=None):
  20         result = {}
  21         for m in self.browse(cr, uid, ids, context=context):
  22             if not m.date_init_deb or not m.date_init_fin:
  23                 result[m.id] = 0
  24                 continue
  25             result[m.id] = Mesurable._nb_jours_ouvre_entre_2_dates(
  26                         datetime.strptime(m.date_init_deb, "%Y-%m-%d").date(),
  27                         datetime.strptime(m.date_init_fin, "%Y-%m-%d").date())
  28         return result
  29
  30     _columns = {
  31         "name": fields.char(string="Title", size=64, required=True),
  32         "description": fields.text(string="Description"),
  33         "commentaire": fields.text(string="Commentaire"),
  34         "state": fields.selection(_states, string="State"),
  35         "version": fields.char(string="Version", size=16),
  36         "date_jalon": fields.date(string="Jalon"),
  37         "date_init_deb": fields.date(string="Init début"),
  38         "date_init_fin": fields.date(string="Init fin"),
  39         "date_plan_deb": fields.date(string="Plan début"),
  40         "date_plan_fin": fields.date(string="Plan fin"),
  41         "date_reel_deb": fields.date(string="Réel début"),
  42         "date_reel_fin": fields.date(string="Réel fin"),
  43         "nb_jours_initial": fields.function(_nb_jours_init,
  44                                             type="integer",
  45                                             string="Nombre de jour"),
  46     }
  47
  48     _defaults = {
  49         "state": "cree",
  50     }
  51
  52     _sql_constraints = [
  53         (
  54             "date_init_deb_before_date_init_fin",
  55             "CHECK(date_init_deb <= date_init_fin)",
  56             "The date_init_deb should be previous date_init_fin",
  57         ),
  58         (
  59             "date_plan_deb_before_date_plan_fin",
  60             "CHECK(date_plan_deb <= date_plan_fin)",
  61             "The date_plan_deb should be previous date_plan_fin",
  62         ),
  63         (
  64             "date_reel_deb_before_date_reel_fin",
  65             "CHECK(date_reel_deb <= date_reel_fin)",
  66             "The date_reel_deb should be previous date_reel_fin",
  67         ),
  68     ]
  69
  70
  71     def commencer(self, cr, uid, ids, context=None):
  72         if type(ids) == list:
  73             if len(ids) != 1:
  74                 return
  75             ids = ids[0]
  76
  77         palier = self.read(cr, uid, ids, ['date_plan_deb', 'date_plan_fin', 'state'], context)
  78
  79         if palier['state'] != 'cree':
  80             return  # TODO: Message d'erreur : ne fonctionne pas pour les boutons
  81                     # Trouver alternative
  82
  83         self.write(
  84             cr,
  85             uid,
  86             ids, {
  87                 'date_init_deb' : palier['date_plan_deb'],
  88                 'date_init_fin' : palier['date_plan_fin'],
  89                 'state': 'encours'
  90             },
  91             context)
  92         return self
  93
  94
  95     def suspendre(self, cr, uid, ids, context=None):
  96         if type(ids) == list:
  97             if len(ids) != 1:
  98                 return
  99             ids = ids[0]
 100
 101         mesurable = self.read(cr, uid, ids, ['state'], context, context)
 102         if mesurable['state'] != 'encours':
 103             return  # TODO: Message d'erreur : ne fonctionne pas pour les boutons
 104                     # Trouver alternative
 105         self.write(
 106             cr,
 107             uid,
 108             ids,
 109             {'state': 'suspendu'},
 110             context,
 111         )
 112         return self
 113
 114
 115     def terminer(self, cr, uid, ids, context=None):
 116         if type(ids) == list:
 117             if len(ids) != 1:
 118                 return
 119             ids = ids[0]
 120
 121         mesurable = self.read(cr, uid, ids, ['state'], context, context)
 122         if mesurable['state'] != 'encours':
 123             return  # TODO: Message d'erreur : ne fonctionne pas pour les boutons
 124                     # Trouver alternative
 125         self.write(
 126             cr,
 127             uid,
 128             ids,
 129             {'state': 'termine'},
 130             context,
 131         )
 132         return self
 133
 134
 135     def abandonner(self, cr, uid, ids, context=None):
 136         if type(ids) == list:
 137             if len(ids) != 1:
 138                 return
 139             ids = ids[0]
 140
 141         mesurable = self.read(cr, uid, ids, ['state'], context, context)
 142         if not ('encours', 'cree').__contains__(mesurable['state']):
 143             return  # TODO: Message d'erreur : ne fonctionne pas pour les boutons
 144                     # Trouver alternative
 145         self.write(
 146             cr,
 147             uid,
 148             ids,
 149             {'state': 'abandonne'},
 150             context,
 151         )
 152         return self
 153
 154
 155     def reprendre(self, cr, uid, ids, context=None):
 156         if type(ids) == list:
 157             if len(ids) != 1:
 158                 return
 159             ids = ids[0]
 160
 161         mesurable = self.read(cr, uid, ids, ['state'], context, context)
 162         if mesurable['state'] != 'suspendu':
 163             return  # TODO: Message d'erreur : ne fonctionne pas pour les boutons
 164                     # Trouver alternative
 165         self.write(
 166             cr,
 167             uid,
 168             ids,
 169             {'state': 'encours'},
 170             context,
 171         )
 172         return self
 173
 174 #------------ TRAVAIL CALCUL JOURS OUVRES ------------
 175     @staticmethod
 176     def _get_date_paques(annee):
 177         """
 178         Retourne la date du dimanque de pâques pour une année donnée
 179             sous la forme d'un objet date.
 180         """
 181         a = annee % 19
 182         b = annee // 100
 183         c = annee % 100
 184         d = (19 * a + b - b // 4 - ((b - (b + 8) // 25 + 1) // 3) + 15) % 30
 185         e = (32 + 2 * (b % 4) + 2 * (c // 4) - d - (c % 4)) % 7
 186         f = d + e - 7 * ((a + 11 * d + 22 * e) // 451) + 114
 187         mois = f // 31
 188         jours = f % 31 + 1
 189         return date(annee, mois, jours)
 190
 191
 192     @staticmethod
 193     def _get_jours_feries(annee):
 194         """
 195         Retourne une liste contenant les jours fériés d'une année donnée.
 196         """
 197         date_paques = Mesurable._get_date_paques(annee)
 198         return [
 199             date_paques+timedelta(days=1), # Lundi de Pâques
 200             date_paques+timedelta(days=39), # Jeudi de l'Ascension
 201             date_paques+timedelta(days=50), # Lundi de Pentecôte
 202             date(annee, 1, 1), # Jour de l'An
 203             date(annee, 5, 1), # Fête du travail
 204             date(annee, 5, 8), # Armistice 1945
 205             date(annee, 7, 14), # Fête Nationale
 206             date(annee, 8, 15), # Assomption
 207             date(annee, 11, 1), # Toussaint
 208             date(annee, 11, 11), # Armistice 1918
 209             date(annee, 12, 25), # Noël
 210         ]
 211
 212
 213     @staticmethod
 214     def _jour_ouvre(d):
 215         """ Retourne vrai si la date est un jour ouvre, faux sinon."""
 216         if (5,6).__contains__(d.weekday()) or Mesurable._get_jours_feries(d.year).__contains__(d):
 217             return False
 218         else:
 219             return True
 220
 221
 222     @staticmethod
 223     def _nb_jours_ouvre_entre_2_dates(d1, d2):
 224         """
 225         Retourne le nombre de jours ouvres entre deux dates données.
 226
 227         >>> nb_jours_ouvre_entre_2_dates(date(2013, 5, 1), date(2013, 7, 31))
 228         62
 229         >>> nb_jours_ouvre_entre_2_dates(date(2013, 7, 31), date(2013, 5, 1))
 230         62
 231         """
 232         if not d1 or not d2:
 233             return 0
 234         if d1>d2:
 235             d1, d2 = d2, d1 #Switch les 2 dates pour que d1 soit la plus petite
 236         tmp = d1
 237         jour_ouvres = 0
 238         while tmp <= d2:
 239             if Mesurable._jour_ouvre(tmp): # Si tmp est un jour ouvre
 240                 jour_ouvres += 1
 241             tmp += timedelta(days=1)
 242         return jour_ouvres
 243
 244
 245
 246 # ================================= PALIER ================================== #
 247 class Palier(osv.Model):
 248     _name = "cmmi.axes.palier"
 249
 250     _description = "Palier d'un projet."
 251
 252     _inherit = "cmmi.axes.mesurable"
 253
 254     _types_palier = [("normal", "Normal"), ("exceptionnel", "Exceptionnel"),
 255                      ("correctif", "Correctif"), ("autre", "Autre")]
 256
 257     _columns = {
 258         "type_palier": fields.selection(_types_palier, string="Type"),
 259         "projet_id": fields.many2one("cmmi.projet",
 260                                      string="Projet",
 261                                      required=True),
 262         "evolutions": fields.one2many("cmmi.evolution",
 263                                       "palier_id",
 264                                       string="Evolutions"),
 265         "phases": fields.one2many("cmmi.axes.palier.phase",
 266                                   "palier_id",
 267                                   string="Phases"),
 268     }
 269
 270     _defaults = {
 271         "type_palier": "normal",
 272     }
 273
 274
 275     def create(self, cr, uid, vals, context=None):
 276         palier_id = osv.Model.create(self, cr, uid, vals, context=context)
 277
 278         # Récupération des ids de toutes les phases
 279         phase_model = self.pool.get("cmmi.projet.phase")
 280         phases_ids = phase_model.search(cr, uid, [('selectionne', '=', True)])
 281
 282         palier_model = self.pool.get("cmmi.axes.palier")
 283         palier = palier_model.read(cr, uid, palier_id, ['date_plan_deb', 'date_plan_fin'])
 284
 285         # Création des PalierPhase
 286         palier_phase_model = self.pool.get("cmmi.axes.palier.phase")
 287         for phase_id in phases_ids:
 288             palier_phase_model.create(
 289                 cr,
 290                 uid,
 291                 {
 292                     'phase_id': phase_id,
 293                     'palier_id': palier_id,
 294                     'date_plan_deb': palier['date_plan_deb'],
 295                     'date_plan_fin': palier['date_plan_fin'],
 296                 }
 297             )
 298         return palier_id
 299
 300
 301
 302 # =============================== PALIER-PHASE ============================== #
 303 class PalierPhase(osv.Model):
 304     _name = "cmmi.axes.palier.phase"
 305
 306     _description = "Phase d'un palier"
 307
 308     _inherit = "cmmi.axes.mesurable"
 309
 310     def _get_name(self, cr, uid, ids, field_name=None, arg=None, context=None):
 311         if isinstance(ids, (int, long)):
 312             ids = [ids]
 313         return dict([(i, r.phase_id.name) for i, r in
 314                 zip(ids, self.browse(cr, uid, ids, context=context))])
 315
 316
 317     _columns = {
 318         "name": fields.function(_get_name,
 319                                 type='char',
 320                                 store=True,
 321                                 string="Nom de la phase"),
 322         "phase_id": fields.many2one("cmmi.projet.phase",
 323                                     string="Phase du projet"),
 324         "palier_id": fields.many2one("cmmi.axes.palier",
 325                                      string="Palier"),
 326         # backrefs
 327         "charges": fields.one2many("cmmi.evolution.charge",
 328                                    "phase_id",
 329                                    string="Charges"),
 330 #        "evolutions": fields.one2many("cmmi.evolution", #Supprimé !
 331 #                                      "phase_id",
 332 #                                      string="Evolutions"),
 333     }
 334
 335     def create(self, cr, uid, vals, context=None):
 336         # TODO: gérer la création d'une phase de palier.
 337         # Vérifier les valeurs contenues dans vals et les modifier / rajouter si nécessaire selon les cas suivants
 338
 339         # Si description est vide, alors par défaut, recopie de la description du palier et de la phase (concaténés avec un retour à la ligne entre les deux).
 340         # Si commentaire est vide, alors par défaut, recopie du commentaire du palier.
 341         # Si version est vide, alors par dégaut, recopie de la version du palier.
 342
 343         return osv.Model.create(self, cr, uid, vals, context=context)
 344
 345
 346
 347 # ================================ CHANTIER ================================= #
 348 class Chantier(osv.Model):
 349     _name = "cmmi.axes.chantier"
 350
 351     _description = "Chantiers d'un projet."
 352
 353     _inherit = "cmmi.axes.mesurable"
 354
 355     _columns = {
 356         "projet_id": fields.many2one("cmmi.projet",
 357                                      string="Projet",
 358                                      required=True),
 359         "module_ids": fields.many2many("cmmi.description.module",
 360                                        "cmmi_module_chantier_rel",
 361                                        "chantier_id",
 362                                        "module_id",
 363                                        "Modules"),
 364         "evolutions": fields.one2many("cmmi.evolution",
 365                                       "chantier_id",
 366                                       string="Evolutions"),
 367     }