Sélectionner une révision Git
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()