activity_notification 1.1.0 → 1.2.0

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

@@ -50,12 +50,25 @@ module ActivityNotification
         subscription_params[:subscribing_to_email] = subscription_params[:subscribing] 
       end
       subscription = subscriptions.new(subscription_params)
-      subscription.subscribing ?
+      subscription.subscribing? ?
         subscription.assign_attributes(subscribing: true, subscribed_at: created_at) :
         subscription.assign_attributes(subscribing: false, unsubscribed_at: created_at)
-      subscription.subscribing_to_email ?
+      subscription.subscribing_to_email? ?
         subscription.assign_attributes(subscribing_to_email: true, subscribed_to_email_at: created_at) :
         subscription.assign_attributes(subscribing_to_email: false, unsubscribed_to_email_at: created_at)
+      optional_targets = subscription.optional_targets
+      subscription.optional_target_names.each do |optional_target_name|
+        optional_targets = subscription.subscribing_to_optional_target?(optional_target_name) ?
+          optional_targets.merge(
+            Subscription.to_optional_target_key(optional_target_name) => true,
+            Subscription.to_optional_target_subscribed_at_key(optional_target_name) => created_at
+          ) :
+          optional_targets.merge(
+            Subscription.to_optional_target_key(optional_target_name) => false,
+            Subscription.to_optional_target_unsubscribed_at_key(optional_target_name) => created_at
+          )
+      end
+      subscription.assign_attributes(optional_targets: optional_targets)
       subscription.save ? subscription : nil
     end
 
@@ -118,7 +131,7 @@ module ActivityNotification
       # @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 notification
       def _subscribes_to_notification?(key, subscribe_as_default = ActivityNotification.config.subscribe_as_default)
-        evaluate_subscription(subscriptions.find_by_key(key), :subscribing, subscribe_as_default)
+        evaluate_subscription(subscriptions.find_by_key(key), :subscribing?, subscribe_as_default)
       end
 
       # Returns if the target subscribes to the notification email.
@@ -129,20 +142,34 @@ module ActivityNotification
       # @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 notification
       def _subscribes_to_notification_email?(key, subscribe_as_default = ActivityNotification.config.subscribe_as_default)
-        evaluate_subscription(subscriptions.find_by_key(key), :subscribing_to_email, subscribe_as_default)
+        evaluate_subscription(subscriptions.find_by_key(key), :subscribing_to_email?, subscribe_as_default)
       end
       alias_method :_subscribes_to_email?, :_subscribes_to_notification_email?
 
+      # Returns if the target subscribes to the specified optional target.
+      # This method can be overriden.
+      # @api protected
+      #
+      # @param [String]         key                  Key of the notification
+      # @param [String, Symbol] optional_target_name 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 _subscribes_to_optional_target?(key, optional_target_name, subscribe_as_default = ActivityNotification.config.subscribe_as_default)
+        _subscribes_to_notification?(key, subscribe_as_default) &&
+          evaluate_subscription(subscriptions.find_by_key(key), :subscribing_to_optional_target?, subscribe_as_default, optional_target_name, subscribe_as_default)
+      end
+
     private
 
       # Returns if the target subscribes.
       # @api private
       # @param [Boolean] record  Subscription record
-      # @param [Symbol]  field   Evaluating subscription field of the record
+      # @param [Symbol]  field   Evaluating subscription field or method of the record
       # @param [Boolean] default Default subscription value to use when the subscription record does not configured
+      # @param [Array]   args    Arguments of evaluating subscription method
       # @return [Boolean] If the target subscribes
-      def evaluate_subscription(record, field, default)
-        default ? record.blank? || record.send(field) : record.present? && record.send(field)
+      def evaluate_subscription(record, field, default, *args)
+        default ? record.blank? || record.send(field, *args) : record.present? && record.send(field)
       end
 
   end

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

@@ -302,13 +302,15 @@ module ActivityNotification
     #
     # @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 [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(notifiable, options = {})
       Notification.notify_to(self, notifiable, options)
@@ -433,24 +435,34 @@ module ActivityNotification
     # Returns if the target subscribes to the notification.
     # It also returns true when the subscription management is not allowed for the target.
     #
-    # @param [String] key                  Key of the notification
-    # @param [String] subscribe_as_default Default subscription value to use when the subscription record does not configured
+    # @param [String]  key                  Key of the notification
+    # @param [Boolean] subscribe_as_default Default subscription value to use when the subscription record does not configured
     # @return [Boolean] If the target subscribes the notification or the subscription management is not allowed for the target
     def subscribes_to_notification?(key, subscribe_as_default = ActivityNotification.config.subscribe_as_default)
-      !subscription_allowed?(key) or _subscribes_to_notification?(key, subscribe_as_default)
+      !subscription_allowed?(key) || _subscribes_to_notification?(key, subscribe_as_default)
     end
 
     # Returns if the target subscribes to the notification email.
     # It also returns true when the subscription management is not allowed for the target.
     #
-    # @param [String] key                  Key of the notification
-    # @param [String] subscribe_as_default Default subscription value to use when the subscription record does not configured
+    # @param [String]  key                  Key of the notification
+    # @param [Boolean] subscribe_as_default Default subscription value to use when the subscription record does not configured
     # @return [Boolean] If the target subscribes the notification email or the subscription management is not allowed for the target
     def subscribes_to_notification_email?(key, subscribe_as_default = ActivityNotification.config.subscribe_as_default)
-      !subscription_allowed?(key) or _subscribes_to_notification_email?(key, subscribe_as_default)
+      !subscription_allowed?(key) || _subscribes_to_notification_email?(key, subscribe_as_default)
     end
     alias_method :subscribes_to_email?, :subscribes_to_notification_email?
 
+    # Returns if the target subscribes to the specified optional target.
+    # It also returns true when the subscription management is not allowed for the target.
+    #
+    # @param [String]         key                  Key of the notification
+    # @param [String, Symbol] optional_target_name 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 the notification email or the subscription management is not allowed for the target
+    def subscribes_to_optional_target?(key, optional_target_name, subscribe_as_default = ActivityNotification.config.subscribe_as_default)
+      !subscription_allowed?(key) || _subscribes_to_optional_target?(key, optional_target_name, subscribe_as_default)
+    end
 
     private
 

data/lib/activity_notification/models/subscription.rb

@@ -10,7 +10,7 @@ module ActivityNotification
     belongs_to :target,               polymorphic: true
 
     # Serialize parameters Hash
-    serialize  :parameters, Hash
+    serialize  :optional_targets, Hash
 
     validates  :target,               presence: true
     validates  :key,                  presence: true
@@ -21,6 +21,7 @@ module ActivityNotification
     validates  :unsubscribed_at,          presence: true, unless: :subscribing
     validates  :subscribed_to_email_at,   presence: true, if:     :subscribing_to_email
     validates  :unsubscribed_to_email_at, presence: true, unless: :subscribing_to_email
+    validate   :subscribing_to_optional_target_cannot_be_true_when_subscribing_is_false
 
     # Selects filtered subscriptions by target instance.
     #   ActivityNotification::Subscription.filtered_by_target(@user)
@@ -82,12 +83,22 @@ module ActivityNotification
     scope :key_order,                 -> { order(key: :asc) }
 
     private
+
       # Validates subscribing_to_email cannot be true when subscribing isfalse.
       def subscribing_to_email_cannot_be_true_when_subscribing_is_false
-        if !subscribing && subscribing_to_email
+        if !subscribing && subscribing_to_email?
           errors.add(:subscribing_to_email, "cannot be true when subscribing is false")
         end
       end
 
+      # Validates subscribing_to_optional_target cannot be true when subscribing isfalse.
+      def subscribing_to_optional_target_cannot_be_true_when_subscribing_is_false
+        optional_target_names.each do |optional_target_name|
+          if !subscribing && subscribing_to_optional_target?(optional_target_name)
+            errors.add(:optional_targets, "#Subscription.to_optional_target_key(optional_target_name) cannot be true when subscribing is false")
+          end
+        end
+      end
+
   end
 end

data/lib/activity_notification/optional_targets/amazon_sns.rb

@@ -0,0 +1,42 @@
+module ActivityNotification
+  module OptionalTarget
+    # Optional target implementation for mobile push notification or SMS using Amazon SNS.
+    class AmazonSNS < ActivityNotification::OptionalTarget::Base
+      require 'aws-sdk'
+
+      # Initialize method to prepare Aws::SNS::Client
+      # @param [Hash] options Options for initializing
+      # @option options [String, Proc, Symbol] :topic_arn    (nil) :topic_arn option for Aws::SNS::Client#publish, it resolved by target instance like email_allowed?
+      # @option options [String, Proc, Symbol] :target_arn   (nil) :target_arn option for Aws::SNS::Client#publish, it resolved by target instance like email_allowed?
+      # @option options [String, Proc, Symbol] :phone_number (nil) :phone_number option for Aws::SNS::Client#publish, it resolved by target instance like email_allowed?
+      # @option options [Hash]                 others              Other options to be set Aws::SNS::Client.new
+      def initialize_target(options = {})
+        @topic_arn    = options.delete(:topic_arn)
+        @target_arn   = options.delete(:target_arn)
+        @phone_number = options.delete(:phone_number)
+        @sns_client = Aws::SNS::Client.new(options)
+      end
+
+      # Publishes notification message to Amazon SNS
+      # @param [Notification] notification Notification instance
+      # @param [Hash] options Options for publishing
+      # @option options [String, Proc, Symbol] :topic_arn    (nil)                     :topic_arn option for Aws::SNS::Client#publish, it resolved by target instance like email_allowed?
+      # @option options [String, Proc, Symbol] :target_arn   (nil)                     :target_arn option for Aws::SNS::Client#publish, it resolved by target instance like email_allowed?
+      # @option options [String, Proc, Symbol] :phone_number (nil)                     :phone_number option for Aws::SNS::Client#publish, it resolved by target instance like email_allowed?
+      # @option options [String]               :partial_root ("activity_notification/optional_targets/#{target}/#{optional_target_name}", "activity_notification/optional_targets/#{target}/base", "activity_notification/optional_targets/default/#{optional_target_name}", "activity_notification/optional_targets/default/base") Partial template name
+      # @option options [String]               :partial      (self.key.tr('.', '/'))   Root path of partial template
+      # @option options [String]               :layout       (nil)                     Layout template name
+      # @option options [String]               :layout_root  ('layouts')               Root path of layout template
+      # @option options [String, Symbol]       :fallback     (:default)                Fallback template to use when MissingTemplate is raised. Set :text to use i18n text as fallback.
+      # @option options [Hash]                 others                                  Parameters to be set as locals
+      def notify(notification, options = {})
+        @sns_client.publish(
+          topic_arn:    notification.target.resolve_value(options.delete(:topic_arn) || @topic_arn),
+          target_arn:   notification.target.resolve_value(options.delete(:target_arn) || @target_arn),
+          phone_number: notification.target.resolve_value(options.delete(:phone_number) || @phone_number),
+          message: render_notification_message(notification, options)
+        )
+      end
+    end
+  end
+end

data/lib/activity_notification/optional_targets/base.rb

@@ -0,0 +1,79 @@
+module ActivityNotification
+  # Optional target module to develop optional notification target classes.
+  module OptionalTarget
+    # Abstract optional target class to develop optional notification target class.
+    class Base
+      # View context to render notification message
+      # @return View context to render notification message
+      attr_accessor :view_context
+
+      # Initialize method to create view context in this OptionalTarget instance
+      def initialize
+        @view_context = ActionView::Base.new(ActionController::Base.view_paths, {})
+        @view_context.class_eval do 
+          include Rails.application.routes.url_helpers
+          def default_url_options
+            ActionMailer::Base.default_url_options
+          end
+        end
+      end
+
+      # Returns demodulized symbol class name as optional target name
+      # @return Demodulized symbol class name as optional target name
+      def to_optional_target_name
+        self.class.name.demodulize.underscore.to_sym
+      end
+
+      # Initialize method to be overriden in user implementation class
+      # @param [Hash] _options Options for initializing
+      def initialize_target(_options = {})
+        raise NotImplementedError, "You have to implement #{self.class}##{__method__}"
+      end
+
+      # Publishing notification method to be overriden in user implementation class
+      # @param [Notification] _notification Notification instance
+      # @param [Hash] _options Options for publishing
+      def notify(_notification, _options = {})
+        raise NotImplementedError, "You have to implement #{self.class}##{__method__}"
+      end
+
+      protected
+
+        # Renders notification message with view context
+        # @param [Notification] notification Notification instance
+        # @param [Hash]         options      Options for rendering
+        # @option options [Hash]           :assignment   (nil)                     Optional instance variables to assign for views
+        # @option options [String]         :partial_root ("activity_notification/optional_targets/#{target}/#{optional_target_name}", "activity_notification/optional_targets/#{target}/base", "activity_notification/optional_targets/default/#{optional_target_name}", "activity_notification/optional_targets/default/base") Partial template name
+        # @option options [String]         :partial      (self.key.tr('.', '/'))   Root path of partial template
+        # @option options [String]         :layout       (nil)                     Layout template name
+        # @option options [String]         :layout_root  ('layouts')               Root path of layout template
+        # @option options [String, Symbol] :fallback     (:default)                Fallback template to use when MissingTemplate is raised. Set :text to use i18n text as fallback.
+        # @option options [Hash]           others                                  Parameters to be set as locals
+        # @return [String] Rendered view or text as string
+        def render_notification_message(notification, options = {})
+          partial_root_list = 
+            options[:partial_root].present? ?
+            [ options[:partial_root] ] :
+            [ "activity_notification/optional_targets/#{notification.target.to_resources_name}/#{to_optional_target_name}",
+              "activity_notification/optional_targets/#{notification.target.to_resources_name}/base",
+              "activity_notification/optional_targets/default/#{to_optional_target_name}",
+              "activity_notification/optional_targets/default/base"
+            ]
+          options[:fallback] ||= :default
+          @view_context.assign((options[:assignment] || {}).merge(notification: notification, target: notification.target))
+
+          message, missing_template = nil, nil
+          partial_root_list.each do |partial_root|
+            begin
+              message = notification.render(@view_context, options.merge(partial_root: partial_root)).to_str
+              break
+            rescue ActionView::MissingTemplate => e
+              missing_template = e
+              # Continue to next partial root
+            end
+          end
+          message.blank? ? (raise missing_template) : message
+        end
+    end
+  end
+end

data/lib/activity_notification/optional_targets/slack.rb

@@ -0,0 +1,33 @@
+module ActivityNotification
+  module OptionalTarget
+    # Optional target implementation for Slack.
+    class Slack < ActivityNotification::OptionalTarget::Base
+      require 'slack-notifier'
+
+      # Initialize method to prepare Slack::Notifier
+      # @param [Hash] options Options for initializing
+      # @option options [String, Proc, Symbol] :slack_name   (nil) Target user name of Slack, it resolved by target instance like email_allowed?
+      # @option options [required, String]     :webhook_url  (nil) Webhook URL of Slack Incoming WebHooks integration
+      # @option options [Hash]                 others              Other options to be set Slack::Notifier.new, like :channel, :username, :icon_emoji etc
+      def initialize_target(options = {})
+        @slack_name = options.delete(:slack_name)
+        @notifier = ::Slack::Notifier.new(options.delete(:webhook_url), options)
+      end
+
+      # Publishes notification message to Slack
+      # @param [Notification] notification Notification instance
+      # @param [Hash] options Options for publishing
+      # @option options [String, Proc, Symbol] :slack_name   (nil)                     Target user name of Slack, it resolved by target instance like email_allowed?
+      # @option options [String]               :partial_root ("activity_notification/optional_targets/#{target}/#{optional_target_name}", "activity_notification/optional_targets/#{target}/base", "activity_notification/optional_targets/default/#{optional_target_name}", "activity_notification/optional_targets/default/base") Partial template name
+      # @option options [String]               :partial      (self.key.tr('.', '/'))   Root path of partial template
+      # @option options [String]               :layout       (nil)                     Layout template name
+      # @option options [String]               :layout_root  ('layouts')               Root path of layout template
+      # @option options [String, Symbol]       :fallback     (:default)                Fallback template to use when MissingTemplate is raised. Set :text to use i18n text as fallback.
+      # @option options [Hash]                 others                                  Parameters to be set as locals
+      def notify(notification, options = {})
+        slack_name = notification.target.resolve_value(options.delete(:slack_name) || @slack_name)
+        @notifier.ping(render_notification_message(notification, options.merge(assignment: { slack_name: slack_name })))
+      end
+    end
+  end
+end

data/lib/activity_notification/rails/routes.rb

@@ -104,44 +104,52 @@ module ActionDispatch::Routing
     #   subscribed_by :users
     # This method creates the needed routes:
     #   # Subscription routes
-    #     user_subscriptions          GET    /users/:user_id/subscriptions(.:format)
+    #     user_subscriptions                                GET    /users/:user_id/subscriptions(.:format)
     #       { controller:"activity_notification/subscriptions", action:"index", target_type:"users" }
-    #     user_subscription           GET    /users/:user_id/subscriptions/:id(.:format)
+    #     user_subscription                                 GET    /users/:user_id/subscriptions/:id(.:format)
     #       { controller:"activity_notification/subscriptions", action:"show", target_type:"users" }
-    #     open_all_user_subscriptions POST   /users/:user_id/subscriptions(.:format)
+    #     open_all_user_subscriptions                       POST   /users/:user_id/subscriptions(.:format)
     #       { controller:"activity_notification/subscriptions", action:"create", target_type:"users" }
-    #     user_subscription           DELETE /users/:user_id/subscriptions/:id(.:format)
+    #     user_subscription                                 DELETE /users/:user_id/subscriptions/:id(.:format)
     #       { controller:"activity_notification/subscriptions", action:"destroy", target_type:"users" }
-    #     open_user_subscription      POST   /users/:user_id/subscriptions/:id/subscribe(.:format)
+    #     subscribe_user_subscription                       POST   /users/:user_id/subscriptions/:id/subscribe(.:format)
     #       { controller:"activity_notification/subscriptions", action:"subscribe", target_type:"users" }
-    #     open_user_subscription      POST   /users/:user_id/subscriptions/:id/unsubscribe(.:format)
+    #     unsubscribe_user_subscription                     POST   /users/:user_id/subscriptions/:id/unsubscribe(.:format)
     #       { controller:"activity_notification/subscriptions", action:"unsubscribe", target_type:"users" }
-    #     open_user_subscription      POST   /users/:user_id/subscriptions/:id/subscribe_to_email(.:format)
+    #     subscribe_to_email_user_subscription              POST   /users/:user_id/subscriptions/:id/subscribe_to_email(.:format)
     #       { controller:"activity_notification/subscriptions", action:"subscribe_to_email", target_type:"users" }
-    #     open_user_subscription      POST   /users/:user_id/subscriptions/:id/unsubscribe_to_email(.:format)
+    #     unsubscribe_to_email_user_subscription            POST   /users/:user_id/subscriptions/:id/unsubscribe_to_email(.:format)
     #       { controller:"activity_notification/subscriptions", action:"unsubscribe_to_email", target_type:"users" }
+    #     subscribe_to_optional_target_user_subscription    POST   /users/:user_id/subscriptions/:id/subscribe_to_optional_target(.:format)
+    #       { controller:"activity_notification/subscriptions", action:"subscribe_to_optional_target", target_type:"users" }
+    #     unsubscribe_to_optional_target_user_subscription  POST   /users/:user_id/subscriptions/:id/unsubscribe_to_optional_target(.:format)
+    #       { controller:"activity_notification/subscriptions", action:"unsubscribe_to_optional_target", target_type:"users" }
     #
     # When you use devise authentication and you want make subscription targets assciated with devise,
     # you can create as follows in your routes:
     #   notify_to :users, with_devise: :users
     # This with_devise option creates the needed routes assciated with devise authentication:
     #   # Subscription with devise routes
-    #     user_subscriptions          GET    /users/:user_id/subscriptions(.:format)
+    #     user_subscriptions                                GET    /users/:user_id/subscriptions(.:format)
     #       { controller:"activity_notification/subscriptions_with_devise", action:"index", target_type:"users", devise_type:"users" }
-    #     user_subscription           GET    /users/:user_id/subscriptions/:id(.:format)
+    #     user_subscription                                 GET    /users/:user_id/subscriptions/:id(.:format)
     #       { controller:"activity_notification/subscriptions_with_devise", action:"show", target_type:"users", devise_type:"users" }
-    #     open_all_user_subscriptions POST   /users/:user_id/subscriptions(.:format)
+    #     open_all_user_subscriptions                       POST   /users/:user_id/subscriptions(.:format)
     #       { controller:"activity_notification/subscriptions_with_devise", action:"create", target_type:"users", devise_type:"users" }
-    #     user_subscription           DELETE /users/:user_id/subscriptions/:id(.:format)
+    #     user_subscription                                 DELETE /users/:user_id/subscriptions/:id(.:format)
     #       { controller:"activity_notification/subscriptions_with_devise", action:"destroy", target_type:"users", devise_type:"users" }
-    #     open_user_subscription      POST   /users/:user_id/subscriptions/:id/subscribe(.:format)
+    #     subscribe_user_subscription                       POST   /users/:user_id/subscriptions/:id/subscribe(.:format)
     #       { controller:"activity_notification/subscriptions_with_devise", action:"subscribe", target_type:"users", devise_type:"users" }
-    #     open_user_subscription      POST   /users/:user_id/subscriptions/:id/unsubscribe(.:format)
+    #     unsubscribe_user_subscription                     POST   /users/:user_id/subscriptions/:id/unsubscribe(.:format)
     #       { controller:"activity_notification/subscriptions_with_devise", action:"unsubscribe", target_type:"users", devise_type:"users" }
-    #     open_user_subscription      POST   /users/:user_id/subscriptions/:id/subscribe_to_email(.:format)
+    #     subscribe_to_email_user_subscription              POST   /users/:user_id/subscriptions/:id/subscribe_to_email(.:format)
     #       { controller:"activity_notification/subscriptions_with_devise", action:"subscribe_to_email", target_type:"users", devise_type:"users" }
-    #     open_user_subscription      POST   /users/:user_id/subscriptions/:id/unsubscribe_to_email(.:format)
+    #     unsubscribe_to_email_user_subscription            POST   /users/:user_id/subscriptions/:id/unsubscribe_to_email(.:format)
     #       { controller:"activity_notification/subscriptions_with_devise", action:"unsubscribe_to_email", target_type:"users", devise_type:"users" }
+    #     subscribe_to_optional_target_user_subscription    POST   /users/:user_id/subscriptions/:id/subscribe_to_optional_target(.:format)
+    #       { controller:"activity_notification/subscriptions_with_devise", action:"subscribe_to_optional_target", target_type:"users", devise_type:"users" }
+    #     unsubscribe_to_optional_target_user_subscription  POST   /users/:user_id/subscriptions/:id/unsubscribe_to_optional_target(.:format)
+    #       { controller:"activity_notification/subscriptions_with_devise", action:"unsubscribe_to_optional_target", target_type:"users", devise_type:"users" }
     #
     # @example Define subscribed_by in config/routes.rb
     #   subscribed_by :users
@@ -168,10 +176,12 @@ module ActionDispatch::Routing
           resources_options = options.select { |key, _| [:with_devise, :model, :devise_defaults].exclude? key }
           self.resources options[:model], resources_options do
             member do
-              post :subscribe            unless ignore_path?(:subscribe, options)
-              post :unsubscribe          unless ignore_path?(:unsubscribe, options)
-              post :subscribe_to_email   unless ignore_path?(:subscribe_to_email, options)
-              post :unsubscribe_to_email unless ignore_path?(:unsubscribe_to_email, options)
+              post :subscribe                      unless ignore_path?(:subscribe, options)
+              post :unsubscribe                    unless ignore_path?(:unsubscribe, options)
+              post :subscribe_to_email             unless ignore_path?(:subscribe_to_email, options)
+              post :unsubscribe_to_email           unless ignore_path?(:unsubscribe_to_email, options)
+              post :subscribe_to_optional_target   unless ignore_path?(:subscribe_to_optional_target, options)
+              post :unsubscribe_to_optional_target unless ignore_path?(:unsubscribe_to_optional_target, options)
             end
           end
         end

data/lib/activity_notification/roles/acts_as_notifiable.rb

@@ -118,14 +118,39 @@ module ActivityNotification
       # * :dependent_notifications
       #   * Dependency for notifications to delete generated notifications with this notifiable.
       #     This option is used to configure generated_notifications_as_notifiable association.
-      #     You can use :delete_all, :destroy, or :nullify for this option.
-      #     This parameter is a optional since no dependent option is used as default.
+      #     You can use :delete_all, :destroy, :restrict_with_error, :restrict_with_exception, :update_group_and_delete_all or :update_group_and_destroy for this option.
+      #     When you use :update_group_and_delete_all or :update_group_and_destroy to this parameter, the oldest group member notification becomes a new group owner as `before_destroy` of this Notifiable.
+      #     This parameter is effective for all target and is a optional since no dependent option is used as default.
       # @example Define :delete_all dependency to generated notifications
       #   # app/models/comment.rb
       #   class Comment < ActiveRecord::Base
       #     acts_as_notifiable :users, targets: User.all, dependent_notifications: :delete_all
       #   end
       #
+      # * :optional_targets
+      #   * Optional targets to integrate external notification serveces like Amazon SNS or Slack.
+      #     You can use hash of optional target implementation class as key and initializing parameters as value for this parameter.
+      #     When the hash parameter is passed, acts_as_notifiable will create new instance of optional target class and call initialize_target method with initializing parameters, then configure them as optional_targets for this notifiable and target.
+      #     You can also use symbol of method name or lambda function which returns array of initialized optional target intstances.
+      #     All optional target class must extends ActivityNotification::OptionalTarget::Base.
+      #     This parameter is completely optional.
+      # @example Define to integrate with Amazon SNS, Slack and your custom ConsoleOutput targets
+      #   # app/models/comment.rb
+      #   class Comment < ActiveRecord::Base
+      #     require 'activity_notification/optional_targets/amazon_sns'
+      #     require 'activity_notification/optional_targets/slack'
+      #     require 'custom_optional_targets/console_output'
+      #     acts_as_notifiable :admins, targets: Admin.all,
+      #       optional_targets: {
+      #         ActivityNotification::OptionalTarget::AmazonSNS => { topic_arn: '<Topin ARN of yours>' },
+      #         ActivityNotification::OptionalTarget::Slack  => {
+      #           webhook_url: '<Slack Webhook URL>',
+      #           slack_name: :slack_name, channel: 'activity_notification', username: 'ActivityNotification', icon_emoji: ":ghost:"
+      #         },
+      #         CustomOptionalTarget::ConsoleOutput => {}
+      #       }
+      #   end
+      #
       # @param [Symbol] target_type Type of notification target as symbol
       # @param [Hash] options Options for notifiable model configuration
       # @option options [Symbol, Proc, Array]   :targets                 (nil)                    Targets to send notifications
@@ -136,21 +161,42 @@ module ActivityNotification
       # @option options [Symbol, Proc, Boolean] :email_allowed           (ActivityNotification.config.email_enabled) Whether activity_notification sends notification email
       # @option options [Symbol, Proc, String]  :notifiable_path         (polymorphic_path(self)) Path to redirect from open or move action of notification controller
       # @option options [Symbol, Proc, String]  :printable_name          (ActivityNotification::Common.printable_name) Printable notifiable name
-      # @option options [Symbol, Proc]          :dependent_notifications (nil)                    Dependency for notifications to delete generated notifications with this notifiable
+      # @option options [Symbol, Proc]          :dependent_notifications (nil)                    Dependency for notifications to delete generated notifications with this notifiable, [:delete_all, :destroy, :restrict_with_error, :restrict_with_exception, :update_group_and_delete_all, :update_group_and_destroy] are available
+      # @option options [Hash<Class, Hash>]     :optional_targets        (nil)                    Optional target configurations with hash of `OptionalTarget` implementation class as key and initializing option parameter as value
       # @return [Hash] Configured parameters as notifiable model
       def acts_as_notifiable(target_type, options = {})
         include Notifiable
+        configured_params = {}
 
-        if [:delete_all, :destroy, :nullify].include? options[:dependent_notifications] 
-          has_many :generated_notifications_as_notifiable,
-            class_name: "::ActivityNotification::Notification",
-            as: :notifiable,
-            dependent: options[:dependent_notifications]
+        if [:delete_all, :destroy, :restrict_with_error, :restrict_with_exception, :update_group_and_delete_all, :update_group_and_destroy].include? options[:dependent_notifications]
+          case options[:dependent_notifications]
+          when :delete_all, :destroy, :restrict_with_error, :restrict_with_exception
+            has_many_generated_notifications options[:dependent_notifications]
+          when :update_group_and_delete_all
+            before_destroy :remove_generated_notifications_from_group
+            has_many_generated_notifications :delete_all
+          when :update_group_and_destroy
+            before_destroy :remove_generated_notifications_from_group
+            has_many_generated_notifications :destroy
+          end
+          configured_params = { dependent_notifications: options[:dependent_notifications] }
+        end
+
+        if options[:optional_targets].is_a?(Hash)
+          options[:optional_targets] = options[:optional_targets].map { |target_class, target_options|
+            optional_target = target_class.new
+            unless optional_target.kind_of?(ActivityNotification::OptionalTarget::Base)
+              raise TypeError, "#{optional_target.class.name} for an optional target is not a kind of ActivityNotification::OptionalTarget::Base"
+            end
+            optional_target.initialize_target(target_options)
+            optional_target
+          }
         end
 
         options[:printable_notifiable_name] ||= options.delete(:printable_name)
-        set_acts_as_parameters_for_target(target_type, [:targets, :group, :group_expiry_delay, :parameters, :email_allowed], options, "notification_")
-          .merge set_acts_as_parameters_for_target(target_type, [:notifier, :notifiable_path, :printable_notifiable_name], options)
+        configured_params
+          .merge set_acts_as_parameters_for_target(target_type, [:targets, :group, :group_expiry_delay, :parameters, :email_allowed], options, "notification_")
+          .merge set_acts_as_parameters_for_target(target_type, [:notifier, :notifiable_path, :printable_notifiable_name, :optional_targets], options)
       end
 
       # Returns array of available notifiable options in acts_as_notifiable.
@@ -164,9 +210,22 @@ module ActivityNotification
           :email_allowed,
           :notifiable_path,
           :printable_notifiable_name, :printable_name,
-          :dependent_notifications
+          :dependent_notifications,
+          :optional_targets
         ].freeze
       end
+
+      private
+
+        # Define to have many notification instances for this notifiable with dependent option.
+        # @api private
+        def has_many_generated_notifications(dependent_option)
+          has_many :generated_notifications_as_notifiable,
+            class_name: "::ActivityNotification::Notification",
+            as: :notifiable,
+            dependent: dependent_option
+        end
+
     end
   end
 end