[REM] website_event_track_session: merge into website_event_track

PURPOSE

Clean organization and models linked to Event Online feature introduced in
semi stable saas-13.3 at odoo/odoo@981f95bbf46658eda9f2d33751b9310cc67d86aa and odoo/enterprise@14722028ae0773c3710ea48ce48ff44703e83b5a

Also clean website event menu not being available in website event but only
in website event track, which implies some extra-code to manage it.

In short: merge website_event_online in website_event, website_event_track
_(online/session) in website_event_track.

RATIONALE

_online modules have been added to extend content of website_event and
website_event_track without having any impact on those module. First step
of cleaning is to move this content directly in base module.

track_session module is mainly a rewrite of track module. Second step of
cleaning is to move its content directly in website_event_track.

SPECIFICATIONS

Move all content of website event track session to website event tracK. It
was mainly of rewriting of views and can now be safely merged into the base
track module.

Update dependencies accordingly.

LINKS

Task ID-2319779
COM odoo/odoo#56067
ENT odoo/enterprise#12520
UPG odoo/upgrade#1654

1 files changed, 168 insertions, 23 deletions

diff --git a/addons/website_event_track/controllers/event_track.py b/addons/website_event_track/controllers/event_track.py
index e338f384580..782b1e839ee 100644
--- a/addons/website_event_track/controllers/event_track.py
+++ b/addons/website_event_track/controllers/event_track.py
@@ -1,7 +1,9 @@
 # -*- coding: utf-8 -*-
 # Part of Odoo. See LICENSE file for full copyright and licensing details.
 
+from ast import literal_eval
 from datetime import timedelta
+from pytz import timezone, utc
 from werkzeug.exceptions import Forbidden, NotFound
 
 import babel
@@ -9,13 +11,28 @@ import babel.dates
 import base64
 import pytz
 
-from odoo import exceptions, http, fields
+from odoo import exceptions, http, fields, _
 from odoo.http import request
-from odoo.tools import plaintext2html, html2plaintext
+from odoo.osv import expression
+from odoo.tools import is_html_empty, plaintext2html
 
 
 class EventTrackController(http.Controller):
 
+    def _get_event_tracks_base_domain(self, event):
+        """ Base domain for displaying tracks. Restrict to accepted or published
+        tracks for people not managing events. Unpublished tracks may be displayed
+        but not reachable for teasing purpose. """
+        search_domain_base = [
+            ('event_id', '=', event.id),
+        ]
+        if not request.env.user.has_group('event.group_event_user'):
+            search_domain_base = expression.AND([
+                search_domain_base,
+                ['|', ('is_published', '=', True), ('is_accepted', '=', True)]
+            ])
+        return search_domain_base
+
     # ------------------------------------------------------------
     # TRACK LIST VIEW
     # ------------------------------------------------------------
@@ -24,27 +41,110 @@ class EventTrackController(http.Controller):
         '''/event/<model("event.event"):event>/track''',
         '''/event/<model("event.event"):event>/track/tag/<model("event.track.tag"):tag>'''
     ], type='http', auth="public", website=True, sitemap=False)
-    def event_tracks(self, event, tag=None, **post):
-        if not event.can_access_from_current_website() or (tag and tag.color == 0):
+    def event_tracks(self, event, tag=None, **searches):
+        """ Main route
+
+        :param event: event whose tracks are about to be displayed;
+        :param tag: deprecated: search for a specific tag
+        :param searches: frontend search dict, containing
+
+          * 'search': search string;
+          * 'tags': list of tag IDs for filtering;
+        """
+        if not event.can_access_from_current_website():
             raise NotFound()
 
+        return request.render(
+            "website_event_track.tracks_session",
+            self._event_tracks_get_values(event, tag=tag, **searches)
+        )
+
+    def _event_tracks_get_values(self, event, tag=None, **searches):
+        # init and process search terms
+        searches.setdefault('search', '')
+        searches.setdefault('search_wishlist', '')
+        searches.setdefault('tags', '')
+        search_domain = self._get_event_tracks_base_domain(event)
+
+        # search on content
+        if searches.get('search'):
+            search_domain = expression.AND([
+                search_domain,
+                [('name', 'ilike', searches['search'])]
+            ])
+
+        # search on tags
+        search_tags = self._get_search_tags(searches['tags'])
+        if not search_tags and tag:  # backward compatibility
+            search_tags = tag
+        if search_tags:
+            # Example: You filter on age: 10-12 and activity: football.
+            # Doing it this way allows to only get events who are tagged "age: 10-12" AND "activity: football".
+            # Add another tag "age: 12-15" to the search and it would fetch the ones who are tagged:
+            # ("age: 10-12" OR "age: 12-15") AND "activity: football
+            grouped_tags = dict()
+            for search_tag in search_tags:
+                grouped_tags.setdefault(search_tag.category_id, list()).append(search_tag)
+            search_domain_items = [
+                [('tag_ids', 'in', [tag.id for tag in grouped_tags[group]])]
+                for group in grouped_tags
+            ]
+            search_domain = expression.AND([
+                search_domain,
+                *search_domain_items
+            ])
+
+        # fetch data to display with TZ set for both event and tracks
+        now_tz = utc.localize(fields.Datetime.now().replace(microsecond=0), is_dst=False).astimezone(timezone(event.date_tz))
+        today_tz = now_tz.date()
         event = event.with_context(tz=event.date_tz or 'UTC')
-        searches = {}
-        if tag:
-            searches.update(tag=tag.id)
-            tracks = event.track_ids.filtered(lambda track: tag in track.tag_ids)
-        else:
-            tracks = event.track_ids
-
-        values = {
+        tracks_sudo = event.env['event.track'].sudo().search(search_domain, order='date asc')
+        tag_categories = request.env['event.track.tag.category'].sudo().search([])
+
+        # filter on wishlist (as post processing due to costly search on is_reminder_on)
+        if searches.get('search_wishlist'):
+            tracks_sudo = tracks_sudo.filtered(lambda track: track.is_reminder_on)
+
+        # organize categories for display: announced, live, soon and day-based
+        tracks_announced = tracks_sudo.filtered(lambda track: not track.date)
+        tracks_wdate = tracks_sudo - tracks_announced
+        date_begin_tz_all = list(set(
+            dt.date()
+            for dt in self._get_dt_in_event_tz(tracks_wdate.mapped('date'), event)
+        ))
+        date_begin_tz_all.sort()
+        tracks_sudo_live = tracks_wdate.filtered(lambda track: track.is_published and track.is_track_live)
+        tracks_sudo_soon = tracks_wdate.filtered(lambda track: track.is_published and not track.is_track_live and track.is_track_soon)
+        tracks_by_day = []
+        for display_date in date_begin_tz_all:
+            matching_tracks = tracks_wdate.filtered(lambda track: self._get_dt_in_event_tz([track.date], event)[0].date() == display_date)
+            tracks_by_day.append({'date': display_date, 'name': display_date, 'tracks': matching_tracks})
+        if tracks_announced:
+            tracks_announced = tracks_announced.sorted('wishlisted_by_default', reverse=True)
+            tracks_by_day.append({'date': False, 'name': _('Coming soon'), 'tracks': tracks_announced})
+
+        # return rendering values
+        return {
+            # event information
             'event': event,
             'main_object': event,
-            'tracks': tracks,
-            'tags': event.tracks_tag_ids,
+            # tracks display information
+            'tracks': tracks_sudo,
+            'tracks_by_day': tracks_by_day,
+            'tracks_live': tracks_sudo_live,
+            'tracks_soon': tracks_sudo_soon,
+            'today_tz': today_tz,
+            # search information
             'searches': searches,
-            'html2plaintext': html2plaintext
+            'search_key': searches['search'],
+            'search_wishlist': searches['search_wishlist'],
+            'search_tags': search_tags,
+            'tag_categories': tag_categories,
+            # environment
+            'is_html_empty': is_html_empty,
+            'hostname': request.httprequest.host.split(':')[0],
+            'user_event_manager': request.env.user.has_group('event.group_event_manager'),
         }
-        return request.render("website_event_track.tracks", values)
 
     # ------------------------------------------------------------
     # AGENDA VIEW
@@ -219,14 +319,41 @@ class EventTrackController(http.Controller):
     # TRACK PAGE VIEW
     # ------------------------------------------------------------
 
-    @http.route(['''/event/<model("event.event"):event>/track/<model("event.track", "[('event_id','=',event.id)]"):track>'''], type='http', auth="public", website=True, sitemap=True)
-    def event_track_view(self, event, track, **post):
-        if not event.can_access_from_current_website():
-            raise NotFound()
+    @http.route('''/event/<model("event.event", "[('website_track', '=', True)]"):event>/track/<model("event.track", "[('event_id', '=', event.id)]"):track>''',
+                type='http', auth="public", website=True, sitemap=True)
+    def event_track_page(self, event, track, **options):
+        track = self._fetch_track(track.id, allow_is_accepted=False)
 
-        track = track.sudo().with_context(tz=event.date_tz or 'UTC')
-        values = {'track': track, 'event': track.event_id, 'main_object': track}
-        return request.render("website_event_track.track_view", values)
+        return request.render(
+            "website_event_track.event_track_main",
+            self._event_track_page_get_values(event, track.sudo(), **options)
+        )
+
+    def _event_track_page_get_values(self, event, track, **options):
+        track = track.sudo()
+
+        option_widescreen = options.get('widescreen', False)
+        option_widescreen = bool(option_widescreen) if option_widescreen != '0' else False
+        # search for tracks list
+        tracks_other = track._get_track_suggestions(
+            restrict_domain=self._get_event_tracks_base_domain(track.event_id),
+            limit=10
+        )
+
+        return {
+            # event information
+            'event': event,
+            'main_object': track,
+            'track': track,
+            # sidebar
+            'tracks_other': tracks_other,
+            # options
+            'option_widescreen': option_widescreen,
+            # environment
+            'is_html_empty': is_html_empty,
+            'hostname': request.httprequest.host.split(':')[0],
+            'user_event_manager': request.env.user.has_group('event.group_event_manager'),
+        }
 
     @http.route("/event/track/toggle_reminder", type="json", auth="public", website=True)
     def track_reminder_toggle(self, track_id, set_reminder_on):
@@ -330,3 +457,21 @@ class EventTrackController(http.Controller):
             raise Forbidden()
 
         return track
+
+    def _get_search_tags(self, tag_search):
+        # TDE FIXME: make me generic (slides, event, ...)
+        try:
+            tag_ids = literal_eval(tag_search)
+        except Exception:
+            tags = request.env['event.track.tag'].sudo()
+        else:
+            # perform a search to filter on existing / valid tags implicitly
+            tags = request.env['event.track.tag'].sudo().search([('id', 'in', tag_ids)])
+        return tags
+
+    def _get_dt_in_event_tz(self, datetimes, event):
+        tz_name = event.date_tz
+        return [
+            utc.localize(dt, is_dst=False).astimezone(timezone(tz_name))
+            for dt in datetimes
+        ]