Newer
Older
# Copyright 2020-2022 Le Filament (<http://www.le-filament.com>)
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
from datetime import datetime, timedelta
from odoo.exceptions import ValidationError
"Nom",
"Prénom",
"Fonction",
"Structure",
"Commune",
"Mobile",
"Fixe",
"Email",
]
@api.model
def _default_explication_financement(self):
if self.env.user.company_id.explication_financement:
return self.env.user.company_id.explication_financement
@api.model
def _default_modalites_intervention(self):
if self.env.user.company_id.modalites_intervention:
return self.env.user.company_id.modalites_intervention
@api.model
def _default_modalites_facturation(self):
if self.env.user.company_id.modalites_facturation:
return self.env.user.company_id.modalites_facturation
@api.model
def _default_modalites_reponse(self):
if self.env.user.company_id.modalites_reponse:
return self.env.user.company_id.modalites_reponse
@api.model
def _default_modalites_modif_marche(self):
if self.env.user.company_id.modalites_modif_marche:
return self.env.user.company_id.modalites_modif_marche
privacy_visibility = fields.Selection(
[
("followers", "On invitation only"),
("employees", "Visible by all employees"),
("portal", "Visible by following customers"),
string="Confidentialité",
required=True,
default="employees",
)
# Champs étape "Demande" => Vue générale
name_subtitle = fields.Char("Sous-titre")
first_contact_id = fields.Many2one(
"res.partner",
string="1er contact",
domain=[("active", "=", True), ("is_company", "=", False)],
)
type_contact = fields.Selection(
[
("adherent", "Adhérent"),
("no_adherent", "Non adhérent"),
("pdp", "Porteur de projet"),
string="Type contact",
)
date_first_contact = fields.Date("Date de 1er contact", default=fields.Date.today)
"res.partner",
string="Prescripteur",
domain=[("active", "=", True), ("is_company", "=", False)],
"res.partner.porteur.project", "project_id", string="Porteurs de projet"
)
description = fields.Text("Description")
territoire_id = fields.Many2one(
("active", "=", True),
("is_company", "=", True),
"|",
("type_structure_id.name", "=", "ComCom"),
("type_structure_id.name", "=", "PETR/PNR"),
],
comodel_name="res.partner",
relation="res_partner_departement_rel",
column1="partner_id",
column2="departement_id",
("active", "=", True),
("is_company", "=", True),
("type_structure_id.name", "=", "Département"),
],
comodel_name="res.partner",
relation="res_partner_region_rel",
column1="partner_id",
column2="region_id",
("active", "=", True),
("is_company", "=", True),
("type_structure_id.name", "=", "Région"),
],
comodel_name="res.partner",
relation="res_partner_petr_rel",
column1="partner_id",
column2="petr_id",
("active", "=", True),
("is_company", "=", True),
("type_structure_id.name", "=", "PETR/PNR"),
],
related="territoire_id.petr_ids",
)
departement = fields.Selection(
[
("12", "12"),
("34", "34"),
("46", "46"),
("48", "48"),
("81", "81"),
("82", "82"),
],
string="Département du projet",
)
comodel_name="res.partner",
column1="project_id",
column2="od_id",
relation="res_partner_od_rel",
string="OD",
domain=[("active", "=", True), ("is_company", "=", True)],
"res.partner",
string="Elu qui présente le dossier",
domain=[("active", "=", True), ("is_company", "=", False)],
comodel_name="res.partner",
column1="project_id",
column2="anim_id",
relation="res_partner_anim_rel",
string="Animateurs",
domain=[("active", "=", True), ("is_company", "=", False)],
"|",
("date_end_validity", ">=", fields.Date.today()),
("date_end_validity", "=", False),
],
string="Type de convention de financement",
)
date_ca_next = fields.Date("Lendemain date de CA", compute="_compute_date_ca_next")
date_demarrage = fields.Date("Date de démarrage prévisionnel")
# Champs étape "Instruction" => Onglet Dossier
contexte = fields.Text("Contexte projet")
caract_beneficiaire = fields.Text("Caractéristiques du bénéficiaire")
historique = fields.Text("Historique & Aujourd’hui")
besoins_beneficiaires = fields.Text("Besoins des bénéficiaires")
objectifs_accompagnement = fields.Text("Objectifs d’accompagnement")
competences_requises = fields.Text("Compétences du CF")
secteurs_requis = fields.Text("Secteurs d’activités")
"Modalités d'intervention", default=_default_modalites_intervention
)
"Modalités de facturation", default=_default_modalites_facturation
)
"Modalités de réponse", default=_default_modalites_reponse
)
"Modalités de modification du marché", default=_default_modalites_modif_marche
)
type_beneficiaire = fields.Char(
"Type de bénéficiares", compute="_compute_type_beneficiaire"
)
("creation", "Création d'entreprise"),
("creation_activite", "Création nouvelle activité"),
("consolidation", "Consolidation"),
("emergence", "Émergence"),
("operation", "Opération territoriale pour les entreprises"),
("post_creation", "Post-création"),
("post_reprise", "Post-reprise"),
("projet_inter", "Projet inter-entreprise"),
("projet_structurant", "Projet structurant territoire"),
("reprise", "Reprise"),
("transmission", "Transmission"),
("agriculture", "Agriculture"),
("agro_alimentaire", "Agro-alimentaire"),
("artisanat", "Artisanat - Commerce - Industrie"),
("culture", "Culture"),
("environnement", "Environnement"),
("intersectoriel", "Intersectoriel"),
("service", "Service"),
("service", "Services à la population"),
("tourisme", "Tourisme - Hôtellerie - Restauration"),
[("inf_10", "De 10 à 250"), ("sup_10", "< 10 salariés")],
string="Taille entreprise",
)
("def_projet", "Définition de projet"),
("def_modele_eco", "Définition d'un modèle économique"),
("def_strat_com", "Définition d'une stratégie de développement"),
("diagnostic", "Diagnostic stratégique"),
("gestion_prod", "Gestion de production"),
("gestion_financ", "Gestion financière"),
("marketing", "Marketing - Commercialisation - Promotion - Communication"),
("management", "Management - Organisation - RH"),
("orga_collective", "Organisation collective"),
("individuelle", "Générale individuelle"),
("collective", "Générale collective"),
("indiv_collect", "Générale collective individualisée"),
("minimis", "De minimis"),
("neant", "Neant"),
("encadrement", "Encadrement des aides à la formation"),
nb_activité = fields.Integer("Nombre d’activités ou entreprises concernées")
nb_coll = fields.Integer(
"Nombre de collectivités accompagnées",
help="Nombre de collectivités représentées dans le groupe projet "
"(par ex 2 mairies, 1 com com et 1 petr)",
)
nb_citoyens = fields.Integer(
"Nombre de citoyens participant à l'accompagnement",
help="Ensemble des participants moins les élus et les chargés de développement, "
"les agents de collectivités",
)
nb_entreprises = fields.Integer(
"Nombre d'entreprises mobilisées dans le cadre " "d'une démarche collective",
help="Entreprises (y compris les associations avec une activité économique "
"régulière) participants à l'accompagnement d'un collectif inter entreprises "
"ou à un projet territorial",
)
nb_emplois = fields.Integer("Nombre d’emplois concernés")
bpi = fields.Boolean(
"BPI", help="projet à valoriser danS le cadre de l'appel à projet BPI"
)
type_accompagnement = fields.Selection(
[
("individualise", "Individualisé"),
("interentreprises", "Inter-Entreprises"),
("territoriaux", "Territoriaux"),
help="Individualisé : accompagne d'entreprise en individuel ou collectif "
"mais qui porte sur le developpement de chaque entreprise\n"
"Inter-Entreprises : accompagnement de plusieurs entreprises autour "
"d'un projet collectif\n"
"Territoriaux : accompagnement d'un groupe multi-type d'acteurs dont "
"au moins une collectivité",
)
est_suite = fields.Boolean(
"Est ce que la sollicitation d'accompagnement est "
"issue d'un autre accompagnement précédent sur la zone Adefpat"
)
lieu = fields.Text("Lieu")
periode_realisation = fields.Text("Période de réalisation")
contenu_formation = fields.Text("Contenu des séances")
methode_savoir = fields.Text("Méthode et savoirs transmis")
travaux_intersessions = fields.Text("Travaux intersessions")
nb_jours_adefpat = fields.Float("Nombre de jours CFD")
cout_jour_adefpat = fields.Float("Coût jour CFD")
nb_jour_theorique_tot = fields.Float(
"Nombre de jours théoriques total", compute="_compute_nb_jour_theorique_tot"
)
"Nombre de jours pratiques total", compute="_compute_nb_jour_pratique_tot"
)
nb_jour_plann = fields.Float(
"Nombre de jours plannifiés", compute="_compute_nb_jour_plann"
)
nb_jour_rest = fields.Float(
"Nombre de jours restants", compute="_compute_nb_jour_rest"
)
"Nombre de jours total", compute="_compute_nb_jour_tot", store=True
)
"Nombre d'heures' total", compute="_compute_nb_jour_tot", store=True
)
"Total coûts CFD", compute="_compute_total_cout_adefpat"
)
"Financement Adefpat", compute="_compute_financement_adefpat"
)
"adefpat.project.financement", "project_id", string="Financements"
)
total_financement = fields.Float(
"Total autres", compute="_compute_total_financment"
)
cout_ids = fields.One2many("adefpat.project.cout", "project_id", string="Coûts")
total_cout = fields.Float("Total coûts", compute="_compute_total_cout")
honoraire_intervenant = fields.Float("Honoraires d'intervenants")
"Total budget coûts", compute="_compute_total_budget_cout"
)
total_budget_financement = fields.Float(
"Total budget financements", compute="_compute_total_budget_financement"
)
explication_financement = fields.Text(
"Explication financement porteur de projet",
"res.partner.consultants.project", "project_id", string="Consultants"
)
date_selection = fields.Date("Date de sélection")
date_notification = fields.Date("Date de notification")
date_cdc = fields.Date("Date d'envoi du CDC")
# Champs étape "Instruction" => Onglet GAP
elu_referent_id = fields.Many2one(
"res.partner",
string="Élu référent",
domain=[("active", "=", True), ("is_company", "=", False)],
"res.partner.membres.project", "project_id", string="Membres"
)
modalite_gap = fields.Text("Modalités GAP")
"adefpat.reunion.gap", "project_id", string="Réunions"
)
# Champs étape "Prêt pour CA" => Onglet Général
num_dossier = fields.Char("Numéro de dossier")
closing_date = fields.Date(
string="Date de clôture",
help="Date de la dernière séance facturée",
)
on_hold = fields.Boolean(
"Accompagement suspendus ou terminé avec l'abandon du projet"
)
number_gap_members = fields.Float(
"Nombre moyen de personnes présentes GAP",
compute="_compute_number_gap_members",
store=True,
)
number_proj_att = fields.Integer(
"Nombre de projets accompagnés dont l'objectif "
"principal est le renforcement de l'attractivité du territoire"
)
number_proj_inn_idea = fields.Integer(
"Nombre de projets aboutis considérés comme " "innovant dans leurs idées",
help="1 - L’idée n’a jamais été développé\n"
"2 - Un projet qui sort d’un cadre normé et apporte une ou plusieurs "
"dimensions sur les idées qui lui donne un caractère innovant\n"
"3 - L’idée peut répondre à un besoin sur “des signaux faibles",
)
number_proj_inn_terr = fields.Integer(
"Nombre de projets aboutis considérés comme "
"innovants dans leur existence sur le territoire",
help="1 - Le projet existe mais pas sur le territoire\n"
"2 - Le projet n’existe pas, nouveauté",
)
number_proj_inn_adap = fields.Integer(
"Nombre de projets aboutis considérés comme "
"innovants dans leur méthode d'adaptation au milieu rural",
help="1 – Création d’un projet en collectif et mutualiser par des entreprises "
"(coopérer, créer pour une stratégie commune au service de tous)\n"
"2 – L’adaptation de services urbains au milieu rural : développer le "
"public / privé, invention de concept de modulation pour créer et pérenniser"
"des services\n"
"3 – L’adaptation des démarches des grandes entreprises au profit de"
"l’entreprenariat local (au profit d’une compétitivité, l’attractivité"
"de l’activité et de l’emploi (RSE, la dynamique managériale et"
"organisationnelle en TPE/PME)",
)
number_proj_dev = fields.Integer(
"Nombre de projet qui ont eu un changement d’échelle",
help="1 - Diversification : créer une nouvelle activité pour enrichir\n"
"2 - Duplication : répliquer son modèle sur d’autres territoires\n"
"3 - Fertilisation : à plus grande échelle\n"
"4 - Coopération : se rapprocher d’autres structures pour faire mieux et plus\n"
"5 - Fusion : regrouper son patrimoine avec une autre structure",
)
number_proj_ind_coll = fields.Integer(
"Nombre de projet qui sont passés d’un projet"
"individuel à un projet collectif",
help="1 - Mise en lien avec d’autres porteurs projets ayant des problématiques"
"similaires",
)
is_service_design = fields.Boolean(
"Utilisation d'éléments de méthode de design de service"
)
is_social_impact = fields.Boolean("Intégration de notions d'Impact Social")
synthesis_website = fields.Char("Phrase de synthèse site Internet")
"Nombre d'entreprises accompagnées pour passer de l'idée au projet"
"Nombre d'entreprise en situation de création ou post création"
number_comp_created = fields.Integer("Nombre d'entreprises créées (AI)")
number_comp_consolidated = fields.Integer("Nombre d'entreprises consolidées")
number_emp_created = fields.Integer("Nombre d'emplois créés")
number_emp_consolidated = fields.Integer("Nombre d'emplois consolidés")
number_ac_created = fields.Integer("Nombre d'actions collectives créées")
number_emp_created_coll = fields.Integer(
"Nombre d'emplois crees sur le projet collectif"
)
number_emp_consolidated_coll = fields.Integer(
"Nombre d'emploi consolidés par l'action collective"
)
number_comp_created_coll = fields.Integer(
"Nombre d'entreprises concernées par la création"
"d'une nouvelle activité collective"
)
"Nombre de projets structurants définis"
number_mean_people_inv = fields.Integer(
"Nombre moyen de personnes sollicitées hors du"
"groupe de travail (enquête, réunion publique)"
)
number_comp_created_at = fields.Integer("Nombre d'entreprises créées (AT)")
number_comp_terr = fields.Integer("Nombre d'entreprises accompagnées (TERR)")
number_day_period = fields.Float(
"Nb jours sur période", compute="_compute_number_day_period", default=0.0)
number_hour_period = fields.Float(
"Nb heures sur période", compute="_compute_number_day_period", default=0.0)
@api.multi
def _compute_date_ca_next(self):
for project in self:
if project.date_ca:
project.date_ca_next = project.date_ca + timedelta(days=1)
@api.depends("financement_ids", "financement_ids.montant")
@api.multi
def _compute_total_financment(self):
for project in self:
for financement in project.financement_ids:
total_financement += financement.montant
project.total_financement = total_financement
@api.multi
def _compute_total_cout(self):
for project in self:
total_cout += cout.montant
project.total_cout = total_cout
@api.depends("cout_ids", "cout_ids.nb_jour_theorique")
@api.multi
def _compute_nb_jour_theorique_tot(self):
for project in self:
total_jour = 0.0
for cout in project.cout_ids:
total_jour += cout.nb_jour_theorique
@api.depends("cout_ids", "cout_ids.nb_jour_pratiques")
@api.multi
def _compute_nb_jour_pratique_tot(self):
for project in self:
total_jour = 0.0
for cout in project.cout_ids:
total_jour += cout.nb_jour_pratiques
@api.multi
def _compute_nb_jour_plann(self):
for project in self:
total_jour = 0.0
for task in project.task_ids:
total_jour += task.duree_hr
@api.depends("nb_jour_plann", "nb_jour_theorique_tot")
@api.multi
def _compute_nb_jour_rest(self):
for project in self:
project.nb_jour_rest = project.nb_jour_theorique_tot - project.nb_jour_plann
@api.depends("cout_ids", "cout_ids.nb_jour_theorique", "cout_ids.nb_jour_pratiques")
@api.multi
def _compute_nb_jour_tot(self):
for project in self:
total_jour = 0.0
for cout in project.cout_ids:
total_jour += cout.nb_jour_theorique + cout.nb_jour_pratiques
@api.depends("nb_jours_adefpat", "cout_jour_adefpat")
@api.multi
def _compute_total_cout_adefpat(self):
for project in self:
project.total_cout_adefpat = (
project.nb_jours_adefpat * project.cout_jour_adefpat
)
@api.multi
def _compute_total_budget_cout(self):
for project in self:
project.total_budget_cout = project.total_cout_adefpat + project.total_cout
@api.depends("total_budget_cout", "total_financement")
@api.multi
def _compute_financement_adefpat(self):
for project in self:
project.financement_adefpat = (
project.total_budget_cout - project.total_financement
)
@api.depends("financement_adefpat", "total_financement")
@api.multi
def _compute_total_budget_financement(self):
for project in self:
project.total_budget_financement = (
project.financement_adefpat + project.total_financement
)
@api.depends("porteurs_projets_ids", "porteurs_projets_ids.statut")
@api.multi
def _compute_type_beneficiaire(self):
for project in self:
project.type_beneficiaire = ", ".join(
project.porteurs_projets_ids.mapped("statut.name")
)
@api.depends("reunion_ids", "reunion_ids.number_participants")
@api.multi
def _compute_number_gap_members(self):
for project in self:
project.number_gap_members = sum(
project.reunion_ids.mapped("number_participants")) / len(
@api.multi
def _compute_number_day_period(self):
"""
fonction qui calcule le nombre de jours et heures par séance
pour des valeurs passées dans le contexte
"""
period_start = fields.Date.to_date(self.env.context.get("period_start"))
period_end = fields.Date.to_date(self.env.context.get("period_end"))
for project in self:
days = project.task_ids.filtered(
lambda t: t.date_deadline and t.date_deadline >= period_start
and t.date_deadline <= period_end).mapped("duree_hr")
project.number_day_period = sum(days)
project.number_hour_period = sum(days) * 7
@api.multi
def validate_ca(self):
for project in self:
project.num_dossier = (
project.departement
+ "/"
+ datetime.strftime(datetime.today(), "%y")
+ "/"
+ self.env["ir.sequence"].next_by_code("increment_num_dossier")
)
def get_workbook(self, filename_, project_id, partner_type):
project = self.env["project.project"].search([("id", "=", project_id)])
workbook = xlwt.Workbook()
worksheet = workbook.add_sheet(filename_)
header_file = HEADER_MEMBER
for i, fieldname in enumerate(header_file):
worksheet.write(0, i, fieldname)
worksheet.col(i).width = 8000 # around 220 pixels
cell_style = base_style
row_index = 1
for gap_id in gap_ids:
worksheet.write(row_index, 0, str(gap_id.lastname), cell_style)
worksheet.write(row_index, 1, str(gap_id.firstname), cell_style)
if partner_type == "gap":
worksheet.write(
row_index, 2, str(gap_id.partner_id.function), cell_style
)
worksheet.write(
row_index, 3, str(gap_id.partner_id.parent_id.name), cell_style
)
worksheet.write(row_index, 3, "None", cell_style)
if partner_type == "benef":
worksheet.write(
row_index, 2, str(gap_id.porteur_id.function), cell_style
)
worksheet.write(
row_index, 3, str(gap_id.porteur_id.parent_id.name), cell_style
)
worksheet.write(row_index, 3, "None", cell_style)
worksheet.write(row_index, 4, str(gap_id.commune), cell_style)
worksheet.write(row_index, 5, str(gap_id.mobile), cell_style)
worksheet.write(row_index, 6, str(gap_id.fixe), cell_style)
worksheet.write(row_index, 7, str(gap_id.email), cell_style)
row_index = row_index + 1
return workbook
@api.multi
def export_gap(self):
for project in self:
filename_ = project.name
project_id = project.id
return {
"url": "/web/export_gap?filename_=%s&project_id=%s&partner_type=%s"
% (filename_, project_id, "gap"),
"target": "new",
}
@api.multi
def export_benef(self):
for project in self:
filename_ = project.name
project_id = project.id
return {
"url": "/web/export_gap?filename_=%s&project_id=%s&partner_type=%s"
% (filename_, project_id, "benef"),
"target": "new",
@api.multi
def write(self, values):
res = super(Project, self).write(values)
for project in self:
# Mise à jour des participant sur les séances si ajout
for porteur in values.get("porteurs_projets_ids"):
if porteur[2].get("eligible") and porteur[2].get("porteur_id"):
"porteur_id": porteur[2]["porteur_id"],
"eligible": porteur[2]["eligible"],
}
participant_ids.append((0, 0, vals))
_name = "adefpat.type.convention"
_description = "Liste type de convention"
name = fields.Char(
string="Convention",
required=True,
)
date_end_validity = fields.Date("Date de fin de validité")
_name = "adefpat.reunion.gap"
_description = "Réunions GAP"
_rec_name = "date"
def _default_participant_ids(self):
if "default_project_id" in self.env.context:
project_id = self.env["project.project"].browse(
self.env.context["default_project_id"]
)
if project_id.exists().membre_ids:
participant_ids = project_id.membre_ids.mapped(lambda p: (0, 0, {
"member_id": p.id,
"present": False
}))
self.update({"participant_ids": participant_ids})
return participant_ids
date = fields.Date(
string="Date du GAP",
required=True,
)
required=True,
ondelete="cascade",
default=lambda self: self.env.context.get("default_project_id"),
)
comodel_name="res.partner.reunion.gap",
inverse_name="gap_id",
string="Participants",
default=_default_participant_ids
)
number_participants = fields.Integer(
string="Moyenne de participants",
compute="_compute_number_participants",
group_operator="avg",
@api.depends("participant_ids", "participant_ids.present")
@api.multi
def _compute_number_participants(self):
for gap in self:
gap.number_participants = len(gap.participant_ids.filtered("present"))
_name = "res.partner.membres.project"
_description = "Membres"
"res.partner",
string="Membre",
domain=[("active", "=", True), ("is_company", "=", False)],
name = fields.Char(related="partner_id.name", store=False)
lastname = fields.Char(related="partner_id.lastname", string="Nom", store=False)
related="partner_id.firstname", string="Prénom", store=False
)
commune = fields.Char(related="partner_id.city", string="Commune", store=False)
mobile = fields.Char(related="partner_id.mobile", string="Mobile", store=False)
fixe = fields.Char(related="partner_id.phone", string="Fixe", store=False)
email = fields.Char(related="partner_id.email", string="Email", store=False)
required=True,
ondelete="cascade",
default=lambda self: self.env.context.get("default_project_id"),
)
_name = "res.partner.consultants.project"
_description = "Consultants"
_rec_name = "name"
("active", "=", True),
("is_company", "=", False),
("is_consultant_form", "=", True),
"|",
("reference", "=", "reference"),
("reference", "=", "prereference"),
],
)
name = fields.Char(related="partner_id.name")
lastname = fields.Char(related="partner_id.lastname", string="Nom", store=False)
related="partner_id.firstname", string="Prénom", store=False
)
mobile = fields.Char(related="partner_id.mobile", string="Mobile", store=False)
email = fields.Char(related="partner_id.email", string="Email", store=False)
reference = fields.Selection(
[
("reference", "Référencé"),
("prereference", "Pré-Référencé"),
("dereference", "Dé-Référencé"),
],
related="partner_id.reference",
Juliana
committed
string="Référencement",
Juliana
committed
cout_journée = fields.Float("Coût journée")
is_selected = fields.Boolean("Est sélectionné")
required=True,
ondelete="cascade",
default=lambda self: self.env.context.get("default_project_id"),
)
_name = "res.partner.porteur.project"
_description = "Porteurs de projets"
_rec_name = "name"
"res.partner",
string="Porteur de projet",
domain=[("is_company", "=", False)],
name = fields.Char(related="porteur_id.name")
lastname = fields.Char(related="porteur_id.lastname", string="Nom", store=False)
related="porteur_id.firstname", string="Prénom", store=False
)
sexe = fields.Selection(related="porteur_id.sexe", string="Sexe", store=False)
commune = fields.Char(compute="_compute_commune", string="Commune", store=False)
string="Commune dans ComCom du lieu de formation",
help="En cas de lieu tournant, si un des lieux de formation est sur la com com "
"du PP cocher la case",
related="porteur_id.date_naissance", string="Date de naissance"
)
mobile = fields.Char(related="porteur_id.mobile", string="Mobile", store=False)
fixe = fields.Char(related="porteur_id.phone", string="Fixe", store=False)
email = fields.Char(related="porteur_id.email", string="Email", store=False)
statut = fields.Many2one("adefpat.project.statut", string="Statut")
eligible = fields.Boolean(string="Eligible", default=True)
is_benef_form = fields.Boolean(string="Fiches bénéficiaires")
h_pratiques = fields.Boolean("H pratiques")
h_theoriques = fields.Boolean("H théoriques")
default=lambda self: self.env.context.get("default_task_id"),
)
default=lambda self: self.env.context.get("default_project_id"),
)
project_num = fields.Char(
related="project_id.num_dossier", string="Numéro du dossier"
)
project_secteur = fields.Selection(
related="project_id.secteur_crit", string="Secteur d'activité du dossier"
)
related="project_id.departement", string="Département"
number_hour_period = fields.Float(
"Nb heures sur période", compute="_compute_hour_period", default=0.0)
# ------------------------------------------------------
# Constrains
# ------------------------------------------------------
@api.constrains("task_id", "project_id")
def _check_task_or_project(self):
for pp in self:
if not pp.task_id and not pp.project_id:
raise ValidationError(
"Un porteur de projet doit être associé à une tâche ou un projet."
)
def _compute_commune(self):
for r in self:
r.commune = r.porteur_id.city.capitalize()
@api.multi
def _compute_hour_period(self):
"""
fonction qui calcule le nombre d'heures par bénéficiaire
pour des valeurs passées dans le contexte
"""
period_start = fields.Date.from_string(self.env.context.get("period_start"))
period_end = fields.Date.from_string(self.env.context.get("period_end"))
for line in self:
if line.project_id:
task_ids = line.project_id.task_ids.filtered(
lambda t: t.date_deadline and t.date_deadline >= period_start
and t.date_deadline <= period_end)
days = []
for task in task_ids:
participant_ids = task.participant_ids.filtered(
lambda p: p.h_theoriques)
if line.porteur_id in participant_ids.mapped("porteur_id"):
days.append(task.duree_hr * 7)
line.number_hour_period = sum(days)
class AdefpatPresentsGap(models.Model):
_name = "res.partner.reunion.gap"
_description = "Présents GAP"
member_id = fields.Many2one(
"res.partner.membres.project",
string="Membre",
required=True,
ondelete="restrict",
)
gap_id = fields.Many2one(
"adefpat.reunion.gap",
string="Séance GAP",
default=lambda self: self.env.context.get("default_gap_id"),
ondelete="cascade",
)
present = fields.Boolean("Présent")
_name = "adefpat.project.statut"
_description = "Statut"