Initial commit: OCA Mrp packages (117 packages)

odoo-bringout-oca-event-event_session/event_session/models/event_event.py

@@ -0,0 +1,140 @@
+# Copyright 2017 David Vidal<david.vidal@tecnativa.com>
+# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
+
+from odoo import _, api, fields, models
+from odoo.exceptions import ValidationError
+
+
+class EventEvent(models.Model):
+    _inherit = "event.event"
+
+    use_sessions = fields.Boolean(
+        string="Event Sessions",
+        help="Manage multiple sessions per event",
+        compute="_compute_use_sessions",
+        store=True,
+        readonly=False,
+    )
+    session_ids = fields.One2many(
+        comodel_name="event.session",
+        inverse_name="event_id",
+        string="Sessions",
+    )
+    session_count = fields.Integer(
+        string="Sessions Count",
+        compute="_compute_session_count",
+    )
+    date_begin = fields.Datetime(
+        compute="_compute_date_begin",
+        store=True,
+        readonly=False,
+    )
+    date_end = fields.Datetime(
+        compute="_compute_date_end",
+        store=True,
+        readonly=False,
+    )
+
+    @api.depends("event_type_id")
+    def _compute_use_sessions(self):
+        for rec in self:
+            rec.use_sessions = rec.event_type_id.use_sessions
+
+    @api.onchange("use_sessions")
+    def _onchange_use_sessions(self):
+        """
+        Automatically fill date_begin and date_end if it's a use_session event.
+        These fields are required but computed from sessions anyway.
+        """
+        if self.use_sessions and not self.date_begin:
+            self.date_begin = fields.Datetime.now()
+        if self.use_sessions and not self.date_end:
+            self.date_end = fields.Datetime.now()
+
+    @api.depends("session_ids")
+    def _compute_session_count(self):
+        groups = self.env["event.session"].read_group(
+            domain=[("event_id", "in", self.ids)],
+            fields=["event_id"],
+            groupby=["event_id"],
+        )
+        result = {g["event_id"][0]: g["event_id_count"] for g in groups}
+        for rec in self:
+            rec.session_count = result.get(rec.id, 0)
+
+    @api.depends("use_sessions", "session_ids.date_begin")
+    def _compute_date_begin(self):
+        session_records = self.filtered("use_sessions")
+        regular_records = self - session_records
+        # This is a core field. Play nice with other modules.
+        # It is also why we compute date_begin and date_end separately.
+        if hasattr(super(), "_compute_date_begin"):  # pragma: no cover
+            super(EventEvent, regular_records)._compute_date_begin()
+        if not session_records:  # pragma: no cover
+            return
+        groups = self.env["event.session"].read_group(
+            domain=[("event_id", "in", session_records.ids)],
+            fields=["event_id", "date_begin:min"],
+            groupby=["event_id"],
+        )
+        data = {d["event_id"][0]: d["date_begin"] for d in groups}
+        for rec in session_records:
+            if data.get(rec.id):
+                rec.date_begin = data.get(rec.id)
+
+    @api.depends("use_sessions", "session_ids.date_end")
+    def _compute_date_end(self):
+        session_records = self.filtered("use_sessions")
+        regular_records = self - session_records
+        # This is a core field. Play nice with other modules.
+        # It is also why we compute date_begin and date_end separately.
+        if hasattr(super(), "_compute_date_end"):  # pragma: no cover
+            super(EventEvent, regular_records)._compute_date_end()
+        if not session_records:  # pragma: no cover
+            return
+        groups = self.env["event.session"].read_group(
+            domain=[("event_id", "in", session_records.ids)],
+            fields=["event_id", "date_end:max"],
+            groupby=["event_id"],
+        )
+        data = {d["event_id"][0]: d["date_end"] for d in groups}
+        for rec in session_records:
+            if data.get(rec.id):
+                rec.date_end = data.get(rec.id)
+
+    def _check_seats_availability(self, minimal_availability=0):  # pragma: no cover
+        # OVERRIDE to ignore this constraint for event with sessions
+        # Seat availability is checked on each session, not here.
+        session_records = self.filtered("use_sessions")
+        regular_records = self - session_records
+        return super(EventEvent, regular_records)._check_seats_availability(
+            minimal_availability=minimal_availability
+        )
+
+    @api.model_create_multi
+    def create(self, vals_list):
+        # OVERRIDE to automatically fill date_begin and date_end if they're
+        # missing and it's a use_session event.
+        # These fields are required but computed from sessions anyway.
+        for vals in vals_list:
+            if vals.get("use_sessions"):
+                vals["date_begin"] = fields.Datetime.now()
+                vals["date_end"] = fields.Datetime.now()
+        return super().create(vals_list)
+
+    def write(self, vals):
+        # OVERRIDE to prevent the switch of use_sessions if the event has registrations
+        # and to automatically subscribe the organizer to sessions, if it changes.
+        if "use_sessions" in vals:
+            if any(
+                rec.use_sessions != vals["use_sessions"] and rec.registration_ids
+                for rec in self
+            ):
+                raise ValidationError(
+                    _("You can't enable/disable sessions on events with registrations.")
+                )
+            if not vals["use_sessions"]:
+                self.with_context(active_test=False).session_ids.unlink()
+        if vals.get("organizer_id"):
+            self.session_ids.message_subscribe([vals["organizer_id"]])
+        return super().write(vals)