activity_notification 1.7.1 → 2.0.0

data/gemfiles/Gemfile.rails-5.0

@@ -3,6 +3,7 @@ source 'https://rubygems.org'
 gemspec path: '../'
 
 gem 'rails', '~> 5.0.0'
+gem 'sqlite3', '~> 1.3.13'
 
 group :development do
   gem 'bullet'
@@ -10,6 +11,7 @@ end
 
 group :test do
   gem 'rails-controller-testing'
+  gem 'action-cable-testing'
   gem 'ammeter'
   gem 'timecop'
   gem 'coveralls', require: false

data/gemfiles/Gemfile.rails-5.1

@@ -10,6 +10,7 @@ end
 
 group :test do
   gem 'rails-controller-testing'
+  gem 'action-cable-testing'
   gem 'ammeter'
   gem 'timecop'
   gem 'coveralls', require: false

data/gemfiles/Gemfile.rails-5.2

@@ -10,6 +10,7 @@ end
 
 group :test do
   gem 'rails-controller-testing'
+  gem 'action-cable-testing'
   gem 'ammeter'
   gem 'timecop'
   gem 'coveralls', require: false

data/gemfiles/Gemfile.rails-6.0.rc

@@ -0,0 +1,21 @@
+source 'https://rubygems.org'
+
+gemspec path: '../'
+
+gem 'rails', '~> 6.0.0.rc2'
+
+group :development do
+  gem 'bullet'
+end
+
+group :test do
+  #TODO https://github.com/rails/rails/issues/35417
+  gem 'rspec-rails', git: 'https://github.com/rspec/rspec-rails', branch: '4-0-dev'
+
+  gem 'rails-controller-testing'
+  gem 'ammeter'
+  gem 'timecop'
+  gem 'coveralls', require: false
+end
+
+gem 'dotenv-rails', groups: [:development, :test]

data/lib/activity_notification.rb

@@ -56,6 +56,7 @@ module ActivityNotification
 end
 
 # Load ActivityNotification helpers
+require 'activity_notification/helpers/errors'
 require 'activity_notification/helpers/polymorphic_helpers'
 require 'activity_notification/helpers/view_helpers'
 require 'activity_notification/controllers/common_controller'

data/lib/activity_notification/apis/notification_api.rb

@@ -10,130 +10,187 @@ module ActivityNotification
       # Defines mailer class to send notification
       set_notification_mailer
 
-      # Selects all notification index.
-      #   ActivityNotification::Notification.all_index!
-      # is defined same as
-      #   ActivityNotification::Notification.group_owners_only.latest_order
-      # @scope class
-      # @example Get all notification index of the @user
-      #   @notifications = @user.notifications.all_index!
-      #   @notifications = @user.notifications.group_owners_only.latest_order
-      # @param [Boolean] reverse If notification index will be ordered as earliest first
-      # @param [Boolean] with_group_members If notification index will include group members
-      # @return [ActiveRecord_AssociationRelation<Notificaion>, Mongoid::Criteria<Notificaion>] Database query of filtered notifications
-      scope :all_index!,                        ->(reverse = false, with_group_members = false) {
-        target_index = with_group_members ? self : group_owners_only
-        reverse ? target_index.earliest_order : target_index.latest_order
-      }
-
-      # Selects unopened notification index.
-      #   ActivityNotification::Notification.unopened_index
-      # is defined same as
-      #   ActivityNotification::Notification.unopened_only.group_owners_only.latest_order
-      # @scope class
-      # @example Get unopened notificaton index of the @user
-      #   @notifications = @user.notifications.unopened_index
-      #   @notifications = @user.notifications.unopened_only.group_owners_only.latest_order
-      # @param [Boolean] reverse If notification index will be ordered as earliest first
-      # @param [Boolean] with_group_members If notification index will include group members
-      # @return [ActiveRecord_AssociationRelation<Notificaion>, Mongoid::Criteria<Notificaion>] Database query of filtered notifications
-      scope :unopened_index,                    ->(reverse = false, with_group_members = false) {
-        target_index = with_group_members ? unopened_only : unopened_only.group_owners_only
-        reverse ? target_index.earliest_order : target_index.latest_order
-      }
-
-      # Selects unopened notification index.
-      #   ActivityNotification::Notification.opened_index(limit)
-      # is defined same as
-      #   ActivityNotification::Notification.opened_only(limit).group_owners_only.latest_order
-      # @scope class
-      # @example Get unopened notificaton index of the @user with limit 10
-      #   @notifications = @user.notifications.opened_index(10)
-      #   @notifications = @user.notifications.opened_only(10).group_owners_only.latest_order
-      # @param [Integer] limit Limit to query for opened notifications
-      # @param [Boolean] reverse If notification index will be ordered as earliest first
-      # @param [Boolean] with_group_members If notification index will include group members
-      # @return [ActiveRecord_AssociationRelation<Notificaion>, Mongoid::Criteria<Notificaion>] Database query of filtered notifications
-      scope :opened_index,                      ->(limit, reverse = false, with_group_members = false) {
-        target_index = with_group_members ? opened_only(limit) : opened_only(limit).group_owners_only
-        reverse ? target_index.earliest_order : target_index.latest_order
-      }
-
-      # Selects filtered notifications by target_type.
-      # @example Get filtered unopened notificatons of User as target type
-      #   @notifications = ActivityNotification.Notification.unopened_only.filtered_by_target_type('User')
-      # @scope class
-      # @param [String] target_type Target type for filter
-      # @return [ActiveRecord_AssociationRelation<Notificaion>, Mongoid::Criteria<Notificaion>] Database query of filtered notifications
-      scope :filtered_by_target_type,           ->(target_type) { where(target_type: target_type) }
-
-      # Selects filtered notifications by notifiable_type.
-      # @example Get filtered unopened notificatons of the @user for Comment notifiable class
-      #   @notifications = @user.notifications.unopened_only.filtered_by_type('Comment')
-      # @scope class
-      # @param [String] notifiable_type Notifiable type for filter
-      # @return [ActiveRecord_AssociationRelation<Notificaion>, Mongoid::Criteria<Notificaion>] Database query of filtered notifications
-      scope :filtered_by_type,                  ->(notifiable_type) { where(notifiable_type: notifiable_type) }
-
-      # Selects filtered notifications by key.
-      # @example Get filtered unopened notificatons of the @user with key 'comment.reply'
-      #   @notifications = @user.notifications.unopened_only.filtered_by_key('comment.reply')
-      # @scope class
-      # @param [String] key Key of the notification for filter
-      # @return [ActiveRecord_AssociationRelation<Notificaion>, Mongoid::Criteria<Notificaion>] Database query of filtered notifications
-      scope :filtered_by_key,                   ->(key) { where(key: key) }
-
-      # Selects filtered notifications by notifiable_type, group or key with filter options.
-      # @example Get filtered unopened notificatons of the @user for Comment notifiable class
-      #   @notifications = @user.notifications.unopened_only.filtered_by_options({ filtered_by_type: 'Comment' })
-      # @example Get filtered unopened notificatons of the @user for @article as group
-      #   @notifications = @user.notifications.unopened_only.filtered_by_options({ filtered_by_group: @article })
-      # @example Get filtered unopened notificatons of the @user for Article instance id=1 as group
-      #   @notifications = @user.notifications.unopened_only.filtered_by_options({ filtered_by_group_type: 'Article', filtered_by_group_id: '1' })
-      # @example Get filtered unopened notificatons of the @user with key 'comment.reply'
-      #   @notifications = @user.notifications.unopened_only.filtered_by_options({ filtered_by_key: 'comment.reply' })
-      # @example Get filtered unopened notificatons of the @user for Comment notifiable class with key 'comment.reply'
-      #   @notifications = @user.notifications.unopened_only.filtered_by_options({ filtered_by_type: 'Comment', filtered_by_key: 'comment.reply' })
-      # @example Get custom filtered notificatons of the @user
-      #   @notifications = @user.notifications.unopened_only.filtered_by_options({ custom_filter: ["created_at >= ?", time.hour.ago] })
-      # @scope class
-      # @param [Hash] options Options for filter
-      # @option options [String]     :filtered_by_type       (nil) Notifiable type for filter
-      # @option options [Object]     :filtered_by_group      (nil) Group instance for filter
-      # @option options [String]     :filtered_by_group_type (nil) Group type for filter, valid with :filtered_by_group_id
-      # @option options [String]     :filtered_by_group_id   (nil) Group instance id for filter, valid with :filtered_by_group_type
-      # @option options [String]     :filtered_by_key        (nil) Key of the notification for filter
-      # @option options [Array|Hash] :custom_filter          (nil) Custom notification filter (e.g. ["created_at >= ?", time.hour.ago])
-      # @return [ActiveRecord_AssociationRelation<Notificaion>, Mongoid::Criteria<Notificaion>] Database query of filtered notifications
-      scope :filtered_by_options,               ->(options = {}) {
-        options = ActivityNotification.cast_to_indifferent_hash(options)
-        filtered_notifications = all
-        if options.has_key?(:filtered_by_type)
-          filtered_notifications = filtered_notifications.filtered_by_type(options[:filtered_by_type])
-        end
-        if options.has_key?(:filtered_by_group)
-          filtered_notifications = filtered_notifications.filtered_by_group(options[:filtered_by_group])
-        end
-        if options.has_key?(:filtered_by_group_type) && options.has_key?(:filtered_by_group_id)
-          filtered_notifications = filtered_notifications
-                                   .where(group_type: options[:filtered_by_group_type], group_id: options[:filtered_by_group_id])
+      # :only-rails5-plus#only-rails-with-callback-issue#except-dynamoid:
+      # :only-rails5-plus#only-rails-without-callback-issue#except-dynamoid:
+      # :except-rails5-plus#only-rails-with-callback-issue#except-dynamoid:
+      # :except-rails5-plus#only-rails-without-callback-issue#except-dynamoid:
+      unless ActivityNotification.config.orm == :dynamoid
+        # Selects all notification index.
+        #   ActivityNotification::Notification.all_index!
+        # is defined same as
+        #   ActivityNotification::Notification.group_owners_only.latest_order
+        # @scope class
+        # @example Get all notification index of the @user
+        #   @notifications = @user.notifications.all_index!
+        #   @notifications = @user.notifications.group_owners_only.latest_order
+        # @param [Boolean] reverse If notification index will be ordered as earliest first
+        # @param [Boolean] with_group_members If notification index will include group members
+        # @return [ActiveRecord_AssociationRelation<Notificaion>, Mongoid::Criteria<Notificaion>] Database query of filtered notifications
+        scope :all_index!,                        ->(reverse = false, with_group_members = false) {
+          target_index = with_group_members ? self : group_owners_only
+          reverse ? target_index.earliest_order : target_index.latest_order
+        }
+
+        # Selects unopened notification index.
+        #   ActivityNotification::Notification.unopened_index
+        # is defined same as
+        #   ActivityNotification::Notification.unopened_only.group_owners_only.latest_order
+        # @scope class
+        # @example Get unopened notificaton index of the @user
+        #   @notifications = @user.notifications.unopened_index
+        #   @notifications = @user.notifications.unopened_only.group_owners_only.latest_order
+        # @param [Boolean] reverse If notification index will be ordered as earliest first
+        # @param [Boolean] with_group_members If notification index will include group members
+        # @return [ActiveRecord_AssociationRelation<Notificaion>, Mongoid::Criteria<Notificaion>] Database query of filtered notifications
+        scope :unopened_index,                    ->(reverse = false, with_group_members = false) {
+          target_index = with_group_members ? unopened_only : unopened_only.group_owners_only
+          reverse ? target_index.earliest_order : target_index.latest_order
+        }
+
+        # Selects unopened notification index.
+        #   ActivityNotification::Notification.opened_index(limit)
+        # is defined same as
+        #   ActivityNotification::Notification.opened_only(limit).group_owners_only.latest_order
+        # @scope class
+        # @example Get unopened notificaton index of the @user with limit 10
+        #   @notifications = @user.notifications.opened_index(10)
+        #   @notifications = @user.notifications.opened_only(10).group_owners_only.latest_order
+        # @param [Integer] limit Limit to query for opened notifications
+        # @param [Boolean] reverse If notification index will be ordered as earliest first
+        # @param [Boolean] with_group_members If notification index will include group members
+        # @return [ActiveRecord_AssociationRelation<Notificaion>, Mongoid::Criteria<Notificaion>] Database query of filtered notifications
+        scope :opened_index,                      ->(limit, reverse = false, with_group_members = false) {
+          target_index = with_group_members ? opened_only(limit) : opened_only(limit).group_owners_only
+          reverse ? target_index.earliest_order : target_index.latest_order
+        }
+
+        # Selects filtered notifications by target_type.
+        # @example Get filtered unopened notificatons of User as target type
+        #   @notifications = ActivityNotification.Notification.unopened_only.filtered_by_target_type('User')
+        # @scope class
+        # @param [String] target_type Target type for filter
+        # @return [ActiveRecord_AssociationRelation<Notificaion>, Mongoid::Criteria<Notificaion>] Database query of filtered notifications
+        scope :filtered_by_target_type,           ->(target_type) { where(target_type: target_type) }
+
+        # Selects filtered notifications by notifiable_type.
+        # @example Get filtered unopened notificatons of the @user for Comment notifiable class
+        #   @notifications = @user.notifications.unopened_only.filtered_by_type('Comment')
+        # @scope class
+        # @param [String] notifiable_type Notifiable type for filter
+        # @return [ActiveRecord_AssociationRelation<Notificaion>, Mongoid::Criteria<Notificaion>] Database query of filtered notifications
+        scope :filtered_by_type,                  ->(notifiable_type) { where(notifiable_type: notifiable_type) }
+
+        # Selects filtered notifications by key.
+        # @example Get filtered unopened notificatons of the @user with key 'comment.reply'
+        #   @notifications = @user.notifications.unopened_only.filtered_by_key('comment.reply')
+        # @scope class
+        # @param [String] key Key of the notification for filter
+        # @return [ActiveRecord_AssociationRelation<Notificaion>, Mongoid::Criteria<Notificaion>] Database query of filtered notifications
+        scope :filtered_by_key,                   ->(key) { where(key: key) }
+
+        # Selects filtered notifications by notifiable_type, group or key with filter options.
+        # @example Get filtered unopened notificatons of the @user for Comment notifiable class
+        #   @notifications = @user.notifications.unopened_only.filtered_by_options({ filtered_by_type: 'Comment' })
+        # @example Get filtered unopened notificatons of the @user for @article as group
+        #   @notifications = @user.notifications.unopened_only.filtered_by_options({ filtered_by_group: @article })
+        # @example Get filtered unopened notificatons of the @user for Article instance id=1 as group
+        #   @notifications = @user.notifications.unopened_only.filtered_by_options({ filtered_by_group_type: 'Article', filtered_by_group_id: '1' })
+        # @example Get filtered unopened notificatons of the @user with key 'comment.reply'
+        #   @notifications = @user.notifications.unopened_only.filtered_by_options({ filtered_by_key: 'comment.reply' })
+        # @example Get filtered unopened notificatons of the @user for Comment notifiable class with key 'comment.reply'
+        #   @notifications = @user.notifications.unopened_only.filtered_by_options({ filtered_by_type: 'Comment', filtered_by_key: 'comment.reply' })
+        # @example Get custom filtered notificatons of the @user
+        #   @notifications = @user.notifications.unopened_only.filtered_by_options({ custom_filter: ["created_at >= ?", time.hour.ago] })
+        # @scope class
+        # @param [Hash] options Options for filter
+        # @option options [String]     :filtered_by_type       (nil) Notifiable type for filter
+        # @option options [Object]     :filtered_by_group      (nil) Group instance for filter
+        # @option options [String]     :filtered_by_group_type (nil) Group type for filter, valid with :filtered_by_group_id
+        # @option options [String]     :filtered_by_group_id   (nil) Group instance id for filter, valid with :filtered_by_group_type
+        # @option options [String]     :filtered_by_key        (nil) Key of the notification for filter
+        # @option options [Array|Hash] :custom_filter          (nil) Custom notification filter (e.g. ["created_at >= ?", time.hour.ago] with ActiveRecord or {:created_at.gt => time.hour.ago} with Mongoid)
+        # @return [ActiveRecord_AssociationRelation<Notificaion>, Mongoid::Criteria<Notificaion>] Database query of filtered notifications
+        scope :filtered_by_options,               ->(options = {}) {
+          options = ActivityNotification.cast_to_indifferent_hash(options)
+          filtered_notifications = all
+          if options.has_key?(:filtered_by_type)
+            filtered_notifications = filtered_notifications.filtered_by_type(options[:filtered_by_type])
+          end
+          if options.has_key?(:filtered_by_group)
+            filtered_notifications = filtered_notifications.filtered_by_group(options[:filtered_by_group])
+          end
+          if options.has_key?(:filtered_by_group_type) && options.has_key?(:filtered_by_group_id)
+            filtered_notifications = filtered_notifications
+                                     .where(group_type: options[:filtered_by_group_type], group_id: options[:filtered_by_group_id])
+          end
+          if options.has_key?(:filtered_by_key)
+            filtered_notifications = filtered_notifications.filtered_by_key(options[:filtered_by_key])
+          end
+          if options.has_key?(:custom_filter)
+            filtered_notifications = filtered_notifications.where(options[:custom_filter])
+          end
+          filtered_notifications
+        }
+
+        # Orders by latest (newest) first as created_at: :desc.
+        # @return [ActiveRecord_AssociationRelation<Notificaion>, Mongoid::Criteria<Notificaion>] Database query of notifications ordered by latest first
+        scope :latest_order,                      -> { order(created_at: :desc) }
+
+        # Orders by earliest (older) first as created_at: :asc.
+        # @return [ActiveRecord_AssociationRelation<Notificaion>, Mongoid::Criteria<Notificaion>] Database query of notifications ordered by earliest first
+        scope :earliest_order,                    -> { order(created_at: :asc) }
+
+        # Orders by latest (newest) first as created_at: :desc.
+        # This method is to be overridden in implementation for each ORM.
+        # @param [Boolean] reverse If notifications will be ordered as earliest first
+        # @return [ActiveRecord_AssociationRelation<Notificaion>, Mongoid::Criteria<Notificaion>] Database query of ordered notifications
+        scope :latest_order!,                     ->(reverse = false) { reverse ? earliest_order : latest_order }
+
+        # Orders by earliest (older) first as created_at: :asc.
+        # This method is to be overridden in implementation for each ORM.
+        # @return [ActiveRecord_AssociationRelation<Notificaion>, Mongoid::Criteria<Notificaion>] Database query of notifications ordered by earliest first
+        scope :earliest_order!,                   -> { earliest_order }
+
+        # Returns latest notification instance.
+        # @return [Notification] Latest notification instance
+        def self.latest
+          latest_order.first
         end
-        if options.has_key?(:filtered_by_key)
-          filtered_notifications = filtered_notifications.filtered_by_key(options[:filtered_by_key])
+
+        # Returns earliest notification instance.
+        # @return [Notification] Earliest notification instance
+        def self.earliest
+          earliest_order.first
         end
-        if options.has_key?(:custom_filter)
-          filtered_notifications = filtered_notifications.where(options[:custom_filter])
+
+        # Returns latest notification instance.
+        # This method is to be overridden in implementation for each ORM.
+        # @return [Notification] Latest notification instance
+        def self.latest!
+          latest
         end
-        filtered_notifications
-      }
 
-      # Orders by latest (newest) first as created_at: :desc.
-      # @return [ActiveRecord_AssociationRelation<Notificaion>, Mongoid::Criteria<Notificaion>] Database query of notifications ordered by latest first
-      scope :latest_order,                      -> { order(created_at: :desc) }
+        # Returns earliest notification instance.
+        # This method is to be overridden in implementation for each ORM.
+        # @return [Notification] Earliest notification instance
+        def self.earliest!
+          earliest
+        end
 
-      # Orders by earliest (older) first as created_at: :asc.
-      # @return [ActiveRecord_AssociationRelation<Notificaion>, Mongoid::Criteria<Notificaion>] Database query of notifications ordered by earliest first
-      scope :earliest_order,                    -> { order(created_at: :asc) }
+        # Selects unique keys from query for notifications.
+        # @return [Array<String>] Array of notification unique keys
+        def self.uniq_keys
+          ## select method cannot be chained with order by other columns like created_at
+          # select(:key).distinct.pluck(:key)
+          ## distinct method cannot keep original sort
+          # distinct(:key)
+          pluck(:key).uniq
+        end
+      end
+      # :only-rails5-plus#only-rails-with-callback-issue#except-dynamoid:
+      # :only-rails5-plus#only-rails-without-callback-issue#except-dynamoid:
+      # :except-rails5-plus#only-rails-with-callback-issue#except-dynamoid:
+      # :except-rails5-plus#only-rails-without-callback-issue#except-dynamoid:
     end
 
     class_methods do
@@ -160,6 +217,8 @@ module ActivityNotification
       # @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]                 :broadcast_action_cable   (true)                                Whether it broadcasts notification to ActionCable channel
+      # @option options [Hash]                    :action_cable_rendering   ({fallback: :default})                Options for rendering params used by ActionCable, e.g. {fallback: :text} or {fallback: :default} etc. See also Renderable#render.
       # @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
@@ -198,6 +257,8 @@ module ActivityNotification
       # @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]                 :broadcast_action_cable   (true)                                Whether it broadcasts notification to ActionCable channel
+      # @option options [Hash]                    :action_cable_rendering   ({fallback: :default})                Options for rendering params used by ActionCable, e.g. {fallback: :text} or {fallback: :default} etc. See also Renderable#render.
       # @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
@@ -224,6 +285,8 @@ module ActivityNotification
       # @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]                 :broadcast_action_cable   (true)                                Whether it broadcasts notification to ActionCable channel
+      # @option options [Hash]                    :action_cable_rendering   ({fallback: :default})                Options for rendering params used by ActionCable, e.g. {fallback: :text} or {fallback: :default} etc. See also Renderable#render.
       # @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
@@ -251,6 +314,8 @@ module ActivityNotification
       # @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]                 :broadcast_action_cable   (true)                                Whether it broadcasts notification to ActionCable channel
+      # @option options [Hash]                    :action_cable_rendering   ({fallback: :default})                Options for rendering params used by ActionCable, e.g. {fallback: :text} or {fallback: :default} etc. See also Renderable#render.
       # @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
@@ -275,6 +340,8 @@ module ActivityNotification
       # @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]                 :broadcast_action_cable   (true)                                Whether it broadcasts notification to ActionCable channel
+      # @option options [Hash]                    :action_cable_rendering   ({fallback: :default})                Options for rendering params used by ActionCable, e.g. {fallback: :text} or {fallback: :default} etc. See also Renderable#render.
       # @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
@@ -282,8 +349,9 @@ module ActivityNotification
         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
+          send_email               = options.has_key?(:send_email)               ? options[:send_email]               : true
+          send_later               = options.has_key?(:send_later)               ? options[:send_later]               : true
+          broadcast_action_cable   = options.has_key?(:broadcast_action_cable)   ? options[:broadcast_action_cable]   : true
           publish_optional_targets = options.has_key?(:publish_optional_targets) ? options[:publish_optional_targets] : true
           # Generate notification
           notification = generate_notification(target, notifiable, options)
@@ -291,6 +359,12 @@ module ActivityNotification
           if notification.present? && send_email
             notification.send_notification_email({ send_later: send_later })
           end
+          # Broadcast to ActionCable subscribers
+          if notification.present? && broadcast_action_cable
+            action_cable_rendering_options = options[:action_cable_rendering] || {}
+            action_cable_rendering_options[:fallback] = action_cable_rendering_options[:fallback] || :default
+            notification.broadcast_to_action_cable_channel(action_cable_rendering_options)
+          end
           # Publish to optional targets
           if notification.present? && publish_optional_targets
             notification.publish_to_optional_targets(options[:optional_targets] || {})
@@ -316,6 +390,8 @@ module ActivityNotification
       # @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]                 :broadcast_action_cable   (true)                                Whether it broadcast∂s notification to ActionCable channel
+      # @option options [Hash]                    :action_cable_rendering   ({fallback: :default})                Options for rendering params used by ActionCable, e.g. {fallback: :text} or {fallback: :default} etc. See also Renderable#render.
       # @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
@@ -336,7 +412,7 @@ module ActivityNotification
         key = options[:key] || notifiable.default_notification_key
         if target.subscribes_to_notification?(key)
           # Store notification
-          store_notification(target, notifiable, key, options)
+          notification = store_notification(target, notifiable, key, options)
         end
       end
 
@@ -366,7 +442,7 @@ module ActivityNotification
       # @param [Array<Notificaion>, ActiveRecord_AssociationRelation<Notificaion>, Mongoid::Criteria<Notificaion>] notifications Array or database query of the notifications to test member exists
       # @return [Boolean] If group member of the notifications exists
       def group_member_exists?(notifications)
-        notifications.present? && group_members_of_owner_ids_only(notifications.map(&:id)).exists?
+        notifications.present? and group_members_of_owner_ids_only(notifications.map(&:id)).exists?
       end
 
       # Sends batch notification email to the target.
@@ -394,7 +470,7 @@ module ActivityNotification
       #
       # @return [Array<Notificaion>] Available options for kinds of notify methods
       def available_options
-        [:key, :group, :parameters, :notifier, :send_email, :send_later].freeze
+        [:key, :group, :group_expiry_delay, :notifier, :parameters, :send_email, :send_later].freeze
       end
 
       # Defines mailer class to send notification
@@ -402,6 +478,25 @@ module ActivityNotification
         @@notification_mailer = ActivityNotification.config.mailer.constantize
       end
 
+      # Returns valid group owner within the expiration period
+      #
+      # @param [Object]                  target             Target to send notifications
+      # @param [Object]                  notifiable         Notifiable instance
+      # @param [String]                  key                Key of the notification
+      # @param [Object]                  group              Group unit of the notifications
+      # @param [ActiveSupport::Duration] group_expiry_delay Expiry period of a notification group
+      # @return [Notificaion] Valid group owner within the expiration period
+      def valid_group_owner(target, notifiable, key, group, group_expiry_delay)
+        return nil if group.blank?
+        # Bundle notification group by target, notifiable_type, group and key
+        # Different notifiable.id can be made in a same group
+        group_owner_notifications = filtered_by_target(target).filtered_by_type(notifiable.to_class_name).filtered_by_key(key)
+                                   .filtered_by_group(group).group_owners_only.unopened_only
+        group_expiry_delay.present? ?
+          group_owner_notifications.within_expiration_only(group_expiry_delay).earliest :
+          group_owner_notifications.earliest
+      end
+
       # Stores notifications to datastore
       # @api private
       def store_notification(target, notifiable, key, options = {})
@@ -412,20 +507,20 @@ module ActivityNotification
         parameters         = options[:parameters]         || {}
         parameters.merge!(options.except(*available_options))
         parameters.merge!(notifiable.notification_parameters(target_type, key))
+        group_owner = valid_group_owner(target, notifiable, key, group, group_expiry_delay)
 
-        # Bundle notification group by target, notifiable_type, group and key
-        # Different notifiable.id can be made in a same group
-        group_owner_notifications = filtered_by_target(target).filtered_by_type(notifiable.to_class_name).filtered_by_key(key)
-                                   .filtered_by_group(group).group_owners_only.unopened_only
-        group_owner = group_expiry_delay.present? ?
-                        group_owner_notifications.within_expiration_only(group_expiry_delay).earliest :
-                        group_owner_notifications.earliest
-        notification_fields = { target: target, notifiable: notifiable, key: key, group: group, parameters: parameters, notifier: notifier }
-        notification_fields = notification_fields.merge(group_owner: group_owner) if group.present? && group_owner.present?
-        create(notification_fields)
+        notification = new({ target: target, notifiable: notifiable, key: key, group: group, parameters: parameters, notifier: notifier, group_owner: group_owner })
+        notification.prepare_to_store.save
+        notification
       end
     end
 
+    # Returns prepared notification object to store
+    # @return [Object] prepared notification object to store
+    def prepare_to_store
+      self
+    end
+
     # Sends notification email to the target.
     #
     # @param [Hash] options Options for notification email
@@ -443,6 +538,64 @@ module ActivityNotification
       end
     end
 
+    # :only-rails5-plus#only-rails-with-callback-issue:
+    # :only-rails5-plus#only-rails-without-callback-issue:
+    # :only-rails5-plus#only-rails-with-callback-issue#except-dynamoid:
+    # :only-rails5-plus#only-rails-without-callback-issue#except-dynamoid:
+    if Rails::VERSION::MAJOR >= 5
+      # Broadcast to ActionCable subscribers
+      # @param [Hash] params Parameters for rendering notifications
+      # @option params [String, Symbol] :target                 (nil)                     Target type name to find template or i18n text
+      # @option params [String]         :partial_root           ("activity_notification/notifications/#{target}", controller.target_view_path, 'activity_notification/notifications/default') Partial template name
+      # @option params [String]         :partial                (self.key.tr('.', '/'))   Root path of partial template
+      # @option params [String]         :layout                 (nil)                     Layout template name
+      # @option params [String]         :layout_root            ('layouts')               Root path of layout template
+      # @option params [String, Symbol] :fallback               (nil)                     Fallback template to use when MissingTemplate is raised. Set :text to use i18n text as fallback.
+      # @option params [String]         :filter                 (nil)                     Filter option to load notification index (Nothing as auto, 'opened' or 'unopened')
+      # @option params [String]         :limit                  (nil)                     Limit to query for notifications
+      # @option params [String]         :without_grouping       ('false')                 If notification index will include group members
+      # @option params [String]         :with_group_members     ('false')                 If notification index will include group members
+      # @option params [String]         :filtered_by_type       (nil)                     Notifiable type for filter
+      # @option params [String]         :filtered_by_group_type (nil)                     Group type for filter, valid with :filtered_by_group_id
+      # @option params [String]         :filtered_by_group_id   (nil)                     Group instance id for filter, valid with :filtered_by_group_type
+      # @option params [String]         :filtered_by_key        (nil)                     Key of the notification for filter
+      # @option params [Hash]           others                                            Parameters to be set as locals
+      def broadcast_to_action_cable_channel(params = {})
+        if target.notification_action_cable_allowed?(notifiable, key) &&
+          notifiable.notification_action_cable_allowed?(target, key)
+          target_channel_name = "#{ActivityNotification.config.notification_channel_prefix}_#{target_type}#{ActivityNotification.config.composite_key_delimiter}#{target_id}"
+          index_options = params.slice(:filter, :limit, :without_grouping, :with_group_members, :filtered_by_type, :filtered_by_group_type, :filtered_by_group_id, :filtered_by_key)
+          ActionCable.server.broadcast(target_channel_name,
+            id:                          id,
+            view:                        render(ActivityNotification::NotificationsController.renderer, params),
+            text:                        text(params),
+            notifiable_path:             notifiable_path,
+            group_owner_id:              group_owner_id,
+            group_owner_view:            group_owner? ? nil : group_owner.render(ActivityNotification::NotificationsController.renderer, params),
+            unopened_notification_count: target.unopened_notification_count(index_options)
+          )
+        end
+      end
+    # :only-rails5-plus#only-rails-with-callback-issue:
+    # :only-rails5-plus#only-rails-without-callback-issue:
+    # :only-rails5-plus#only-rails-with-callback-issue#except-dynamoid:
+    # :only-rails5-plus#only-rails-without-callback-issue#except-dynamoid:
+    # :except-rails5-plus#only-rails-with-callback-issue:
+    # :except-rails5-plus#only-rails-without-callback-issue:
+    # :except-rails5-plus#only-rails-with-callback-issue#except-dynamoid:
+    # :except-rails5-plus#only-rails-without-callback-issue#except-dynamoid:
+    else
+      # Broadcast to ActionCable subscribers
+      # Do nothing with Rails < 5.0
+      # @param [Hash] params Parameters for rendering notifications
+      def broadcast_to_action_cable_channel(params = {})
+      end
+    end
+    # :except-rails5-plus#only-rails-with-callback-issue:
+    # :except-rails5-plus#only-rails-without-callback-issue:
+    # :except-rails5-plus#only-rails-with-callback-issue#except-dynamoid:
+    # :except-rails5-plus#only-rails-without-callback-issue#except-dynamoid:
+
     # Publishes notification to the optional targets.
     #
     # @param [Hash] options Options for optional targets
@@ -611,13 +764,13 @@ module ActivityNotification
       target.subscribes_to_optional_target?(key, optional_target_name)
     end
 
-    # Returns optional_targets of the notification from configured field or overriden method.
+    # Returns optional_targets of the notification from configured field or overridden 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.
+    # Returns optional_target names of the notification from configured field or overridden method.
     # @return [Array<Symbol>] Array of optional target names
     def optional_target_names
       notifiable.optional_target_names(target.to_resources_name, key)