activity_notification 1.0.2 → 1.1.0

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

@@ -0,0 +1,149 @@
+module ActivityNotification
+  # Subscriber implementation included in target model to manage subscriptions, like users or administrators.
+  module Subscriber
+    extend ActiveSupport::Concern
+    included do
+      # Has many subscription instances of this target.
+      # @scope instance
+      # @return [Array<Notificaion>] Array or database query of subscriptions of this target
+      has_many :subscriptions,
+        class_name: "::ActivityNotification::Subscription",
+        as: :target,
+        dependent: :delete_all
+    end
+
+    class_methods do
+      # Checks if the model includes subscriber and subscriber methods are available.
+      # Also checks if the model includes target and target methods are available, then return true.
+      # @return [Boolean] If the model includes target and subscriber are available
+      def available_as_subscriber?
+        available_as_target?
+      end
+    end
+
+
+    # Gets subscription of the target and notification key.
+    #
+    # @param [Hash] key Key of the notification for subscription
+    # @return [Subscription] Configured subscription instance
+    def find_subscription(key)
+      subscriptions.find_by_key(key)
+    end
+
+    # Gets subscription of the target and notification key.
+    #
+    # @param [Hash] key                 Key of the notification for subscription
+    # @param [Hash] subscription_params Parameters to create subscription record
+    # @return [Subscription] Found or created subscription instance
+    def find_or_create_subscription(key, subscription_params = {})
+      subscription = find_subscription(key)
+      subscription || create_subscription(subscription_params.merge(key: key))
+    end
+
+    # Creates new subscription of the target.
+    #
+    # @param [Hash] subscription_params Parameters to create subscription record
+    # @return [Subscription] Created subscription instance
+    def create_subscription(subscription_params = {})
+      created_at = Time.current
+      if subscription_params[:subscribing] == false && subscription_params[:subscribing_to_email].nil?
+        subscription_params[:subscribing_to_email] = subscription_params[:subscribing] 
+      end
+      subscription = subscriptions.new(subscription_params)
+      subscription.subscribing ?
+        subscription.assign_attributes(subscribing: true, subscribed_at: created_at) :
+        subscription.assign_attributes(subscribing: false, unsubscribed_at: created_at)
+      subscription.subscribing_to_email ?
+        subscription.assign_attributes(subscribing_to_email: true, subscribed_to_email_at: created_at) :
+        subscription.assign_attributes(subscribing_to_email: false, unsubscribed_to_email_at: created_at)
+      subscription.save ? subscription : nil
+    end
+
+    # Gets configured subscription index of the target.
+    #
+    # @example Get configured subscription index of the @user
+    #   @subscriptions = @user.subscription_index
+    #
+    # @param [Hash] options Options for subscription index
+    # @option options [Integer]    :limit                  (nil)   Limit to query for subscriptions
+    # @option options [Boolean]    :reverse                (false) If subscription index will be ordered as earliest first
+    # @option options [String]     :filtered_by_key        (nil)   Key of the notification for filter
+    # @option options [Array|Hash] :custom_filter          (nil)   Custom subscription filter (e.g. ["created_at >= ?", time.hour.ago])
+    # @option options [Boolean]    :with_target            (false) If it includes target with subscriptions
+    # @return [Array<Notificaion>] Configured subscription index of the target
+    def subscription_index(options = {})
+      target_index = subscriptions.filtered_by_options(options)
+      target_index = options[:reverse] ? target_index.earliest_order : target_index.latest_order
+      target_index = target_index.includes(:target) if options[:with_target]
+      options[:limit].present? ? target_index.limit(options[:limit]) : target_index
+    end
+
+    # Gets received notification keys of the target.
+    #
+    # @example Get unconfigured notification keys of the @user
+    #   @notification_keys = @user.notification_keys(filter: :unconfigured)
+    #
+    # @param [Hash] options Options for unconfigured notification keys
+    # @option options [Integer]       :limit                  (nil)   Limit to query for subscriptions
+    # @option options [Boolean]       :reverse                (false) If notification keys will be ordered as earliest first
+    # @option options [Symbol|String] :filter                 (nil)   Filter option to load notification keys (Nothing as all, 'configured' with configured subscriptions or 'unconfigured' without subscriptions)
+    # @option options [String]        :filtered_by_key        (nil)   Key of the notification for filter
+    # @option options [Array|Hash]    :custom_filter          (nil)   Custom subscription filter (e.g. ["created_at >= ?", time.hour.ago])
+    # @return [Array<Notificaion>] Unconfigured notification keys of the target
+    def notification_keys(options = {})
+      subscription_keys    = subscriptions.select(:key).distinct.pluck(:key)
+      target_notifications = notifications.filtered_by_options(options.select { |k, _| [:filtered_by_key, :custom_filter].include?(k) })
+      target_notifications = options[:reverse] ? target_notifications.earliest_order : target_notifications.latest_order
+      target_notifications = options[:limit].present? ? target_notifications.limit(options[:limit] + subscription_keys.size) : target_notifications
+      notification_keys    = target_notifications.select(:key).distinct.pluck(:key)
+      notification_keys    =
+        case options[:filter]
+        when :configured, 'configured'
+          notification_keys & subscription_keys
+        when :unconfigured, 'unconfigured'
+          notification_keys - subscription_keys
+        else
+          notification_keys
+        end
+      options[:limit].present? ? notification_keys.take(options[:limit]) : notification_keys
+    end
+
+    protected
+
+      # Returns if the target subscribes to the notification.
+      # This method can be overriden.
+      # @api protected
+      #
+      # @param [String]  key                  Key of the notification
+      # @param [Boolean] subscribe_as_default Default subscription value to use when the subscription record does not configured
+      # @return [Boolean] If the target subscribes to the notification
+      def _subscribes_to_notification?(key, subscribe_as_default = ActivityNotification.config.subscribe_as_default)
+        evaluate_subscription(subscriptions.find_by_key(key), :subscribing, subscribe_as_default)
+      end
+
+      # Returns if the target subscribes to the notification email.
+      # This method can be overriden.
+      # @api protected
+      #
+      # @param [String]  key                  Key of the notification
+      # @param [Boolean] subscribe_as_default Default subscription value to use when the subscription record does not configured
+      # @return [Boolean] If the target subscribes to the notification
+      def _subscribes_to_notification_email?(key, subscribe_as_default = ActivityNotification.config.subscribe_as_default)
+        evaluate_subscription(subscriptions.find_by_key(key), :subscribing_to_email, subscribe_as_default)
+      end
+      alias_method :_subscribes_to_email?, :_subscribes_to_notification_email?
+
+    private
+
+      # Returns if the target subscribes.
+      # @api private
+      # @param [Boolean] record  Subscription record
+      # @param [Symbol]  field   Evaluating subscription field of the record
+      # @param [Boolean] default Default subscription value to use when the subscription record does not configured
+      # @return [Boolean] If the target subscribes
+      def evaluate_subscription(record, field, default)
+        default ? record.blank? || record.send(field) : record.present? && record.send(field)
+      end
+
+  end
+end

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

@@ -16,6 +16,7 @@ module ActivityNotification
       class_attribute :_notification_email,
                       :_notification_email_allowed,
                       :_batch_notification_email_allowed,
+                      :_notification_subscription_allowed,
                       :_notification_devise_resource,
                       :_printable_notification_target_name
       set_target_class_defaults
@@ -34,6 +35,7 @@ module ActivityNotification
         self._notification_email                 = nil
         self._notification_email_allowed         = ActivityNotification.config.email_enabled
         self._batch_notification_email_allowed   = ActivityNotification.config.email_enabled
+        self._notification_subscription_allowed  = ActivityNotification.config.subscription_enabled
         self._notification_devise_resource       = ->(model) { model }
         self._printable_notification_target_name = :printable_name
         nil
@@ -45,6 +47,7 @@ module ActivityNotification
       # @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_status     (:all)  Status for filter, :all, :opened and :unopened are available
       # @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
@@ -53,12 +56,23 @@ module ActivityNotification
       # @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
+        reverse                = options[:reverse] || false
+        with_group_members     = options[:with_group_members] || false
+        as_latest_group_member = options[:as_latest_group_member] || 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
+                                           .with_target
+        case options[:filtered_by_status]
+        when :opened, 'opened'
+          target_notifications = target_notifications.opened_only!
+        when :unopened, 'unopened'
+          target_notifications = target_notifications.unopened_only
+        end
+        target_notifications = target_notifications.limit(options[:limit]) if options[:limit].present?
+        as_latest_group_member ?
+          target_notifications.map{ |n| n.latest_group_member } :
+          target_notifications.to_a
       end
 
       # Gets all notifications for this target type grouped by targets.
@@ -73,6 +87,7 @@ module ActivityNotification
       # @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_status     (:all)  Status for filter, :all, :opened and :unopened are available
       # @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
@@ -84,29 +99,6 @@ module ActivityNotification
         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
@@ -114,23 +106,34 @@ module ActivityNotification
       # @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])
+      # @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])
+      # @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 [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 = notification_index_map(options.merge(filtered_by_status: :unopened))
+        mailer_options = options.select { |k, _| [:send_later, :fallback, :batch_key].include?(k) }
         unopened_notification_index_map.map { |target, notifications|
-          [target, Notification.send_batch_notification_email(target, notifications, options)]
+          [target, Notification.send_batch_notification_email(target, notifications, mailer_options)]
         }.to_h
       end
+
+      # Returns if subscription management is allowed for this target type.
+      # @return [Boolean] If subscription management is allowed for this target type
+      def subscription_enabled?
+        _notification_subscription_allowed ? true : false
+      end
+      alias_method :notification_subscription_enabled?, :subscription_enabled?
     end
 
     # Returns target email address for email notification.
@@ -154,13 +157,22 @@ module ActivityNotification
     # 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)
+    def batch_notification_email_allowed?(key)
+      resolve_value(_batch_notification_email_allowed, key)
     end
 
+    # Returns if subscription management is allowed for the target from configured field or overriden method.
+    # This method is able to be overriden.
+    #
+    # @param [String] key Key of the notifications
+    # @return [Boolean] If subscription management is allowed for the target
+    def subscription_allowed?(key)
+      resolve_value(_notification_subscription_allowed, key)
+    end
+    alias_method :notification_subscription_allowed?, :subscription_allowed?
+
     # Returns if current resource signed in with Devise is authenticated for the notification.
     # This method is able to be overriden.
     #
@@ -174,7 +186,7 @@ module ActivityNotification
           "with devise resource #{devise_resource.class} has been passed to #{self.class}##{__method__}. "\
           "You have to override #{self.class}##{__method__} method or set devise_resource in acts_as_target."
       end
-      current_resource.present? and current_resource == devise_resource
+      current_resource.present? && current_resource == devise_resource
     end
 
     # Returns printable target model name to show in view or email.
@@ -215,13 +227,13 @@ module ActivityNotification
       _unopened_notification_index(options).present?
     end
 
-    # Gets automatically arranged notification index of the target.
-    # This method is the typical way to get notifications index from controller of view.
-    # When the target have unopened notifications, it returns unopened notifications first.
+    # Returns automatically arranged notification index of the target.
+    # This method is the typical way to get notification index from controller and view.
+    # When the target has unopened notifications, it returns unopened notifications first.
     # Additionaly, it returns opened notifications unless unopened index size overs the limit.
-    # @todo Is this switching the best solution?
+    # @todo Is this conbimned array the best solution?
     #
-    # @example Get automatically arranged notification index of the @user
+    # @example Get automatically arranged notification index of @user
     #   @notifications = @user.notification_index
     #
     # @param [Hash] options Options for notification index
@@ -242,9 +254,9 @@ module ActivityNotification
                                  options)
     end
 
-    # Gets unopened notification index of the target.
+    # Returns unopened notification index of the target.
     #
-    # @example Get unopened notification index of the @user
+    # @example Get unopened notification index of @user
     #   @notifications = @user.unopened_notification_index
     #
     # @param [Hash] options Options for notification index
@@ -263,9 +275,9 @@ module ActivityNotification
       arrange_single_notification_index(method(:_unopened_notification_index), options)
     end
 
-    # Gets opened notification index of the target.
+    # Returns opened notification index of the target.
     #
-    # @example Get opened notification index of the @user
+    # @example Get opened notification index of @user
     #   @notifications = @user.opened_notification_index(10)
     #
     # @param [Hash] options Options for notification index
@@ -290,12 +302,13 @@ module ActivityNotification
     #
     # @param [Object] notifiable Notifiable instance to notify
     # @param [Hash] options Options for notifications
-    # @option options [String]  :key        (notifiable.default_notification_key) Key of the notification
-    # @option options [Object]  :group      (nil)                                 Group unit of the notifications
-    # @option options [Object]  :notifier   (nil)                                 Notifier of the notifications
-    # @option options [Hash]    :parameters ({})                                  Additional parameters of the notifications
-    # @option options [Boolean] :send_email (true)                                Whether it sends notification email
-    # @option options [Boolean] :send_later (true)                                Whether it sends notification email asynchronously
+    # @option options [String]                  :key                (notifiable.default_notification_key) Key of the notification
+    # @option options [Object]                  :group              (nil)                                 Group unit of the notifications
+    # @option options [ActiveSupport::Duration] :group_expiry_delay (nil)                                 Expiry period of a notification group
+    # @option options [Object]                  :notifier           (nil)                                 Notifier of the notifications
+    # @option options [Hash]                    :parameters         ({})                                  Additional parameters of the notifications
+    # @option options [Boolean]                 :send_email         (true)                                Whether it sends notification email
+    # @option options [Boolean]                 :send_later         (true)                                Whether it sends notification email asynchronously        
     # @return [Notification] Generated notification instance
     def notify_to(notifiable, options = {})
       Notification.notify_to(self, notifiable, options)
@@ -306,12 +319,12 @@ module ActivityNotification
     # @see NotificationApi#open_all_of
     #
     # @param [Hash] options Options for opening notifications
-    # @option options [DateTime] :opened_at (DateTime.now) Time to set to opened_at of the notification record
-    # @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 [DateTime] :opened_at              (Time.current) Time to set to opened_at of the notification record
+    # @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
     # @return [Integer] Number of opened notification records
     def open_all_notifications(options = {})
       Notification.open_all_of(self, options)
@@ -328,9 +341,9 @@ module ActivityNotification
     #   @notifications = @user.notification_index_with_attributes
     #
     # @param [Hash] options Options for notification index
-    # @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 [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
@@ -417,6 +430,27 @@ module ActivityNotification
       end
     end
 
+    # Returns if the target subscribes to the notification.
+    # It also returns true when the subscription management is not allowed for the target.
+    #
+    # @param [String] key                  Key of the notification
+    # @param [String] subscribe_as_default Default subscription value to use when the subscription record does not configured
+    # @return [Boolean] If the target subscribes the notification or the subscription management is not allowed for the target
+    def subscribes_to_notification?(key, subscribe_as_default = ActivityNotification.config.subscribe_as_default)
+      !subscription_allowed?(key) or _subscribes_to_notification?(key, subscribe_as_default)
+    end
+
+    # Returns if the target subscribes to the notification email.
+    # It also returns true when the subscription management is not allowed for the target.
+    #
+    # @param [String] key                  Key of the notification
+    # @param [String] subscribe_as_default Default subscription value to use when the subscription record does not configured
+    # @return [Boolean] If the target subscribes the notification email or the subscription management is not allowed for the target
+    def subscribes_to_notification_email?(key, subscribe_as_default = ActivityNotification.config.subscribe_as_default)
+      !subscription_allowed?(key) or _subscribes_to_notification_email?(key, subscribe_as_default)
+    end
+    alias_method :subscribes_to_email?, :subscribes_to_notification_email?
+
 
     private
 

data/lib/activity_notification/models/notification.rb

@@ -4,7 +4,9 @@ module ActivityNotification
     include Renderable
     include Common
     include NotificationApi
-    self.table_name = ActivityNotification.config.table_name
+    # @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
@@ -61,10 +63,10 @@ module ActivityNotification
     #   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
-    # @scope class
     # @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>] Array or database query of filtered notifications
@@ -82,10 +84,10 @@ module ActivityNotification
     #   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
-    # @scope class
     # @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>] Array or database query of filtered notifications
@@ -110,10 +112,10 @@ module ActivityNotification
     #   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
-    # @scope class
     # @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
@@ -214,7 +216,7 @@ module ActivityNotification
       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) and options.has_key?(:filtered_by_group_id)
+      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