Skip to content
Extraits de code Groupes Projets
Sélectionner une révision Git
  • cd1cb637bdc50a3d4efe351c5059dfdd74a21c77
  • 12.0-evo-202003 par défaut
  • 14-RV-20250324
  • 14-RV-20240830
  • 14-RV-20231222
  • 12-RV-Bug_ecrasement_date_radiation
  • 12-RV-revision-staff
  • 12-RV-copadev
  • 12-RV-Correctif-open-instagram
  • 12-RV-Tree-Coop-Ajout-effectif
  • 12.0-RV-Instagram
  • 12.0-RV-segment_visibility
  • 12.0 protégée
  • 12.0-RV-Abonnements
14 résultats

scop_questionnaire.py

Blame
  • Bifurcation depuis Le Filament / Confédération Générale des SCOP / cgscop_partner
    Le projet source a une visibilité limitée.
    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")