activity_notification 1.0.0 → 1.0.1

data/lib/activity_notification/helpers/view_helpers.rb

@@ -32,27 +32,36 @@ module ActivityNotification
     #
     # @param [Object] target Target instance of the rendering notifications
     # @param [Hash] options Options for rendering notifications
-    # @option options [String, Symbol] :target               (nil)       Target type name to find template or i18n text
-    # @option options [String]         :partial_root         ("activity_notification/notifications/#{target.to_resources_name}", 'activity_notification/notifications/default') Root path of partial template
-    # @option options [String]         :notification_partial ("activity_notification/notifications/#{target.to_resources_name}", controller.target_view_path, 'activity_notification/notifications/default') Partial template name of the notification index content
-    # @option options [String]         :layout_root          ('layouts') Root path of layout template
-    # @option options [String]         :notification_layout  (nil)       Layout template name of the notification index content
-    # @option options [String]         :fallback             (nil)       Fallback template to use when MissingTemplate is raised. Set :text to use i18n text as fallback.
-    # @option options [String]         :partial              ('index')   Partial template name of the partial index
-    # @option options [String]         :layout               (nil)       Layout template name of the partial index
+    # @option options [String, Symbol] :target                 (nil)       Target type name to find template or i18n text
+    # @option options [Symbol]         :index_content          (:with_attributes) Option method to load target notification index, [:simple, :unopened_simple, :opened_simple, :with_attributes, :unopened_with_attributes, :opened_with_attributes, :none] are available
+    # @option options [String]         :partial_root           ("activity_notification/notifications/#{target.to_resources_name}", 'activity_notification/notifications/default') Root path of partial template
+    # @option options [String]         :notification_partial   ("activity_notification/notifications/#{target.to_resources_name}", controller.target_view_path, 'activity_notification/notifications/default') Partial template name of the notification index content
+    # @option options [String]         :layout_root            ('layouts') Root path of layout template
+    # @option options [String]         :notification_layout    (nil)       Layout template name of the notification index content
+    # @option options [String]         :fallback               (nil)       Fallback template to use when MissingTemplate is raised. Set :text to use i18n text as fallback.
+    # @option options [String]         :partial                ('index')   Partial template name of the partial index
+    # @option options [String]         :layout                 (nil)       Layout template name of the partial index
+    # @option options [Integer]        :limit                  (nil)       Limit to query for notifications
+    # @option options [Boolean]        :reverse                (false)     If notification index will be ordered as earliest first
+    # @option options [Boolean]        :with_group_members     (false)     If notification index will include group members
+    # @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]          :custom_filter          (nil)       Custom notification filter (e.g. ["created_at >= ?", time.hour.ago])
     # @return [String] Rendered view or text as string
     def render_notification_of target, options = {}
       return unless target.is_a? ActivityNotification::Target
 
       # Prepare content for notifications index
-      notification_options = options.merge target: target.to_resources_name, 
-                               partial: options[:notification_partial], layout: options[:notification_layout]
-      notification_index =
-        case options[:index_content]
-        when :simple then target.notification_index
-        when :none   then []
-        else              target.notification_index_with_attributes
-        end
+      notification_options = options.merge( target: target.to_resources_name,
+                                            partial: options[:notification_partial],
+                                            layout: options[:notification_layout] )
+      index_options = options.slice( :limit, :reverse, :with_group_members,
+                                     :filtered_by_group, :filtered_by_group_type, :filtered_by_group_id,
+                                     :filtered_by_type, :filtered_by_key, :custom_filter )
+      notification_index = load_notification_index(target, options[:index_content], index_options)
       prepare_content_for(target, notification_index, notification_options)
 
       # Render partial index
@@ -173,6 +182,26 @@ module ActivityNotification
 
     private
 
+      # Load notification index from :index_content parameter
+      # @api private
+      #
+      # @param [Object] target Notification target instance
+      # @param [Symbol] index_content Method to load target notification index, [:simple, :unopened_simple, :opened_simple, :with_attributes, :unopened_with_attributes, :opened_with_attributes, :none] are available
+      # @param [Hash] params Option parameter to load notification index
+      # @return [Array<Notification>] Array of notification index
+      def load_notification_index(target, index_content, options = {})
+        case index_content
+        when :simple                   then target.notification_index(options)
+        when :unopened_simple          then target.unopened_notification_index(options)
+        when :opened_simple            then target.opened_notification_index(options)
+        when :with_attributes          then target.notification_index_with_attributes(options)
+        when :unopened_with_attributes then target.unopened_notification_index_with_attributes(options)
+        when :opened_with_attributes   then target.opened_notification_index_with_attributes(options)
+        when :none                     then []
+        else                                target.notification_index_with_attributes(options)
+        end
+      end
+
       # Prepare content for notification index
       # @api private
       #
@@ -194,14 +223,14 @@ module ActivityNotification
       # Render partial index of notifications
       # @api private
       #
-      # @param [Object] target Notification target instance
-      # @param [Hash] params Option parameter to send render
+      # @param [Object] target        Notification target instance
+      # @param [Hash]   params        Option parameter to send render
       # @return [String] Rendered partial index view as string
       def render_partial_index(target, params)
         index_path = params.delete(:partial)
         partial    = partial_index_path(target, index_path, params[:partial_root])
         layout     = layout_path(params.delete(:layout), params[:layout_root])
-        locals     = (params[:locals] || {}).merge(target: target)
+        locals     = (params[:locals] || {}).merge(target: target, parameters: params)
         begin
           render params.merge(partial: partial, layout: layout, locals: locals)
         rescue ActionView::MissingTemplate

data/lib/activity_notification/mailers/helpers.rb

@@ -10,43 +10,61 @@ module ActivityNotification
 
         # Send notification email with configured options.
         #
-        # @param [Notification] notification Notification instance
-        # @param [Hash] options Options for email notification
+        # @param [Notification] notification Notification instance to send email
+        # @param [Hash]         options      Options for notification email
+        # @option options [String, Symbol] :fallback (:default) Fallback template to use when MissingTemplate is raised
         def notification_mail(notification, options = {})
           initialize_from_notification(notification)
           headers = headers_for(notification.key, options)
-          begin
-            mail headers
-          rescue ActionView::MissingTemplate => e
-            if options[:fallback].present?
-              mail headers.merge(template_name: options[:fallback])
-            else
-              raise e
-            end
-          end
+          send_mail(headers, options[:fallback])
         end
-  
+
+        # Send batch notification email with configured options.
+        #
+        # @param [Object]              target        Target of batch notification email
+        # @param [Array<Notification>] notifications Target notifications to send batch notification email
+        # @param [Hash]                options       Options for notification email
+        # @option options [String, Symbol] :fallback    (:batch_default) Fallback template to use when MissingTemplate is raised
+        # @option options [String]         :batch_key   (nil)            Key of the batch notification email, a key of the first notification will be used if not specified
+        def batch_notification_mail(target, notifications, options = {})
+          initialize_from_notifications(target, notifications)
+          batch_key = options.delete(:batch_key)
+          batch_key ||= @notification.key
+          headers = headers_for(batch_key, options)
+          @notification = nil
+          send_mail(headers, options[:fallback])
+        end
+
         # Initialize instance variables from notification.
         #
         # @param [Notification] notification Notification instance
         def initialize_from_notification(notification)
-          @notification, @target, @notifiable = notification, notification.target, notification.notifiable
+          @notification, @target, @batch_email = notification, notification.target, false
         end
-  
+
+        # Initialize instance variables from notifications.
+        #
+        # @param [Object]              target        Target of batch notification email
+        # @param [Array<Notification>] notifications Target notifications to send batch notification email
+        def initialize_from_notifications(target, notifications)
+          @target, @notifications, @notification, @batch_email = target, notifications, notifications.first, true
+        end
+
         # Prepare email header from notification key and options.
         #
         # @param [String] key Key of the notification
         # @param [Hash] options Options for email notification
         def headers_for(key, options)
-          if @notifiable.respond_to?(:overriding_notification_email_key) and 
-             @notifiable.overriding_notification_email_key(@target, key).present?
-            key = @notifiable.overriding_notification_email_key(@target, key)
+          if !@batch_email and
+             @notification.notifiable.respond_to?(:overriding_notification_email_key) and 
+             @notification.notifiable.overriding_notification_email_key(@target, key).present?
+            key = @notification.notifiable.overriding_notification_email_key(@target, key)
           end
           headers = {
             subject: subject_for(key),
             to: mailer_to(@target),
-            from: mailer_from(@notification),
-            reply_to: mailer_reply_to(@notification),
+            from: mailer_from(key),
+            reply_to: mailer_reply_to(key),
             template_path: template_paths,
             template_name: template_name(key)
           }.merge(options)
@@ -54,7 +72,7 @@ module ActivityNotification
           @email = headers[:to]
           headers
         end
-  
+
         # Returns target email address as 'to'.
         #
         # @param [Object] target Target instance to notify
@@ -62,38 +80,38 @@ module ActivityNotification
         def mailer_to(target)
           target.mailer_to
         end
-  
+
         # Returns sender email address as 'reply_to'.
         #
-        # @param [Notification] notification Notification instance
+        # @param [String] key Key of the notification or batch notification email
         # @return [String] Sender email address as 'reply_to'
-        def mailer_reply_to(notification)
-          mailer_sender(notification, :reply_to)
+        def mailer_reply_to(key)
+          mailer_sender(key, :reply_to)
         end
-  
+
         # Returns sender email address as 'from'.
         #
-        # @param [Notification] notification Notification instance
+        # @param [String] key Key of the notification or batch notification email
         # @return [String] Sender email address as 'from'
-        def mailer_from(notification)
-          mailer_sender(notification, :from)
+        def mailer_from(key)
+          mailer_sender(key, :from)
         end
-  
+
         # Returns sender email address configured in initializer or mailer class.
         #
-        # @param [Notification] notification Notification instance
+        # @param [String] key Key of the notification or batch notification email
         # @return [String] Sender email address configured in initializer or mailer class
-        def mailer_sender(notification, sender = :from)
+        def mailer_sender(key, sender = :from)
           default_sender = default_params[sender]
           if default_sender.present?
             default_sender.respond_to?(:to_proc) ? instance_eval(&default_sender) : default_sender
           elsif ActivityNotification.config.mailer_sender.is_a?(Proc)
-            ActivityNotification.config.mailer_sender.call(notification)
+            ActivityNotification.config.mailer_sender.call(key)
           else
             ActivityNotification.config.mailer_sender
           end
         end
-  
+
         # Returns template paths to find email view
         #
         # @return [Array<String>] Template paths to find email view
@@ -102,7 +120,7 @@ module ActivityNotification
           paths.unshift("activity_notification/mailer/#{@target.to_resources_name}") if @target.present?
           paths
         end
-  
+
         # Returns template name from notification key
         #
         # @param [String] key Key of the notification
@@ -110,8 +128,8 @@ module ActivityNotification
         def template_name(key)
           key.gsub('.', '/')
         end
-  
-  
+
+
         # Set up a subject doing an I18n lookup.
         # At first, it attempts to set a subject based on the current mapping:
         #   en:
@@ -131,7 +149,26 @@ module ActivityNotification
           k.insert(1, @target.to_resource_name)
           k = k.join('.')
           I18n.t(:mail_subject, scope: k,
-            default: ["Notification of #{@notifiable.printable_type.downcase}"])
+            default: ["Notification of #{@notification.notifiable.printable_type.downcase}"])
+        end
+
+
+      private
+
+        # Send email with fallback option.
+        #
+        # @param [Hash]           headers  Prepared email header
+        # @param [String, Symbol] fallback Fallback option
+        def send_mail(headers, fallback = nil)
+          begin
+            mail headers
+          rescue ActionView::MissingTemplate => e
+            if fallback.present?
+              mail headers.merge(template_name: fallback)
+            else
+              raise e
+            end
+          end
         end
 
     end

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

@@ -15,6 +15,7 @@ module ActivityNotification
 
       class_attribute :_notification_email,
                       :_notification_email_allowed,
+                      :_batch_notification_email_allowed,
                       :_notification_devise_resource,
                       :_printable_notification_target_name
       set_target_class_defaults
@@ -32,10 +33,104 @@ module ActivityNotification
       def set_target_class_defaults
         self._notification_email                 = nil
         self._notification_email_allowed         = ActivityNotification.config.email_enabled
+        self._batch_notification_email_allowed   = ActivityNotification.config.email_enabled
         self._notification_devise_resource       = ->(model) { model }
         self._printable_notification_target_name = :printable_name
         nil
       end
+
+      # Gets all notifications for this target type.
+      #
+      # @option options [Integer]    :limit                  (nil)   Limit to query for notifications
+      # @option options [Boolean]    :reverse                (false) If notification index will be ordered as earliest first
+      # @option options [Boolean]    :with_group_members     (false) If notification index will include group members
+      # @option options [Boolean]    :as_latest_group_member (false) If grouped notification will be shown as the latest group member (default is shown as the earliest member)
+      # @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 [Array<Notificaion>] All notifications for this target type
+      def all_notifications(options = {})
+        reverse            = options[:reverse] || false
+        with_group_members = options[:with_group_members] || false
+        target_notifications = Notification.filtered_by_target_type(self.name)
+                                           .all_index!(reverse, with_group_members)
+                                           .filtered_by_options(options)
+        options[:limit].present? ? target_notifications.limit(options[:limit]) : target_notifications
+      end
+
+      # Gets all notifications for this target type grouped by targets.
+      #
+      # @example Get all notifications for for users grouped by user
+      #   @notification_index_map = User.notification_index_map
+      #   @notification_index_map.each do |user, notifications|
+      #     # Do something for user and notifications
+      #   end
+      #
+      # @option options [Integer]    :limit                  (nil)   Limit to query for notifications
+      # @option options [Boolean]    :reverse                (false) If notification index will be ordered as earliest first
+      # @option options [Boolean]    :with_group_members     (false) If notification index will include group members
+      # @option options [Boolean]    :as_latest_group_member (false) If grouped notification will be shown as the latest group member (default is shown as the earliest member)
+      # @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 [Array<Notificaion>] All notifications for this target type grouped by targets
+      def notification_index_map(options = {})
+        all_notifications(options).group_by(&:target)
+      end
+
+      # Gets all unopened notifications for this target type grouped by targets.
+      #
+      # @example Get all unopened notifications for users grouped by user
+      #   @unopened_notification_index_map = User.unopened_notification_index_map
+      #   @unopened_notification_index_map.each do |user, notifications|
+      #     # Do something for user and notifications
+      #   end
+      #
+      # @option options [Integer]    :limit                  (nil)   Limit to query for notifications
+      # @option options [Boolean]    :reverse                (false) If notification index will be ordered as earliest first
+      # @option options [Boolean]    :with_group_members     (false) If notification index will include group members
+      # @option options [Boolean]    :as_latest_group_member (false) If grouped notification will be shown as the latest group member (default is shown as the earliest member)
+      # @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 [Array<Notificaion>] All unopened notifications for this target type grouped by targets
+      def unopened_notification_index_map(options = {})
+        all_notifications(options).unopened_only.group_by(&:target)
+      end
+
+      # Send batch notification email to this type targets with unopened notifications.
+      #
+      # @example Send batch notification email to the users with unopened notifications of specified key
+      #   User.send_batch_unopened_notification_email(filtered_by_key: 'this.key')
+      # @example Send batch notification email to the users with unopened notifications of specified key in 1 hour
+      #   User.send_batch_unopened_notification_email(filtered_by_key: 'this.key', custom_filter: ["created_at >= ?", time.hour.ago])
+      #
+      # @option options [Integer]    :limit                  (nil)   Limit to query for notifications
+      # @option options [Boolean]    :reverse                (false) If notification index will be ordered as earliest first
+      # @option options [Boolean]    :with_group_members     (false) If notification index will include group members
+      # @option options [Boolean]    :as_latest_group_member (false) If grouped notification will be shown as the latest group member (default is shown as the earliest member)
+      # @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 [Hash<Object, Mail::Message|ActionMailer::DeliveryJob>] Hash of target and sent email message or its delivery job
+      def send_batch_unopened_notification_email(options = {})
+        unopened_notification_index_map = unopened_notification_index_map(options)
+        unopened_notification_index_map.map { |target, notifications|
+          [target, Notification.send_batch_notification_email(target, notifications, options)]
+        }.to_h
+      end
     end
 
     # Returns target email address for email notification.
@@ -56,6 +151,16 @@ module ActivityNotification
       resolve_value(_notification_email_allowed, notifiable, key)
     end
 
+    # Returns if sending batch notification email is allowed for the target from configured field or overriden method.
+    # This method is able to be overriden.
+    #
+    # @param [Object] notifiable_type Notifiable type of the notifications
+    # @param [String] key Key of the notifications
+    # @return [Boolean] If sending batch notification email is allowed for the target
+    def batch_notification_email_allowed?(notifiable_type, key)
+      resolve_value(_batch_notification_email_allowed, notifiable_type, key)
+    end
+
     # Returns if current resource signed in with Devise is authenticated for the notification.
     # This method is able to be overriden.
     #
@@ -81,21 +186,33 @@ module ActivityNotification
     # Returns count of unopened notifications of the target.
     #
     # @param [Hash] options Options for notification index
-    # @option options [Integer] :limit                  (nil) Limit to query for notifications
+    # @option options [Integer]    :limit                  (nil)   Limit to query for notifications
+    # @option options [Boolean]    :with_group_members     (false) If notification index will include group members
+    # @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 [Integer] Count of unopened notifications of the target
-    # @todo Add filter and reverse options
     def unopened_notification_count(options = {})
-      unopened_notification_index(options).count
+      target_notifications = _unopened_notification_index(options)
+      target_notifications.present? ? target_notifications.count : 0
     end
 
     # Returns if the target has unopened notifications.
     #
     # @param [Hash] options Options for notification index
-    # @option options [Integer] :limit                  (nil) Limit to query for notifications
+    # @option options [Integer]    :limit                  (nil)   Limit to query for notifications
+    # @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 [Boolean] If the target has unopened notifications
-    # @todo Add filter and reverse options
     def has_unopened_notifications?(options = {})
-      unopened_notification_index(options).present?
+      _unopened_notification_index(options).present?
     end
 
     # Gets automatically arranged notification index of the target.
@@ -108,9 +225,17 @@ module ActivityNotification
     #   @notifications = @user.notification_index
     #
     # @param [Hash] options Options for notification index
-    # @option options [Integer] :limit                  (nil) Limit to query for notifications
+    # @option options [Integer]    :limit                  (nil)   Limit to query for notifications
+    # @option options [Boolean]    :reverse                (false) If notification index will be ordered as earliest first
+    # @option options [Boolean]    :with_group_members     (false) If notification index will include group members
+    # @option options [Boolean]    :as_latest_group_member (false) If grouped notification will be shown as the latest group member (default is shown as the earliest member)
+    # @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 [Array<Notificaion>] Notification index of the target
-    # @todo Add filter and reverse options
     def notification_index(options = {})
       arrange_notification_index(method(:unopened_notification_index),
                                  method(:opened_notification_index),
@@ -123,13 +248,19 @@ module ActivityNotification
     #   @notifications = @user.unopened_notification_index
     #
     # @param [Hash] options Options for notification index
-    # @option options [Integer] :limit                  (nil) Limit to query for notifications
+    # @option options [Integer]    :limit                  (nil)   Limit to query for notifications
+    # @option options [Boolean]    :reverse                (false) If notification index will be ordered as earliest first
+    # @option options [Boolean]    :with_group_members     (false) If notification index will include group members
+    # @option options [Boolean]    :as_latest_group_member (false) If grouped notification will be shown as the latest group member (default is shown as the earliest member)
+    # @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 [Array<Notificaion>] Unopened notification index of the target
-    # @todo Add filter and reverse options
     def unopened_notification_index(options = {})
-      options[:limit].present? ?
-        notifications.unopened_index.limit(options[:limit]) :
-        notifications.unopened_index
+      arrange_single_notification_index(method(:_unopened_notification_index), options)
     end
 
     # Gets opened notification index of the target.
@@ -138,12 +269,19 @@ module ActivityNotification
     #   @notifications = @user.opened_notification_index(10)
     #
     # @param [Hash] options Options for notification index
-    # @option options [Integer] :limit                  (ActivityNotification.config.opened_index_limit) Limit to query for notifications
+    # @option options [Integer]    :limit                  (nil)   Limit to query for notifications
+    # @option options [Boolean]    :reverse                (false) If notification index will be ordered as earliest first
+    # @option options [Boolean]    :with_group_members     (false) If notification index will include group members
+    # @option options [Boolean]    :as_latest_group_member (false) If grouped notification will be shown as the latest group member (default is shown as the earliest member)
+    # @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 [Array<Notificaion>] Opened notification index of the target
-    # @todo Add filter and reverse options
     def opened_notification_index(options = {})
-      limit = options[:limit] || ActivityNotification.config.opened_index_limit
-      notifications.opened_index(limit)
+      arrange_single_notification_index(method(:_opened_notification_index), options)
     end
 
     # Generates notifications to this target.
@@ -190,9 +328,20 @@ module ActivityNotification
     #   @notifications = @user.notification_index_with_attributes
     #
     # @param [Hash] options Options for notification index
-    # @option options [Integer] :limit                  (nil) Limit to query for notifications
+    # @option options [Boolean]        :send_later            (false)          If it sends notification email asynchronously
+    # @option options [String, Symbol] :fallback              (:batch_default) Fallback template to use when MissingTemplate is raised
+    # @option options [String]         :batch_key             (nil)            Key of the batch notification email, a key of the first notification will be used if not specified
+    # @option options [Integer]        :limit                  (nil)           Limit to query for notifications
+    # @option options [Boolean]        :reverse                (false)         If notification index will be ordered as earliest first
+    # @option options [Boolean]        :with_group_members     (false)         If notification index will include group members
+    # @option options [Boolean]        :as_latest_group_member (false)         If grouped notification will be shown as the latest group member (default is shown as the earliest member)
+    # @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 [Array<Notificaion>] Notification index of the target with attributes
-    # @todo Add filter and reverse options
     def notification_index_with_attributes(options = {})
       arrange_notification_index(method(:unopened_notification_index_with_attributes),
                                  method(:opened_notification_index_with_attributes),
@@ -205,11 +354,19 @@ module ActivityNotification
     #   @notifications = @user.unopened_notification_index_with_attributes
     #
     # @param [Hash] options Options for notification index
-    # @option options [Integer] :limit                  (nil) Limit to query for notifications
+    # @option options [Integer]    :limit                  (nil)   Limit to query for notifications
+    # @option options [Boolean]    :reverse                (false) If notification index will be ordered as earliest first
+    # @option options [Boolean]    :with_group_members     (false) If notification index will include group members
+    # @option options [Boolean]    :as_latest_group_member (false) If grouped notification will be shown as the latest group member (default is shown as the earliest member)
+    # @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 [Array<Notificaion>] Unopened notification index of the target with attributes
-    # @todo Add filter and reverse options
     def unopened_notification_index_with_attributes(options = {})
-      include_attributes unopened_notification_index(options)
+      include_attributes _unopened_notification_index(options)
     end
 
     # Gets opened notification index of the target with including attributes like target, notifiable, group and notifier.
@@ -218,15 +375,92 @@ module ActivityNotification
     #   @notifications = @user.opened_notification_index_with_attributes(10)
     #
     # @param [Hash] options Options for notification index
-    # @option options [Integer] :limit                  (ActivityNotification.config.opened_index_limit) Limit to query for notifications
+    # @option options [Integer]    :limit                  (nil)   Limit to query for notifications
+    # @option options [Boolean]    :reverse                (false) If notification index will be ordered as earliest first
+    # @option options [Boolean]    :with_group_members     (false) If notification index will include group members
+    # @option options [Boolean]    :as_latest_group_member (false) If grouped notification will be shown as the latest group member (default is shown as the earliest member)
+    # @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 [Array<Notificaion>] Opened notification index of the target with attributes
-    # @todo Add filter and reverse options
     def opened_notification_index_with_attributes(options = {})
-      include_attributes opened_notification_index(options)
+      include_attributes _opened_notification_index(options)
     end
 
+    # Sends notification email to the target.
+    #
+    # @param [Hash] options Options for notification email
+    # @option options [Boolean]        :send_later            If it sends notification email asynchronously
+    # @option options [String, Symbol] :fallback   (:default) Fallback template to use when MissingTemplate is raised
+    # @return [Mail::Message|ActionMailer::DeliveryJob] Email message or its delivery job, return NilClass for wrong target
+    def send_notification_email(notification, options = {})
+      if notification.target == self
+        notification.send_notification_email(options)
+      end
+    end
+
+    # Sends batch notification email to the target.
+    #
+    # @param [Array<Notification>] notifications Target notifications to send batch notification email
+    # @param [Hash]                options       Options for notification email
+    # @option options [Boolean]        :send_later  (false)          If it sends notification email asynchronously
+    # @option options [String, Symbol] :fallback    (:batch_default) Fallback template to use when MissingTemplate is raised
+    # @option options [String]         :batch_key   (nil)            Key of the batch notification email, a key of the first notification will be used if not specified
+    # @return [Mail::Message|ActionMailer::DeliveryJob|NilClass] Email message or its delivery job, return NilClass for wrong target
+    def send_batch_notification_email(notifications, options = {})
+      return if notifications.blank?
+      if notifications.map{ |n| n.target }.uniq == [self]
+        Notification.send_batch_notification_email(self, notifications, options)
+      end
+    end
+
+
     private
 
+      # Gets unopened notification index of the target as ActiveRecord.
+      # @api private
+      #
+      # @param [Hash] options Options for notification index
+      # @option options [Integer]    :limit                  (nil)   Limit to query for notifications
+      # @option options [Boolean]    :reverse                (false) If notification index will be ordered as earliest first
+      # @option options [Boolean]    :with_group_members     (false) If notification index will include group members
+      # @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>] Unopened notification index of the target
+      def _unopened_notification_index(options = {})
+        reverse            = options[:reverse] || false
+        with_group_members = options[:with_group_members] || false
+        target_index = notifications.unopened_index(reverse, with_group_members).filtered_by_options(options)
+        options[:limit].present? ? target_index.limit(options[:limit]) : target_index
+      end
+
+      # Gets opened notification index of the target as ActiveRecord.
+      #
+      # @param [Hash] options Options for notification index
+      # @option options [Integer]    :limit                  (nil)   Limit to query for notifications
+      # @option options [Boolean]    :reverse                (false) If notification index will be ordered as earliest first
+      # @option options [Boolean]    :with_group_members     (false) If notification index will include group members
+      # @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 [Array<Notificaion>] Opened notification index of the target
+      def _opened_notification_index(options = {})
+        limit              = options[:limit] || ActivityNotification.config.opened_index_limit
+        reverse            = options[:reverse] || false
+        with_group_members = options[:with_group_members] || false
+        notifications.opened_index(limit, reverse, with_group_members).filtered_by_options(options)
+      end
+
       # Includes attributes like target, notifiable, group or notifier from the notification index.
       # When group member exists in the notification index, group will be included in addition to target, notifiable and or notifier.
       # Otherwise, target, notifiable and or notifier will be include without group.
@@ -244,6 +478,28 @@ module ActivityNotification
         end
       end
 
+      # Gets arranged single notification index of the target.
+      # @api private
+      #
+      # @param [Method] loading_index_method Method to load index
+      # @param [Hash] options Options for notification index
+      # @option options [Integer]    :limit                  (nil)   Limit to query for notifications
+      # @option options [Boolean]    :reverse                (false) If notification index will be ordered as earliest first
+      # @option options [Boolean]    :with_group_members     (false) If notification index will include group members
+      # @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 [Array<Notificaion>] Notification index of the target
+      def arrange_single_notification_index(loading_index_method, options = {})
+        as_latest_group_member = options[:as_latest_group_member] || false
+        as_latest_group_member ?
+          loading_index_method.call(options).map{ |n| n.latest_group_member } :
+          loading_index_method.call(options).to_a
+      end
+
       # Gets automatically arranged notification index of the target.
       # When the target have unopened notifications, it returns unopened notifications first.
       # Additionaly, it returns opened notifications unless unopened index size overs the limit.
@@ -253,7 +509,15 @@ module ActivityNotification
       # @param [Method] loading_unopened_index_method Method to load unopened index
       # @param [Method] loading_opened_index_method Method to load opened index
       # @param [Hash] options Options for notification index
-      # @option options [Integer] :limit (nil) Limit to query for notifications
+      # @option options [Integer]    :limit                  (nil)   Limit to query for notifications
+      # @option options [Boolean]    :reverse                (false) If notification index will be ordered as earliest first
+      # @option options [Boolean]    :with_group_members     (false) If notification index will include group members
+      # @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 [Array<Notificaion>] Notification index of the target
       def arrange_notification_index(loading_unopened_index_method, loading_opened_index_method, options = {})
         # When the target have unopened notifications