Add in-app notification configuration

app/models/notification.rb

@@ -16,18 +16,10 @@ def self.for(recipient, opts={})
     where(opts.merge!(recipient_id: recipient.id)).order("updated_at DESC")
   end
 
-  def email_the_user(target, actor)
-    recipient.mail(mail_job, recipient_id, actor.id, target.id)
-  end
-
   def set_read_state( read_state )
     update_column(:unread, !read_state)
   end
 
-  def mail_job
-    raise NotImplementedError.new("Subclass this.")
-  end
-
   def linked_object
     target
   end

app/models/notifications/also_commented.rb

@@ -4,24 +4,8 @@ module Notifications
   class AlsoCommented < Notification
     include Notifications::Commented
 
-    def mail_job
-      Workers::Mail::AlsoCommented
-    end
-
     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

@@ -4,22 +4,8 @@ module Notifications
   class CommentOnPost < Notification
     include Notifications::Commented
 
-    def mail_job
-      Workers::Mail::CommentOnPost
-    end
-
     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

@@ -2,18 +2,8 @@
 
 module Notifications
   class ContactsBirthday < Notification
-    def mail_job
-      Workers::Mail::ContactsBirthday
-    end
-
     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

@@ -2,25 +2,12 @@
 
 module Notifications
   class Liked < Notification
-    def mail_job
-      Workers::Mail::Liked
-    end
-
     def popup_translation_key
       "notifications.liked"
     end
 
     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

@@ -11,25 +11,5 @@ def popup_translation_key
     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
-      elsif shareable.author.owner_id == recipient_id
-        Workers::Mail::CommentOnPost
-      elsif shareable.participants.local.where(owner_id: recipient_id)
-        Workers::Mail::AlsoCommented
-      end
-    end
-
-    private
-
-    def shareable
-      linked_object.parent
-    end
   end
 end

app/models/notifications/mentioned_in_post.rb

@@ -4,21 +4,12 @@ module Notifications
   class MentionedInPost < Notification
     include Notifications::Mentioned
 
-    def mail_job
-      Workers::Mail::Mentioned
-    end
-
     def popup_translation_key
       "notifications.mentioned"
     end
 
     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

@@ -2,29 +2,8 @@
 
 module Notifications
   class PrivateMessage < Notification
-    def mail_job
-      Workers::Mail::PrivateMessage
-    end
-
     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

@@ -2,23 +2,12 @@
 
 module Notifications
   class Reshared < Notification
-    def mail_job
-      Workers::Mail::Reshared
-    end
-
     def popup_translation_key
       "notifications.reshared"
     end
 
     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

@@ -2,19 +2,10 @@
 
 module Notifications
   class StartedSharing < Notification
-    def mail_job
-      Workers::Mail::StartedSharing
-    end
-
     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/models/user.rb

@@ -350,14 +350,6 @@ def perform_export_photos!
   end
 
   ######### Mailer #######################
-  def mail(job, *args)
-    return unless job.present?
-    pref = job.to_s.gsub('Workers::Mail::', '').underscore
-    email_enabled = (disable_mail == false) &&
-      NotificationSettingsService.new(self).email_enabled?(pref)
-
-    job.perform_async(*args) if email_enabled
-  end
 
   def send_confirm_email
     return if unconfirmed_email.blank?

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 = {
@@ -51,12 +55,24 @@ def update_status_by_guid(guid, is_read_status)
     true
   end
 
+  def mail(job, *args)
+    return if job.blank?
+
+    pref = job.to_s.gsub("Workers::Mail::", "").underscore
+    email_enabled = (user.disable_mail == false) &&
+      NotificationSettingsService.new(user).email_enabled?(pref)
+
+    job.perform_async(*args) if email_enabled
+  end
+
   def notify(object, recipient_user_ids)
     notification_types(object).each {|type| type.notify(object, recipient_user_ids) }
   end
 
   private
 
+  attr_reader :user
+
   def notification_types(object)
     NOTIFICATION_TYPES.fetch(object.class, [])
   end

app/services/notifications/also_commented_service.rb

@@ -0,0 +1,25 @@
+# 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)
+
+        NotificationService.new(recipient).mail(
+          Workers::Mail::AlsoCommented,
+          recipient.id,
+          actor.id,
+          comment.id
+        )
+      end
+    end
+  end
+end

app/services/notifications/comment_on_post_service.rb

@@ -0,0 +1,24 @@
+# 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)
+
+      recipient = commentable_author.owner
+      Notifications::CommentOnPost
+        .concatenate_or_create(recipient, comment.commentable, actor)
+
+      NotificationService.new(recipient).mail(
+        Workers::Mail::CommentOnPost,
+        recipient.id,
+        actor.id,
+        comment.id
+      )
+    end
+  end
+end

app/services/notifications/contacts_birthday_service.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Notifications
+  class ContactsBirthdayService
+    def self.notify(contact, _=nil)
+      recipient = contact.user
+      actor = contact.person
+      Notifications::ContactsBirthday
+        .create_notification(recipient, actor, actor)
+
+      NotificationService.new(recipient).mail(
+        Workers::Mail::ContactsBirthday,
+        recipient.id,
+        actor.id,
+        actor.id
+      )
+    end
+  end
+end