acc_priority_group.py

from odoo import api, fields, models


class AccPriorityGroup(models.Model):
    _name = "acc.priority.group"
    _description = "Groupe de clés de répartition"
    _rec_name = "display_name"
    _order = "sequence, id"

    # ------------------------------------------------------
    # Fields declaration
    # ------------------------------------------------------

    acc_operation_id = fields.Many2one("acc.operation", "Opération", required=True)
    sequence = fields.Integer(required=True, default=1)
    type_algo = fields.Selection(
        [
            ("prorata", "Répartition au prorata"),
        ],
        string="Répartition au sein du groupe",
        default="prorata",
        required=True,
    )
    display_name = fields.Char(
        compute="_compute_display_name", store=True, readonly=True
    )
    acc_priority_group_counter_ids = fields.One2many(
        comodel_name="acc.priority.group.counter",
        inverse_name="acc_priority_group_id",
        string="Affectation de compteur par groupe de priorité",
        required=True,
    )

    counter_datas = fields.Json(compute="_compute_counter_datas")
    # ------------------------------------------------------
    # SQL Constraints
    # ------------------------------------------------------

    # ------------------------------------------------------
    # Default methods
    # ------------------------------------------------------

    # ------------------------------------------------------
    # Computed fields / Search Fields
    # ------------------------------------------------------

    @api.depends("type_algo", "sequence")
    def _compute_display_name(self):
        for prio_group in self:
            prio_group.display_name = f"Priorité {str(prio_group.sequence)}"

    def _compute_counter_datas(self):
        for priority in self:
            priority.counter_datas = (
                priority.acc_priority_group_counter_ids.acc_counter_id.mapped(
                    lambda q: {
                        "name": q.name,
                        "partner": q.partner_id.name,
                        "street": q.street,
                    }
                )
            )

    # ------------------------------------------------------
    # Onchange / Constraints
    # ------------------------------------------------------
    @api.onchange("sequence")
    def on_change_algo(self):
        self._compute_display_name()

    # ------------------------------------------------------
    # CRUD methods (ORM overrides)
    # ------------------------------------------------------
    @api.model
    def unlink(self, _id):
        self = self.env["acc.priority.group"].browse(_id)
        current_operation_id = self.env.context.get("active_id")
        existing_groups = self.env["acc.priority.group"].search(
            [("acc_operation_id", "=", current_operation_id), ("id", "!=", _id)]
        )
        seq = 1
        for group in existing_groups:
            group.sequence = seq
            seq += 1

        return super().unlink()

    @api.model_create_multi
    def create(self, vals_list):
        """
        si c est le premier groupe cree on y affecte tout les compteurs
        """
        current_operation_id = self.env.context.get("active_id")

        existing_groups = self.env["acc.priority.group"].search(
            [
                ("acc_operation_id", "=", current_operation_id),
            ]
        )

        res = super().create(vals_list)

        if existing_groups:
            res.sequence = max(existing_groups.mapped("sequence")) + 1
            return res

        counters_to_affect = self.env["acc.counter"].search(
            [
                ("acc_operation_id", "=", res.acc_operation_id.id),
                ("type", "in", ["del", "del_inj"]),
            ]
        )
        for counter in counters_to_affect:
            self.env["acc.priority.group.counter"].create(
                {
                    "acc_priority_group_id": res.id,
                    "acc_operation_id": res.acc_operation_id.id,
                    "acc_counter_id": counter.id,
                    "counter_street": counter.street,
                    "counter_owner": counter.partner_id.name,
                }
            )
        return res

    # ------------------------------------------------------
    # Actions
    # ------------------------------------------------------

    def compute(self, data=None):
        compute_algo = {
            "prorata": self._prorata,
        }
        if data is None:
            data = self.env["acc.enedis.raw.cdc"].get_repartition_data(
                operation_id=self.acc_operation_id
            )

        d = compute_algo[self.type_algo](data)

        return d

    def get_conso_sum(self, data_slot):
        conso = 0.0
        for counter in self.acc_priority_group_counter_ids.acc_counter_id.mapped(
            "name"
        ):
            consok = data_slot.get("conso").get(counter)
            if consok:
                conso += consok
        return conso

    def _prorata(self, data):
        for slot in data:
            prod = data.get(slot).get("prod_totale")
            priority_counters_conso_sum = self.get_conso_sum(data.get(slot))

            total_affecte = 0.0
            if not data.get(slot).get("affect"):
                data[slot]["affect"] = {}

            for counter in self.acc_priority_group_counter_ids.acc_counter_id:
                if prod == 0 or priority_counters_conso_sum == 0:
                    part_a_affecter = 0.0
                else:
                    conso_k = data.get(slot).get("conso").get(counter.name)
                    part_a_affecter = min(
                        conso_k, prod * (conso_k / priority_counters_conso_sum)
                    )
                data[slot]["affect"][counter] = part_a_affecter
                total_affecte += part_a_affecter

            data[slot]["prod_totale"] = prod - total_affecte

        return data