activity_notification 1.6.1 → 1.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c4bddcd228924d6a594bb826a9e815a5bc31baed
-  data.tar.gz: 0d2e2517c32fab5cf3310d1f6261ee1a40323c52
+  metadata.gz: 6640bcffc0f4acb3afd7021387feb76db52dea7a
+  data.tar.gz: 2ecda41bc9b8e3a76e89a10263cdb805eee2cd63
 SHA512:
-  metadata.gz: 3015810028cce0174fb091f46ded488310307e527b16b27f36bd72942112356373dbac8c9ed5e4ff2e2ebfb55fb4d33878003bf7f46165c2a0cfe0e822e355a2
-  data.tar.gz: 13bf2aa5ec658cbbc95236e3fd83a2c48ce513a12bc2daa07ee788757cdf5d6516d75fa7f7e5f2fd0a0b9c0dffdbaac02746cb214407a066496dfdd9079645b5
+  metadata.gz: 961d0f2f0e201522b7e8e2899087dca1f868c0c9950b69d22aa2a69f64a46ddf6d3b0ec3f5f0e5cd22f33afdc27c7670226a3a493ac90848d5496430c6cbfd45
+  data.tar.gz: 2fe01f57e0f14964b77af8d9e9eac995cdb4e8c7a412c8491fe94fe6dd4731a28384dc4c5be4d902591803bcf88b212a88a99002492beda80663f690eeb88eb4

data/CHANGELOG.md

@@ -1,3 +1,18 @@
+## 1.7.0 / 2018-12-09
+[Full Changelog](http://github.com/simukappu/activity_notification/compare/v1.6.1...v1.7.0)
+
+Enhancements:
+
+* Support asynchronous notification API - [#29](https://github.com/simukappu/activity_notification/issues/29)
+
+Bug Fixes:
+
+* Fix migration generator to specify the Rails release in generated migration files for Rails 5.x - [#96](https://github.com/simukappu/activity_notification/issues/96)
+
+Breaking Changes:
+
+* Change method name of *Target#notify_to* into *Target#receive_notification_of* to avoid ambiguous method name with *Notifiable#notify_to* - [#88](https://github.com/simukappu/activity_notification/issues/88)
+
 ## 1.6.1 / 2018-11-19
 [Full Changelog](http://github.com/simukappu/activity_notification/compare/v1.6.0...v1.6.1)
 

data/README.md

@@ -60,6 +60,7 @@
     - [Routes with scope](#routes-with-scope)
   - [Creating notifications](#creating-notifications)
     - [Notification API](#notification-api)
+    - [Asynchronous notification API with ActiveJob](#asynchronous-notification-api-with-activejob)
     - [Automatic tracked notifications](#automatic-tracked-notifications)
   - [Displaying notifications](#displaying-notifications)
     - [Preparing target notifications](#preparing-target-notifications)
@@ -345,8 +346,7 @@ Then, pages are shown as */myscope/users/1/notifications*.
 
 #### Notification API
 
-You can trigger notifications by setting all your required parameters and triggering **notify**
-on the notifiable model, like this:
+You can trigger notifications by setting all your required parameters and triggering **notify** on the notifiable model, like this:
 
 ```ruby
 @comment.notify :users, key: "comment.reply"
@@ -364,6 +364,31 @@ The new instances of **ActivityNotification::Notification** model will be genera
 *Hint*: *:key* is a option. Default key `#{notifiable_type}.default` which means *comment.default* will be used without specified key.
 You can override it by *Notifiable#default_notification_key*.
 
+#### Asynchronous notification API with ActiveJob
+
+Using Notification API with default configurations, the notifications will be generated synchronously. *activity_notification* also supports **asynchronous notification API** with ActiveJob to improve application performance. You can use **notify_later** method on the notifiable model, like this:
+
+```ruby
+@comment.notify_later :users, key: "comment.reply"
+```
+
+You can also use *:notify_later* option in *notify* method. This is the same operation as calling *notify_later* method.
+
+```ruby
+@comment.notify :users, key: "comment.reply", notify_later: true
+```
+
+*Note*: *notify_now* is an alias for *notify* and does the same.
+
+When you use asynchronous notification API, you should setup ActiveJob with background queuing service such as Sidekiq.
+You can set *config.active_job_queue* in your initializer to specify a queue name *activity_notification* will use.
+The default queue name is *:activity_notification*.
+
+```ruby
+# Configure ActiveJob queue name for delayed notifications.
+config.active_job_queue = :my_notification_queue
+```
+
 #### Automatic tracked notifications
 
 You can also generate automatic tracked notifications by **:tracked** option in *acts_as_notifiable*.
@@ -404,7 +429,7 @@ class Comment < ActiveRecord::Base
     },
     # Set { except: [:update] } to :tracked option to generate tracked notifications except update (creation only).
     # It adds required callbacks to generate notifications for creation of the notifiable model.
-    tracked: { except: [:update], key: 'comment.edit', send_later: false }
+    tracked: { except: [:update], key: 'comment.create.now', send_later: false }
 end
 ```
 
@@ -412,6 +437,19 @@ end
 You can override them by *Notifiable#notification_key_for_tracked_creation* and *Notifiable#notification_key_for_tracked_update*.
 You can also specify key option in the *:tracked* statement.
 
+As a default, the notifications will be generated synchronously along with model creation or update. If you want to generate notifications asynchronously, use *:notify_later* option with the *:tracked* option, like this:
+
+```ruby
+class Comment < ActiveRecord::Base
+  acts_as_notifiable :users,
+    targets: ->(comment, key) {
+      ([comment.article.user] + comment.article.commented_users.to_a - [comment.user]).uniq
+    },
+    # It adds required callbacks to generate notifications asynchronously for creation of the notifiable model.
+    tracked: { only: [:create], key: 'comment.create.later', notify_later: true }
+end
+```
+
 ### Displaying notifications
 
 #### Preparing target notifications

data/app/jobs/activity_notification/notify_all_job.rb

@@ -0,0 +1,9 @@
+if defined?(ActiveJob)
+  class ActivityNotification::NotifyAllJob < ActivityNotification.config.parent_job.constantize
+    queue_as ActivityNotification.config.active_job_queue
+  
+    def perform(targets, notifiable, options = {})
+      ActivityNotification::Notification.notify_all(targets, notifiable, options)
+    end
+  end
+end

data/app/jobs/activity_notification/notify_job.rb

@@ -0,0 +1,9 @@
+if defined?(ActiveJob)
+  class ActivityNotification::NotifyJob < ActivityNotification.config.parent_job.constantize
+    queue_as ActivityNotification.config.active_job_queue
+  
+    def perform(target_type, notifiable, options = {})
+      ActivityNotification::Notification.notify(target_type, notifiable, options)
+    end
+  end
+end

data/app/jobs/activity_notification/notify_to_job.rb

@@ -0,0 +1,9 @@
+if defined?(ActiveJob)
+  class ActivityNotification::NotifyToJob < ActivityNotification.config.parent_job.constantize
+    queue_as ActivityNotification.config.active_job_queue
+  
+    def perform(target, notifiable, options = {})
+      ActivityNotification::Notification.notify_to(target, notifiable, options)
+    end
+  end
+end

data/lib/activity_notification/apis/notification_api.rb

@@ -157,6 +157,7 @@ module ActivityNotification
       # @option options [ActiveSupport::Duration] :group_expiry_delay       (nil)                                 Expiry period of a notification group
       # @option options [Object]                  :notifier                 (nil)                                 Notifier of the notifications
       # @option options [Hash]                    :parameters               ({})                                  Additional parameters of the notifications
+      # @option options [Boolean]                 :notify_later             (false)                               Whether it generates notifications asynchronously
       # @option options [Boolean]                 :send_email               (true)                                Whether it sends notification email
       # @option options [Boolean]                 :send_later               (true)                                Whether it sends notification email asynchronously
       # @option options [Boolean]                 :publish_optional_targets (true)                                Whether it publishes notification to optional targets
@@ -164,11 +165,48 @@ module ActivityNotification
       # @option options [Hash<String, Hash>]      :optional_targets         ({})                                  Options for optional targets, keys are optional target name (:amazon_sns or :slack etc) and values are options
       # @return [Array<Notificaion>] Array of generated notifications
       def notify(target_type, notifiable, options = {})
-        targets = notifiable.notification_targets(target_type, options[:pass_full_options] ? options : options[:key])
-        unless targets.blank?
-          notify_all(targets, notifiable, options)
+        if options[:notify_later]
+          notify_later(target_type, notifiable, options)
+        else
+          targets = notifiable.notification_targets(target_type, options[:pass_full_options] ? options : options[:key])
+          unless targets.blank?
+            notify_all(targets, notifiable, options)
+          end
         end
       end
+      alias_method :notify_now, :notify
+
+      # Generates notifications to configured targets with notifiable model later by ActiveJob queue.
+      #
+      # @example Use with target_type as Symbol
+      #   ActivityNotification::Notification.notify_later :users, @comment
+      # @example Use with target_type as String
+      #   ActivityNotification::Notification.notify_later 'User', @comment
+      # @example Use with target_type as Class
+      #   ActivityNotification::Notification.notify_later User, @comment
+      # @example Use with options
+      #   ActivityNotification::Notification.notify_later :users, @comment, key: 'custom.comment', group: @comment.article
+      #   ActivityNotification::Notification.notify_later :users, @comment, parameters: { reply_to: @comment.reply_to }, send_later: false
+      #
+      # @param [Symbol, String, Class] target_type Type of target
+      # @param [Object] notifiable Notifiable instance
+      # @param [Hash] options Options for notifications
+      # @option options [String]                  :key                      (notifiable.default_notification_key) Key of the notification
+      # @option options [Object]                  :group                    (nil)                                 Group unit of the notifications
+      # @option options [ActiveSupport::Duration] :group_expiry_delay       (nil)                                 Expiry period of a notification group
+      # @option options [Object]                  :notifier                 (nil)                                 Notifier of the notifications
+      # @option options [Hash]                    :parameters               ({})                                  Additional parameters of the notifications
+      # @option options [Boolean]                 :send_email               (true)                                Whether it sends notification email
+      # @option options [Boolean]                 :send_later               (true)                                Whether it sends notification email asynchronously
+      # @option options [Boolean]                 :publish_optional_targets (true)                                Whether it publishes notification to optional targets
+      # @option options [Boolean]                 :pass_full_options        (false)                               Whether it passes full options to notifiable.notification_targets, not a key only
+      # @option options [Hash<String, Hash>]      :optional_targets         ({})                                  Options for optional targets, keys are optional target name (:amazon_sns or :slack etc) and values are options
+      # @return [Array<Notificaion>] Array of generated notifications
+      def notify_later(target_type, notifiable, options = {})
+        target_type = target_type.to_s if target_type.is_a? Symbol
+        options.delete(:notify_later)
+        ActivityNotification::NotifyJob.perform_later(target_type, notifiable, options)
+      end
 
       # Generates notifications to specified targets.
       #
@@ -183,13 +221,42 @@ module ActivityNotification
       # @option options [ActiveSupport::Duration] :group_expiry_delay       (nil)                                 Expiry period of a notification group
       # @option options [Object]                  :notifier                 (nil)                                 Notifier of the notifications
       # @option options [Hash]                    :parameters               ({})                                  Additional parameters of the notifications
+      # @option options [Boolean]                 :notify_later             (false)                               Whether it generates notifications asynchronously
       # @option options [Boolean]                 :send_email               (true)                                Whether it sends notification email
       # @option options [Boolean]                 :send_later               (true)                                Whether it sends notification email asynchronously
       # @option options [Boolean]                 :publish_optional_targets (true)                                Whether it publishes notification to optional targets
       # @option options [Hash<String, Hash>]      :optional_targets         ({})                                  Options for optional targets, keys are optional target name (:amazon_sns or :slack etc) and values are options
       # @return [Array<Notificaion>] Array of generated notifications
       def notify_all(targets, notifiable, options = {})
-        targets.map { |target| notify_to(target, notifiable, options) }
+        if options[:notify_later]
+          notify_all_later(targets, notifiable, options)
+        else
+          targets.map { |target| notify_to(target, notifiable, options) }
+        end
+      end
+      alias_method :notify_all_now, :notify_all
+
+      # Generates notifications to specified targets later by ActiveJob queue.
+      #
+      # @example Notify to all users later
+      #   ActivityNotification::Notification.notify_all_later User.all, @comment
+      #
+      # @param [Array<Object>] targets Targets to send notifications
+      # @param [Object] notifiable Notifiable instance
+      # @param [Hash] options Options for notifications
+      # @option options [String]                  :key                      (notifiable.default_notification_key) Key of the notification
+      # @option options [Object]                  :group                    (nil)                                 Group unit of the notifications
+      # @option options [ActiveSupport::Duration] :group_expiry_delay       (nil)                                 Expiry period of a notification group
+      # @option options [Object]                  :notifier                 (nil)                                 Notifier of the notifications
+      # @option options [Hash]                    :parameters               ({})                                  Additional parameters of the notifications
+      # @option options [Boolean]                 :send_email               (true)                                Whether it sends notification email
+      # @option options [Boolean]                 :send_later               (true)                                Whether it sends notification email asynchronously
+      # @option options [Boolean]                 :publish_optional_targets (true)                                Whether it publishes notification to optional targets
+      # @option options [Hash<String, Hash>]      :optional_targets         ({})                                  Options for optional targets, keys are optional target name (:amazon_sns or :slack etc) and values are options
+      # @return [Array<Notificaion>] Array of generated notifications
+      def notify_all_later(targets, notifiable, options = {})
+        options.delete(:notify_later)
+        ActivityNotification::NotifyAllJob.perform_later(targets, notifiable, options)
       end
 
       # Generates notifications to one target.
@@ -205,27 +272,56 @@ module ActivityNotification
       # @option options [ActiveSupport::Duration] :group_expiry_delay       (nil)                                 Expiry period of a notification group
       # @option options [Object]                  :notifier                 (nil)                                 Notifier of the notifications
       # @option options [Hash]                    :parameters               ({})                                  Additional parameters of the notifications
+      # @option options [Boolean]                 :notify_later             (false)                               Whether it generates notifications asynchronously
       # @option options [Boolean]                 :send_email               (true)                                Whether it sends notification email
       # @option options [Boolean]                 :send_later               (true)                                Whether it sends notification email asynchronously
       # @option options [Boolean]                 :publish_optional_targets (true)                                Whether it publishes notification to optional targets
       # @option options [Hash<String, Hash>]      :optional_targets         ({})                                  Options for optional targets, keys are optional target name (:amazon_sns or :slack etc) and values are options
       # @return [Notification] Generated notification instance
       def notify_to(target, notifiable, options = {})
-        send_email            = options.has_key?(:send_email)                  ? options[:send_email]            : true
-        send_later            = options.has_key?(:send_later)                  ? options[:send_later]            : true
-        publish_optional_targets = options.has_key?(:publish_optional_targets) ? options[:publish_optional_targets] : true
-        # Generate notification
-        notification = generate_notification(target, notifiable, options)
-        # Send notification email
-        if notification.present? && send_email
-          notification.send_notification_email({ send_later: send_later })
-        end
-        # Publish to optional targets
-        if notification.present? && publish_optional_targets
-          notification.publish_to_optional_targets(options[:optional_targets] || {})
+        if options[:notify_later]
+          notify_later_to(target, notifiable, options)
+        else
+          send_email            = options.has_key?(:send_email)                  ? options[:send_email]            : true
+          send_later            = options.has_key?(:send_later)                  ? options[:send_later]            : true
+          publish_optional_targets = options.has_key?(:publish_optional_targets) ? options[:publish_optional_targets] : true
+          # Generate notification
+          notification = generate_notification(target, notifiable, options)
+          # Send notification email
+          if notification.present? && send_email
+            notification.send_notification_email({ send_later: send_later })
+          end
+          # Publish to optional targets
+          if notification.present? && publish_optional_targets
+            notification.publish_to_optional_targets(options[:optional_targets] || {})
+          end
+          # Return generated notification
+          notification
         end
-        # Return generated notification
-        notification
+      end
+      alias_method :notify_now_to, :notify_to
+
+      # Generates notifications to one target later by ActiveJob queue.
+      #
+      # @example Notify to one user later
+      #   ActivityNotification::Notification.notify_later_to @comment.auther, @comment
+      #
+      # @param [Object] target Target to send notifications
+      # @param [Object] notifiable Notifiable instance
+      # @param [Hash] options Options for notifications
+      # @option options [String]                  :key                      (notifiable.default_notification_key) Key of the notification
+      # @option options [Object]                  :group                    (nil)                                 Group unit of the notifications
+      # @option options [ActiveSupport::Duration] :group_expiry_delay       (nil)                                 Expiry period of a notification group
+      # @option options [Object]                  :notifier                 (nil)                                 Notifier of the notifications
+      # @option options [Hash]                    :parameters               ({})                                  Additional parameters of the notifications
+      # @option options [Boolean]                 :send_email               (true)                                Whether it sends notification email
+      # @option options [Boolean]                 :send_later               (true)                                Whether it sends notification email asynchronously
+      # @option options [Boolean]                 :publish_optional_targets (true)                                Whether it publishes notification to optional targets
+      # @option options [Hash<String, Hash>]      :optional_targets         ({})                                  Options for optional targets, keys are optional target name (:amazon_sns or :slack etc) and values are options
+      # @return [Notification] Generated notification instance
+      def notify_later_to(target, notifiable, options = {})
+        options.delete(:notify_later)
+        ActivityNotification::NotifyToJob.perform_later(target, notifiable, options)
       end
 
       # Generates a notification

data/lib/activity_notification/config.rb

@@ -92,6 +92,15 @@ module ActivityNotification
     #   @return [String] Base mailer class for email notification.
     attr_accessor :parent_mailer
 
+    # @overload parent_job
+    #   Returns base job class for delayed notifications
+    #   @return [String] Base job class for delayed notifications.
+    # @overload parent_job=(value)
+    #   Sets base job class for delayed notifications
+    #   @param [String] parent_job The new parent_job
+    #   @return [String] Base job class for delayed notifications.
+    attr_accessor :parent_job
+
     # @overload parent_controller
     #   Returns base controller class for notifications_controller
     #   @return [String] Base controller class for notifications_controller.
@@ -119,6 +128,15 @@ module ActivityNotification
     #   @return [Integer] Default limit to query for opened notifications.
     attr_accessor :opened_index_limit
 
+    # @overload active_job_queue
+    #   Returns ActiveJob queue name for delayed notifications
+    #   @return [Symbol] ActiveJob queue name for delayed notifications.
+    # @overload active_job_queue=(value)
+    #   Sets ActiveJob queue name for delayed notifications
+    #   @param [Symbol] active_job_queue The new active_job_queue
+    #   @return [Symbol] ActiveJob queue name for delayed notifications.
+    attr_accessor :active_job_queue
+
     # @overload :orm
     #   Returns ORM name for ActivityNotification (:active_record or :mongoid)
     #   @return [Boolean] ORM name for ActivityNotification (:active_record or :mongoid).
@@ -137,9 +155,11 @@ module ActivityNotification
       @mailer_sender           = nil
       @mailer                  = 'ActivityNotification::Mailer'
       @parent_mailer           = 'ActionMailer::Base'
+      @parent_job              = 'ActiveJob::Base'
       @parent_controller       = 'ApplicationController'
       @mailer_templates_dir    = 'activity_notification/mailer'
       @opened_index_limit      = 10
+      @active_job_queue        = :activity_notification
       @orm                     = :active_record
     end
 

data/lib/activity_notification/models/concerns/notifiable.rb

@@ -249,6 +249,27 @@ module ActivityNotification
       Notification.notify(target_type, self, options)
     end
 
+    # Generates notifications to configured targets with notifiable model later by ActiveJob queue.
+    # This method calls NotificationApi#notify_later internally with self notifiable instance.
+    # @see NotificationApi#notify_later
+    #
+    # @param [Symbol, String, Class] target_type Type of target
+    # @param [Hash] options Options for notifications
+    # @option options [String]                  :key                      (notifiable.default_notification_key) Key of the notification
+    # @option options [Object]                  :group                    (nil)                                 Group unit of the notifications
+    # @option options [ActiveSupport::Duration] :group_expiry_delay       (nil)                                 Expiry period of a notification group
+    # @option options [Object]                  :notifier                 (nil)                                 Notifier of the notifications
+    # @option options [Hash]                    :parameters               ({})                                  Additional parameters of the notifications
+    # @option options [Boolean]                 :send_email               (true)                                Whether it sends notification email
+    # @option options [Boolean]                 :send_later               (true)                                Whether it sends notification email asynchronously
+    # @option options [Boolean]                 :publish_optional_targets (true)                                Whether it publishes notification to optional targets
+    # @option options [Hash<String, Hash>]      :optional_targets         ({})                                  Options for optional targets, keys are optional target name (:amazon_sns or :slack etc) and values are options
+    # @return [Array<Notificaion>] Array of generated notifications
+    def notify_later(target_type, options = {})
+      Notification.notify_later(target_type, self, options)
+    end
+    alias_method :notify_now, :notify
+
     # Generates notifications to one target.
     # This method calls NotificationApi#notify_all internally with self notifiable instance.
     # @see NotificationApi#notify_all
@@ -268,6 +289,27 @@ module ActivityNotification
     def notify_all(targets, options = {})
       Notification.notify_all(targets, self, options)
     end
+    alias_method :notify_all_now, :notify_all
+
+    # Generates notifications to one target later by ActiveJob queue.
+    # This method calls NotificationApi#notify_all_later internally with self notifiable instance.
+    # @see NotificationApi#notify_all_later
+    #
+    # @param [Array<Object>] targets Targets to send notifications
+    # @param [Hash] options Options for notifications
+    # @option options [String]                  :key                      (notifiable.default_notification_key) Key of the notification
+    # @option options [Object]                  :group                    (nil)                                 Group unit of the notifications
+    # @option options [ActiveSupport::Duration] :group_expiry_delay       (nil)                                 Expiry period of a notification group
+    # @option options [Object]                  :notifier                 (nil)                                 Notifier of the notifications
+    # @option options [Hash]                    :parameters               ({})                                  Additional parameters of the notifications
+    # @option options [Boolean]                 :send_email               (true)                                Whether it sends notification email
+    # @option options [Boolean]                 :send_later               (true)                                Whether it sends notification email asynchronously
+    # @option options [Boolean]                 :publish_optional_targets (true)                                Whether it publishes notification to optional targets
+    # @option options [Hash<String, Hash>]      :optional_targets         ({})                                  Options for optional targets, keys are optional target name (:amazon_sns or :slack etc) and values are options
+    # @return [Array<Notificaion>] Array of generated notifications
+    def notify_all_later(targets, options = {})
+      Notification.notify_all_later(targets, self, options)
+    end
 
     # Generates notifications to one target.
     # This method calls NotificationApi#notify_to internally with self notifiable instance.
@@ -288,6 +330,27 @@ module ActivityNotification
     def notify_to(target, options = {})
       Notification.notify_to(target, self, options)
     end
+    alias_method :notify_now_to, :notify_to
+
+    # Generates notifications to one target later by ActiveJob queue.
+    # This method calls NotificationApi#notify_later_to internally with self notifiable instance.
+    # @see NotificationApi#notify_later_to
+    #
+    # @param [Object] target Target to send notifications
+    # @param [Hash] options Options for notifications
+    # @option options [String]                  :key                      (notifiable.default_notification_key) Key of the notification
+    # @option options [Object]                  :group                    (nil)                                 Group unit of the notifications
+    # @option options [ActiveSupport::Duration] :group_expiry_delay       (nil)                                 Expiry period of a notification group
+    # @option options [Object]                  :notifier                 (nil)                                 Notifier of the notifications
+    # @option options [Hash]                    :parameters               ({})                                  Additional parameters of the notifications
+    # @option options [Boolean]                 :send_email               (true)                                Whether it sends notification email
+    # @option options [Boolean]                 :send_later               (true)                                Whether it sends notification email asynchronously
+    # @option options [Boolean]                 :publish_optional_targets (true)                                Whether it publishes notification to optional targets
+    # @option options [Hash<String, Hash>]      :optional_targets         ({})                                  Options for optional targets, keys are optional target name (:amazon_sns or :slack etc) and values are options
+    # @return [Notification] Generated notification instance
+    def notify_later_to(target, options = {})
+      Notification.notify_later_to(target, self, options)
+    end
 
     # Returns default key of the notification.
     # This method is able to be overriden.

data/lib/activity_notification/models/concerns/target.rb

@@ -325,10 +325,31 @@ module ActivityNotification
     # @option options [Boolean]                 :publish_optional_targets (true)                                Whether it publishes notification to optional targets
     # @option options [Hash<String, Hash>]      :optional_targets         ({})                                  Options for optional targets, keys are optional target name (:amazon_sns or :slack etc) and values are options
     # @return [Notification] Generated notification instance
-    def notify_to(notifiable, options = {})
+    def receive_notification_of(notifiable, options = {})
       Notification.notify_to(self, notifiable, options)
     end
-  
+    alias_method :receive_notification_now_of, :receive_notification_of
+
+    # Generates notifications to this target later by ActiveJob queue.
+    # This method calls NotificationApi#notify_later_to internally with self target instance.
+    # @see NotificationApi#notify_later_to
+    #
+    # @param [Object] notifiable Notifiable instance to notify
+    # @param [Hash] options Options for notifications
+    # @option options [String]                  :key                      (notifiable.default_notification_key) Key of the notification
+    # @option options [Object]                  :group                    (nil)                                 Group unit of the notifications
+    # @option options [ActiveSupport::Duration] :group_expiry_delay       (nil)                                 Expiry period of a notification group
+    # @option options [Object]                  :notifier                 (nil)                                 Notifier of the notifications
+    # @option options [Hash]                    :parameters               ({})                                  Additional parameters of the notifications
+    # @option options [Boolean]                 :send_email               (true)                                Whether it sends notification email
+    # @option options [Boolean]                 :send_later               (true)                                Whether it sends notification email asynchronously
+    # @option options [Boolean]                 :publish_optional_targets (true)                                Whether it publishes notification to optional targets
+    # @option options [Hash<String, Hash>]      :optional_targets         ({})                                  Options for optional targets, keys are optional target name (:amazon_sns or :slack etc) and values are options
+    # @return [Notification] Generated notification instance
+    def receive_notification_later_of(notifiable, options = {})
+      Notification.notify_later_to(self, notifiable, options)
+    end
+
     # Opens all notifications of this target.
     # This method calls NotificationApi#open_all_of internally with self target instance.
     # @see NotificationApi#open_all_of