[MERGE] forward port branch saas-12.2 up to fcb972db9dc

1 files changed, 64 insertions, 26 deletions

diff --git a/addons/website_slides/controllers/main.py b/addons/website_slides/controllers/main.py
index 50cea64c078..7ab6b6052d7 100644
--- a/addons/website_slides/controllers/main.py
+++ b/addons/website_slides/controllers/main.py
@@ -53,8 +53,8 @@ class WebsiteSlides(WebsiteProfile):
         return True
 
     def _get_slide_detail(self, slide):
-        most_viewed_slides = slide.get_most_viewed_slides(self._slides_per_list)
-        related_slides = slide.get_related_slides(self._slides_per_list)
+        most_viewed_slides = slide._get_most_viewed_slides(self._slides_per_list)
+        related_slides = slide._get_related_slides(self._slides_per_list)
         values = {
             'slide': slide,
             'most_viewed_slides': most_viewed_slides,
@@ -100,9 +100,8 @@ class WebsiteSlides(WebsiteProfile):
                     tags |= search_tag
         return tags
 
-    def _build_channel_domain(self, base_domain, slide_type=None, **post):
+    def _build_channel_domain(self, base_domain, slide_type=None, my=False, **post):
         search_term = post.get('search')
-        category_id = post.get('category_id')
         channel_tag_id = post.get('channel_tag_id')
         tags = self._extract_channel_tag_search(**post)
 
@@ -111,15 +110,16 @@ class WebsiteSlides(WebsiteProfile):
             domain = expression.AND([
                 domain,
                 ['|', ('name', 'ilike', search_term), ('description', 'ilike', search_term)]])
-        if category_id:
-            domain = expression.AND([domain, [('category_ids', 'in', [category_id])]])
-        elif channel_tag_id:
+        if channel_tag_id:
             domain = expression.AND([domain, [('tag_ids', 'in', [channel_tag_id])]])
         elif tags:
             domain = expression.AND([domain, [('tag_ids', 'in', tags.ids)]])
 
-        if slide_type and 'nbr_%ss' % slide_type in request.env['slide.channel']:
-            domain = expression.AND([domain, [('nbr_%ss' % slide_type, '>', 0)]])
+        if slide_type and 'nbr_%s' % slide_type in request.env['slide.channel']:
+            domain = expression.AND([domain, [('nbr_%s' % slide_type, '>', 0)]])
+
+        if my:
+            domain = expression.AND([domain, [('partner_ids', '=', request.env.user.partner_id.id)]])
         return domain
 
     def _prepare_channel_values(self, **kwargs):
@@ -179,24 +179,29 @@ class WebsiteSlides(WebsiteProfile):
         })
 
     @http.route('/slides/all', type='http', auth="public", website=True)
-    def slides_channel_all(self, slide_type=None, **post):
+    def slides_channel_all(self, slide_type=None, my=False, **post):
         """ Home page displaying a list of courses displayed according to some
         criterion and search terms.
 
-         : param string slide_type: if provided, filter the slide.channels
-           to contain at least one slide of type 'slide_type'
-         : param dict post: post parameters, including
-           * search_term: keywords entered in the search box, used to filter on slide content;
-           * category_id: id of a slide.category;
-           * channel_tag_id: id of a channel.tag;
+          :param string slide_type: if provided, filter the course to contain at
+           least one slide of type 'slide_type'. Used notably to display courses
+           with certifications;
+          :param bool my: if provided, filter the slide.channels for which the
+           current user is a member of
+          :param dict post: post parameters, including
+
+           * ``search``: filter on course description / name;
+           * ``channel_tag_id``: filter on courses containing this tag;
+           * ``channel_tag_group_id_<id>``: filter on courses containing this tag
+             in the tag group given by <id> (used in navigation based on tag group);
         """
         domain = request.website.website_domain()
-        domain = self._build_channel_domain(domain, slide_type=slide_type, **post)
+        domain = self._build_channel_domain(domain, slide_type=slide_type, my=my, **post)
 
         order = self._channel_order_by_criterion.get(post.get('sorting', 'date'), 'create_date desc')
 
         channels = request.env['slide.channel'].search(domain, order=order)
-        channels_layouted = list(itertools.zip_longest(*[iter(channels)] * 4, fillvalue=None))
+        # channels_layouted = list(itertools.zip_longest(*[iter(channels)] * 4, fillvalue=None))
 
         tag_groups = request.env['slide.channel.tag.group'].search(['&', ('tag_ids', '!=', False), ('website_published', '=', True)])
         search_tags = self._extract_channel_tag_search(**post)
@@ -204,10 +209,13 @@ class WebsiteSlides(WebsiteProfile):
         return request.render('website_slides.courses_all', {
             'user': request.env.user,
             'is_public_user': request.website.is_public_user(),
-            'channels_layouted': channels_layouted,
+            'channels': channels,
             'tag_groups': tag_groups,
             'search_term': post.get('search'),
+            'search_slide_type': slide_type,
+            'search_my': my,
             'search_tags': search_tags,
+            'search_channel_tag_id': post.get('channel_tag_id'),
         })
 
     def _prepare_additional_channel_values(self, values, **kwargs):
@@ -221,11 +229,12 @@ class WebsiteSlides(WebsiteProfile):
         '/slides/<model("slide.channel"):channel>/category/<model("slide.category"):category>',
         '/slides/<model("slide.channel"):channel>/category/<model("slide.category"):category>/page/<int:page>'
     ], type='http', auth="public", website=True, sitemap=sitemap_slide)
-    def channel(self, channel, category=None, tag=None, page=1, slide_type=None, sorting=None, search=None, **kw):
+    def channel(self, channel, category=None, tag=None, page=1, slide_type=None, uncategorized=False, sorting=None, search=None, **kw):
         if not channel.can_access_from_current_website():
             raise werkzeug.exceptions.NotFound()
+
         domain = [('channel_id', '=', channel.id)]
-        if not request.env.user.has_group('website.group_website_publisher'):
+        if not channel.can_publish:
             domain = expression.AND([
                 domain,
                 ['&', ('website_published', '=', True), ('channel_id.website_published', '=', True)]
@@ -250,7 +259,10 @@ class WebsiteSlides(WebsiteProfile):
             elif tag:
                 domain += [('tag_ids.id', '=', tag.id)]
                 pager_url += "/tag/%s" % tag.id
-            if slide_type:
+            if uncategorized:
+                domain += [('category_id', '=', False)]
+                pager_url += "?uncategorized=1"
+            elif slide_type:
                 domain += [('slide_type', '=', slide_type)]
                 pager_url += "?slide_type=%s" % slide_type
 
@@ -270,6 +282,7 @@ class WebsiteSlides(WebsiteProfile):
             'search_category': category,
             'search_tag': tag,
             'search_slide_type': slide_type,
+            'search_uncategorized': uncategorized,
             'slide_types': slide_types,
             'sorting': actual_sorting,
             'search': search,
@@ -287,6 +300,7 @@ class WebsiteSlides(WebsiteProfile):
                 ('model', '=', channel._name),
                 ('res_id', '=', channel.id),
                 ('author_id', '=', request.env.user.partner_id.id),
+                ('message_type', '=', 'comment'),
                 ('website_published', '=', True)
             ], order='write_date DESC', limit=1).read(['body', 'rating_value'])
             last_message_data = last_message_values[0] if last_message_values else {}
@@ -301,24 +315,48 @@ class WebsiteSlides(WebsiteProfile):
         # Display uncategorized slides
         # fetch slides; done as sudo because we want to display all of them but
         # unreachable ones won't be clickable (+ slide controller will crash anyway)
-        if not category:
+        if not category and not uncategorized:
             category_data = []
             for category in request.env['slide.slide'].sudo().read_group(domain, ['category_id'], ['category_id']):
                 category_id, name = category.get('category_id') or (False, _('Uncategorized'))
+                slides_sudo = request.env['slide.slide'].sudo().search(category['__domain'], limit=4, offset=0, order=order)
                 category_data.append({
                     'id': category_id,
                     'name': name,
+                    'slug_name': slug((category_id, name)) if category_id else name,
                     'total_slides': category['category_id_count'],
-                    'slides': request.env['slide.slide'].sudo().search(category['__domain'], limit=4, offset=0, order=order)
+                    'slides': slides_sudo,
                 })
+        elif uncategorized:
+            slides_sudo = request.env['slide.slide'].sudo().search(domain, limit=self._slides_per_page, offset=pager['offset'], order=order)
+            category_data = [{
+                'id': False,
+                'name':  _('Uncategorized'),
+                'slug_name':  _('Uncategorized'),
+                'total_slides': len(slides_sudo),
+                'slides': slides_sudo,
+            }]
         else:
             slides_sudo = request.env['slide.slide'].sudo().search(domain, limit=self._slides_per_page, offset=pager['offset'], order=order)
             category_data = [{
                 'id': category.id,
                 'name': category.name,
+                'slug_name': slug(category),
                 'total_slides': len(slides_sudo),
                 'slides': slides_sudo,
             }]
+
+        # post slide-fetch computation: promoted, user completion (separated because sudo-ed)
+        if not request.website.is_public_user() and channel.is_member:
+            displayed_slide_ids = list(set(sid for item in category_data for sid in item['slides'].ids))
+            done_slide_ids = request.env['slide.slide.partner'].sudo().search([
+                ('slide_id', 'in', displayed_slide_ids),
+                ('partner_id', '=', request.env.user.partner_id.id),
+                ('completed', '=', True)
+            ]).mapped('slide_id').ids
+        else:
+            done_slide_ids = []
+        values['done_slide_ids'] = done_slide_ids
         values['slide_promoted'] = request.env['slide.slide'].sudo().search(domain, limit=1, order=order)
         values['category_data'] = category_data
 
@@ -500,7 +538,7 @@ class WebsiteSlides(WebsiteProfile):
         }
 
     # JSONRPC
-    @http.route('/slides/slide/like', type='json', auth="user", website=True)
+    @http.route('/slides/slide/like', type='json', auth="public", website=True)
     def slide_like(self, slide_id, upvote):
         if request.website.is_public_user():
             return {'error': 'public_user'}
@@ -521,7 +559,7 @@ class WebsiteSlides(WebsiteProfile):
     @http.route(['/slides/slide/send_share_email'], type='json', auth='user', website=True)
     def slide_send_share_email(self, slide_id, email):
         slide = request.env['slide.slide'].browse(int(slide_id))
-        result = slide.send_share_email(email)
+        result = slide._send_share_email(email)
         return result
 
     # --------------------------------------------------