activity_notification 1.2.1 → 1.3.0

data/lib/activity_notification/optional_targets/base.rb

@@ -8,7 +8,10 @@ module ActivityNotification
       attr_accessor :view_context
 
       # Initialize method to create view context in this OptionalTarget instance
-      def initialize
+      # @param [Hash] options Options for initializing target
+      # @option options [Boolean] :skip_initializing_target (false) Whether skip calling initialize_target method
+      # @option options [Hash]    others                            Options for initializing target
+      def initialize(options = {})
         @view_context = ActionView::Base.new(ActionController::Base.view_paths, {})
         @view_context.class_eval do 
           include Rails.application.routes.url_helpers
@@ -16,6 +19,7 @@ module ActivityNotification
             ActionMailer::Base.default_url_options
           end
         end
+        initialize_target(options) unless options.delete(:skip_initializing_target)
       end
 
       # Returns demodulized symbol class name as optional target name

data/lib/activity_notification/orm/active_record.rb

@@ -0,0 +1,16 @@
+module ActivityNotification
+  module Association
+    extend ActiveSupport::Concern
+
+    class_methods do
+      # Defines has_many association with ActivityNotification models.
+      # @return [ActiveRecord_AssociationRelation<Object>] Database query of associated model instances
+      def has_many_records(name, options = {})
+        has_many name, options
+      end
+    end
+  end
+end
+
+require_relative 'active_record/notification.rb'
+require_relative 'active_record/subscription.rb'

data/lib/activity_notification/orm/active_record/notification.rb

@@ -0,0 +1,252 @@
+require 'activity_notification/apis/notification_api'
+
+module ActivityNotification
+  module ORM
+    module ActiveRecord
+      # Notification model implementation generated by ActivityNotification.
+      class Notification < ::ActiveRecord::Base
+        include Common
+        include Renderable
+        include NotificationApi
+        # @deprecated ActivityNotification.config.table_name as of 1.1.0
+        self.table_name = ActivityNotification.config.table_name || ActivityNotification.config.notification_table_name
+        # self.table_name = ActivityNotification.config.notification_table_name
+
+        # Belongs to target instance of this notification as polymorphic association.
+        # @scope instance
+        # @return [Object] Target instance of this notification
+        belongs_to :target,        polymorphic: true
+
+        # Belongs to notifiable instance of this notification as polymorphic association.
+        # @scope instance
+        # @return [Object] Notifiable instance of this notification
+        belongs_to :notifiable,    polymorphic: true
+
+        # Belongs to group instance of this notification as polymorphic association.
+        # @scope instance
+        # @return [Object] Group instance of this notification
+        belongs_to :group,         polymorphic: true
+
+        # Belongs to group owner notification instance of this notification.
+        # Only group member instance has :group_owner value.
+        # Group owner instance has nil as :group_owner association.
+        # @scope instance
+        # @return [Notification] Group owner notification instance of this notification
+        belongs_to :group_owner, { class_name: "ActivityNotification::Notification" }.merge(Rails::VERSION::MAJOR >= 5 ? { optional: true } : {})
+
+        # Has many group member notification instances of this notification.
+        # Only group owner instance has :group_members value.
+        # Group member instance has nil as :group_members association.
+        # @scope instance
+        # @return [ActiveRecord_AssociationRelation<Notificaion>] Database query of the group member notification instances of this notification
+        has_many   :group_members, class_name: "ActivityNotification::Notification", foreign_key: :group_owner_id
+
+        # Belongs to :otifier instance of this notification.
+        # @scope instance
+        # @return [Object] Notifier instance of this notification
+        belongs_to :notifier,      polymorphic: true
+
+        # Serialize parameters Hash
+        serialize  :parameters, Hash
+
+        validates  :target,        presence: true
+        validates  :notifiable,    presence: true
+        validates  :key,           presence: true
+
+        # Selects group owner notifications only.
+        # @scope class
+        # @return [ActiveRecord_AssociationRelation<Notificaion>] Database query of filtered notifications
+        scope :group_owners_only,                 -> { where(group_owner_id: nil) }
+
+        # Selects group member notifications only.
+        # @scope class
+        # @return [ActiveRecord_AssociationRelation<Notificaion>] Database query of filtered notifications
+        scope :group_members_only,                -> { where.not(group_owner_id: nil) }
+
+        # Selects unopened notifications only.
+        # @scope class
+        # @return [ActiveRecord_AssociationRelation<Notificaion>] Database query of filtered notifications
+        scope :unopened_only,                     -> { where(opened_at: nil) }
+
+        # Selects opened notifications only without limit.
+        # Be careful to get too many records with this method.
+        # @scope class
+        # @return [ActiveRecord_AssociationRelation<Notificaion>] Database query of filtered notifications
+        scope :opened_only!,                      -> { where.not(opened_at: nil) }
+
+        # Selects opened notifications only with limit.
+        # @scope class
+        # @param [Integer] limit Limit to query for opened notifications
+        # @return [ActiveRecord_AssociationRelation<Notificaion>] Database query of filtered notifications
+        scope :opened_only,                       ->(limit) { opened_only!.limit(limit) }
+
+        # Selects group member notifications in unopened_index.
+        # @scope class
+        # @return [ActiveRecord_AssociationRelation<Notificaion>] Database query of filtered notifications
+        scope :unopened_index_group_members_only, -> { where(group_owner_id: unopened_index.map(&:id)) }
+
+        # Selects group member notifications in opened_index.
+        # @scope class
+        # @param [Integer] limit Limit to query for opened notifications
+        # @return [ActiveRecord_AssociationRelation<Notificaion>] Database query of filtered notifications
+        scope :opened_index_group_members_only,   ->(limit) { where(group_owner_id: opened_index(limit).map(&:id)) }
+
+        # Selects notifications within expiration.
+        # @scope class
+        # @param [ActiveSupport::Duration] expiry_delay Expiry period of notifications
+        # @return [ActiveRecord_AssociationRelation<Notificaion>] Database query of filtered notifications
+        scope :within_expiration_only,            ->(expiry_delay) { where("created_at > ?", expiry_delay.ago) }
+
+        # Selects group member notifications with specified group owner ids.
+        # @scope class
+        # @param [Array<String>] owner_ids Array of group owner ids
+        # @return [ActiveRecord_AssociationRelation<Notificaion>] Database query of filtered notifications
+        scope :group_members_of_owner_ids_only,   ->(owner_ids) { where(group_owner_id: owner_ids) }
+
+        # Selects filtered notifications by target instance.
+        #   ActivityNotification::Notification.filtered_by_target(@user)
+        # is the same as
+        #   @user.notifications
+        # @scope class
+        # @param [Object] target Target instance for filter
+        # @return [ActiveRecord_AssociationRelation<Notificaion>] Database query of filtered notifications
+        scope :filtered_by_target,                ->(target) { where(target: target) }
+
+        # Selects filtered notifications by notifiable instance.
+        # @example Get filtered unopened notificatons of the @user for @comment as notifiable
+        #   @notifications = @user.notifications.unopened_only.filtered_by_instance(@comment)
+        # @scope class
+        # @param [Object] notifiable Notifiable instance for filter
+        # @return [ActiveRecord_AssociationRelation<Notificaion>] Database query of filtered notifications
+        scope :filtered_by_instance,              ->(notifiable) { where(notifiable: notifiable) }
+
+        # 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>] Database query of filtered notifications
+        scope :filtered_by_type,                  ->(notifiable_type) { where(notifiable_type: notifiable_type) }
+
+        # Selects filtered notifications by group instance.
+        # @example Get filtered unopened notificatons of the @user for @article as group
+        #   @notifications = @user.notifications.unopened_only.filtered_by_group(@article)
+        # @scope class
+        # @param [Object] group Group instance for filter
+        # @return [ActiveRecord_AssociationRelation<Notificaion>] Database query of filtered notifications
+        scope :filtered_by_group,                 ->(group) { where(group: group) }
+
+        # Includes target instance with query for notifications.
+        # @return [ActiveRecord_AssociationRelation<Notificaion>] Database query of notifications with target
+        scope :with_target,                       -> { includes(:target) }
+
+        # Includes notifiable instance with query for notifications.
+        # @return [ActiveRecord_AssociationRelation<Notificaion>] Database query of notifications with notifiable
+        scope :with_notifiable,                   -> { includes(:notifiable) }
+
+        # Includes group instance with query for notifications.
+        # @return [ActiveRecord_AssociationRelation<Notificaion>] Database query of notifications with group
+        scope :with_group,                        -> { includes(:group) }
+
+        # Includes group owner instances with query for notifications.
+        # @return [ActiveRecord_AssociationRelation<Notificaion>] Database query of notifications with group owner
+        scope :with_group_owner,                  -> { includes(:group_owner) }
+
+        # Includes group member instances with query for notifications.
+        # @return [ActiveRecord_AssociationRelation<Notificaion>] Database query of notifications with group members
+        scope :with_group_members,                -> { includes(:group_members) }
+
+        # Includes notifier instance with query for notifications.
+        # @return [ActiveRecord_AssociationRelation<Notificaion>] Database query of notifications with notifier
+        scope :with_notifier,                     -> { includes(:notifier) }
+
+        # Returns latest notification instance.
+        # @return [Notification] Latest notification instance
+        def self.latest
+          latest_order.first
+        end
+
+        # Returns earliest notification instance.
+        # @return [Notification] Earliest notification instance
+        def self.earliest
+          earliest_order.first
+        end
+
+        # Selects unique keys from query for notifications.
+        # @return [Array<String>] Array of notification unique keys
+        def self.uniq_keys
+          select(:key).distinct.pluck(:key)
+        end
+
+        protected
+
+          # Returns count of group members of the unopened notification.
+          # This method is designed to cache group by query result to avoid N+1 call.
+          # @api protected
+          #
+          # @return [Integer] Count of group members of the unopened notification
+          def unopened_group_member_count
+            # Cache group by query result to avoid N+1 call
+            unopened_group_member_counts = target.notifications
+                                                 .unopened_index_group_members_only
+                                                 .group(:group_owner_id)
+                                                 .count
+            unopened_group_member_counts[id] || 0
+          end
+
+          # Returns count of group members of the opened notification.
+          # This method is designed to cache group by query result to avoid N+1 call.
+          # @api protected
+          #
+          # @return [Integer] Count of group members of the opened notification
+          def opened_group_member_count(limit = ActivityNotification.config.opened_index_limit)
+            # Cache group by query result to avoid N+1 call
+            opened_group_member_counts   = target.notifications
+                                                 .opened_index_group_members_only(limit)
+                                                 .group(:group_owner_id)
+                                                 .count
+            count = opened_group_member_counts[id] || 0
+            count > limit ? limit : count
+          end
+
+          # Returns count of group member notifiers of the unopened notification not including group owner notifier.
+          # This method is designed to cache group by query result to avoid N+1 call.
+          # @api protected
+          #
+          # @return [Integer] Count of group member notifiers of the unopened notification
+          def unopened_group_member_notifier_count
+            # Cache group by query result to avoid N+1 call
+            unopened_group_member_notifier_counts = target.notifications
+                                                          .unopened_index_group_members_only
+                                                          .includes(:group_owner)
+                                                          .where('group_owners_notifications.notifier_type = notifications.notifier_type')
+                                                          .where.not('group_owners_notifications.notifier_id = notifications.notifier_id')
+                                                          .references(:group_owner)
+                                                          .group(:group_owner_id, :notifier_type)
+                                                          .count('distinct notifications.notifier_id')
+            unopened_group_member_notifier_counts[[id, notifier_type]] || 0
+          end
+
+          # Returns count of group member notifiers of the opened notification not including group owner notifier.
+          # This method is designed to cache group by query result to avoid N+1 call.
+          # @api protected
+          #
+          # @return [Integer] Count of group member notifiers of the opened notification
+          def opened_group_member_notifier_count(limit = ActivityNotification.config.opened_index_limit)
+            # Cache group by query result to avoid N+1 call
+            opened_group_member_notifier_counts   = target.notifications
+                                                          .opened_index_group_members_only(limit)
+                                                          .includes(:group_owner)
+                                                          .where('group_owners_notifications.notifier_type = notifications.notifier_type')
+                                                          .where.not('group_owners_notifications.notifier_id = notifications.notifier_id')
+                                                          .references(:group_owner)
+                                                          .group(:group_owner_id, :notifier_type)
+                                                          .count('distinct notifications.notifier_id')
+            count = opened_group_member_notifier_counts[[id, notifier_type]] || 0
+            count > limit ? limit : count
+          end
+
+      end
+    end
+  end
+end

data/lib/activity_notification/orm/active_record/subscription.rb

@@ -0,0 +1,52 @@
+require 'activity_notification/apis/subscription_api'
+
+module ActivityNotification
+  module ORM
+    module ActiveRecord
+      # Subscription model implementation generated by ActivityNotification.
+      class Subscription < ::ActiveRecord::Base
+        include SubscriptionApi
+        self.table_name = ActivityNotification.config.subscription_table_name
+
+        # Belongs to target instance of this subscription as polymorphic association.
+        # @scope instance
+        # @return [Object] Target instance of this subscription
+        belongs_to :target,               polymorphic: true
+
+        # Serialize parameters Hash
+        serialize  :optional_targets, Hash
+
+        validates  :target,               presence: true
+        validates  :key,                  presence: true
+        validates_inclusion_of :subscribing,          in: [true, false]
+        validates_inclusion_of :subscribing_to_email, in: [true, false]
+        validate   :subscribing_to_email_cannot_be_true_when_subscribing_is_false
+        validates  :subscribed_at,            presence: true, if:     :subscribing
+        validates  :unsubscribed_at,          presence: true, unless: :subscribing
+        validates  :subscribed_to_email_at,   presence: true, if:     :subscribing_to_email
+        validates  :unsubscribed_to_email_at, presence: true, unless: :subscribing_to_email
+        validate   :subscribing_to_optional_target_cannot_be_true_when_subscribing_is_false
+
+        # Selects filtered subscriptions by target instance.
+        #   ActivityNotification::Subscription.filtered_by_target(@user)
+        # is the same as
+        #   @user.subscriptions
+        # @scope class
+        # @param [Object] target Target instance for filter
+        # @return [ActiveRecord_AssociationRelation<Subscription>] Database query of filtered subscriptions
+        scope :filtered_by_target,  ->(target) { where(target: target) }
+
+        # Includes target instance with query for subscriptions.
+        # @return [ActiveRecord_AssociationRelation<Subscription>] Database query of subscriptions with target
+        scope :with_target,               -> { includes(:target) }
+
+        # Selects unique keys from query for subscriptions.
+        # @return [Array<String>] Array of subscription unique keys
+        def self.uniq_keys
+          select(:key).distinct.pluck(:key)
+        end
+
+      end
+    end
+  end
+end

data/lib/activity_notification/orm/mongoid.rb

@@ -0,0 +1,63 @@
+module ActivityNotification
+  module Association
+    extend ActiveSupport::Concern
+
+    class_methods do
+      # Defines has_many association with ActivityNotification models.
+      # @return [Mongoid::Criteria<Object>] Database query of associated model instances
+      def has_many_records(name, options = {})
+        has_many_polymorphic_xdb_records name, options
+      end
+
+      # Defines polymorphic belongs_to association with models in other database.
+      def belongs_to_polymorphic_xdb_record(name, _options = {})
+        association_name     = name.to_s.singularize.underscore
+        id_field, type_field = "#{association_name}_id", "#{association_name}_type"
+        field id_field,   type: Integer
+        field type_field, type: String
+
+        self.instance_eval do
+          define_method(name) do |reload = false|
+            reload and self.instance_variable_set("@#{name}", nil)
+            if self.instance_variable_get("@#{name}").blank?
+              if (class_name = self.send(type_field)).present?
+                object_class = class_name.classify.constantize
+                self.instance_variable_set("@#{name}", object_class.where(object_class.primary_key => self.send(id_field)).first)
+              end
+            end
+            self.instance_variable_get("@#{name}")
+          end
+
+          define_method("#{name}=") do |new_instance|
+            if new_instance.nil? then instance_id, instance_type = nil, nil else instance_id, instance_type = new_instance.id, new_instance.class.name end
+            self.send("#{id_field}=", instance_id)
+            self.send("#{type_field}=", instance_type)
+            self.instance_variable_set("@#{name}", nil)
+          end
+        end
+      end
+
+      # Defines polymorphic has_many association with models in other database.
+      # @todo Add dependent option
+      def has_many_polymorphic_xdb_records(name, options = {})
+        association_name     = options[:as] || name.to_s.underscore
+        id_field, type_field = "#{association_name}_id", "#{association_name}_type"
+        object_name          = options[:class_name] || name.to_s.singularize.camelize
+        object_class         = object_name.classify.constantize
+
+        self.instance_eval do
+          define_method(name) do |reload = false|
+            reload and self.instance_variable_set("@#{name}", nil)
+            if self.instance_variable_get("@#{name}").blank?
+              self.instance_variable_set("@#{name}", object_class.where(id_field => self.id, type_field => self.class.name))
+            end
+            self.instance_variable_get("@#{name}")
+          end
+        end
+      end
+    end
+  end
+end
+
+require_relative 'mongoid/notification.rb'
+require_relative 'mongoid/subscription.rb'

data/lib/activity_notification/orm/mongoid/notification.rb

@@ -0,0 +1,255 @@
+require 'mongoid'
+require 'activity_notification/apis/notification_api'
+
+module ActivityNotification
+  module ORM
+    module Mongoid
+      # Notification model implementation generated by ActivityNotification.
+      class Notification
+        include ::Mongoid::Document
+        include ::Mongoid::Timestamps
+        include ::Mongoid::Attributes::Dynamic
+        include GlobalID::Identification
+        include Common
+        include Renderable
+        include Association
+        include NotificationApi
+        store_in collection: ActivityNotification.config.notification_table_name
+
+        # Belongs to target instance of this notification as polymorphic association.
+        # @scope instance
+        # @return [Object] Target instance of this notification
+        belongs_to_polymorphic_xdb_record :target
+
+        # Belongs to notifiable instance of this notification as polymorphic association.
+        # @scope instance
+        # @return [Object] Notifiable instance of this notification
+        belongs_to_polymorphic_xdb_record :notifiable
+
+        # Belongs to group instance of this notification as polymorphic association.
+        # @scope instance
+        # @return [Object] Group instance of this notification
+        belongs_to_polymorphic_xdb_record :group
+
+        field :key,            type: String
+        field :parameters,     type: Hash,     default: {}
+        field :opened_at,      type: DateTime
+        field :group_owner_id, type: String
+
+        # Belongs to group owner notification instance of this notification.
+        # Only group member instance has :group_owner value.
+        # Group owner instance has nil as :group_owner association.
+        # @scope instance
+        # @return [Notification] Group owner notification instance of this notification
+        belongs_to :group_owner, { class_name: "ActivityNotification::Notification" }.merge(Rails::VERSION::MAJOR >= 5 ? { optional: true } : {})
+
+        # Has many group member notification instances of this notification.
+        # Only group owner instance has :group_members value.
+        # Group member instance has nil as :group_members association.
+        # @scope instance
+        # @return [Mongoid::Criteria<Notificaion>] Database query of the group member notification instances of this notification
+        has_many   :group_members, class_name: "ActivityNotification::Notification", foreign_key: :group_owner_id
+
+        # Belongs to :otifier instance of this notification.
+        # @scope instance
+        # @return [Object] Notifier instance of this notification
+        belongs_to_polymorphic_xdb_record :notifier
+
+        validates  :target,        presence: true
+        validates  :notifiable,    presence: true
+        validates  :key,           presence: true
+
+        # Selects filtered notifications by type of the object.
+        # Filtering with ActivityNotification::Notification is defined as default scope.
+        # @return [Mongoid::Criteria<Notification>] Database query of filtered notifications
+        default_scope -> { where(_type: "ActivityNotification::Notification") }
+
+        # Selects group owner notifications only.
+        # @scope class
+        # @return [Mongoid::Criteria<Notificaion>] Database query of filtered notifications
+        scope :group_owners_only,                 -> { where(:group_owner_id.exists => false) }
+
+        # Selects group member notifications only.
+        # @scope class
+        # @return [Mongoid::Criteria<Notificaion>] Database query of filtered notifications
+        scope :group_members_only,                -> { where(:group_owner_id.exists => true) }
+
+        # Selects unopened notifications only.
+        # @scope class
+        # @return [Mongoid::Criteria<Notificaion>] Database query of filtered notifications
+        scope :unopened_only,                     -> { where(:opened_at.exists => false) }
+
+        # Selects opened notifications only without limit.
+        # Be careful to get too many records with this method.
+        # @scope class
+        # @return [Mongoid::Criteria<Notificaion>] Database query of filtered notifications
+        scope :opened_only!,                      -> { where(:opened_at.exists => true) }
+
+        # Selects opened notifications only with limit.
+        # @scope class
+        # @param [Integer] limit Limit to query for opened notifications
+        # @return [Mongoid::Criteria<Notificaion>] Database query of filtered notifications
+        scope :opened_only,                       ->(limit) { limit == 0 ? none : opened_only!.limit(limit) }
+
+        # Selects group member notifications in unopened_index.
+        # @scope class
+        # @return [Mongoid::Criteria<Notificaion>] Database query of filtered notifications
+        scope :unopened_index_group_members_only, -> { where(:group_owner_id.in => unopened_index.map(&:id)) }
+
+        # Selects group member notifications in opened_index.
+        # @scope class
+        # @param [Integer] limit Limit to query for opened notifications
+        # @return [Mongoid::Criteria<Notificaion>] Database query of filtered notifications
+        scope :opened_index_group_members_only,   ->(limit) { where(:group_owner_id.in => opened_index(limit).map(&:id)) }
+
+        # Selects notifications within expiration.
+        # @scope class
+        # @param [ActiveSupport::Duration] expiry_delay Expiry period of notifications
+        # @return [Mongoid::Criteria<Notificaion>] Database query of filtered notifications
+        scope :within_expiration_only,            ->(expiry_delay) { where(:created_at.gt => expiry_delay.ago) }
+
+        # Selects group member notifications with specified group owner ids.
+        # @scope class
+        # @param [Array<String>] owner_ids Array of group owner ids
+        # @return [Mongoid::Criteria<Notificaion>] Database query of filtered notifications
+        scope :group_members_of_owner_ids_only,   ->(owner_ids) { where(:group_owner_id.in => owner_ids) }
+
+        # Selects filtered notifications by target instance.
+        #   ActivityNotification::Notification.filtered_by_target(@user)
+        # is the same as
+        #   @user.notifications
+        # @scope class
+        # @param [Object] target Target instance for filter
+        # @return [Mongoid::Criteria<Notificaion>] Database query of filtered notifications
+        scope :filtered_by_target,                ->(target) { target.present? ? where(target_id: target.id, target_type: target.class.name) : none }
+
+        # Selects filtered notifications by notifiable instance.
+        # @example Get filtered unopened notificatons of the @user for @comment as notifiable
+        #   @notifications = @user.notifications.unopened_only.filtered_by_instance(@comment)
+        # @scope class
+        # @param [Object] notifiable Notifiable instance for filter
+        # @return [Mongoid::Criteria<Notificaion>] Database query of filtered notifications
+        scope :filtered_by_instance,              ->(notifiable) { notifiable.present? ? where(notifiable_id: notifiable.id, notifiable_type: notifiable.class.name) : none }
+
+        # Selects filtered notifications by group instance.
+        # @example Get filtered unopened notificatons of the @user for @article as group
+        #   @notifications = @user.notifications.unopened_only.filtered_by_group(@article)
+        # @scope class
+        # @param [Object] group Group instance for filter
+        # @return [Mongoid::Criteria<Notificaion>] Database query of filtered notifications
+        scope :filtered_by_group,                 ->(group) {
+          group.present? ?
+            where(group_id: group.id, group_type: group.class.name) :
+            any_of({ :group_id.exists => false, :group_type.exists => false }, { group_id: nil, group_type: nil })
+        }
+
+        # Includes target instance with query for notifications.
+        # @return [Mongoid::Criteria<Notificaion>] Database query of notifications with target
+        scope :with_target,                       -> { }
+
+        # Includes notifiable instance with query for notifications.
+        # @return [Mongoid::Criteria<Notificaion>] Database query of notifications with notifiable
+        scope :with_notifiable,                   -> { }
+
+        # Includes group instance with query for notifications.
+        # @return [Mongoid::Criteria<Notificaion>] Database query of notifications with group
+        scope :with_group,                        -> { }
+
+        # Includes group owner instances with query for notifications.
+        # @return [Mongoid::Criteria<Notificaion>] Database query of notifications with group owner
+        scope :with_group_owner,                  -> { }
+
+        # Includes group member instances with query for notifications.
+        # @return [Mongoid::Criteria<Notificaion>] Database query of notifications with group members
+        scope :with_group_members,                -> { }
+
+        # Includes notifier instance with query for notifications.
+        # @return [Mongoid::Criteria<Notificaion>] Database query of notifications with notifier
+        scope :with_notifier,                     -> { }
+
+        # Dummy reload method for test of notifications.
+        scope :reload,                            -> { }
+
+        # Returns latest notification instance.
+        # @return [Notification] Latest notification instance
+        def self.latest
+          latest_order.first
+        end
+
+        # Returns earliest notification instance.
+        # @return [Notification] Earliest notification instance
+        def self.earliest
+          earliest_order.first
+        end
+
+        # Selects unique keys from query for notifications.
+        # @return [Array<String>] Array of notification unique keys
+        def self.uniq_keys
+          # distinct method cannot keep original sort
+          # distinct(:key)
+          pluck(:key).uniq
+        end
+
+        # Returns if the notification is group owner.
+        # Calls NotificationApi#group_owner? as super method.
+        # @return [Boolean] If the notification is group owner
+        def group_owner?
+          super
+        end
+
+        protected
+
+          # Returns count of group members of the unopened notification.
+          # This method is designed to cache group by query result to avoid N+1 call.
+          # @api protected
+          # @todo Avoid N+1 call
+          #
+          # @return [Integer] Count of group members of the unopened notification
+          def unopened_group_member_count
+            group_members.unopened_only.count
+          end
+
+          # Returns count of group members of the opened notification.
+          # This method is designed to cache group by query result to avoid N+1 call.
+          # @api protected
+          # @todo Avoid N+1 call
+          #
+          # @return [Integer] Count of group members of the opened notification
+          def opened_group_member_count(limit = ActivityNotification.config.opened_index_limit)
+            limit == 0 and return 0
+            group_members.opened_only(limit).to_a.length #.count(true)
+          end
+
+          # Returns count of group member notifiers of the unopened notification not including group owner notifier.
+          # This method is designed to cache group by query result to avoid N+1 call.
+          # @api protected
+          # @todo Avoid N+1 call
+          #
+          # @return [Integer] Count of group member notifiers of the unopened notification
+          def unopened_group_member_notifier_count
+            group_members.unopened_only
+                         .where(notifier_type: notifier_type)
+                         .where(:notifier_id.ne => notifier_id)
+                         .distinct(:notifier_id)
+                         .count
+          end
+
+          # Returns count of group member notifiers of the opened notification not including group owner notifier.
+          # This method is designed to cache group by query result to avoid N+1 call.
+          # @api protected
+          # @todo Avoid N+1 call
+          #
+          # @return [Integer] Count of group member notifiers of the opened notification
+          def opened_group_member_notifier_count(limit = ActivityNotification.config.opened_index_limit)
+            limit == 0 and return 0
+            group_members.opened_only(limit)
+                         .where(notifier_type: notifier_type)
+                         .where(:notifier_id.ne => notifier_id)
+                         .distinct(:notifier_id)
+                         .to_a.length #.count(true)
+          end
+
+      end
+    end
+  end
+end