activity_notification 1.1.0 → 1.2.0

data/lib/activity_notification.rb

@@ -54,6 +54,7 @@ require 'activity_notification/helpers/view_helpers'
 require 'activity_notification/controllers/common_controller'
 require 'activity_notification/controllers/store_controller'
 require 'activity_notification/controllers/devise_authentication_controller'
+require 'activity_notification/optional_targets/base'
 
 # Load role for models
 require 'activity_notification/models'

data/lib/activity_notification/apis/notification_api.rb

@@ -24,13 +24,15 @@ module ActivityNotification
       # @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 [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(target_type, notifiable, options = {})
         targets = notifiable.notification_targets(target_type, options[:key])
@@ -47,13 +49,15 @@ module ActivityNotification
       # @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 [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(targets, notifiable, options = {})
         targets.map { |target| target.notify_to(notifiable, options) }
@@ -67,23 +71,30 @@ module ActivityNotification
       # @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 [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_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
+        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
@@ -192,8 +203,8 @@ module ActivityNotification
     # @return [Mail::Message, ActionMailer::DeliveryJob] Email message or its delivery job
     def send_notification_email(options = {})
       if target.notification_email_allowed?(notifiable, key) &&
-         email_subscribed?(key) &&
-         notifiable.notification_email_allowed?(target, key)
+         notifiable.notification_email_allowed?(target, key) &&
+         email_subscribed?
         send_later = options.has_key?(:send_later) ? options[:send_later] : true
         send_later ?
           Mailer.send_notification_email(self, options).deliver_later :
@@ -201,6 +212,22 @@ module ActivityNotification
       end
     end
 
+    # Publishes notification to the optional targets.
+    #
+    # @param [Hash] options Options for optional targets
+    # @return [Hash] Result of publishing to optional target
+    def publish_to_optional_targets(options = {})
+      notifiable.optional_targets(target.to_resources_name, key).map { |optional_target|
+        optional_target_name = optional_target.to_optional_target_name
+        if optional_target_subscribed?(optional_target_name)
+          optional_target.notify(self, options[optional_target_name] || {})
+          [optional_target_name, true]
+        else
+          [optional_target_name, false]
+        end
+      }.to_h
+    end
+
     # Opens the notification.
     #
     # @param [Hash] options Options for opening notifications
@@ -311,6 +338,18 @@ module ActivityNotification
       notification.group_member_exists? ? notification.group_members.latest : self
     end
 
+    # Remove from notification group and make a new group owner.
+    #
+    # @return [Notificaion] New group owner instance of the notification group
+    def remove_from_group
+      new_group_owner = group_members.earliest
+      if new_group_owner.present?
+        new_group_owner.update(group_owner_id: nil)
+        group_members.update_all(group_owner_id: new_group_owner)
+      end
+      new_group_owner
+    end
+
     # Returns notifiable_path to move after opening notification with notifiable.notifiable_path.
     #
     # @return [String] Notifiable path URL to move after opening notification
@@ -327,10 +366,28 @@ module ActivityNotification
 
     # Returns if the target subscribes this notification email.
     # @return [Boolean] If the target subscribes the notification
-    def email_subscribed?(key)
+    def email_subscribed?
       target.subscribes_to_notification_email?(key)
     end
 
+    # Returns if the target subscribes this notification email.
+    # @param [String, Symbol] optional_target_name Class name of the optional target implementation (e.g. :amazon_sns, :slack)
+    # @return [Boolean] If the target subscribes the specified optional target of the notification
+    def optional_target_subscribed?(optional_target_name)
+      target.subscribes_to_optional_target?(key, optional_target_name)
+    end
+
+    # Returns optional_targets of the notification from configured field or overriden method.
+    # @return [Array<ActivityNotification::OptionalTarget::Base>] Array of optional target instances
+    def optional_targets
+      notifiable.optional_targets(target.to_resources_name, key)
+    end
+
+    # Returns optional_target names of the notification from configured field or overriden method.
+    # @return [Array<Symbol>] Array of optional target names
+    def optional_target_names
+      notifiable.optional_target_names(target.to_resources_name, key)
+    end
 
     protected
 

data/lib/activity_notification/apis/subscription_api.rb

@@ -3,33 +3,73 @@ module ActivityNotification
   module SubscriptionApi
     extend ActiveSupport::Concern
 
+    class_methods do
+      # Returns key of optional_targets hash from symbol class name of the optional target implementation.
+      # @param [String, Symbol] optional_target_name Class name of the optional target implementation (e.g. :amazon_sns, :slack)
+      # @return [Symbol] Key of optional_targets hash
+      def to_optional_target_key(optional_target_name)
+        ("subscribing_to_" + optional_target_name.to_s).to_sym
+      end
+
+      # Returns subscribed_at parameter key of optional_targets hash from symbol class name of the optional target implementation.
+      # @param [String, Symbol] optional_target_name Class name of the optional target implementation (e.g. :amazon_sns, :slack)
+      # @return [Symbol] Subscribed_at parameter key of optional_targets hash
+      def to_optional_target_subscribed_at_key(optional_target_name)
+        ("subscribed_to_" + optional_target_name.to_s + "_at").to_sym
+      end
+
+      # Returns unsubscribed_at parameter key of optional_targets hash from symbol class name of the optional target implementation.
+      # @param [String, Symbol] optional_target_name Class name of the optional target implementation (e.g. :amazon_sns, :slack)
+      # @return [Symbol] Unsubscribed_at parameter key of optional_targets hash
+      def to_optional_target_unsubscribed_at_key(optional_target_name)
+        ("unsubscribed_to_" + optional_target_name.to_s + "_at").to_sym
+      end
+    end
+
     # Subscribes to the notification and notification email.
     #
-    # @param [Hash] options Options for subscribing notification
+    # @param [Hash] options Options for subscribing to the notification
     # @option options [DateTime] :subscribed_at           (Time.current) Time to set to subscribed_at and subscribed_to_email_at of the subscription record
     # @option options [Boolean]  :with_email_subscription (true)         If the subscriber also subscribes notification email
+    # @option options [Boolean]  :with_optional_targets   (true)         If the subscriber also subscribes optional_targets
     # @return [Boolean] If successfully updated subscription instance
     def subscribe(options = {})
       subscribed_at = options[:subscribed_at] || Time.current
       with_email_subscription = options.has_key?(:with_email_subscription) ? options[:with_email_subscription] : true
-      with_email_subscription ?
-        update(subscribing: true, subscribing_to_email: true, subscribed_at: subscribed_at, subscribed_to_email_at: subscribed_at) :
-        update(subscribing: true, subscribed_at: subscribed_at)
+      with_optional_targets   = options.has_key?(:with_optional_targets) ? options[:with_optional_targets] : true
+      new_attributes = { subscribing: true, subscribed_at: subscribed_at, optional_targets: optional_targets }
+      new_attributes = new_attributes.merge(subscribing_to_email: true, subscribed_to_email_at: subscribed_at) if with_email_subscription
+      if with_optional_targets
+        optional_target_names.each do |optional_target_name|
+          new_attributes[:optional_targets] = new_attributes[:optional_targets].merge(
+            Subscription.to_optional_target_key(optional_target_name) => true,
+            Subscription.to_optional_target_subscribed_at_key(optional_target_name) => subscribed_at)
+        end
+      end
+      update(new_attributes)
     end
 
     # Unsubscribes to the notification and notification email.
     #
-    # @param [Hash] options Options for unsubscribing notification
+    # @param [Hash] options Options for unsubscribing to the notification
     # @option options [DateTime] :unsubscribed_at (Time.current) Time to set to unsubscribed_at and unsubscribed_to_email_at of the subscription record
     # @return [Boolean] If successfully updated subscription instance
     def unsubscribe(options = {})
       unsubscribed_at = options[:unsubscribed_at] || Time.current
-      update(subscribing: false, subscribing_to_email: false, unsubscribed_at: unsubscribed_at, unsubscribed_to_email_at: unsubscribed_at)
+      new_attributes = { subscribing:          false, unsubscribed_at:          unsubscribed_at,
+                         subscribing_to_email: false, unsubscribed_to_email_at: unsubscribed_at,
+                         optional_targets: optional_targets }
+      optional_target_names.each do |optional_target_name|
+        new_attributes[:optional_targets] = new_attributes[:optional_targets].merge(
+          Subscription.to_optional_target_key(optional_target_name) => false,
+          Subscription.to_optional_target_unsubscribed_at_key(optional_target_name) => subscribed_at)
+      end
+      update(new_attributes)
     end
 
     # Subscribes to the notification email.
     #
-    # @param [Hash] options Options for subscribing notification email
+    # @param [Hash] options Options for subscribing to the notification email
     # @option options [DateTime] :subscribed_to_email_at (Time.current) Time to set to subscribed_to_email_at of the subscription record
     # @return [Boolean] If successfully updated subscription instance
     def subscribe_to_email(options = {})
@@ -39,7 +79,7 @@ module ActivityNotification
 
     # Unsubscribes to the notification email.
     #
-    # @param [Hash] options Options for unsubscribing notification email
+    # @param [Hash] options Options for unsubscribing the notification email
     # @option options [DateTime] :subscribed_to_email_at (Time.current) Time to set to subscribed_to_email_at of the subscription record
     # @return [Boolean] If successfully updated subscription instance
     def unsubscribe_to_email(options = {})
@@ -47,5 +87,50 @@ module ActivityNotification
       update(subscribing_to_email: false, unsubscribed_to_email_at: unsubscribed_to_email_at)
     end
 
+    # Returns if the target subscribes to the specified optional target.
+    #
+    # @param [Symbol]  optional_target_name Symbol class name of the optional target implementation (e.g. :amazon_sns, :slack)
+    # @param [Boolean] subscribe_as_default Default subscription value to use when the subscription record does not configured
+    # @return [Boolean] If the target subscribes to the specified optional target
+    def subscribing_to_optional_target?(optional_target_name, subscribe_as_default = ActivityNotification.config.subscribe_as_default)
+      optional_target_key = Subscription.to_optional_target_key(optional_target_name)
+      subscribe_as_default ?
+        !optional_targets.has_key?(optional_target_key) || optional_targets[optional_target_key] :
+         optional_targets.has_key?(optional_target_key) && optional_targets[optional_target_key]
+    end
+
+    # Subscribes to the specified optional target.
+    #
+    # @param [String, Symbol]  optional_target_name Symbol class name of the optional target implementation (e.g. :amazon_sns, :slack)
+    # @param [Hash]            options              Options for unsubscribing to the specified optional target
+    # @option options [DateTime] :subscribed_at (Time.current) Time to set to subscribed_[optional_target_name]_at in optional_targets hash of the subscription record
+    # @return [Boolean] If successfully updated subscription instance
+    def subscribe_to_optional_target(optional_target_name, options = {})
+      subscribed_at = options[:subscribed_at] || Time.current
+      update(optional_targets: optional_targets.merge(
+        Subscription.to_optional_target_key(optional_target_name) => true,
+        Subscription.to_optional_target_subscribed_at_key(optional_target_name) => subscribed_at)
+      )
+    end
+
+    # Unsubscribes to the specified optional target.
+    #
+    # @param [String, Symbol] optional_target_name Class name of the optional target implementation (e.g. :amazon_sns, :slack)
+    # @param [Hash]           options              Options for unsubscribing to the specified optional target
+    # @option options [DateTime] :unsubscribed_at (Time.current) Time to set to unsubscribed_[optional_target_name]_at in optional_targets hash of the subscription record
+    # @return [Boolean] If successfully updated subscription instance
+    def unsubscribe_to_optional_target(optional_target_name, options = {})
+      unsubscribed_at = options[:unsubscribed_at] || Time.current
+      update(optional_targets: optional_targets.merge(
+        Subscription.to_optional_target_key(optional_target_name) => false,
+        Subscription.to_optional_target_unsubscribed_at_key(optional_target_name) => unsubscribed_at)
+      )
+    end
+
+    # Returns optional_target names of the subscription from optional_targets field.
+    # @return [Array<Symbol>] Array of optional target names
+    def optional_target_names
+      optional_targets.keys.select { |key| key.to_s.start_with?("subscribing_to_") }.map { |key| key.slice(15..-1) }
+    end
   end
 end

data/lib/activity_notification/common.rb

@@ -27,8 +27,10 @@ module ActivityNotification
         thing.call(ActivityNotification.get_controller, context, *args)
       elsif thing.arity > 1
         thing.call(ActivityNotification.get_controller, context)
-      else
+      elsif thing.arity > 0
         thing.call(context)
+      else
+        thing.call
       end
     when Hash
       thing.dup.tap do |hash|
@@ -79,8 +81,10 @@ module ActivityNotification
       when Proc
         if thing.arity > 1
           thing.call(self, *args)
-        else
+        elsif thing.arity > 0
           thing.call(self)
+        else
+          thing.call
         end
       when Hash
         thing.dup.tap do |hash|

data/lib/activity_notification/helpers/view_helpers.rb

@@ -243,6 +243,28 @@ module ActivityNotification
     end
     alias_method :unsubscribe_to_email_path_for, :unsubscribe_to_email_subscription_path_for
 
+    # Returns subscribe_to_optional_target_subscription_path for the target of specified subscription
+    #
+    # @param [Subscription] subscription Subscription instance
+    # @param [Hash] params Request parameters
+    # @return [String] subscription_path for the subscription
+    # @todo Needs any other better implementation
+    def subscribe_to_optional_target_subscription_path_for(subscription, params = {})
+      send("subscribe_to_optional_target_#{subscription.target.to_resource_name}_subscription_path", subscription.target, subscription, params)
+    end
+    alias_method :subscribe_to_optional_target_path_for, :subscribe_to_optional_target_subscription_path_for
+
+    # Returns unsubscribe_to_optional_target_subscription_path for the target of specified subscription
+    #
+    # @param [Subscription] subscription Subscription instance
+    # @param [Hash] params Request parameters
+    # @return [String] subscription_path for the subscription
+    # @todo Needs any other better implementation
+    def unsubscribe_to_optional_target_subscription_path_for(subscription, params = {})
+      send("unsubscribe_to_optional_target_#{subscription.target.to_resource_name}_subscription_path", subscription.target, subscription, params)
+    end
+    alias_method :unsubscribe_to_optional_target_path_for, :unsubscribe_to_optional_target_subscription_path_for
+
     # Returns subscriptions_url for the target
     #
     # @param [Object] target Target instance
@@ -307,6 +329,27 @@ module ActivityNotification
     end
     alias_method :unsubscribe_to_email_url_for, :unsubscribe_to_email_subscription_url_for
 
+    # Returns subscribe_to_optional_target_subscription_url for the target of specified subscription
+    #
+    # @param [Subscription] subscription Subscription instance
+    # @param [Hash] params Request parameters
+    # @return [String] subscription_url for the subscription
+    # @todo Needs any other better implementation
+    def subscribe_to_optional_target_subscription_url_for(subscription, params = {})
+      send("subscribe_to_optional_target_#{subscription.target.to_resource_name}_subscription_url", subscription.target, subscription, params)
+    end
+    alias_method :subscribe_to_optional_target_url_for, :subscribe_to_optional_target_subscription_url_for
+
+    # Returns unsubscribe_to_optional_target_subscription_url for the target of specified subscription
+    #
+    # @param [Subscription] subscription Subscription instance
+    # @param [Hash] params Request parameters
+    # @return [String] subscription_url for the subscription
+    # @todo Needs any other better implementation
+    def unsubscribe_to_optional_target_subscription_url_for(subscription, params = {})
+      send("unsubscribe_to_optional_target_#{subscription.target.to_resource_name}_subscription_url", subscription.target, subscription, params)
+    end
+    alias_method :unsubscribe_to_optional_target_url_for, :unsubscribe_to_optional_target_subscription_url_for
 
     private
 

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

@@ -25,7 +25,8 @@ module ActivityNotification
                        :_notification_parameters,
                        :_notification_email_allowed,
                        :_notifiable_path,
-                       :_printable_notifiable_name
+                       :_printable_notifiable_name,
+                       :_optional_targets
       set_notifiable_class_defaults
     end
 
@@ -53,6 +54,7 @@ module ActivityNotification
         self._notification_email_allowed      = {}
         self._notifiable_path                 = {}
         self._printable_notifiable_name       = {}
+        self._optional_targets                = {}
         nil
       end
     end
@@ -68,7 +70,8 @@ module ActivityNotification
       resolved_parameter = resolve_parameter(
         target_typed_method_name,
         _notification_targets[cast_to_resources_sym(target_type)],
-        nil, key)
+        nil,
+        key)
       unless resolved_parameter
         raise NotImplementedError, "You have to implement #{self.class}##{target_typed_method_name} "\
                                    "or set :targets in acts_as_notifiable"
@@ -86,7 +89,8 @@ module ActivityNotification
       resolve_parameter(
         "notification_group_for_#{cast_to_resources_name(target_type)}",
         _notification_group[cast_to_resources_sym(target_type)],
-        nil, key)
+        nil,
+        key)
     end
 
     # Returns group expiry period of the notifications from configured field or overriden method.
@@ -99,7 +103,8 @@ module ActivityNotification
       resolve_parameter(
         "notification_group_expiry_delay_for_#{cast_to_resources_name(target_type)}",
         _notification_group_expiry_delay[cast_to_resources_sym(target_type)],
-        nil, key)
+        nil,
+        key)
     end
 
     # Returns additional notification parameters from configured field or overriden method.
@@ -112,7 +117,8 @@ module ActivityNotification
       resolve_parameter(
         "notification_parameters_for_#{cast_to_resources_name(target_type)}",
         _notification_parameters[cast_to_resources_sym(target_type)],
-        {}, key)
+        {},
+        key)
     end
 
     # Returns notifier of the notification from configured field or overriden method.
@@ -125,7 +131,8 @@ module ActivityNotification
       resolve_parameter(
         "notifier_for_#{cast_to_resources_name(target_type)}",
         _notifier[cast_to_resources_sym(target_type)],
-        nil, key)
+        nil,
+        key)
     end
 
     # Returns if sending notification email is allowed for the notifiable from configured field or overriden method.
@@ -152,7 +159,8 @@ module ActivityNotification
       resolved_parameter = resolve_parameter(
         "notifiable_path_for_#{cast_to_resources_name(target_type)}",
         _notifiable_path[cast_to_resources_sym(target_type)],
-        nil, key)
+        nil,
+        key)
       unless resolved_parameter
         begin
           resolved_parameter = polymorphic_path(self)
@@ -175,6 +183,30 @@ module ActivityNotification
         target, key)
     end
 
+    # Returns optional_targets of the notification from configured field or overriden method.
+    # This method is able to be overriden.
+    #
+    # @param [String] target_type Target type to notify
+    # @param [String] key Key of the notification
+    # @return [Array<ActivityNotification::OptionalTarget::Base>] Array of optional target instances
+    def optional_targets(target_type, key = nil)
+      resolve_parameter(
+        "optional_targets_for_#{cast_to_resources_name(target_type)}",
+        _optional_targets[cast_to_resources_sym(target_type)],
+        [],
+        key)
+    end
+
+    # Returns optional_target names of the notification from configured field or overriden method.
+    # This method is able to be overriden.
+    #
+    # @param [String] target_type Target type to notify
+    # @param [String] key Key of the notification
+    # @return [Array<Symbol>] Array of optional target names
+    def optional_target_names(target_type, key = nil)
+      optional_targets(target_type, key).map { |optional_target| optional_target.to_optional_target_name }
+    end
+
     # overriding_notification_email_key is the method to override key definition for Mailer
     # When respond_to?(overriding_notification_email_key) returns true,
     # Mailer uses overriding_notification_email_key instead of original key.
@@ -188,13 +220,15 @@ module ActivityNotification
     #
     # @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 [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(target_type, options = {})
       Notification.notify(target_type, self, options)
@@ -206,13 +240,15 @@ module ActivityNotification
     #
     # @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 [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(targets, options = {})
       Notification.notify_all(targets, self, options)
@@ -224,13 +260,15 @@ module ActivityNotification
     #
     # @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 [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_to(target, options = {})
       Notification.notify_to(target, self, options)
@@ -265,6 +303,13 @@ module ActivityNotification
         end
       end
 
+      # Remove generated notifications from notification group to new group owner.
+      # This method is intended to be called before destroy this notifiable as dependent configuration.
+      # @api private
+      def remove_generated_notifications_from_group
+        generated_notifications_as_notifiable.group_owners_only.each { |n| n.remove_from_group }
+      end
+
       # Casts to resources name.
       # @api private
       def cast_to_resources_name(target_type)