activity_notification 1.4.4 → 2.2.4

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
@@ -25,14 +23,14 @@ module ActivityNotification
         # Belongs to group instance of this notification as polymorphic association.
         # @scope instance
         # @return [Object] Group instance of this notification
-        belongs_to :group,         { polymorphic: true }.merge(Rails::VERSION::MAJOR >= 5 ? { optional: true } : {})
+        belongs_to :group,         polymorphic: true, optional: 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 } : {})
+        belongs_to :group_owner,   class_name: "ActivityNotification::Notification", optional: true
 
         # Has many group member notification instances of this notification.
         # Only group owner instance has :group_members value.
@@ -44,7 +42,7 @@ module ActivityNotification
         # Belongs to :notifier instance of this notification.
         # @scope instance
         # @return [Object] Notifier instance of this notification
-        belongs_to :notifier,      { polymorphic: true }.merge(Rails::VERSION::MAJOR >= 5 ? { optional: true } : {})
+        belongs_to :notifier,      polymorphic: true, optional: true
 
         # Serialize parameters Hash
         serialize  :parameters, Hash
@@ -120,14 +118,6 @@ module ActivityNotification
         # @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)
@@ -136,6 +126,22 @@ module ActivityNotification
         # @return [ActiveRecord_AssociationRelation<Notificaion>] Database query of filtered notifications
         scope :filtered_by_group,                 ->(group) { where(group: group) }
 
+        # Selects filtered notifications later than specified time.
+        # @example Get filtered unopened notificatons of the @user later than @notification
+        #   @notifications = @user.notifications.unopened_only.later_than(@notification.created_at)
+        # @scope class
+        # @param [Time] Created time of the notifications for filter
+        # @return [ActiveRecord_AssociationRelation<Notificaion>, Mongoid::Criteria<Notificaion>] Database query of filtered notifications
+        scope :later_than,                        ->(created_time) { where('created_at > ?', created_time) }
+
+        # Selects filtered notifications earlier than specified time.
+        # @example Get filtered unopened notificatons of the @user earlier than @notification
+        #   @notifications = @user.notifications.unopened_only.earlier_than(@notification.created_at)
+        # @scope class
+        # @param [Time] Created time of the notifications for filter
+        # @return [ActiveRecord_AssociationRelation<Notificaion>, Mongoid::Criteria<Notificaion>] Database query of filtered notifications
+        scope :earlier_than,                      ->(created_time) { where('created_at < ?', created_time) }
+
         # Includes target instance with query for notifications.
         # @return [ActiveRecord_AssociationRelation<Notificaion>] Database query of notifications with target
         scope :with_target,                       -> { includes(:target) }
@@ -160,27 +166,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 [ActiveRecord::DeleteRestrictionError] DeleteRestrictionError from used ORM
+        # @return [void]
         def self.raise_delete_restriction_error(error_text)
           raise ::ActiveRecord::DeleteRestrictionError.new(error_text)
         end

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

@@ -17,7 +17,7 @@ module ActivityNotification
         serialize  :optional_targets, Hash
 
         validates  :target,               presence: true
-        validates  :key,                  presence: true
+        validates  :key,                  presence: true, uniqueness: { scope: :target }
         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

data/lib/activity_notification/orm/active_record.rb

@@ -6,7 +6,7 @@ module ActivityNotification
       # 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
+        has_many name, **options
       end
     end
   end

data/lib/activity_notification/orm/dynamoid/extension.rb

@@ -0,0 +1,262 @@
+require 'dynamoid/adapter_plugin/aws_sdk_v3'
+
+# Entend Dynamoid v3.1.0 to support none, limit, exists?, update_all, serializable_hash in Dynamoid::Criteria::Chain.
+# ActivityNotification project will try to contribute these fundamental functions to Dynamoid upstream.
+# @private
+module Dynamoid # :nodoc: all
+  # https://github.com/Dynamoid/dynamoid/blob/master/lib/dynamoid/criteria.rb
+  # @private
+  module Criteria
+    # @private
+    class None < Chain
+      def ==(other)
+        other.is_a?(None)
+      end
+
+      def records
+        []
+      end
+
+      def count
+        0
+      end
+
+      def delete_all
+      end
+
+      def empty?
+        true
+      end
+    end
+
+    # https://github.com/Dynamoid/dynamoid/blob/master/lib/dynamoid/criteria/chain.rb
+    # @private
+    class Chain
+      # Return new none object
+      def none
+        None.new(self.source)
+      end
+
+      # Set query result limit as record_limit of Dynamoid
+      # @scope class
+      # @param [Integer] limit Query result limit as record_limit
+      # @return [Dynamoid::Criteria::Chain] Database query of filtered notifications or subscriptions
+      def limit(limit)
+        record_limit(limit)
+      end
+
+      # Return if records exist
+      # @scope class
+      # @return [Boolean] If records exist
+      def exists?
+        record_limit(1).count > 0
+      end
+
+      # Return size of records as count
+      # @scope class
+      # @return [Integer] Size of records
+      def size
+        count
+      end
+
+      #TODO Make this batch
+      def update_all(conditions = {})
+        each do |document|
+          document.update_attributes(conditions)
+        end
+      end
+
+      # Return serializable_hash as array
+      def serializable_hash(options = {})
+        all.to_a.map { |r| r.serializable_hash(options) }
+      end
+    end
+
+    # https://github.com/Dynamoid/dynamoid/blob/master/lib/dynamoid/criteria.rb
+    # @private
+    module ClassMethods
+      define_method(:none) do |*args, &blk|
+        chain = Dynamoid::Criteria::Chain.new(self)
+        chain.send(:none, *args, &blk)
+      end
+    end
+  end
+end
+
+# Entend Dynamoid to support query and scan with 'null' and 'not_null' conditions
+# @private
+module Dynamoid # :nodoc: all
+  # @private
+  module Criteria
+    # https://github.com/Dynamoid/dynamoid/blob/master/lib/dynamoid/criteria/chain.rb
+    # @private
+    module NullOperatorExtension
+      # @private
+      def field_hash(key)
+        name, operation = key.to_s.split('.')
+        val = type_cast_condition_parameter(name, query[key])
+
+        hash = case operation
+               when 'null'
+                 { null: val }
+               when 'not_null'
+                 { not_null: val }
+               else
+                 return super(key)
+               end
+
+        { name.to_sym => hash }
+      end
+    end
+
+    # https://github.com/Dynamoid/dynamoid/blob/master/lib/dynamoid/criteria/chain.rb
+    # @private
+    class Chain
+      prepend NullOperatorExtension
+    end
+  end
+
+  # @private
+  module AdapterPlugin
+    # @private
+    class AwsSdkV3
+
+      NULL_OPERATOR_FIELD_MAP = {
+        null:         'NULL',
+        not_null:     'NOT_NULL'
+      }.freeze
+
+      # https://github.com/Dynamoid/dynamoid/blob/master/lib/dynamoid/adapter_plugin/aws_sdk_v3/query.rb
+      # @private
+      class Query < ::Dynamoid::AdapterPlugin::Query
+        # @private
+        def query_filter
+          conditions.except(*AwsSdkV3::RANGE_MAP.keys).reduce({}) do |result, (attr, cond)|
+            if AwsSdkV3::NULL_OPERATOR_FIELD_MAP.has_key?(cond.keys[0])
+              condition = { comparison_operator: AwsSdkV3::NULL_OPERATOR_FIELD_MAP[cond.keys[0]] }
+            else
+              condition = {
+                comparison_operator: AwsSdkV3::FIELD_MAP[cond.keys[0]],
+                attribute_value_list: AwsSdkV3.attribute_value_list(AwsSdkV3::FIELD_MAP[cond.keys[0]], cond.values[0].freeze)
+              }
+            end
+            result[attr] = condition
+            result
+          end
+        end
+      end
+
+      # https://github.com/Dynamoid/dynamoid/blob/master/lib/dynamoid/adapter_plugin/aws_sdk_v3/scan.rb
+      # @private
+      class Scan < ::Dynamoid::AdapterPlugin::Scan
+        # @private
+        def scan_filter
+          conditions.reduce({}) do |result, (attr, cond)|
+            if AwsSdkV3::NULL_OPERATOR_FIELD_MAP.has_key?(cond.keys[0])
+              condition = { comparison_operator: AwsSdkV3::NULL_OPERATOR_FIELD_MAP[cond.keys[0]] }
+            else
+              condition = {
+                comparison_operator: AwsSdkV3::FIELD_MAP[cond.keys[0]],
+                attribute_value_list: AwsSdkV3.attribute_value_list(AwsSdkV3::FIELD_MAP[cond.keys[0]], cond.values[0].freeze)
+              }
+            end
+            result[attr] = condition
+            result
+          end
+        end
+      end
+    end
+  end
+end
+
+# Entend Dynamoid to support uniqueness validator
+# @private
+module Dynamoid # :nodoc: all
+  # https://github.com/Dynamoid/dynamoid/blob/master/lib/dynamoid/validations.rb
+  # @private
+  module Validations
+    # Validates whether or not a field is unique against the records in the database.
+    class UniquenessValidator < ActiveModel::EachValidator
+      # Validate the document for uniqueness violations.
+      # @param [Document] document The document to validate.
+      # @param [Symbol] attribute  The name of the attribute.
+      # @param [Object] value      The value of the object.
+      def validate_each(document, attribute, value)
+        return unless validation_required?(document, attribute)
+        document.errors.add(attribute, :taken, options.except(:scope).merge(value: value)) if not_unique?(document, attribute, value)
+      end
+
+      private
+
+      # Are we required to validate the document?
+      # @api private
+      def validation_required?(document, attribute)
+        document.new_record? ||
+          document.send("attribute_changed?", attribute.to_s) ||
+          scope_value_changed?(document)
+      end
+
+      # Scope reference has changed?
+      # @api private
+      def scope_value_changed?(document)
+        Array.wrap(options[:scope]).any? do |item|
+          document.send("attribute_changed?", item.to_s)
+        end
+      end
+
+      # Check whether a record is uniqueness.
+      # @api private
+      def not_unique?(document, attribute, value)
+        klass = document.class
+        while klass.superclass.respond_to?(:validators) && klass.superclass.validators.include?(self)
+          klass = klass.superclass
+        end
+        criteria = create_criteria(klass, document, attribute, value)
+        criteria.exists?
+      end
+
+      # Create the validation criteria.
+      # @api private
+      def create_criteria(base, document, attribute, value)
+        criteria = scope(base, document)
+        filter_criteria(criteria, document, attribute)
+      end
+
+      # Scope the criteria to the scope options provided.
+      # @api private
+      def scope(criteria, document)
+        Array.wrap(options[:scope]).each do |item|
+          criteria = filter_criteria(criteria, document, item)
+        end
+        criteria
+      end
+
+      # Filter the criteria.
+      # @api private
+      def filter_criteria(criteria, document, attribute)
+        value = document.read_attribute(attribute)
+        value.nil? ? criteria.where("#{attribute}.null" => true) : criteria.where(attribute => value)
+      end
+    end
+  end
+end
+
+module ActivityNotification
+  # Dynamoid extension module for ActivityNotification.
+  module DynamoidExtension
+    extend ActiveSupport::Concern
+
+    class_methods do
+      # Defines delete_all method as calling delete_table and create_table methods
+      def delete_all
+        delete_table
+        create_table(sync: true)
+      end
+    end
+
+    # Returns an instance of the specified +klass+ with the attributes of the current record.
+    def becomes(klass)
+      self
+    end
+  end
+end

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

@@ -0,0 +1,224 @@
+require 'dynamoid'
+require 'activity_notification/apis/notification_api'
+
+module ActivityNotification
+  module ORM
+    module Dynamoid
+      # Notification model implementation generated by ActivityNotification.
+      class Notification
+        include ::Dynamoid::Document
+        include ActiveModel::AttributeAssignment
+        include GlobalID::Identification
+        include DynamoidExtension
+        include Common
+        include Renderable
+        include Association
+        include NotificationApi
+
+        table name: ActivityNotification.config.notification_table_name, key: :id
+
+        # Belongs to target instance of this notification as polymorphic association using composite key.
+        # @scope instance
+        # @return [Object] Target instance of this notification
+        belongs_to_composite_xdb_record :target, store_with_associated_records: true, as_json_options: { methods: [:printable_type, :printable_target_name] }
+
+        # Belongs to notifiable instance of this notification as polymorphic association using composite key.
+        # @scope instance
+        # @return [Object] Notifiable instance of this notification
+        belongs_to_composite_xdb_record :notifiable, store_with_associated_records: true, as_json_options: { methods: [:printable_type] }
+
+        # Belongs to group instance of this notification as polymorphic association using composite key.
+        # @scope instance
+        # @return [Object] Group instance of this notification
+        belongs_to_composite_xdb_record :group, store_with_associated_records: true, as_json_options: { methods: [:printable_type, :printable_group_name] }
+
+        field :key,            :string
+        field :parameters,     :raw,      default: {}
+        field :opened_at,      :datetime
+        field :group_owner_id, :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", foreign_key: :group_owner_id, optional: true }
+
+        # Customized method that belongs to group owner notification instance of this notification.
+        # @raise [Errors::RecordNotFound] Record not found error
+        # @return [Notification] Group owner notification instance of this notification
+        def group_owner
+          group_owner_id.nil? ? nil : Notification.find(group_owner_id)
+        end
+
+        # 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 [Dynamoid::Criteria::Chain] Database query of the group member notification instances of this notification
+        # has_many   :group_members, class_name: "ActivityNotification::Notification", foreign_key: :group_owner_id
+        def group_members
+          Notification.where(group_owner_id: id)
+        end
+
+        # Belongs to :otifier instance of this notification.
+        # @scope instance
+        # @return [Object] Notifier instance of this notification
+        belongs_to_composite_xdb_record :notifier, store_with_associated_records: true, as_json_options: { methods: [:printable_type, :printable_notifier_name] }
+
+        # Additional fields to store from instance method when config.store_with_associated_records is enabled
+        if ActivityNotification.config.store_with_associated_records
+          field :stored_notifiable_path,             :string
+          field :stored_printable_notifiable_name,   :string
+          field :stored_group_member_notifier_count, :integer
+          field :stored_group_notification_count,    :integer
+          field :stored_group_members,               :array
+
+          # Returns prepared notification object to store
+          # @return [Object] prepared notification object to store
+          def prepare_to_store
+            self.stored_notifiable_path           = notifiable_path
+            self.stored_printable_notifiable_name = printable_notifiable_name
+            if group_owner?
+              self.stored_group_notification_count    = 0
+              self.stored_group_member_notifier_count = 0
+              self.stored_group_members               = []
+            end
+            self
+          end
+
+          # Call after store action with stored notification
+          def after_store
+            if group_owner?
+              self.stored_group_notification_count    = group_notification_count
+              self.stored_group_member_notifier_count = group_member_notifier_count
+              self.stored_group_members               = group_members.as_json
+              self.stored_group_members.each do |group_member|
+                # Cast Time and DateTime field to String to handle Dynamoid unsupported type error
+                group_member.each do |k, v|
+                  group_member[k] = v.to_s if v.is_a?(Time) || v.is_a?(DateTime)
+                end
+              end
+              save
+            else
+              group_owner.after_store
+            end
+          end
+        end
+
+        # Mandatory global secondary index to query effectively
+        global_secondary_index name: :index_target_key_created_at,     hash_key: :target_key,     range_key: :created_at, projected_attributes: :all
+        global_secondary_index name: :index_group_owner_id_created_at, hash_key: :group_owner_id, range_key: :created_at, projected_attributes: :all
+        # Optional global secondary index to sort by created_at
+        global_secondary_index name: :index_notifier_key_created_at,   hash_key: :notifier_key,   range_key: :created_at, projected_attributes: :all
+        global_secondary_index name: :index_notifiable_key_created_at, hash_key: :notifiable_key, range_key: :created_at, projected_attributes: :all
+
+        validates  :target,     presence: true
+        validates  :notifiable, presence: true
+        validates  :key,        presence: true
+
+        %i[ all_index! unopened_index opened_index
+            filtered_by_association filtered_by_target filtered_by_instance filtered_by_group
+            filtered_by_target_type filtered_by_type filtered_by_key filtered_by_options
+            latest_order earliest_order latest_order! earliest_order!
+            group_owners_only group_members_only unopened_only opened_only! opened_only
+            unopened_index_group_members_only opened_index_group_members_only
+            within_expiration_only(expiry_delay
+            group_members_of_owner_ids_only
+            reload
+            latest earliest latest! earliest!
+            uniq_keys
+          ].each do |method|
+          # Return a criteria chain in response to a method that will begin or end a chain.
+          # For more information, see Dynamoid::Criteria::Chain.
+          singleton_class.send(:define_method, method) do |*args, &block|
+            # Use scan_index_forward with true as default value to convert Dynamoid::Document into Dynamoid::Criteria::Chain
+            # https://github.com/Dynamoid/dynamoid/blob/master/lib/dynamoid/document.rb
+            # https://github.com/Dynamoid/dynamoid/blob/master/lib/dynamoid/components.rb
+            # https://github.com/Dynamoid/dynamoid/blob/master/lib/dynamoid/criteria.rb
+            # https://github.com/Dynamoid/dynamoid/blob/master/lib/dynamoid/criteria/chain.rb
+            scan_index_forward(true).send(method, *args, &block)
+          end
+        end
+
+        %i[ with_target with_notifiable with_group with_group_owner with_group_members with_notifier ].each do |method|
+          singleton_class.send(:define_method, method) do |*args, &block|
+            self
+          end
+        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
+
+        # Raise ActivityNotification::DeleteRestrictionError for notifications.
+        # @param [String] error_text Error text for raised exception
+        # @raise [ActivityNotification::DeleteRestrictionError] DeleteRestrictionError from used ORM
+        # @return [void]
+        def self.raise_delete_restriction_error(error_text)
+          raise ActivityNotification::DeleteRestrictionError, error_text
+        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
+          #
+          # @param [Integer] limit Limit to query for opened notifications
+          # @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
+          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
+                         .filtered_by_association_type("notifier", notifier)
+                         .where("notifier_key.ne": notifier_key)
+                         .to_a
+                         .collect {|n| n.notifier_key }.compact.uniq
+                         .length
+          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
+          #
+          # @param [Integer] limit Limit to query for opened notifications
+          # @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)
+                         .filtered_by_association_type("notifier", notifier)
+                         .where("notifier_key.ne": notifier_key)
+                         .to_a
+                         .collect {|n| n.notifier_key }.compact.uniq
+                         .length
+          end
+
+      end
+    end
+  end
+end