activity_notification 1.7.1 → 2.0.0

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

@@ -52,7 +52,8 @@ module ActivityNotification
       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 = Subscription.new(subscription_params)
+      subscription.assign_attributes(target: self)
       subscription.subscribing? ?
         subscription.assign_attributes(subscribing: true, subscribed_at: created_at) :
         subscription.assign_attributes(subscribing: false, unsubscribed_at: created_at)
@@ -65,11 +66,11 @@ module ActivityNotification
         optional_targets = subscription.subscribing_to_optional_target?(optional_target_name) ?
           optional_targets.merge(
             Subscription.to_optional_target_key(optional_target_name) => true,
-            Subscription.to_optional_target_subscribed_at_key(optional_target_name) => created_at
+            Subscription.to_optional_target_subscribed_at_key(optional_target_name) => Subscription.convert_time_as_hash(created_at)
           ) :
           optional_targets.merge(
             Subscription.to_optional_target_key(optional_target_name) => false,
-            Subscription.to_optional_target_unsubscribed_at_key(optional_target_name) => created_at
+            Subscription.to_optional_target_unsubscribed_at_key(optional_target_name) => Subscription.convert_time_as_hash(created_at)
           )
       end
       subscription.assign_attributes(optional_targets: optional_targets)
@@ -128,7 +129,7 @@ module ActivityNotification
     protected
 
       # Returns if the target subscribes to the notification.
-      # This method can be overriden.
+      # This method can be overridden.
       # @api protected
       #
       # @param [String]  key                  Key of the notification
@@ -139,7 +140,7 @@ module ActivityNotification
       end
 
       # Returns if the target subscribes to the notification email.
-      # This method can be overriden.
+      # This method can be overridden.
       # @api protected
       #
       # @param [String]  key                  Key of the notification
@@ -151,7 +152,7 @@ module ActivityNotification
       alias_method :_subscribes_to_email?, :_subscribes_to_notification_email?
 
       # Returns if the target subscribes to the specified optional target.
-      # This method can be overriden.
+      # This method can be overridden.
       # @api protected
       #
       # @param [String]         key                  Key of the notification

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

@@ -19,6 +19,8 @@ module ActivityNotification
                       :_notification_email_allowed,
                       :_batch_notification_email_allowed,
                       :_notification_subscription_allowed,
+                      :_notification_action_cable_allowed,
+                      :_notification_action_cable_with_devise,
                       :_notification_devise_resource,
                       :_notification_current_devise_target,
                       :_printable_notification_target_name
@@ -35,13 +37,15 @@ module ActivityNotification
       # Sets default values to target class fields.
       # @return [NilClass] nil
       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_subscription_allowed  = ActivityNotification.config.subscription_enabled
-        self._notification_devise_resource       = ->(model) { model }
-        self._notification_current_devise_target = ->(current_resource) { current_resource }
-        self._printable_notification_target_name = :printable_name
+        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_action_cable_allowed     = ActivityNotification.config.action_cable_enabled
+        self._notification_action_cable_with_devise = ActivityNotification.config.action_cable_with_devise
+        self._notification_devise_resource          = ->(model) { model }
+        self._notification_current_devise_target    = ->(current_resource) { current_resource }
+        self._printable_notification_target_name    = :printable_name
         nil
       end
 
@@ -75,8 +79,8 @@ module ActivityNotification
         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
+          target_notifications.latest_order!(reverse).map{ |n| n.latest_group_member } :
+          target_notifications.latest_order!(reverse).to_a
       end
 
       # Gets all notifications for this target type grouped by targets.
@@ -133,7 +137,7 @@ module ActivityNotification
       end
 
       # Resolves current authenticated target by devise authentication from current resource signed in with Devise.
-      # This method is able to be overriden.
+      # This method is able to be overridden.
       #
       # @param [Object] current_resource Current resource signed in with Devise
       # @return [Object] Current authenticated target by devise authentication
@@ -150,15 +154,15 @@ module ActivityNotification
     end
 
     # Returns target email address for email notification.
-    # This method is able to be overriden.
+    # This method is able to be overridden.
     #
     # @return [String] Target email address
     def mailer_to
       resolve_value(_notification_email)
     end
 
-    # Returns if sending notification email is allowed for the target from configured field or overriden method.
-    # This method is able to be overriden.
+    # Returns if sending notification email is allowed for the target from configured field or overridden method.
+    # This method is able to be overridden.
     #
     # @param [Object] notifiable Notifiable instance of the notification
     # @param [String] key Key of the notification
@@ -167,8 +171,8 @@ 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.
+    # Returns if sending batch notification email is allowed for the target from configured field or overridden method.
+    # This method is able to be overridden.
     #
     # @param [String] key Key of the notifications
     # @return [Boolean] If sending batch notification email is allowed for the target
@@ -176,8 +180,8 @@ module ActivityNotification
       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.
+    # Returns if subscription management is allowed for the target from configured field or overridden method.
+    # This method is able to be overridden.
     #
     # @param [String] key Key of the notifications
     # @return [Boolean] If subscription management is allowed for the target
@@ -186,13 +190,54 @@ module ActivityNotification
     end
     alias_method :notification_subscription_allowed?, :subscription_allowed?
 
+    # Returns if publishing WebSocket using ActionCable is allowed for the target from configured field or overridden method.
+    # This method is able to be overridden.
+    #
+    # @param [Object] notifiable Notifiable instance of the notification
+    # @param [String] key Key of the notification
+    # @return [Boolean] If publishing WebSocket using ActionCable is allowed for the target
+    def notification_action_cable_allowed?(notifiable = nil, key = nil)
+      resolve_value(_notification_action_cable_allowed, notifiable, key)
+    end
+
+    # Returns if publishing WebSocket using ActionCable is allowed only for the authenticated target with Devise from configured field or overridden method.
+    #
+    # @return [Boolean] If publishing WebSocket using ActionCable is allowed for the target
+    def notification_action_cable_with_devise?
+      resolve_value(_notification_action_cable_with_devise)
+    end
+
+    # :only-rails5-plus#only-rails-with-callback-issue:
+    # :only-rails5-plus#only-rails-without-callback-issue:
+    # :only-rails5-plus#only-rails-with-callback-issue#except-dynamoid:
+    # :only-rails5-plus#only-rails-without-callback-issue#except-dynamoid:
+    if Rails::VERSION::MAJOR >= 5
+      # Returns notification ActionCable channel class name from action_cable_with_devise? configuration.
+      #
+      # @return [String] Notification ActionCable channel class name from action_cable_with_devise? configuration
+      def notification_action_cable_channel_class_name
+        notification_action_cable_with_devise? ? "ActivityNotification::NotificationWithDeviseChannel" : "ActivityNotification::NotificationChannel"
+      end
+    end
+    # :only-rails5-plus#only-rails-with-callback-issue:
+    # :only-rails5-plus#only-rails-without-callback-issue:
+    # :only-rails5-plus#only-rails-with-callback-issue#except-dynamoid:
+    # :only-rails5-plus#only-rails-without-callback-issue#except-dynamoid:
+
+    # Returns Devise resource model associated with this target.
+    #
+    # @return [Object] Devise resource model associated with this target
+    def notification_devise_resource
+      resolve_value(_notification_devise_resource)
+    end
+
     # Returns if current resource signed in with Devise is authenticated for the notification.
-    # This method is able to be overriden.
+    # This method is able to be overridden.
     #
     # @param [Object] current_resource Current resource signed in with Devise
     # @return [Boolean] If current resource signed in with Devise is authenticated for the notification
     def authenticated_with_devise?(current_resource)
-      devise_resource = resolve_value(_notification_devise_resource)
+      devise_resource = notification_devise_resource
       unless current_resource.blank? or current_resource.is_a? devise_resource.class
         raise TypeError,
           "Different type of current resource #{current_resource.class} "\
@@ -237,7 +282,7 @@ module ActivityNotification
     # @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
     def has_unopened_notifications?(options = {})
-      _unopened_notification_index(options).present?
+      _unopened_notification_index(options).exists?
     end
 
     # Returns automatically arranged notification index of the target.
@@ -415,7 +460,7 @@ module ActivityNotification
     # @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
     def unopened_notification_index_with_attributes(options = {})
-      include_attributes _unopened_notification_index(options)
+      include_attributes(_unopened_notification_index(options)).to_a
     end
 
     # Gets opened notification index of the target with including attributes like target, notifiable, group and notifier.
@@ -436,7 +481,7 @@ module ActivityNotification
     # @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
     def opened_notification_index_with_attributes(options = {})
-      include_attributes _opened_notification_index(options)
+      include_attributes(_opened_notification_index(options)).to_a
     end
 
     # Sends notification email to the target.
@@ -513,7 +558,7 @@ module ActivityNotification
       # @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
+      # @return [ActiveRecord_AssociationRelation<Notificaion>|Mongoid::Criteria<Notificaion>|Dynamoid::Criteria::Chain] Unopened notification index of the target
       def _unopened_notification_index(options = {})
         reverse            = options[:reverse] || false
         with_group_members = options[:with_group_members] || false
@@ -533,7 +578,7 @@ module ActivityNotification
       # @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
+      # @return [ActiveRecord_AssociationRelation<Notificaion>|Mongoid::Criteria<Notificaion>|Dynamoid::Criteria::Chain] Opened notification index of the target
       def _opened_notification_index(options = {})
         limit              = options[:limit] || ActivityNotification.config.opened_index_limit
         reverse            = options[:reverse] || false
@@ -546,11 +591,11 @@ module ActivityNotification
       # Otherwise, target, notifiable and or notifier will be include without group.
       # @api private
       #
-      # @param [ActiveRecord_AssociationRelation<Notificaion>] target_index Notification index
-      # @return [ActiveRecord_AssociationRelation<Notificaion>] Notification index with attributes
+      # @param [ActiveRecord_AssociationRelation<Notificaion>|Mongoid::Criteria<Notificaion>|Dynamoid::Criteria::Chain] target_index Notification index
+      # @return [ActiveRecord_AssociationRelation<Notificaion>|Mongoid::Criteria<Notificaion>|Dynamoid::Criteria::Chain] Notification index with attributes
       def include_attributes(target_index)
         if target_index.present?
-          Notification.group_member_exists?(target_index) ?
+          Notification.group_member_exists?(target_index.to_a) ?
             target_index.with_target.with_notifiable.with_group.with_notifier :
             target_index.with_target.with_notifiable.with_notifier
         else
@@ -606,7 +651,7 @@ module ActivityNotification
         if has_unopened_notifications?(options)
           # Return unopened notifications first
           target_unopened_index = arrange_single_notification_index(loading_unopened_index_method, options)
-          # Total limit if notification index
+          # Total limit of notification index
           total_limit = options[:limit] || ActivityNotification.config.opened_index_limit
           # Additionaly, return opened notifications unless unopened index size overs the limit
           if (opened_limit = total_limit - target_unopened_index.size) > 0

data/lib/activity_notification/optional_targets/base.rb

@@ -28,13 +28,13 @@ module ActivityNotification
         self.class.name.demodulize.underscore.to_sym
       end
 
-      # Initialize method to be overriden in user implementation class
+      # Initialize method to be overridden in user implementation class
       # @param [Hash] _options Options for initializing
       def initialize_target(_options = {})
         raise NotImplementedError, "You have to implement #{self.class}##{__method__}"
       end
 
-      # Publishing notification method to be overriden in user implementation class
+      # Publishing notification method to be overridden in user implementation class
       # @param [Notification] _notification Notification instance
       # @param [Hash] _options Options for publishing
       def notify(_notification, _options = {})

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

@@ -8,9 +8,7 @@ module ActivityNotification
         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
+        self.table_name = ActivityNotification.config.notification_table_name
 
         # Belongs to target instance of this notification as polymorphic association.
         # @scope instance
@@ -152,27 +150,10 @@ module ActivityNotification
         # @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 method cannot be chained with order by other columns like created_at
-          # select(:key).distinct.pluck(:key)
-          pluck(:key).uniq
-        end
-
         # Raise DeleteRestrictionError for notifications.
+        # @param [String] error_text Error text for raised exception
+        # @raise DeleteRestrictionError
+        # @return [void]
         def self.raise_delete_restriction_error(error_text)
           raise ::ActiveRecord::DeleteRestrictionError.new(error_text)
         end

data/lib/activity_notification/orm/dynamoid.rb

@@ -0,0 +1,495 @@
+require 'dynamoid/adapter_plugin/aws_sdk_v3'
+require_relative 'dynamoid/extension.rb'
+
+module ActivityNotification
+  module Association
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :_associated_composite_records
+      self._associated_composite_records = []
+    end
+
+    class_methods do
+      # Defines has_many association with ActivityNotification models.
+      # @return [Dynamoid::Criteria::Chain] Database query of associated model instances
+      def has_many_records(name, options = {})
+        has_many_composite_xdb_records name, options
+      end
+
+      # Defines polymorphic belongs_to association using composite key with models in other database.
+      def belongs_to_composite_xdb_record(name, _options = {})
+        association_name     = name.to_s.singularize.underscore
+        composite_field = "#{association_name}_key".to_sym
+        field composite_field, :string
+        associated_record_field = "#{association_name}_record".to_sym
+        field associated_record_field, :string if ActivityNotification.config.store_with_associated_records && _options[:store_with_associated_records]
+
+        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?
+              composite_key = self.send(composite_field)
+              if composite_key.present? && (class_name = composite_key.split(ActivityNotification.config.composite_key_delimiter).first).present?
+                object_class = class_name.classify.constantize
+                self.instance_variable_set("@#{name}", object_class.where(id: composite_key.split(ActivityNotification.config.composite_key_delimiter).last).first)
+              end
+            end
+            self.instance_variable_get("@#{name}")
+          end
+
+          define_method("#{name}=") do |new_instance|
+            if new_instance.nil?
+              self.send("#{composite_field}=", nil)
+            else
+              self.send("#{composite_field}=", "#{new_instance.class.name}#{ActivityNotification.config.composite_key_delimiter}#{new_instance.id}")
+              self.send("#{associated_record_field}=", new_instance.to_json) if ActivityNotification.config.store_with_associated_records && _options[:store_with_associated_records]
+            end
+            self.instance_variable_set("@#{name}", nil)
+          end
+
+          define_method("#{association_name}_type") do
+            composite_key = self.send(composite_field)
+            composite_key.present? ? composite_key.split(ActivityNotification.config.composite_key_delimiter).first : nil
+          end
+
+          define_method("#{association_name}_id") do
+            composite_key = self.send(composite_field)
+            composite_key.present? ? composite_key.split(ActivityNotification.config.composite_key_delimiter).last : nil
+          end
+        end
+
+        self._associated_composite_records.push(association_name.to_sym)
+      end
+
+      # Defines polymorphic has_many association using composite key with models in other database.
+      # @todo Add dependent option
+      def has_many_composite_xdb_records(name, options = {})
+        association_name     = options[:as] || name.to_s.underscore
+        composite_field = "#{association_name}_key".to_sym
+        object_name          = options[:class_name] || name.to_s.singularize.camelize
+        object_class         = object_name.classify.constantize
+
+        self.instance_eval do
+          # Set default reload arg to true since Dynamoid::Criteria::Chain is stateful on the query
+          define_method(name) do |reload = true|
+            reload and self.instance_variable_set("@#{name}", nil)
+            if self.instance_variable_get("@#{name}").blank?
+              new_value = object_class.where(composite_field => "#{self.class.name}#{ActivityNotification.config.composite_key_delimiter}#{self.id}")
+              self.instance_variable_set("@#{name}", new_value)
+            end
+            self.instance_variable_get("@#{name}")
+          end
+        end
+      end
+    end
+
+    # Defines update method as update_attributes method
+    def update(attributes)
+      attributes_with_association = attributes.map { |attribute, value|
+        self.class._associated_composite_records.include?(attribute) ?
+          ["#{attribute}_key".to_sym, value.nil? ? nil : "#{value.class.name}#{ActivityNotification.config.composite_key_delimiter}#{value.id}"] :
+          [attribute, value]
+      }.to_h
+      update_attributes(attributes_with_association)
+    end
+  end
+end
+
+# Monkey patching for Rails 6.0+
+class ActiveModel::NullMutationTracker
+  # Monkey patching for Rails 6.0+
+  def force_change(attr_name); end if Rails::VERSION::MAJOR >= 6
+end
+
+# Entend Dynamoid to support ActivityNotification scope in Dynamoid::Criteria::Chain
+# @private
+module Dynamoid # :nodoc: all
+  # https://github.com/Dynamoid/dynamoid/blob/master/lib/dynamoid/criteria.rb
+  # @private
+  module Criteria
+    # https://github.com/Dynamoid/dynamoid/blob/master/lib/dynamoid/criteria/chain.rb
+    # @private
+    class Chain
+      # Selects all notification index.
+      #   ActivityNotification::Notification.all_index!
+      # is defined same as
+      #   ActivityNotification::Notification.group_owners_only.latest_order
+      # @scope class
+      # @example Get all notification index of the @user
+      #   @notifications = @user.notifications.all_index!
+      #   @notifications = @user.notifications.group_owners_only.latest_order
+      # @param [Boolean] reverse If notification index will be ordered as earliest first
+      # @param [Boolean] with_group_members If notification index will include group members
+      # @return [Dynamoid::Criteria::Chain] Database query of filtered notifications
+      def all_index!(reverse = false, with_group_members = false)
+        target_index = with_group_members ? self : group_owners_only
+        reverse ? target_index.earliest_order : target_index.latest_order
+      end
+
+      # Selects unopened notification index.
+      #   ActivityNotification::Notification.unopened_index
+      # is defined same as
+      #   ActivityNotification::Notification.unopened_only.group_owners_only.latest_order
+      # @scope class
+      # @example Get unopened notificaton index of the @user
+      #   @notifications = @user.notifications.unopened_index
+      #   @notifications = @user.notifications.unopened_only.group_owners_only.latest_order
+      # @param [Boolean] reverse If notification index will be ordered as earliest first
+      # @param [Boolean] with_group_members If notification index will include group members
+      # @return [Dynamoid::Criteria::Chain] Database query of filtered notifications
+      def unopened_index(reverse = false, with_group_members = false)
+        target_index = with_group_members ? unopened_only : unopened_only.group_owners_only
+        reverse ? target_index.earliest_order : target_index.latest_order
+      end
+
+      # Selects unopened notification index.
+      #   ActivityNotification::Notification.opened_index(limit)
+      # is defined same as
+      #   ActivityNotification::Notification.opened_only(limit).group_owners_only.latest_order
+      # @scope class
+      # @example Get unopened notificaton index of the @user with limit 10
+      #   @notifications = @user.notifications.opened_index(10)
+      #   @notifications = @user.notifications.opened_only(10).group_owners_only.latest_order
+      # @param [Integer] limit Limit to query for opened notifications
+      # @param [Boolean] reverse If notification index will be ordered as earliest first
+      # @param [Boolean] with_group_members If notification index will include group members
+      # @return [Dynamoid::Criteria::Chain] Database query of filtered notifications
+      def opened_index(limit, reverse = false, with_group_members = false)
+        target_index = with_group_members ? opened_only(limit) : opened_only(limit).group_owners_only
+        reverse ? target_index.earliest_order : target_index.latest_order
+      end
+
+      # Selects filtered notifications or subscriptions by associated instance.
+      # @scope class
+      # @param [String] name     Association name
+      # @param [Object] instance Associated instance
+      # @return [Dynamoid::Criteria::Chain] Database query of filtered notifications or subscriptions
+      def filtered_by_association(name, instance)
+        instance.present? ? where("#{name}_key" => "#{instance.class.name}#{ActivityNotification.config.composite_key_delimiter}#{instance.id}") : where("#{name}_key.null" => true)
+      end
+
+      # Selects filtered notifications or subscriptions by association type.
+      # @scope class
+      # @param [String] name     Association name
+      # @param [Object] type     Association type
+      # @return [Dynamoid::Criteria::Chain] Database query of filtered notifications or subscriptions
+      def filtered_by_association_type(name, type)
+        type.present? ? where("#{name}_key.begins_with" => "#{type}#{ActivityNotification.config.composite_key_delimiter}") : none
+      end
+
+      # Selects filtered notifications or subscriptions by association type and id.
+      # @scope class
+      # @param [String] name     Association name
+      # @param [Object] type     Association type
+      # @param [String] id       Association id
+      # @return [Dynamoid::Criteria::Chain] Database query of filtered notifications or subscriptions
+      def filtered_by_association_type_and_id(name, type, id)
+        type.present? && id.present? ? where("#{name}_key" => "#{type}#{ActivityNotification.config.composite_key_delimiter}#{id}") : none
+      end
+
+      # Selects filtered notifications or subscriptions 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 [Dynamoid::Criteria::Chain] Database query of filtered notifications or subscriptions
+      def filtered_by_target(target)
+        filtered_by_association("target", target)
+      end
+
+      # 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 [Dynamoid::Criteria::Chain] Database query of filtered notifications
+      def filtered_by_instance(notifiable)
+        filtered_by_association("notifiable", notifiable)
+      end
+
+      # 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 [Dynamoid::Criteria::Chain] Database query of filtered notifications
+      def filtered_by_group(group)
+        filtered_by_association("group", group)
+      end
+
+      # Selects filtered notifications or subscriptions by target_type.
+      # @example Get filtered unopened notificatons of User as target type
+      #   @notifications = ActivityNotification.Notification.unopened_only.filtered_by_target_type('User')
+      # @scope class
+      # @param [String] target_type Target type for filter
+      # @return [Dynamoid::Criteria::Chain] Database query of filtered notifications or subscriptions
+      def filtered_by_target_type(target_type)
+        filtered_by_association_type("target", target_type)
+      end
+
+      # 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 [Dynamoid::Criteria::Chain] Database query of filtered notifications
+      def filtered_by_type(notifiable_type)
+        filtered_by_association_type("notifiable", notifiable_type)
+      end
+
+      # Selects filtered notifications or subscriptions by key.
+      # @example Get filtered unopened notificatons of the @user with key 'comment.reply'
+      #   @notifications = @user.notifications.unopened_only.filtered_by_key('comment.reply')
+      # @scope class
+      # @param [String] key Key of the notification for filter
+      # @return [Dynamoid::Criteria::Chain] Database query of filtered notifications or subscriptions
+      def filtered_by_key(key)
+        where(key: key)
+      end
+
+      # Selects filtered notifications or subscriptions by notifiable_type, group or key with filter options.
+      # @example Get filtered unopened notificatons of the @user for Comment notifiable class
+      #   @notifications = @user.notifications.unopened_only.filtered_by_options({ filtered_by_type: 'Comment' })
+      # @example Get filtered unopened notificatons of the @user for @article as group
+      #   @notifications = @user.notifications.unopened_only.filtered_by_options({ filtered_by_group: @article })
+      # @example Get filtered unopened notificatons of the @user for Article instance id=1 as group
+      #   @notifications = @user.notifications.unopened_only.filtered_by_options({ filtered_by_group_type: 'Article', filtered_by_group_id: '1' })
+      # @example Get filtered unopened notificatons of the @user with key 'comment.reply'
+      #   @notifications = @user.notifications.unopened_only.filtered_by_options({ filtered_by_key: 'comment.reply' })
+      # @example Get filtered unopened notificatons of the @user for Comment notifiable class with key 'comment.reply'
+      #   @notifications = @user.notifications.unopened_only.filtered_by_options({ filtered_by_type: 'Comment', filtered_by_key: 'comment.reply' })
+      # @example Get custom filtered notificatons of the @user
+      #   @notifications = @user.notifications.unopened_only.filtered_by_options({ custom_filter: ["created_at >= ?", time.hour.ago] })
+      # @scope class
+      # @param [Hash] options Options for filter
+      # @option options [String]     :filtered_by_type       (nil) Notifiable type for filter
+      # @option options [Object]     :filtered_by_group      (nil) Group instance for filter
+      # @option options [String]     :filtered_by_group_type (nil) Group type for filter, valid with :filtered_by_group_id
+      # @option options [String]     :filtered_by_group_id   (nil) Group instance id for filter, valid with :filtered_by_group_type
+      # @option options [String]     :filtered_by_key        (nil) Key of the notification for filter
+      # @option options [Array|Hash] :custom_filter          (nil) Custom notification filter (e.g. ['created_at.gt': time.hour.ago])
+      # @return [Dynamoid::Criteria::Chain] Database query of filtered notifications or subscriptions
+      def filtered_by_options(options = {})
+        options = ActivityNotification.cast_to_indifferent_hash(options)
+        filtered_notifications = self
+        if options.has_key?(:filtered_by_type)
+          filtered_notifications = filtered_notifications.filtered_by_type(options[:filtered_by_type])
+        end
+        if options.has_key?(:filtered_by_group)
+          filtered_notifications = filtered_notifications.filtered_by_group(options[:filtered_by_group])
+        end
+        if options.has_key?(:filtered_by_group_type) && options.has_key?(:filtered_by_group_id)
+          filtered_notifications = filtered_notifications.filtered_by_association_type_and_id("group", options[:filtered_by_group_type], options[:filtered_by_group_id])
+        end
+        if options.has_key?(:filtered_by_key)
+          filtered_notifications = filtered_notifications.filtered_by_key(options[:filtered_by_key])
+        end
+        if options.has_key?(:custom_filter)
+          filtered_notifications = filtered_notifications.where(options[:custom_filter])
+        end
+        filtered_notifications
+      end
+
+      # Orders by latest (newest) first as created_at: :desc.
+      # It uses sort key of Global Secondary Index in DynamoDB tables.
+      # @return [Dynamoid::Criteria::Chain] Database query of notifications or subscriptions ordered by latest first
+      def latest_order
+        # order(created_at: :desc)
+        scan_index_forward(false)
+      end
+
+      # Orders by earliest (older) first as created_at: :asc.
+      # It uses sort key of Global Secondary Index in DynamoDB tables.
+      # @return [Dynamoid::Criteria::Chain] Database query of notifications or subscriptions ordered by earliest first
+      def earliest_order
+        # order(created_at: :asc)
+        scan_index_forward(true)
+      end
+
+      # Orders by latest (newest) first as created_at: :desc and returns as array.
+      # @param [Boolean] reverse If notifications or subscriptions will be ordered as earliest first
+      # @return [Array] Array of notifications or subscriptions ordered by latest first
+      def latest_order!(reverse = false)
+        # order(created_at: :desc)
+        reverse ? earliest_order! : earliest_order!.reverse
+      end
+
+      # Orders by earliest (older) first as created_at: :asc and returns as array.
+      # It does not use sort key in DynamoDB tables.
+      # @return [Array] Array of notifications or subscriptions ordered by earliest first
+      def earliest_order!
+        # order(created_at: :asc)
+        all.to_a.sort_by {|n| n.created_at }
+      end
+
+      # Orders by latest (newest) first as subscribed_at: :desc.
+      # @return [Array] Array of subscriptions ordered by latest subscribed_at first
+      def latest_subscribed_order
+        # order(subscribed_at: :desc)
+        earliest_subscribed_order.reverse
+      end
+
+      # Orders by earliest (older) first as subscribed_at: :asc.
+      # @return [Array] Array of subscriptions ordered by earliest subscribed_at first
+      def earliest_subscribed_order
+        # order(subscribed_at: :asc)
+        all.to_a.sort_by {|n| n.subscribed_at }
+      end
+
+      # Orders by key name as key: :asc.
+      # @return [Array] Array of subscriptions ordered by key name
+      def key_order
+        # order(key: :asc)
+        all.to_a.sort_by {|n| n.key }
+      end
+
+      # Selects group owner notifications only.
+      # @scope class
+      # @return [Dynamoid::Criteria::Chain] Database query of filtered notifications
+      def group_owners_only
+        where('group_owner_id.null': true)
+      end
+
+      # Selects group member notifications only.
+      # @scope class
+      # @return [Dynamoid::Criteria::Chain] Database query of filtered notifications
+      def group_members_only
+        where('group_owner_id.not_null': true)
+      end
+
+      # Selects unopened notifications only.
+      # @scope class
+      # @return [Dynamoid::Criteria::Chain] Database query of filtered notifications
+      def unopened_only
+        where('opened_at.null': true)
+      end
+
+      # Selects opened notifications only without limit.
+      # Be careful to get too many records with this method.
+      # @scope class
+      # @return [Dynamoid::Criteria::Chain] Database query of filtered notifications
+      def opened_only!
+        where('opened_at.not_null': true)
+      end
+
+      # Selects opened notifications only with limit.
+      # @scope class
+      # @param [Integer] limit Limit to query for opened notifications
+      # @return [Dynamoid::Criteria::Chain] Database query of filtered notifications
+      def opened_only(limit)
+        limit == 0 ? none : opened_only!.limit(limit)
+      end
+
+      # Selects group member notifications in unopened_index.
+      # @scope class
+      # @return [Dynamoid::Criteria::Chain] Database query of filtered notifications
+      def unopened_index_group_members_only
+        group_owner_ids = unopened_index.map(&:id)
+        group_owner_ids.empty? ? none : where('group_owner_id.in': group_owner_ids)
+      end
+
+      # Selects group member notifications in opened_index.
+      # @scope class
+      # @param [Integer] limit Limit to query for opened notifications
+      # @return [Dynamoid::Criteria::Chain] Database query of filtered notifications
+      def opened_index_group_members_only(limit)
+        group_owner_ids = opened_index(limit).map(&:id)
+        group_owner_ids.empty? ? none : where('group_owner_id.in': group_owner_ids)
+      end
+
+      # Selects notifications within expiration.
+      # @scope class
+      # @param [ActiveSupport::Duration] expiry_delay Expiry period of notifications
+      # @return [Dynamoid::Criteria::Chain] Database query of filtered notifications
+      def within_expiration_only(expiry_delay)
+        where('created_at.gt': expiry_delay.ago)
+      end
+
+      # Selects group member notifications with specified group owner ids.
+      # @scope class
+      # @param [Array<String>] owner_ids Array of group owner ids
+      # @return [Dynamoid::Criteria::Chain] Database query of filtered notifications
+      def group_members_of_owner_ids_only(owner_ids)
+        owner_ids.present? ? where('group_owner_id.in': owner_ids) : none
+      end
+
+      # Includes target instance with query for notifications or subscriptions.
+      # @return [Dynamoid::Criteria::Chain] Database query of notifications with target
+      def with_target
+        self
+      end
+
+      # Includes notifiable instance with query for notifications.
+      # @return [Dynamoid::Criteria::Chain] Database query of notifications with notifiable
+      def with_notifiable
+        self
+      end
+
+      # Includes group instance with query for notifications.
+      # @return [Dynamoid::Criteria::Chain] Database query of notifications with group
+      def with_group
+        self
+      end
+
+      # Includes group owner instances with query for notifications.
+      # @return [Dynamoid::Criteria::Chain] Database query of notifications with group owner
+      def with_group_owner
+        self
+      end
+
+      # Includes group member instances with query for notifications.
+      # @return [Dynamoid::Criteria::Chain] Database query of notifications with group members
+      def with_group_members
+        self
+      end
+
+      # Includes notifier instance with query for notifications.
+      # @return [Dynamoid::Criteria::Chain] Database query of notifications with notifier
+      def with_notifier
+        self
+      end
+
+      # Dummy reload method for test of notifications or subscriptions.
+      def reload
+        self
+      end
+
+      # Returns latest notification instance.
+      # @return [Notification] Latest notification instance
+      def latest
+        latest_order.first
+      end
+
+      # Returns earliest notification instance.
+      # @return [Notification] Earliest notification instance
+      def earliest
+        earliest_order.first
+      end
+
+      # Returns latest notification instance.
+      # It does not use sort key in DynamoDB tables.
+      # @return [Notification] Latest notification instance
+      def latest!
+        latest_order!.first
+      end
+
+      # Returns earliest notification instance.
+      # It does not use sort key in DynamoDB tables.
+      # @return [Notification] Earliest notification instance
+      def earliest!
+        earliest_order!.first
+      end
+
+      # Selects unique keys from query for notifications or subscriptions.
+      # @return [Array<String>] Array of notification unique keys
+      def uniq_keys
+        all.to_a.collect {|n| n.key }.uniq
+      end
+    end
+  end
+end
+
+require_relative 'dynamoid/notification.rb'
+require_relative 'dynamoid/subscription.rb'