activity_notification 2.0.0 → 2.1.4

data/lib/activity_notification/optional_targets/base.rb

@@ -3,22 +3,11 @@ module ActivityNotification
   module OptionalTarget
     # Abstract optional target class to develop optional notification target class.
     class Base
-      # View context to render notification message
-      # @return View context to render notification message
-      attr_accessor :view_context
-
       # Initialize method to create view context in this OptionalTarget instance
       # @param [Hash] options Options for initializing target
       # @option options [Boolean] :skip_initializing_target (false) Whether skip calling initialize_target method
       # @option options [Hash]    others                            Options for initializing target
       def initialize(options = {})
-        @view_context = ActionView::Base.new(ActionController::Base.view_paths, {})
-        @view_context.class_eval do 
-          include Rails.application.routes.url_helpers
-          def default_url_options
-            ActionMailer::Base.default_url_options
-          end
-        end
         initialize_target(options) unless options.delete(:skip_initializing_target)
       end
 
@@ -64,12 +53,17 @@ module ActivityNotification
               "activity_notification/optional_targets/default/base"
             ]
           options[:fallback] ||= :default
-          @view_context.assign((options[:assignment] || {}).merge(notification: notification, target: notification.target))
 
           message, missing_template = nil, nil
           partial_root_list.each do |partial_root|
             begin
-              message = notification.render(@view_context, options.merge(partial_root: partial_root)).to_str
+              message = notification.render(
+                ActivityNotification::NotificationsController.renderer,
+                options.merge(
+                  partial_root: partial_root,
+                  assigns: (options[:assignment] || {}).merge(notification: notification, target: notification.target)
+                )
+              ).to_s
               break
             rescue ActionView::MissingTemplate => e
               missing_template = e

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

@@ -126,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) }
@@ -152,7 +168,7 @@ module ActivityNotification
 
         # Raise DeleteRestrictionError for notifications.
         # @param [String] error_text Error text for raised exception
-        # @raise DeleteRestrictionError
+        # @raise [ActiveRecord::DeleteRestrictionError] DeleteRestrictionError from used ORM
         # @return [void]
         def self.raise_delete_restriction_error(error_text)
           raise ::ActiveRecord::DeleteRestrictionError.new(error_text)

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/dynamoid.rb

@@ -22,8 +22,8 @@ module ActivityNotification
         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]
+        associated_record_field = "stored_#{association_name}".to_sym
+        field associated_record_field, :raw if ActivityNotification.config.store_with_associated_records && _options[:store_with_associated_records]
 
         self.instance_eval do
           define_method(name) do |reload = false|
@@ -43,7 +43,14 @@ module ActivityNotification
               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]
+              associated_record_json = new_instance.as_json(_options[:as_json_options] || {})
+              # Cast Time and DateTime field to String to handle Dynamoid unsupported type error
+              if associated_record_json.present?
+                associated_record_json.each do |k, v|
+                  associated_record_json[k] = v.to_s if v.is_a?(Time) || v.is_a?(DateTime)
+                end
+              end
+              self.send("#{associated_record_field}=", associated_record_json) if ActivityNotification.config.store_with_associated_records && _options[:store_with_associated_records]
             end
             self.instance_variable_set("@#{name}", nil)
           end
@@ -249,6 +256,26 @@ module Dynamoid # :nodoc: all
         where(key: key)
       end
 
+      # 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
+      def later_than(created_time)
+        where('created_at.gt': created_time)
+      end
+
+      # 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
+      def earlier_than(created_time)
+        where('created_at.lt': created_time)
+      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' })
@@ -269,6 +296,8 @@ module Dynamoid # :nodoc: all
       # @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 [String]     :later_than             (nil) ISO 8601 format time to filter notification index later than specified time
+      # @option options [String]     :earlier_than           (nil) ISO 8601 format time to filter notification index earlier than specified time
       # @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 = {})
@@ -286,6 +315,12 @@ module Dynamoid # :nodoc: all
         if options.has_key?(:filtered_by_key)
           filtered_notifications = filtered_notifications.filtered_by_key(options[:filtered_by_key])
         end
+        if options.has_key?(:later_than)
+          filtered_notifications = filtered_notifications.later_than(Time.iso8601(options[:later_than]))
+        end
+        if options.has_key?(:earlier_than)
+          filtered_notifications = filtered_notifications.earlier_than(Time.iso8601(options[:earlier_than]))
+        end
         if options.has_key?(:custom_filter)
           filtered_notifications = filtered_notifications.where(options[:custom_filter])
         end

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

@@ -1,6 +1,6 @@
 require 'dynamoid/adapter_plugin/aws_sdk_v3'
 
-# Entend Dynamoid to support none, limit, exists?, update_all in Dynamoid::Criteria::Chain.
+# 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
@@ -32,6 +32,7 @@ module Dynamoid # :nodoc: all
     # 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
@@ -64,6 +65,11 @@ module Dynamoid # :nodoc: all
           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
@@ -163,6 +169,78 @@ module Dynamoid # :nodoc: all
   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

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

@@ -20,17 +20,17 @@ module ActivityNotification
         # 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
+        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
+        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
+        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: {}
@@ -64,14 +64,54 @@ module ActivityNotification
         # 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
+        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 hash_key: :target_key,     range_key: :created_at, projected_attributes: :all
-        global_secondary_index hash_key: :group_owner_id, range_key: :created_at, projected_attributes: :all
+        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 hash_key: :notifier_key,   range_key: :created_at, projected_attributes: :all
-        global_secondary_index hash_key: :notifiable_key, range_key: :created_at, projected_attributes: :all
+        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
@@ -116,17 +156,12 @@ module ActivityNotification
 
         # Raise ActivityNotification::DeleteRestrictionError for notifications.
         # @param [String] error_text Error text for raised exception
-        # @raise ActivityNotification::DeleteRestrictionError
+        # @raise [ActivityNotification::DeleteRestrictionError] DeleteRestrictionError from used ORM
         # @return [void]
         def self.raise_delete_restriction_error(error_text)
           raise ActivityNotification::DeleteRestrictionError, error_text
         end
 
-        # Returns prepared notification object to store
-        # @return [Object] prepared notification object to store
-        # def prepare_to_store
-        # end
-
         protected
 
           # Returns count of group members of the unopened notification.

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

@@ -28,10 +28,10 @@ module ActivityNotification
         field :unsubscribed_to_email_at,  :datetime
         field :optional_targets,          :raw,     default: {}
 
-        global_secondary_index hash_key: :target_key, range_key: :created_at, projected_attributes: :all
+        global_secondary_index name: :index_target_key_created_at, hash_key: :target_key, range_key: :created_at, projected_attributes: :all
 
         validates  :target,               presence: true
-        validates  :key,                  presence: true
+        validates  :key,                  presence: true, uniqueness: { scope: :target_key }
         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/mongoid.rb

@@ -24,8 +24,8 @@ module ActivityNotification
         id_field, type_field = "#{association_name}_id", "#{association_name}_type"
         field id_field,   type: String
         field type_field, type: String
-        associated_record_field = "#{association_name}_record"
-        field associated_record_field, type: String if ActivityNotification.config.store_with_associated_records && _options[:store_with_associated_records]
+        associated_record_field = "stored_#{association_name}"
+        field associated_record_field, type: Hash if ActivityNotification.config.store_with_associated_records && _options[:store_with_associated_records]
 
         self.instance_eval do
           define_method(name) do |reload = false|
@@ -43,7 +43,14 @@ module ActivityNotification
             if new_instance.nil? then instance_id, instance_type = nil, nil else instance_id, instance_type = new_instance.id, new_instance.class.name end
             self.send("#{id_field}=", instance_id)
             self.send("#{type_field}=", instance_type)
-            self.send("#{associated_record_field}=", new_instance.to_json) if ActivityNotification.config.store_with_associated_records && _options[:store_with_associated_records]
+            associated_record_json = new_instance.as_json(_options[:as_json_options] || {})
+            # Cast Hash $oid field to String id to handle BSON::String::IllegalKey
+            if associated_record_json.present?
+              associated_record_json.each do |k, v|
+                associated_record_json[k] = v['$oid'] if v.is_a?(Hash) && v.has_key?('$oid')
+              end
+            end
+            self.send("#{associated_record_field}=", associated_record_json) if ActivityNotification.config.store_with_associated_records && _options[:store_with_associated_records]
             self.instance_variable_set("@#{name}", nil)
           end
         end
@@ -72,5 +79,27 @@ module ActivityNotification
   end
 end
 
+# Monkey patching for Mongoid::Document as_json
+module Mongoid
+  # Monkey patching for Mongoid::Document as_json
+  module Document
+    # Monkey patching for Mongoid::Document as_json
+    # @param [Hash] options Options parameter
+    # @return [Hash] Hash representing the model
+    def as_json(options = {})
+      json = super(options)
+      json["id"] = json["_id"].to_s.start_with?("{\"$oid\"=>") ? self.id.to_s : json["_id"].to_s
+      if options.has_key?(:include)
+        case options[:include]
+        when Symbol then json[options[:include].to_s] = self.send(options[:include]).as_json
+        when Array  then options[:include].each {|model| json[model.to_s] = self.send(model).as_json }
+        when Hash   then options[:include].each {|model, options| json[model.to_s] = self.send(model).as_json(options) }
+        end
+      end
+      json
+    end
+  end
+end
+
 require_relative 'mongoid/notification.rb'
 require_relative 'mongoid/subscription.rb'

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

@@ -19,17 +19,17 @@ module ActivityNotification
         # Belongs to target instance of this notification as polymorphic association.
         # @scope instance
         # @return [Object] Target instance of this notification
-        belongs_to_polymorphic_xdb_record :target, store_with_associated_records: true
+        belongs_to_polymorphic_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.
         # @scope instance
         # @return [Object] Notifiable instance of this notification
-        belongs_to_polymorphic_xdb_record :notifiable, store_with_associated_records: true
+        belongs_to_polymorphic_xdb_record :notifiable, store_with_associated_records: true, as_json_options: { methods: [:printable_type] }
 
         # Belongs to group instance of this notification as polymorphic association.
         # @scope instance
         # @return [Object] Group instance of this notification
-        belongs_to_polymorphic_xdb_record :group
+        belongs_to_polymorphic_xdb_record :group, as_json_options: { methods: [:printable_type, :printable_group_name] }
 
         field :key,            type: String
         field :parameters,     type: Hash,     default: {}
@@ -53,7 +53,7 @@ module ActivityNotification
         # Belongs to :otifier instance of this notification.
         # @scope instance
         # @return [Object] Notifier instance of this notification
-        belongs_to_polymorphic_xdb_record :notifier, store_with_associated_records: true
+        belongs_to_polymorphic_xdb_record :notifier, store_with_associated_records: true, as_json_options: { methods: [:printable_type, :printable_notifier_name] }
 
         validates  :target,        presence: true
         validates  :notifiable,    presence: true
@@ -140,9 +140,27 @@ module ActivityNotification
         scope :filtered_by_group,                 ->(group) {
           group.present? ?
             where(group_id: group.id, group_type: group.class.name) :
-            any_of({ :group_id.exists => false, :group_type.exists => false }, { group_id: nil, group_type: nil })
+            Gem::Version.new(::Mongoid::VERSION) >= Gem::Version.new('7.1.0') ?
+              where(:group_id.exists => false, :group_type.exists => false).or(group_id: nil, group_type: nil) :
+              any_of({ :group_id.exists => false, :group_type.exists => false }, { group_id: nil, group_type: nil })
         }
 
+        # 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.gt => 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.lt => created_time) }
+
         # Includes target instance with query for notifications.
         # @return [Mongoid::Criteria<Notificaion>] Database query of notifications with target
         scope :with_target,                       -> { }
@@ -179,7 +197,7 @@ module ActivityNotification
 
         # Raise ActivityNotification::DeleteRestrictionError for notifications.
         # @param [String] error_text Error text for raised exception
-        # @raise ActivityNotification::DeleteRestrictionError
+        # @raise [ActivityNotification::DeleteRestrictionError] DeleteRestrictionError from used ORM
         # @return [void]
         def self.raise_delete_restriction_error(error_text)
           raise ActivityNotification::DeleteRestrictionError, error_text