[FIX] website_slides: adjust member completion percentage

Steps to reproduce:

  - Install eLearning module
  - Create a course with 2 slides and publish them
  - Add a user as a member of the course
  - Complete the first slide
  - Add a new slide to the course and publish it
  - Go to course and click on `Attendees` stat button

Issue:

  The member completion percentage is not updated.

Cause:

  When (un)publishing a slide, only the current user that publish the
  course have his completion percentage updated.

Solution:

  When (un)publishing, (un)archiving, unlinking or creating slide(s)
  (slide must be published for the creation case), or when user mark
  slide as (un)completed manually, update the completion percentage of
  all members of the course except the members that already have
  completed the course.

  From version saas-16.3 we do not need the custom context key we
  introduced in 94e2dd2 because we will not update the completion
  percentage of members that have completed the course even if they
  manually mark a slide as uncompleted.

opw-3225707

closes odoo/odoo#134845

X-original-commit: 2796b3163c02306f1309e2dde764fff2f1b287cc
Signed-off-by: Thibault Delavallee (tde) <tde@openerp.com>
Signed-off-by: Nasreddin Boulif (bon) <bon@odoo.com>

addons/website_slides/models/slide_slide.py

@@ -659,6 +659,7 @@ class Slide(models.Model):
 
             if slide.is_published and not slide.is_category:
                 slide._post_publication()
+                slide.channel_id.channel_partner_ids._recompute_completion()
         return slides
 
     def write(self, values):
@@ -686,8 +687,8 @@ class Slide(models.Model):
                 })
 
         if 'is_published' in values or 'active' in values:
-            # if the slide is published/unpublished, recompute the completion for the partners
-            self.slide_partner_ids._recompute_completion()
+            # recompute the completion for all partners of the channel
+            self.channel_id.channel_partner_ids._recompute_completion()
 
         return res
 
@@ -702,7 +703,10 @@ class Slide(models.Model):
     def unlink(self):
         for category in self.filtered(lambda slide: slide.is_category):
             category.channel_id._move_category_slides(category, False)
-        return super().unlink()
+        channel_partner_ids = self.channel_id.channel_partner_ids
+        res = super(Slide, self).unlink()
+        channel_partner_ids._recompute_completion()
+        return res
 
     def toggle_active(self):
         # archiving/unarchiving a channel does it on its slides, too

addons/website_slides/tests/test_statistics.py

@@ -64,8 +64,13 @@ class TestChannelStatistics(common.SlidesCase):
         channel_publisher._action_add_members(self.user_emp.partner_id)
         channel_emp = self.channel.with_user(self.user_emp)
 
+        members = self.env['slide.channel.partner'].search([('channel_id', '=', self.channel.id)])
+        member_emp = members.filtered(lambda m: m.partner_id == self.user_emp.partner_id)
+        member_publisher = members.filtered(lambda m: m.partner_id == self.user_officer.partner_id)
+
         slides_emp = (self.slide | self.slide_2).with_user(self.user_emp)
         slides_emp.action_set_viewed()
+        self.assertEqual(member_emp.completion, 0)
         self.assertEqual(channel_emp.completion, 0)
 
         slides_emp.action_mark_completed()
@@ -76,18 +81,80 @@ class TestChannelStatistics(common.SlidesCase):
         self.assertFalse(channel_emp.completed)
 
         self.slide_3.with_user(self.user_emp)._action_mark_completed()
+        self.assertEqual(member_emp.completion, 100)
         self.assertEqual(channel_emp.completion, 100)
         self.assertTrue(channel_emp.completed)
 
+        # The following tests should not update the completion for users that has already completed the course
+
         self.slide_3.is_published = False
+        self.assertEqual(member_emp.completion, 100)
         self.assertEqual(channel_emp.completion, 100)
         self.assertTrue(channel_emp.completed)
 
         self.slide_3.is_published = True
         self.slide_3.active = False
+        self.assertEqual(member_emp.completion, 100)
         self.assertEqual(channel_emp.completion, 100)
         self.assertTrue(channel_emp.completed)
 
+        # Should update completion when slide is marked as completed
+
+        self.assertEqual(member_publisher.completion, 0)
+        self.assertEqual(channel_publisher.completion, 0)
+        self.slide.with_user(self.user_officer).action_mark_completed()
+        self.assertEqual(member_publisher.completion, 50)
+        self.assertEqual(channel_publisher.completion, 50)
+
+        # Should update completion when slide is (un)archived
+        self.slide_3.active = True
+        self.assertEqual(member_emp.completion, 100)
+        self.assertEqual(channel_emp.completion, 100)
+        self.assertEqual(member_publisher.completion, 33)
+        self.assertEqual(channel_publisher.completion, 33)
+
+        # Should update completion when a new published slide is created
+        self.slide_4 = self.slide_3.copy({'is_published': True})
+        self.assertEqual(member_emp.completion, 100)
+        self.assertEqual(channel_emp.completion, 100)
+        self.assertEqual(member_publisher.completion, 25)
+        self.assertEqual(channel_publisher.completion, 25)
+
+        # Should update completion when slide is (un)published
+        self.slide_4.is_published = False
+        self.assertEqual(member_emp.completion, 100)
+        self.assertEqual(channel_emp.completion, 100)
+        self.assertEqual(member_publisher.completion, 33)
+        self.assertEqual(channel_publisher.completion, 33)
+
+        self.slide_4.is_published = True
+        self.assertEqual(member_emp.completion, 100)
+        self.assertEqual(channel_emp.completion, 100)
+        self.assertEqual(member_publisher.completion, 25)
+        self.assertEqual(channel_publisher.completion, 25)
+
+        # Should update completion when a slide is unlinked
+        self.slide_4.with_user(self.user_manager).unlink()
+        self.assertEqual(member_emp.completion, 100)
+        self.assertEqual(channel_emp.completion, 100)
+        self.assertEqual(member_publisher.completion, 33)
+        self.assertEqual(channel_publisher.completion, 33)
+
+        # Should update completion when slide is marked as uncompleted
+        slide_emp = self.slide.with_user(self.user_emp)
+        slide_emp.action_mark_uncompleted()
+        self.assertEqual(member_emp.completion, 100)
+        self.assertEqual(channel_emp.completion, 100)
+        self.assertTrue(channel_emp.completed)
+        self.assertFalse(slide_emp.user_membership_id.completed)
+        self.slide.invalidate_model(['user_has_completed'])
+        slide_publisher = self.slide.with_user(self.user_officer)
+        slide_publisher.action_mark_uncompleted()
+        self.assertEqual(member_publisher.completion, 0)
+        self.assertEqual(channel_publisher.completion, 0)
+        self.assertFalse(channel_publisher.completed)
+        self.assertFalse(slide_emp.user_membership_id.completed)
+
     @mute_logger('odoo.models')
     def test_channel_user_statistics_complete_check_member(self):
         slides = (self.slide | self.slide_2)