Sélectionner une révision Git
adefpat_project_justif_zip_wizard.py
res_partner.py NaN Gio
# © 2022 Le Filament (<http://www.le-filament.com>)
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
from odoo import _, api, fields, models
from odoo.exceptions import UserError, ValidationError
class ScopPartner(models.Model):
_inherit = "res.partner"
# Processus d'adhésion
project_number = fields.Char("N° Projet")
percent_realisation = fields.Selection(
[
("0", "0"),
("20", "20"),
("40", "40"),
("60", "60"),
("80", "80"),
("100", "100"),
],
string="Probabilité de réalisation",
)
date_realisation = fields.Date("Date prévue de réalisation")
prescriber_canal_id = fields.Many2one(
"res.partner.prescriber.canal",
string="Canal de Prescription",
ondelete="restrict",
)
project_federation = fields.Many2one(
comodel_name="res.partner.federation",
string="Fédération",
ondelete="restrict",
tracking=True,
)
date_first_rdv = fields.Date("Date du 1er rdv")
year_project = fields.Char("Année du projet", compute="_compute_year_project")
is_first_rdv_infocoll = fields.Boolean("Réunion d'info. collective")
date_send_guide = fields.Date("Date d’envoi du guide de faisabilité")
date_abort = fields.Date("Date d'abandon")
abort_comments = fields.Text("Commentaires abandon projet")
staff_existing = fields.Integer("Effectif connu")
staff_planned = fields.Integer("Effectif prévu")
ca_previsionnel = fields.Integer("CA Prévisionnel")
adhesion_comments = fields.Text("Commentaires Adhésion")
feasibility_study = fields.Boolean("Etude de faisabilité signée / validée")
amount_feasibility_study = fields.Integer("Montant de l’étude de faisabilité")
date_prediag = fields.Date("Date de pré-diagnostic")
date_convention = fields.Date("Date de signature de la convention")
amount_convention = fields.Integer("Montant de la convention")
file_full = fields.Boolean("Dossier d’adhésion complet")
date_transmission_cg = fields.Date("Date de transmission du dossier à la CG")
date_bureau_validation = fields.Date("Date du bureau de validation")
invoice_adhesion_id = fields.Many2one(
comodel_name="account.move", string="Facture d'adhésion"
)
# Dossier UE
file_fse_open = fields.Boolean("Dossier FSE ouvert Oui/Non")
is_id_card = fields.Boolean("Carte d'identité reçue")
date_return_file = fields.Date("Date de retour du dossier")
fse_full = fields.Boolean("FSE Complet")
recipient_file_fse = fields.Many2one(
"res.partner", string="Destinataire du dossier FSE"
)
project_invoicing_status_id = fields.Many2many(
"res.partner.project.invoicing.status",
column1="partner_id",
column2="invoicing_status_id",
string="Etat de facturation",
)
project_invoicing_status_nb = fields.Integer(
string="Nb de statuts de facturation",
compute="_compute_project_invoicing_status_nb",
)
liasse_membership_id = fields.Many2one(
comodel_name="scop.liasse.fiscale", string="Liasse fiscale adhésion"
)
# Changement de statuts
list_logs = fields.Text("Liste des erreurs")
# ------------------------------------------------------
# Compute function
# ------------------------------------------------------
def _compute_project_invoicing_status_nb(self):
for partner in self:
# Calcul nombre de statut 1
sta = partner.env["res.partner.project.invoicing.status"].search(
[("ur_id", "=", self.env.user.ur_id.id)]
)
partner.project_invoicing_status_nb = len(sta)
def _compute_year_project(self):
for partner in self:
partner.year_project = None
if partner.date_first_rdv:
partner.year_project = str(partner.date_first_rdv.year)
# ------------------------------------------------------
# Onchange function
# ------------------------------------------------------
@api.onchange("project_status")
def _onchange_project_status(self):
if self.project_status != "5_abandonne":
self.date_abort = None
# ------------------------------------------------------
# Actions / Buttons
# ------------------------------------------------------
def fill_membership_staff(self):
self.ensure_one()
staff_id = self.env["scop.partner.staff"].search(
[
("partner_id", "=", self.id),
("type_entry", "=", "membership"),
(
"effective_date",
">",
fields.Date.subtract(fields.Date.today(), years=1),
),
],
limit=1,
)
wizard = self.env["scop.membership.staff.wizard"].create(
{
"partner_id": self.id,
"staff_id": staff_id.id if staff_id else None,
"effective_date": fields.Date.today()
if not staff_id
else staff_id.effective_date,
}
)
return {
"name": "Effectifs à l'adhésion",
"type": "ir.actions.act_window",
"view_mode": "form",
"res_model": "scop.membership.staff.wizard",
"res_id": wizard.id,
"target": "new",
}
def fill_membership_liasse(self):
self.ensure_one()
wizard = self.env["scop.membership.liasse.wizard"].create(
{
"partner_id": self.id,
"liasse_id": self.liasse_membership_id.id,
}
)
return {
"name": "Données financières",
"type": "ir.actions.act_window",
"view_mode": "form",
"res_model": "scop.membership.liasse.wizard",
"res_id": wizard.id,
"target": "new",
}
def scop_cancel_membership(self):
for partner in self:
partner.update({"member_status": "not_member"})
# ------------------------------------------------------
# Business methods
# ------------------------------------------------------
def create_num_adherent(self):
"""
Generate new num adherent with sequence
:return:
"""
self.ensure_one()
num = self.env["ir.sequence"].next_by_code("scop.membership.period")
self.write({"member_number_int": num})
return num
def create_period_adhesion_cg(self, num_adherent):
"""
Create new period adhesion for type CG
:param num_adherent:
:return:
"""
self.ensure_one()
type_id = self.env.ref("cgscop_partner.membership_type_1")
self.create_period_adhesion(type_id, num_adherent)
return True
def create_period_adhesion_fede(self, num_adherent):
"""
Create new period adhesion for type fédération if naf is linked to fede
:param num_adherent:
:return:
"""
self.ensure_one()
fede = self.naf_id.federation_id
fede_com = self.env.ref("cgscop_partner.COM")
fede_indus = self.env.ref("cgscop_partner.IND")
fede_btp = self.env.ref("cgscop_partner.BTP")
if fede == fede_com:
type_id = self.env.ref("cgscop_partner.membership_type_2")
elif fede == fede_indus:
type_id = self.env.ref("cgscop_partner.membership_type_3")
elif fede == fede_btp:
type_id = self.env.ref("cgscop_partner.membership_type_4")
else:
type_id = None
if type_id:
self.create_period_adhesion(type_id, num_adherent)
return True
else:
return False
def create_period_adhesion(self, type_id, number):
"""
Generic function to create period adhesion with type and number
:param type_id:
:param number:
:return:
"""
date = self.date_bureau_validation or fields.Date.today()
if self.env["scop.membership.period"].search(
[
("partner_id", "=", self.id),
("end", "=", False),
("type_id", "=", type_id.id),
],
limit=1,
):
raise ValidationError(_("Une période d'adhésion existe déjà pour ce type"))
else:
self.env["scop.membership.period"].create(
{
"partner_id": self.id,
"type_id": type_id.id,
"start": date,
"number": number,
}
)
def create_invoice_adhesion(self):
"""
Crée une facture d'adhésion avec l'article et le journal configurés
‐ Moins de 11 salariés (ou effectif inconnu) : 80€
‐ Entre 11 et 50 salariés : 160€
‐ Plus de 50 salariés : 235€
:param lm:
:return:
"""
self.ensure_one()
product_id = self.env.company.product_adhesion_id
journal_id = self.env.company.journal_adhesion_id
if not (product_id or journal_id):
raise ValidationError(
_("Vous devez configurer un article et un journal d'adhésion !")
)
else:
staff_line = self.staff_ids.filtered(
lambda s: s.type_entry == "membership"
).sorted(key="effective_date", reverse=True)
staff_number = staff_line[0].staff_count if staff_line else 0
amount_adhesion = self.get_amount_adhesion(staff_number)
Invoice = self.env["account.move"]
date_invoice = self.date_bureau_validation or fields.Date.today()
adhesion_invoice = Invoice.create(
{
"partner_id": self.id,
"move_type": "out_invoice",
"journal_id": journal_id.id,
"state": "draft",
"invoice_date": date_invoice,
"invoice_line_ids": [
(
0,
None,
{
"product_id": product_id.id,
"account_id": product_id.property_account_income_id.id,
"tax_ids": [(6, 0, product_id.taxes_id.ids)],
"name": product_id.name,
"price_unit": amount_adhesion,
"price_subtotal": amount_adhesion,
},
),
],
}
)
adhesion_invoice.action_post()
return adhesion_invoice
def get_amount_adhesion(self, effectif):
"""
Return amount adhésion thanks to effectif
"""
self.ensure_one()
if 11 <= effectif <= 50:
amount_adhesion = 160
elif effectif > 50:
amount_adhesion = 235
else:
amount_adhesion = 80
return amount_adhesion
# ------------------------------------------------------
# Override parent / Change of status
# ------------------------------------------------------
def scop_sumbit_cg(self):
"""
Ouvre le wizard
"""
wizard = self.env["scop.membership.submit.wizard"].create(
{
"partner_id": self.id,
"list_logs": self.list_logs,
}
)
return {
"name": "Confirmation de l'adhésion",
"type": "ir.actions.act_window",
"view_mode": "form",
"res_model": "scop.membership.submit.wizard",
"res_id": wizard.id,
"target": "new",
}
def scop_send_to_cg(self):
"""
Modifie le statut de la coopérative pour transmission du dossier à la CG
- positionner la date_transmission_cg avec la date du jour
@return : True
"""
# Check Staff
staff_line = self.get_last_membership_staff()
if not (staff_line or staff_line.staff_count > 0):
raise UserError(_("Les effectifs à l'adhésion ne sont pas renseignés."))
# Check financial datas
if not self.liasse_membership_id:
raise UserError(
_(
"Il est nécessaire de renseigner les données financières pour valider"
)
)
if self.liasse_membership_id.check_compulsory_fields_lf():
raise UserError(_("Les données financières ne peuvent pas être nulles."))
self.update(
{
"membership_status": "soumis_cg",
"date_transmission_cg": fields.Date.today(),
"list_logs": False,
}
)
def scop_abandonne(self):
"""
Hérite la fonction d'abandon pour déterminer la date
@return : True
"""
super(ScopPartner, self).scop_abandonne()
self.date_abort = fields.Date.today()
return True
def scop_suivi_adhesion(self):
"""
Shows validation wizard
"""
wizard = self.env["scop.compulsory.fields.suivi.wizard"].create(
{
"partner_id": self.id,
"list_logs": self.list_logs,
"with_adhesion": self.env.context.get("default_with_adhesion", False),
}
)
return {
"name": "Confirmation des champs obligatoires",
"type": "ir.actions.act_window",
"view_mode": "form",
"res_model": "scop.compulsory.fields.suivi.wizard",
"res_id": wizard.id,
"target": "new",
}
def scop_valid_cg_button(self):
self.ensure_one()
self.scop_valid_cg()
def scop_valid_cg(self):
"""
Inherit function to :
- create period adhesion CG
- create period adhesion Fédé if needed
- create invoice adhesion
- set liasse_fiscale_adhesion as qualified
"""
# Create period adhésions with num adherent
num_adherent = self.member_number_int or self.create_num_adherent()
self.create_period_adhesion_cg(num_adherent)
self.create_period_adhesion_fede(num_adherent)
# TODO : check pour fede CAE si coop is CAE ?
# Create invoice adhésion
invoice = self.create_invoice_adhesion()
self.invoice_adhesion_id = invoice
self.update(
{
"membership_status": "member",
"extranet_update_company": True,
"extranet_service_access": True,
}
)
return True
def get_last_membership_staff(self):
self.ensure_one()
staff_line = self.staff_ids.filtered(
lambda s: s.type_entry == "membership"
).sorted(key="effective_date", reverse=True)
return staff_line[0] if staff_line else False
class ResPartnerPrescriberCanal(models.Model):
_name = "res.partner.prescriber.canal"
_description = "Canal de Prescription"
name = fields.Char("Canal de Prescription")