🎉 Initialize module repository

models/mvd_tcg_game.py

@@ -0,0 +1,140 @@
+"""Game-neutral models for supported TCG systems."""
+
+import re
+
+from odoo import _, api, fields, models
+from odoo.exceptions import UserError
+
+
+class MvdTcgGame(models.Model):
+    """Represent a supported trading card game within the suite."""
+
+    _name = "mvd.tcg.game"
+    _description = "TCG Game"
+    _order = "sequence, name, id"
+
+    name = fields.Char(required=True, translate=True, index="trigram")
+    code = fields.Char(required=True, index=True)
+    active = fields.Boolean(default=True)
+    sequence = fields.Integer(default=10)
+    description = fields.Text(translate=True)
+    card_ids = fields.One2many("mvd.tcg.card", "game_id")
+    card_count = fields.Integer(compute="_compute_card_count")
+
+    _code_unique = models.Constraint(
+        "UNIQUE (code)",
+        "The game code must be unique.",
+    )
+
+    @api.model
+    def _mvd_tcg_generate_game_code(self, name):
+        """Return a slug-like technical code for one game name."""
+        return re.sub(r"[^a-z0-9]+", "_", (name or "").strip().lower()).strip("_") or "game"
+
+    @api.model
+    def _mvd_tcg_get_unique_game_code(self, name):
+        """Return a globally unique technical code for one game name."""
+        base_code = self._mvd_tcg_generate_game_code(name)
+        existing_codes = set(self.search([]).mapped("code"))
+        if base_code not in existing_codes:
+            return base_code
+        suffix = 2
+        while f"{base_code}_{suffix}" in existing_codes:
+            suffix += 1
+        return f"{base_code}_{suffix}"
+
+    def _mvd_tcg_can_edit_game_code(self):
+        """Return whether the current user may edit technical game codes."""
+        return self.env.is_superuser() or any(
+            self.env.user.has_group(xmlid)
+            for xmlid in (
+                "mvd_tcg_base.mvd_tcg_base_group_administrator",
+                "base.group_system",
+            )
+        )
+
+    @api.model_create_multi
+    def create(self, vals_list):
+        """Generate missing technical game codes on manual creates."""
+        prepared_vals_list = []
+        for vals in vals_list:
+            prepared_vals = dict(vals)
+            if (
+                prepared_vals.get("code")
+                and not self.env.context.get("mvd_tcg_bypass_game_code_write")
+                and not self._mvd_tcg_can_edit_game_code()
+            ):
+                raise UserError(
+                    _(
+                        "Game codes are technical identifiers and can only be set "
+                        "by TCG administrators."
+                    )
+                )
+            if not prepared_vals.get("code"):
+                prepared_vals["code"] = self._mvd_tcg_get_unique_game_code(
+                    prepared_vals.get("name")
+                )
+            prepared_vals_list.append(prepared_vals)
+        return super().create(prepared_vals_list)
+
+    def write(self, vals):
+        """Protect technical game codes from normal business edits."""
+        if "code" in vals and not self.env.context.get("mvd_tcg_bypass_game_code_write"):
+            if not self._mvd_tcg_can_edit_game_code():
+                raise UserError(
+                    _(
+                        "Game codes are technical identifiers and can only be changed "
+                        "by TCG administrators."
+                    )
+                )
+        return super().write(vals)
+
+    @api.depends("card_ids")
+    def _compute_card_count(self):
+        """Compute the number of base cards linked to each game."""
+        card_data = self.env["mvd.tcg.card"]._read_group(
+            [("game_id", "in", self.ids)],
+            ["game_id"],
+            ["__count"],
+        )
+        counts_by_game = {game.id: count for game, count in card_data}
+        for game in self:
+            game.card_count = counts_by_game.get(game.id, 0)
+
+    def action_open_cards(self):
+        """Open the cards catalog filtered on the selected game."""
+        self.ensure_one()
+        action = self.env["ir.actions.actions"]._for_xml_id(
+            "mvd_tcg_base.mvd_tcg_card_action"
+        )
+        action["domain"] = [("game_id", "=", self.id)]
+        action["context"] = {"default_game_id": self.id}
+        return action
+
+    def _mvd_tcg_get_default_deck_board_templates(self):
+        """Return default board definitions for new decks of this game.
+
+        Returns:
+            list[dict[str, object]]: Ordered board configuration dictionaries.
+        """
+        self.ensure_one()
+        return [
+            {
+                "name": _("Mainboard"),
+                "code": "mainboard",
+                "sequence": 10,
+                "include_in_total": True,
+            },
+            {
+                "name": _("Sideboard"),
+                "code": "sideboard",
+                "sequence": 20,
+                "include_in_total": True,
+            },
+            {
+                "name": _("Maybeboard"),
+                "code": "maybeboard",
+                "sequence": 30,
+                "include_in_total": False,
+            },
+        ]