Skip to content
Extraits de code Groupes Projets
Sélectionner une révision Git
  • eebf22299f88143d570a4ac489da8b6779c60f3c
  • 16.0 par défaut
  • 18.0
  • 17.0
  • 15.0
  • 13.0
  • 12.0 protégée
  • 14.0
8 résultats

main.py

Blame
  • training_training.py 8,15 Kio
    # Copyright 2019-2022 Le Filament (<https://le-filament.com>)
    # License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
    
    from odoo import api, fields, models
    
    
    class Training(models.Model):
        _name = "training.training"
        _inherit = "mail.thread"
        _rec_name = "course_id"
        _order = "date_begin desc"
        _description = "Training for customers"
    
        customer_id = fields.Many2one(
            comodel_name="res.partner", string="Client", domain=[("is_company", "=", True)]
        )
        opco_id = fields.Many2one(
            comodel_name="res.partner",
            string="OPCO",
            domain=[("is_company", "=", True), ("is_opco", "=", True)],
        )
        student_ids = fields.One2many(
            comodel_name="training.student",
            inverse_name="training_id",
            string="Stagiaires",
        )
        session_ids = fields.One2many(
            comodel_name="training.session",
            inverse_name="training_id",
            string="Sessions",
        )
        course_id = fields.Many2one(comodel_name="training.course", string="Programme")
        type = fields.Selection(
            required=True, selection=[("intra", "INTRA"), ("inter", "INTER")]
        )
        agreement_number = fields.Char(
            string="Numéro Convention",
            required=True,
            copy=False,
            readonly=True,
            states={"draft": [("readonly", False)]},
            index=True,
            default="Brouillon",
        )
        payment = fields.Boolean(string="Subrogation de paiement")
        date_begin = fields.Date(string="Début de la formation")
        date_end = fields.Date(string="Fin de la formation")
        session_hours = fields.Char(string="Horaires")
        students_nb_prev = fields.Char(string="Nb Stagiaires Prévisionnel")
        convention = fields.Binary(attachment=True)
        signin_person = fields.Char(
            string="Signataire", help="Signataire de la convention et des attestations"
        )
        signin_function = fields.Char(
            string="Fonction Signataire",
            help="Fonction du signataire de la convention et des attestations",
        )
        date_convocation = fields.Date()
        date_convention = fields.Date()
        place_convention = fields.Char(
            "Lieu signature convention",
            default=lambda self: self.env["res.company"]._company_default_get().city,
        )
        date_attestation = fields.Date()
        place_attestation = fields.Char(
            "Lieu signature attestation",
            default=lambda self: self.env["res.company"]._company_default_get().city,
        )
        hours = fields.Integer(string="Durée (h)", compute="_compute_sessions", store=True)
        hours_total = fields.Integer(
            string="Nombre d'heures", compute="_compute_hours_total", store=True
        )
        session_count = fields.Integer(
            string="Nbre Sessions", compute="_compute_sessions", default=0, store=True
        )
        rate = fields.Integer(string="Taux horaire", compute="_compute_costs", default=0)
        students_count = fields.Integer(
            string="Nombre de stagiaires",
            compute="_compute_students_count",
            store=True,
        )
        cost = fields.Float(string="Prix de vente")
        student_cost = fields.Float(string="Prix / Stagiaire")
        amount = fields.Float(
            string="Commandé",
            compute="_compute_amount",
            store=True,
        )
        invoiced = fields.Float(
            string="Facturé",
            compute="_compute_invoiced",
            store=True,
        )
        order_ids = fields.One2many(
            comodel_name="sale.order",
            inverse_name="training_id",
            string="Commandes",
        )
        invoice_ids = fields.One2many(
            comodel_name="account.move",
            inverse_name="training_id",
            string="Factures",
        )
        state = fields.Selection(
            selection=[("draft", "Brouillon"), ("current", "Accepté"), ("done", "Réalisé")],
            default="draft",
        )
        place = fields.Char(string="Lieu de la formation")
        place_detail = fields.Text(string="Détails du lieu")
        company_id = fields.Many2one(
            comodel_name="res.company",
            string="Company",
            change_default=True,
            required=True,
            readonly=True,
            default=lambda self: self.env["res.company"]._company_default_get(),
        )
        file_number = fields.Char(string="N° Dossier OPCO")
        plan = fields.Char(string="Dispositif OPCO")
        meanings = fields.Text("Dispositif formation")
        is_vat = fields.Boolean("TVA 20% applicable", default=True)
        training_type_id = fields.Many2one(
            comodel_name="training.type",
            string="Type de formation",
        )
        payment_term_id = fields.Many2one(
            comodel_name="account.payment.term",
            string="Condition de règlement",
            check_company=True,
            domain="['|', ('company_id', '=', False), ('company_id', '=', company_id)]",
        )
        email_contact = fields.Char("Email contact formation")
        equipment = fields.Text(string="Équipement/éléments nécessaires pour la formation")
    
        # ------------------------------------------------------
        # Override ORM
        # ------------------------------------------------------
        @api.model_create_multi
        @api.returns("self", lambda value: value.id)
        def create(self, vals_list):
            records = super(Training, self).create(vals_list)
            for record in records.filtered("course_id"):
                for s in record.course_id.session_ids:
                    self.env["training.session"].create(
                        {
                            "session_id": s.id,
                            "training_id": record.id,
                            "date_delay": s.duration,
                            "sequence": s.sequence,
                        }
                    )
            return records
    
        def write(self, vals):
            res = super(Training, self).write(vals)
            # If we modify the course, then we delete and recreate sessions
            if vals.get("course_id", False):
                self.session_ids.unlink()
                for s in self.course_id.session_ids:
                    self.env["training.session"].create(
                        {
                            "session_id": s.id,
                            "training_id": self.id,
                            "date_delay": s.duration,
                            "sequence": s.sequence,
                        }
                    )
            return res
    
        # ------------------------------------------------------
        # compute
        # ------------------------------------------------------
        @api.depends("student_ids")
        def _compute_students_count(self):
            for record in self:
                record.students_count = len(record.student_ids)
    
        @api.depends("students_count", "cost", "hours_total")
        def _compute_costs(self):
            for record in self:
                record.student_cost = 0
                record.rate = 0
                if record.students_count > 0:
                    record.student_cost = record.cost / record.students_count
                if record.hours_total > 0:
                    record.rate = record.cost / record.hours_total
    
        @api.depends("session_ids")
        def _compute_sessions(self):
            for record in self:
                record.session_count = len(record.session_ids)
                record.hours = sum(record.session_ids.mapped("date_delay"))
    
        @api.depends("students_count", "hours")
        def _compute_hours_total(self):
            for record in self:
                record.hours_total = record.students_count * record.hours
    
        @api.depends("order_ids")
        def _compute_amount(self):
            self.amount = sum(self.order_ids.mapped("amount_untaxed"))
    
        @api.depends("invoice_ids")
        def _compute_invoiced(self):
            for record in self:
                record.invoiced = sum(record.invoice_ids.mapped("amount_untaxed_signed"))
    
        # ------------------------------------------------------
        # Buttons
        # ------------------------------------------------------
        def action_valid(self):
            for training in self:
                training.state = "current"
                training.agreement_number = self.env["ir.sequence"].next_by_code(
                    "training.training"
                )
    
        def action_done(self):
            for training in self:
                training.state = "done"
    
        def action_draft(self):
            for training in self:
                training.state = "draft"
    
        def _get_trainers(self):
            for training in self:
                trainers = training.session_ids.mapped("user_id")
                return trainers