Add in-app notification configuration

app/models/notifications/also_commented.rb

@@ -11,17 +11,5 @@ def mail_job
     def popup_translation_key
       "notifications.also_commented"
     end
-
-    def self.notify(comment, _recipient_user_ids)
-      actor = comment.author
-      commentable = comment.commentable
-      recipient_ids = commentable.participants.local.where.not(id: [commentable.author_id, actor.id]).pluck(:owner_id)
-
-      User.where(id: recipient_ids).find_each do |recipient|
-        next if recipient.is_shareable_hidden?(commentable) || mention_notification_exists?(comment, recipient.person)
-
-        concatenate_or_create(recipient, commentable, actor).try(:email_the_user, comment, actor)
-      end
-    end
   end
 end

app/models/notifications/comment_on_post.rb

@@ -11,15 +11,5 @@ def mail_job
     def popup_translation_key
       "notifications.comment_on_post"
     end
-
-    def self.notify(comment, _recipient_user_ids)
-      actor = comment.author
-      commentable_author = comment.commentable.author
-
-      return unless commentable_author.local? && actor != commentable_author
-      return if mention_notification_exists?(comment, commentable_author)
-
-      concatenate_or_create(commentable_author.owner, comment.commentable, actor).email_the_user(comment, actor)
-    end
   end
 end

app/models/notifications/contacts_birthday.rb

@@ -9,11 +9,5 @@ def mail_job
     def popup_translation_key
       "notifications.contacts_birthday"
     end
-
-    def self.notify(contact, _recipient_user_ids)
-      recipient = contact.user
-      actor = contact.person
-      create_notification(recipient, actor, actor).try(:email_the_user, actor, actor)
-    end
   end
 end

app/models/notifications/liked.rb

@@ -13,14 +13,5 @@ def popup_translation_key
     def deleted_translation_key
       "notifications.liked_post_deleted"
     end
-
-    def self.notify(like, _recipient_user_ids)
-      actor = like.author
-      target_author = like.target.author
-
-      return unless like.target_type == "Post" && target_author.local? && actor != target_author
-
-      concatenate_or_create(target_author.owner, like.target, actor).email_the_user(like, actor)
-    end
   end
 end

app/models/notifications/mentioned.rb

@@ -7,23 +7,5 @@ module Mentioned
     def linked_object
       target.mentions_container
     end
-
-    module ClassMethods
-      def notify(mentionable, recipient_user_ids)
-        actor = mentionable.author
-        relevant_mentions = filter_mentions(
-          mentionable.mentions.local.where.not(person: actor),
-          mentionable,
-          recipient_user_ids
-        )
-
-        relevant_mentions.each do |mention|
-          recipient = mention.person.owner
-          unless exists?(recipient: recipient, target: mention)
-            create_notification(recipient, mention, actor).try(:email_the_user, mention, actor)
-          end
-        end
-      end
-    end
   end
 end

app/models/notifications/mentioned_in_comment.rb

@@ -12,10 +12,6 @@ def deleted_translation_key
       "notifications.mentioned_in_comment_deleted"
     end
 
-    def self.filter_mentions(mentions, mentionable, _recipient_user_ids)
-      mentions.includes(:person).merge(Person.allowed_to_be_mentioned_in_a_comment_to(mentionable.parent))
-    end
-
     def mail_job
       if NotificationSettingsService.new(recipient).email_enabled?(:mentioned_in_comment)
         Workers::Mail::MentionedInComment

app/models/notifications/mentioned_in_post.rb

@@ -15,10 +15,5 @@ def popup_translation_key
     def deleted_translation_key
       "notifications.mentioned_deleted"
     end
-
-    def self.filter_mentions(mentions, mentionable, recipient_user_ids)
-      return mentions if mentionable.public
-      mentions.where(person: Person.where(owner_id: recipient_user_ids).ids)
-    end
   end
 end

app/models/notifications/private_message.rb

@@ -9,22 +9,5 @@ def mail_job
     def popup_translation_key
       "notifications.private_message"
     end
-
-    def self.notify(object, _recipient_user_ids)
-      case object
-      when Conversation
-        object.messages.each {|message| notify_message(message) }
-      when Message
-        notify_message(object)
-      end
-    end
-
-    private_class_method def self.notify_message(message)
-      recipient_ids = message.conversation.participants.local.where.not(id: message.author_id).pluck(:owner_id)
-      User.where(id: recipient_ids).find_each do |recipient|
-        message.increase_unread(recipient)
-        new(recipient: recipient).email_the_user(message, message.author)
-      end
-    end
   end
 end

app/models/notifications/reshared.rb

@@ -13,12 +13,5 @@ def popup_translation_key
     def deleted_translation_key
       "notifications.reshared_post_deleted"
     end
-
-    def self.notify(reshare, _recipient_user_ids)
-      return unless reshare.root.present? && reshare.root.author.local?
-
-      actor = reshare.author
-      concatenate_or_create(reshare.root.author.owner, reshare.root, actor).try(:email_the_user, reshare, actor)
-    end
   end
 end

app/models/notifications/started_sharing.rb

@@ -10,11 +10,6 @@ def popup_translation_key
       "notifications.started_sharing"
     end
 
-    def self.notify(contact, _recipient_user_ids)
-      sender = contact.person
-      create_notification(contact.user, sender, sender).try(:email_the_user, sender, sender)
-    end
-
     def contact
       recipient.contact_for(target)
     end

app/services/notification_service.rb

@@ -2,13 +2,17 @@
 
 class NotificationService
   NOTIFICATION_TYPES = {
-    Comment       => [Notifications::MentionedInComment, Notifications::CommentOnPost, Notifications::AlsoCommented],
-    Like          => [Notifications::Liked],
-    StatusMessage => [Notifications::MentionedInPost],
-    Conversation  => [Notifications::PrivateMessage],
-    Message       => [Notifications::PrivateMessage],
-    Reshare       => [Notifications::Reshared],
-    Contact       => [Notifications::StartedSharing]
+    Comment       => [
+      Notifications::MentionedInCommentService,
+      Notifications::CommentOnPostService,
+      Notifications::AlsoCommentedService
+    ],
+    Like          => [Notifications::LikedService],
+    StatusMessage => [Notifications::MentionedInPostService],
+    Conversation  => [Notifications::PrivateMessageService],
+    Message       => [Notifications::PrivateMessageService],
+    Reshare       => [Notifications::ResharedService],
+    Contact       => [Notifications::StartedSharingService]
   }.freeze
 
   NOTIFICATIONS_JSON_TYPES = {

app/services/notifications/also_comment_service.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Notifications
+  class AlsoCommentedService
+    def self.notify(comment, _)
+      actor = comment.author
+      commentable = comment.commentable
+      recipient_ids = commentable.participants.local.where.not(id: [commentable.author_id, actor.id]).pluck(:owner_id)
+
+      User.where(id: recipient_ids).find_each do |recipient|
+        next if recipient.is_shareable_hidden?(commentable) || mention_notification_exists?(comment, recipient.person)
+
+        Notifications::AlsoCommented
+          .concatenate_or_create(recipient, commentable, actor)
+          .try(:email_the_user, comment, actor)
+      end
+    end
+  end
+end

app/services/notifications/comment_on_post_service.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Notifications
+  class CommentOnPostService
+    def self.notify(comment, _)
+      actor = comment.author
+      commentable_author = comment.commentable.author
+
+      return unless commentable_author.local? && actor != commentable_author
+      return if mention_notification_exists?(comment, commentable_author)
+
+      Notifications::CommentOnPost
+        .concatenate_or_create(commentable_author.owner, comment.commentable, actor)
+        .email_the_user(comment, actor)
+    end
+  end
+end

app/services/notifications/contacts_birthday_service.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Notifications
+  class ContactsBirthdayService
+    def self.notify(contact, _=nil)
+      recipient = contact.user
+      actor = contact.person
+      create_notification(recipient, actor, actor).try(:email_the_user, actor, actor)
+    end
+  end
+end

app/services/notifications/liked_service.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Notifications
+  class LikedService
+    def self.notify(like, _)
+      actor = like.author
+      target_author = like.target.author
+
+      return unless like.target_type == "Post" && target_author.local? && actor != target_author
+
+      Notifications::Liked
+        .concatenate_or_create(target_author.owner, like.target, actor)
+        .email_the_user(like, actor)
+    end
+  end
+end

app/services/notifications/mentioned_in_comment_service.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Notifications
+  class MentionedInCommentService
+    def self.model
+      Notifications::MentionedInComment
+    end
+
+    def self.notify(mentionable, recipient_user_ids)
+      actor = mentionable.author
+      relevant_mentions = filter_mentions(
+        mentionable.mentions.local.where.not(person: actor),
+        mentionable,
+        recipient_user_ids
+      )
+
+      relevant_mentions.each do |mention|
+        recipient = mention.person.owner
+        next if model.exists?(recipient: recipient, target: mention)
+
+        model
+          .create_notification(recipient, mention, actor)
+          .try(:email_the_user, mention, actor)
+      end
+    end
+
+    def self.filter_mentions(mentions, mentionable, _recipient_user_ids)
+      mentions.includes(:person).merge(Person.allowed_to_be_mentioned_in_a_comment_to(mentionable.parent))
+    end
+  end
+end

app/services/notifications/mentioned_in_post_service.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Notifications
+  class MentionedInPostService
+    def self.model
+      Notifications::MentionedInPost
+    end
+
+    def self.notify(mentionable, recipient_user_ids)
+      actor = mentionable.author
+      relevant_mentions = filter_mentions(
+        mentionable.mentions.local.where.not(person: actor),
+        mentionable,
+        recipient_user_ids
+      )
+
+      relevant_mentions.each do |mention|
+        recipient = mention.person.owner
+        next if model.exists?(recipient: recipient, target: mention)
+
+        model
+          .create_notification(recipient, mention, actor)
+          .try(:email_the_user, mention, actor)
+      end
+    end
+
+    def self.filter_mentions(mentions, mentionable, recipient_user_ids)
+      return mentions if mentionable.public
+
+      mentions.where(person: Person.where(owner_id: recipient_user_ids).ids)
+    end
+  end
+end

app/services/notifications/private_message_service.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Notifications
+  class PrivateMessageService
+    def self.notify(object, _)
+      case object
+      when Conversation
+        object.messages.each {|message| notify_message(message) }
+      when Message
+        notify_message(object)
+      end
+    end
+
+    private_class_method def self.notify_message(message)
+      recipient_ids = message.conversation.participants.local.where.not(id: message.author_id).pluck(:owner_id)
+      User.where(id: recipient_ids).find_each do |recipient|
+        message.increase_unread(recipient)
+        Notifications::PrivateMessage
+          .new(recipient: recipient)
+          .email_the_user(message, message.author)
+      end
+    end
+  end
+end

app/services/notifications/reshared_service.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Notifications
+  class ResharedService
+    def self.notify(reshare, _)
+      return unless reshare.root.present? && reshare.root.author.local?
+
+      actor = reshare.author
+      Notifications::Reshared
+        .concatenate_or_create(reshare.root.author.owner, reshare.root, actor)
+        .try(:email_the_user, reshare, actor)
+    end
+  end
+end

app/services/notifications/started_sharing_service.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Notifications
+  class StartedSharingService
+    def self.notify(contact, _)
+      sender = contact.person
+      Notifications::StartedSharing
+        .create_notification(contact.user, sender, sender)
+        .try(:email_the_user, sender, sender)
+    end
+  end
+end

app/workers/check_birthday.rb

@@ -10,7 +10,7 @@ def perform
                  .where("EXTRACT(DAY FROM birthday) = ?", Time.zone.today.day)
       profiles.each do |profile|
         profile.person.contacts.where(sharing: true, receiving: true).each do |contact|
-          Notifications::ContactsBirthday.notify(contact, [])
+          Notifications::ContactsBirthdayService.notify(contact)
         end
       end
     end