DEV: treats private invitees as public and only create them on attendance

app/models/discourse_post_event/event.rb

@@ -179,45 +179,47 @@ module DiscoursePostEvent
     end
 
     def most_likely_going(limit = SiteSetting.displayed_invitees_limit)
-      self.invitees
+      going = self.invitees
         .order([:status, :user_id])
         .limit(limit)
+
+      if self.private? && going.count < limit
+        # invitees are only created when an attendance is set
+        # so we create a dummy invitee object with only what's needed for serializer
+        going = going + GroupUser
+          .includes(:group, :user)
+          .where('groups.name' => self.raw_invitees)
+          .where.not('users.id' => going.pluck(:user_id))
+          .limit(limit - going.count)
+          .map { |gu| Invitee.new(user: gu.user, post_id: self.id) }
+      end
+
+      going
     end
 
     def publish_update!
       self.post.publish_message!("/discourse-post-event/#{self.post.topic_id}", id: self.id)
     end
 
-    def destroy_extraneous_invitees!
-      self.invitees.where.not(user_id: fetch_users.select(:id)).delete_all
-    end
-
-    def fill_invitees!
-      invited_users_ids = fetch_users.pluck(:id) - self.invitees.pluck(:user_id)
-      if invited_users_ids.present?
-        self.create_invitees(invited_users_ids.map { |user_id|
-          { user_id: user_id }
-        })
-      end
-    end
-
     def fetch_users
       @fetched_users ||= Invitee.extract_uniq_usernames(self.raw_invitees)
     end
 
-    def enforce_raw_invitees!
+    def enforce_private_invitees!
-      self.destroy_extraneous_invitees!
+      self.invitees.where.not(user_id: fetch_users.select(:id)).delete_all
-      self.fill_invitees!
       self.notify_invitees!(auto: false)
     end
 
     def can_user_update_attendance(user)
       !self.is_expired? &&
       (
-        self.status == Event.statuses[:public] ||
+        self.public? ||
         (
-          self.status == Event.statuses[:private] &&
+          self.private? &&
-          self.invitees.exists?(user_id: user.id)
+          (
+            self.invitees.exists?(user_id: user.id) ||
+            (user.groups.pluck(:name) & self.raw_invitees).any?
+          )
         )
       )
     end
@@ -251,7 +253,7 @@ module DiscoursePostEvent
       when Event.statuses[:private]
         raw_invitees = Array(params[:raw_invitees]) - ['trust_level_0']
         self.update!(params.merge(raw_invitees: raw_invitees))
-        self.enforce_raw_invitees!
+        self.enforce_private_invitees!
       when Event.statuses[:public]
         self.update!(params.merge(raw_invitees: ['trust_level_0']))
       when Event.statuses[:standalone]

app/serializers/discourse_post_event/event_serializer.rb

@@ -113,7 +113,7 @@ module DiscoursePostEvent
     end
 
     def should_display_invitees
-      object.status != Event.statuses[:standalone] && object.invitees.count > 0
+      (object.public? && object.invitees.count > 0) || (object.private? && object.raw_invitees.count > 0)
     end
   end
 end

jobs/regular/discourse_post_event/bulk_invite.rb

@@ -56,7 +56,7 @@ module Jobs
         group = Group.find_by(name: invitee['identifier'])
         if group
           users = group.users.pluck(:id)
-          @event.update!(raw_invitees: (@event.raw_invitees || []).push(group.name).uniq)
+          @event.update_with_params!(raw_invitees: (@event.raw_invitees || []).push(group.name).uniq)
         end
       end
 

spec/acceptance/post_spec.rb

@@ -54,7 +54,7 @@ describe Post do
 
         context 'when in edit grace period' do
           before do
-            post_1.reload.event.update!(starts_at: 2.hours.ago)
+            post_1.reload.event.update_with_params!(starts_at: 2.hours.ago)
           end
 
           it 'sends a post revision to going invitees' do
@@ -75,7 +75,7 @@ describe Post do
 
         context 'when not edit grace period' do
           before do
-            post_1.reload.event.update!(starts_at: 5.hours.ago)
+            post_1.reload.event.update_with_params!(starts_at: 5.hours.ago)
           end
 
           it 'doesn’t send a post revision to anyone' do

spec/models/discourse_post_event/event_spec.rb

@@ -164,7 +164,7 @@ describe DiscoursePostEvent::Event do
             expect(first_post.is_first_post?).to be(true)
             expect(first_post.topic.custom_fields[Field]).to eq(starts_at)
 
-            post_event.update!(starts_at: alt_starts_at)
+            post_event.update_with_params!(starts_at: alt_starts_at)
             first_post.topic.reload
 
             expect(first_post.topic.custom_fields[Field]).to eq(alt_starts_at)
@@ -178,7 +178,7 @@ describe DiscoursePostEvent::Event do
             expect(second_post.is_first_post?).to be(false)
             expect(second_post.topic.custom_fields[Field]).to be_blank
 
-            post_event.update!(starts_at: alt_starts_at)
+            post_event.update_with_params!(starts_at: alt_starts_at)
             second_post.topic.reload
 
             expect(second_post.topic.custom_fields[Field]).to be_blank

spec/requests/events_controller_spec.rb

@@ -157,7 +157,7 @@ module DiscoursePostEvent
 
           context 'when status changes from standalone to private' do
             it 'changes the status, raw_invitees and invitees' do
-              event.update!(status: Event.statuses[:standalone])
+              event.update_with_params!(status: Event.statuses[:standalone])
 
               put "/discourse-post-event/events/#{event.id}.json", params: {
                 event: {
@@ -170,13 +170,13 @@ module DiscoursePostEvent
 
               expect(event.status).to eq(Event.statuses[:private])
               expect(event.raw_invitees).to eq([group.name])
-              expect(event.invitees.pluck(:user_id)).to match_array(group.group_users.map { |gu| gu.user.id })
+              expect(event.invitees).to eq([])
             end
           end
 
           context 'when status changes from standalone to public' do
             it 'changes the status' do
-              event.update!(status: Event.statuses[:standalone])
+              event.update_with_params!(status: Event.statuses[:standalone])
 
               put "/discourse-post-event/events/#{event.id}.json", params: {
                 event: {
@@ -194,15 +194,14 @@ module DiscoursePostEvent
 
           context 'when status changes from private to standalone' do
             it 'changes the status' do
-              event.update!(
+              event.update_with_params!(
                 status: Event.statuses[:private],
                 raw_invitees: [group.name]
               )
-              event.fill_invitees!
 
               event.reload
 
-              expect(event.invitees.pluck(:user_id)).to match_array(group.group_users.map { |gu| gu.user.id })
+              expect(event.invitees).to eq([])
               expect(event.raw_invitees).to eq([group.name])
 
               put "/discourse-post-event/events/#{event.id}.json", params: {
@@ -220,16 +219,15 @@ module DiscoursePostEvent
           end
 
           context 'when status changes from private to public' do
-            it 'changes the status, removes raw_invitees and keeps invitees' do
+            it 'changes the status, removes raw_invitees and drops invitees' do
-              event.update!(
+              event.update_with_params!(
                 status: Event.statuses[:private],
                 raw_invitees: [group.name]
               )
-              event.fill_invitees!
 
               event.reload
 
-              expect(event.invitees.pluck(:user_id)).to match_array(group.group_users.map { |gu| gu.user.id })
+              expect(event.invitees).to eq([])
               expect(event.raw_invitees).to eq([group.name])
 
               put "/discourse-post-event/events/#{event.id}.json", params: {
@@ -242,13 +240,13 @@ module DiscoursePostEvent
 
               expect(event.status).to eq(Event.statuses[:public])
               expect(event.raw_invitees).to eq(['trust_level_0'])
-              expect(event.invitees.pluck(:user_id)).to match_array(group.group_users.map { |gu| gu.user.id })
+              expect(event.invitees).to eq([])
             end
           end
 
           context 'when status changes from public to private' do
-            it 'changes the status, removes raw_invitees and keeps invitees' do
+            it 'changes the status, removes raw_invitees and drops invitees not part of new raw_invitees' do
-              event.update!(status: Event.statuses[:public])
+              event.update_with_params!(status: Event.statuses[:public])
               event.create_invitees([
                 { user_id: invitee1.id },
                 { user_id: invitee2.id },
@@ -256,7 +254,7 @@ module DiscoursePostEvent
               event.reload
 
               expect(event.invitees.pluck(:user_id)).to match_array([invitee1.id, invitee2.id])
-              expect(event.raw_invitees).to eq(nil)
+              expect(event.raw_invitees).to eq(['trust_level_0'])
 
               put "/discourse-post-event/events/#{event.id}.json", params: {
                 event: {
@@ -269,20 +267,20 @@ module DiscoursePostEvent
 
               expect(event.status).to eq(Event.statuses[:private])
               expect(event.raw_invitees).to eq([group.name])
-              expect(event.invitees.pluck(:user_id)).to match_array(group.group_users.map { |gu| gu.user.id })
+              expect(event.invitees.pluck(:user_id)).to eq([invitee2.id])
             end
           end
 
           context 'when status changes from public to standalone' do
             it 'changes the status, removes invitees' do
-              event.update!(
+              event.update_with_params!(
                 status: Event.statuses[:public]
               )
               event.create_invitees([ { user_id: invitee1.id } ])
               event.reload
 
               expect(event.invitees.pluck(:user_id)).to eq([invitee1.id])
-              expect(event.raw_invitees).to eq(nil)
+              expect(event.raw_invitees).to eq(['trust_level_0'])
 
               put "/discourse-post-event/events/#{event.id}.json", params: {
                 event: {