Skip to content
Extraits de code Groupes Projets
Sélectionner une révision Git
  • 95a63b6c45067893fbbcc2764b15a85a3a088038
  • 12.0 par défaut protégée
2 résultats

project.py

Blame
  • project.py 12,74 Kio
    # Copyright 2020 Le Filament (<http://www.le-filament.com>)
    # License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
    
    from datetime import datetime
    
    from odoo import api, models
    from odoo import fields as odooFields
    from odoo.exceptions import UserError
    from odoo.addons.cmis_field import fields
    
    
    class AdefpatPorteursProjets(models.Model):
        _inherit = 'res.partner.porteur.project'
    
        cmis_folder = fields.CmisFolder(
            allow_create=True,
            allow_delete=False,
            create_properties_get='_get_folder_properties',
        )
    
        cmis_folder_completion = odooFields.Selection(
            [(9, 'Inconnu'),
             (0, 'Incomplet'),
             (1, 'Complet'),
             (2, 'Validé')],
            default=9)
    
        @api.multi
        def get_content_details_url(self):
            for pp in self:
                if pp.cmis_folder:
                    backend_name = self._fields['cmis_folder']
                    backend = backend_name.get_backend(pp.env)
                    properties = backend.get_cmis_repository().getFolder(
                        pp.cmis_folder).getProperties()
                    url = backend.get_content_details_url_from_props(properties)
                    return {   
                       'type': 'ir.actions.act_url',
                       'url': url,
                       'target': 'new',
                     }  
    
        # ------------------------------------------------------
        # Override Alfodoo
        # ------------------------------------------------------
        def _get_folder_properties(self):
            """
            Ajoute les propriétés au dossier lors de la création dans Alfresco
            """
            return {
                'cmis:secondaryObjectTypeIds': [
                    'P:adefpat:dossier',
                    'P:adefpat:beneficiaire',
                    'P:adefpat:validation',
                    'P:up:UploadFolder',
                    'P:cm:titled',
                    'P:sys:cascadeUpdate',
                    'P:adefpat:typesListe',
                    'P:cm:taggable',
                    'P:sys:localized'
                ],
                'up:allowedTypes': 'adefpat:content',
                'adefpat:beneficiaireNom': self.lastname if self.lastname else '',
                'adefpat:beneficiairePrenom': self.firstname if self.firstname else '',
            }
    
        @api.multi
        def _get_completion_status(self):
            for pp in self:
                if pp.cmis_folder:
                    backend_name = self._fields['cmis_folder']
                    backend = backend_name.get_backend(pp.env)
                    pp.cmis_folder_completion = backend.get_cmis_repository().getFolder(pp.cmis_folder).getProperties()['adefpat:validationStatut'] or 9
    
    
    class AdefpatConsultantsProjets(models.Model):
        _inherit = 'res.partner.consultants.project'
    
        cmis_folder = fields.CmisFolder(
            allow_create=True,
            allow_delete=False,
            create_properties_get='_get_folder_properties',
        )
    
        @api.multi
        def get_content_details_url(self):
            for pp in self:
                if pp.cmis_folder:
                    backend_name = self._fields['cmis_folder']
                    folder = backend_name.get_cmis_object(pp)
                    backend = backend_name.get_backend(pp.env)
                    repo = backend.get_cmis_repository()
                    properties = repo.getObject(folder).getProperties() 
                    url = backend.get_content_details_url_from_props(properties)
                    return {   
                       'type': 'ir.actions.act_url',
                       'url': url,
                       'target': 'new',
                     }  
    
        def _get_folder_properties(self):
            """
                Ajoute les propriétés au dossier lors de la création dans Alfresco
            """
            return {
                'cmis:secondaryObjectTypeIds': [
                    'P:adefpat:dossier',
                    'P:adefpat:consultant',
                    'P:up:UploadFolder',
                    'P:cm:titled',
                    'P:sys:cascadeUpdate',
                    'P:adefpat:typesListe',
                    'P:cm:taggable', 'P:sys:localized'
                ],
                'up:allowedTypes': 'adefpat:content',
                'adefpat:consultantNom': self.lastname if self.lastname else '',
                'adefpat:consultantPrenom': self.firstname if self.firstname else '',
            }
    
    
    class AdefpatReunionGAP(models.Model):
        _inherit = 'adefpat.reunion.gap'
    
        cmis_folder = fields.CmisFolder(
            allow_create=True,
            allow_delete=False,
            create_properties_get='_get_folder_properties',
        )
    
        # ------------------------------------------------------
        # Override Alfodoo
        # ------------------------------------------------------
        def _get_folder_properties(self):
            """
            Ajoute les propriétés au dossier lors de la création dans Alfresco
            """
            return {
                'cmis:secondaryObjectTypeIds': [
                    'P:adefpat:dossier',
                    'P:adefpat:ca',
                    'P:up:UploadFolder',
                    'P:cm:titled',
                    'P:sys:cascadeUpdate',
                    'P:adefpat:typesListe',
                    'P:cm:taggable', 'P:sys:localized'
                ],
                'up:allowedTypes': 'adefpat:content',
                'adefpat:caDate': datetime(
                    self.date.year, self.date.month, self.date.day).isoformat(),
            }
    
        @api.multi
        def get_content_details_url(self):
            for pp in self:
                if pp.cmis_folder:
                    backend_name = self._fields['cmis_folder']
                    folder = backend_name.get_cmis_object(pp)
                    backend = backend_name.get_backend(pp.env)
                    repo = backend.get_cmis_repository()
                    properties = repo.getObject(folder).getProperties() 
                    url = backend.get_content_details_url_from_props(properties)
                    return {   
                       'type': 'ir.actions.act_url',
                       'url': url,
                       'target': 'new',
                     }  
    
    
    class AlfodooProject(models.Model):
        _inherit = 'project.project'
    
        cmis_folder = fields.CmisFolder(
            allow_create=True,
            allow_delete=False,
            create_properties_get='_get_folder_properties',
            create_method='_create_folder',
        )
        task_cmis_folder = fields.CmisFolder(
            allow_create=False,
            allow_delete=False,
        )
    
        # ------------------------------------------------------
        # Override Alfodoo
        # ------------------------------------------------------
        def _get_folder_properties(self, records, backend):
            """
            Ajoute les propriétés au dossier lors de la création dans Alfresco
            """
            return {
                'cmis:secondaryObjectTypeIds': [
                    'P:adefpat:departement',
                    'P:adefpat:dossier',
                    'P:adefpat:typesListe',
                    'P:cm:taggable',
                    'P:cm:titled',
                    'P:sys:cascadeUpdate',
                    'P:sys:localized',
                    'P:up:UploadFolder'
                ],
    
                'adefpat:cfd': str(self.user_id.name),
                'adefpat:departement': str(
                    self.departement) if self.departement else '',
                'adefpat:dossierNom': str(self.name),
                'adefpat:dossierNumero': str(self.num_dossier) if self.num_dossier else '',
                'adefpat:financementConvention': str(self.type_convention_id.name),
                'up:allowedTypes': 'adefpat:content'
            }
    
    
        def _create_folder(self, records, backend):
            """
            Crée le répertoire Projets si il n'existe pas
            Crées l'architecture à mettre en place (PP, Gap, Consultants)
            Met à jour le répertoire et les sous dossiers si ils existent
            :param records: project records
            :param backend: project backend
            :return: cmis_folder objectId
            """
            # Get project folder
            project_cmis = self.env.user.company_id.project_cmis
            if not project_cmis:
                raise UserError(
                    "Le répertoire Projet d'Alfresco n'est pas configuré")
    
            for project in self:
                if not project.cmis_folder:
                    # Path parent des projets
                    parent_path = backend.get_cmis_repository().getFolder(
                        project_cmis).getPaths()
                    # Path projet
                    path_proj = parent_path + [project.name]
                    path = '/'.join(path_proj)
                    # Création du dossier projet
                    project.cmis_folder = backend.get_folder_by_path(path)
                    # Actualisation de ses propriétés
                    project.cmis_folder.updateProperties(
                        project._get_folder_properties(records, backend))
    
                # Création / Mise à jour de l'architecture
                else:
                    # Path du dossier projet
                    path_proj = backend.get_cmis_repository().getFolder(
                        project.cmis_folder).getPaths()
    
                # Dossiers Niveau 0 (sans parent)
                archi_dossier = self.env['adefpat.archi.dossier'].search([
                    ('parent_id', '=', False),
                ])
                for dossier in archi_dossier:
                    # Création du dossier N0
                    path_n0 = path_proj + [dossier.name]
                    path = '/'.join(path_n0)
                    cmis_obj = backend.get_folder_by_path(path)
                    # Mise à jour des listes de documents
                    self.update_list_properties(dossier, cmis_obj)
    
                    # Fonction récursive de création pour les enfants
                    if dossier.child_ids:
                        self.recursive_child(
                            project, dossier.child_ids, path_n0, cmis_obj, backend)
    
                # Stockage du dossier séance pour les tâches
                path_seances = '/'.join(path_proj + ['seances'])
                project.task_cmis_folder = backend.get_folder_by_path(path_seances)
    
        def update_folder(self):
            """
            Mets à jour les dossiers qui ne sont pas encore crés (PP, Gap, Consultants)
            :param records: project records
            :param backend: project backend
            :return: cmis_folder objectId
            """
            for project in self:
                backend = self.env['cmis.backend'].sudo().search([])
                project._create_folder(self, backend)
    
        def update_list_properties(self, dossier, cmis_folder):
            # Récupération de tous les documents pour le dossier en entrée
            list_doc = self.env['adefpat.list.type.doc'].search([
                '&', '|', ('convention_ids', '=', False),
                ('convention_ids', '=', self.type_convention_id.id),
                ('dossier', '=', dossier.id)])
    
            # Récupération des documents obligatoires
            list_doc_completude = list_doc.filtered(lambda r: r.completude == True)
    
            doc = list_doc.mapped('name')
            doc_completude = list_doc_completude.mapped('name')
    
            properties = self._get_folder_properties(self, cmis_folder)
    
            if doc:
                properties.update({
                    'adefpat:typesListe': doc,
                    'adefpat:typesListeCompletude': doc_completude,
                })
            cmis_folder.updateProperties(properties)
    
        def recursive_child(self, project, child_ids, path, cmis_obj, backend):
            for child in child_ids:
                if child.specifique:
                    object_ids = self.env[child.model_id.model].search([
                        ('project_id', '=', project.id)
                    ])
                    for obj in object_ids:
                        if not obj.cmis_folder:
                            path_n = path + [obj.display_name]
                            path_o = '/'.join(path_n)
                            obj.cmis_folder = cmis_obj_n = backend.get_folder_by_path(path_o)
                            self.update_list_properties(child, cmis_obj_n)
                            cmis_obj_n.updateProperties(obj._get_folder_properties())
                            if child.child_ids:
                                self.recursive_child(
                                    child, child.child_ids, path_n, cmis_obj_n,
                                    backend)
                else:
                    path_n = path + [child.name]
                    path_o = '/'.join(path_n)
                    cmis_obj_n = backend.get_folder_by_path(path_o)
                    self.update_list_properties(child, cmis_obj_n)
                    if child.child_ids:
                        self.recursive_child(
                            child, child.child_ids, path_n, cmis_obj_n, backend)
    
        @api.multi
        def validate_ca(self):
            super(AlfodooProject, self).validate_ca()
            for project in self:
                backend = self._fields['cmis_folder']
                properties = project._get_folder_properties(
                    project, backend)
                properties.update({'adefpat:dossierNumero': project.num_dossier})
                folder = backend.get_cmis_object(project)
                folder.updateProperties(properties)
    
        @api.multi
        def get_pp_completion(self):
            for project in self:
                project.porteurs_projets_ids._get_completion_status()