activity_notification 1.2.1 → 1.3.0

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

@@ -2,11 +2,18 @@ module ActivityNotification
   # Notifier implementation included in notifier model to be notified, like users or administrators.
   module Notifier
     extend ActiveSupport::Concern
+
     included do
       include Common
-      has_many :sent_notifications,
+      include Association
+
+      # Has many sent notification instances from this notifier.
+      # @scope instance
+      # @return [Array<Notificaion>, Mongoid::Criteria<Notificaion>] Array or database query of sent notifications from this notifier
+      has_many_records :sent_notifications,
         class_name: "::ActivityNotification::Notification",
         as: :notifier
+
       class_attribute :_printable_notifier_name
       set_notifier_class_defaults
     end

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

@@ -2,11 +2,14 @@ module ActivityNotification
   # Subscriber implementation included in target model to manage subscriptions, like users or administrators.
   module Subscriber
     extend ActiveSupport::Concern
+
     included do
+      include Association
+
       # Has many subscription instances of this target.
       # @scope instance
-      # @return [Array<Notificaion>] Array or database query of subscriptions of this target
-      has_many :subscriptions,
+      # @return [Array<Subscription>, Mongoid::Criteria<Subscription>] Array or database query of subscriptions of this target
+      has_many_records :subscriptions,
         class_name: "::ActivityNotification::Subscription",
         as: :target,
         dependent: :delete_all
@@ -27,7 +30,7 @@ module ActivityNotification
     # @param [Hash] key Key of the notification for subscription
     # @return [Subscription] Configured subscription instance
     def find_subscription(key)
-      subscriptions.find_by_key(key)
+      subscriptions.where(key: key).first
     end
 
     # Gets subscription of the target and notification key.
@@ -87,8 +90,8 @@ module ActivityNotification
     def subscription_index(options = {})
       target_index = subscriptions.filtered_by_options(options)
       target_index = options[:reverse] ? target_index.earliest_order : target_index.latest_order
-      target_index = target_index.includes(:target) if options[:with_target]
-      options[:limit].present? ? target_index.limit(options[:limit]) : target_index
+      target_index = target_index.with_target if options[:with_target]
+      options[:limit].present? ? target_index.limit(options[:limit]).to_a : target_index.to_a
     end
 
     # Gets received notification keys of the target.
@@ -104,11 +107,11 @@ module ActivityNotification
     # @option options [Array|Hash]    :custom_filter          (nil)   Custom subscription filter (e.g. ["created_at >= ?", time.hour.ago])
     # @return [Array<Notificaion>] Unconfigured notification keys of the target
     def notification_keys(options = {})
-      subscription_keys    = subscriptions.select(:key).distinct.pluck(:key)
+      subscription_keys    = subscriptions.uniq_keys
       target_notifications = notifications.filtered_by_options(options.select { |k, _| [:filtered_by_key, :custom_filter].include?(k) })
       target_notifications = options[:reverse] ? target_notifications.earliest_order : target_notifications.latest_order
       target_notifications = options[:limit].present? ? target_notifications.limit(options[:limit] + subscription_keys.size) : target_notifications
-      notification_keys    = target_notifications.select(:key).distinct.pluck(:key)
+      notification_keys    = target_notifications.uniq_keys
       notification_keys    =
         case options[:filter]
         when :configured, 'configured'
@@ -131,7 +134,7 @@ module ActivityNotification
       # @param [Boolean] subscribe_as_default Default subscription value to use when the subscription record does not configured
       # @return [Boolean] If the target subscribes to the notification
       def _subscribes_to_notification?(key, subscribe_as_default = ActivityNotification.config.subscribe_as_default)
-        evaluate_subscription(subscriptions.find_by_key(key), :subscribing?, subscribe_as_default)
+        evaluate_subscription(subscriptions.where(key: key).first, :subscribing?, subscribe_as_default)
       end
 
       # Returns if the target subscribes to the notification email.
@@ -142,7 +145,7 @@ module ActivityNotification
       # @param [Boolean] subscribe_as_default Default subscription value to use when the subscription record does not configured
       # @return [Boolean] If the target subscribes to the notification
       def _subscribes_to_notification_email?(key, subscribe_as_default = ActivityNotification.config.subscribe_as_default)
-        evaluate_subscription(subscriptions.find_by_key(key), :subscribing_to_email?, subscribe_as_default)
+        evaluate_subscription(subscriptions.where(key: key).first, :subscribing_to_email?, subscribe_as_default)
       end
       alias_method :_subscribes_to_email?, :_subscribes_to_notification_email?
 
@@ -156,7 +159,7 @@ module ActivityNotification
       # @return [Boolean] If the target subscribes to the specified optional target
       def _subscribes_to_optional_target?(key, optional_target_name, subscribe_as_default = ActivityNotification.config.subscribe_as_default)
         _subscribes_to_notification?(key, subscribe_as_default) &&
-          evaluate_subscription(subscriptions.find_by_key(key), :subscribing_to_optional_target?, subscribe_as_default, optional_target_name, subscribe_as_default)
+          evaluate_subscription(subscriptions.where(key: key).first, :subscribing_to_optional_target?, subscribe_as_default, optional_target_name, subscribe_as_default)
       end
 
     private

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

@@ -2,13 +2,15 @@ module ActivityNotification
   # Target implementation included in target model to notify, like users or administrators.
   module Target
     extend ActiveSupport::Concern
+
     included do
       include Common
+      include Association
 
       # Has many notification instances of this target.
       # @scope instance
-      # @return [Array<Notificaion>] Array or database query of notifications of this target
-      has_many :notifications,
+      # @return [Array<Notificaion>, Mongoid::Criteria<Notificaion>] Array or database query of notifications of this target
+      has_many_records :notifications,
         class_name: "::ActivityNotification::Notification",
         as: :target,
         dependent: :delete_all
@@ -180,9 +182,9 @@ module ActivityNotification
     # @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)
-      unless current_resource.blank? or current_resource.instance_of? devise_resource.class
+      unless current_resource.blank? or current_resource.is_a? devise_resource.class
         raise TypeError,
-          "Defferent type of current resource #{current_resource.class} "\
+          "Different type of current resource #{current_resource.class} "\
           "with devise resource #{devise_resource.class} has been passed to #{self.class}##{__method__}. "\
           "You have to override #{self.class}##{__method__} method or set devise_resource in acts_as_target."
       end
@@ -581,7 +583,7 @@ module ActivityNotification
           end
         else
           # Otherwise, return opened notifications
-          loading_opened_index_method.call(options)
+          loading_opened_index_method.call(options).to_a
         end
       end
 

data/lib/activity_notification/models/notification.rb

@@ -1,273 +1,5 @@
 module ActivityNotification
-  # Notification model implementation generated by ActivityNotification.
-  class Notification < ActiveRecord::Base
-    include Renderable
-    include Common
-    include NotificationApi
-    # @deprecated ActivityNotification.config.table_name as of 1.1.0
-    self.table_name = ActivityNotification.config.table_name || ActivityNotification.config.notification_table_name
-    # self.table_name = ActivityNotification.config.notification_table_name
-
-    # Belongs to target instance of this notification as polymorphic association.
-    # @scope instance
-    # @return [Object] Target instance of this notification
-    belongs_to :target,        polymorphic: true
-
-    # Belongs to notifiable instance of this notification as polymorphic association.
-    # @scope instance
-    # @return [Object] Notifiable instance of this notification
-    belongs_to :notifiable,    polymorphic: true
-
-    # Belongs to group instance of this notification as polymorphic association.
-    # @scope instance
-    # @return [Object] Group instance of this notification
-    belongs_to :group,         polymorphic: true
-
-    # Belongs to group owner notification instance of this notification.
-    # Only group member instance has :group_owner value.
-    # Group owner instance has nil as :group_owner association.
-    # @scope instance
-    # @return [Notification] Group owner notification instance of this notification
-    belongs_to :group_owner,   class_name: :Notification
-
-    # Has many group member notification instances of this notification.
-    # Only group owner instance has :group_members value.
-    # Group member instance has nil as :group_members association.
-    # @scope instance
-    # @return [ActiveRecord_AssociationRelation<Notificaion>] Array or database query of the group member notification instances of this notification
-    has_many   :group_members, class_name: :Notification, foreign_key: :group_owner_id
-
-    # Belongs to :otifier instance of this notification.
-    # @scope instance
-    # @return [Object] Notifier instance of this notification
-    belongs_to :notifier,      polymorphic: true
-
-    # Serialize parameters Hash
-    serialize  :parameters, Hash
-
-    validates  :target,        presence: true
-    validates  :notifiable,    presence: true
-    validates  :key,           presence: true
-
-    # Selects group owner notifications only.
-    # @scope class
-    # @return [ActiveRecord_AssociationRelation<Notificaion>] Array or database query of filtered notifications
-    scope :group_owners_only,                 -> { where(group_owner_id: nil) }
-
-    # Selects group member notifications only.
-    # @scope class
-    # @return [ActiveRecord_AssociationRelation<Notificaion>] Array or database query of filtered notifications
-    scope :group_members_only,                -> { where.not(group_owner_id: nil) }
-
-    # 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 [ActiveRecord_AssociationRelation<Notificaion>] Array or database query of filtered notifications
-    scope :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
-    }
-
-    # Selects unopened notifications only.
-    # @scope class
-    # @return [ActiveRecord_AssociationRelation<Notificaion>] Array or database query of filtered notifications
-    scope :unopened_only,                     -> { where(opened_at: nil) }
-
-    # 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 [ActiveRecord_AssociationRelation<Notificaion>] Array or database query of filtered notifications
-    scope :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
-    }
-
-    # Selects opened notifications only without limit.
-    # Be careful to get too many records with this method.
-    # @scope class
-    # @return [ActiveRecord_AssociationRelation<Notificaion>] Array or database query of filtered notifications
-    scope :opened_only!,                      -> { where.not(opened_at: nil) }
-
-    # Selects opened notifications only with limit.
-    # @scope class
-    # @param [Integer] limit Limit to query for opened notifications
-    # @return [ActiveRecord_AssociationRelation<Notificaion>] Array or database query of filtered notifications
-    scope :opened_only,                       ->(limit) { opened_only!.limit(limit) }
-
-    # 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 [ActiveRecord_AssociationRelation<Notificaion>] Array or database query of filtered notifications
-    scope :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
-    }
-
-    # Selects group member notifications in unopened_index.
-    # @scope class
-    # @return [ActiveRecord_AssociationRelation<Notificaion>] Array or database query of filtered notifications
-    scope :unopened_index_group_members_only, -> { where(group_owner_id: unopened_index.map(&:id)) }
-
-    # Selects group member notifications in opened_index.
-    # @scope class
-    # @param [Integer] limit Limit to query for opened notifications
-    # @return [ActiveRecord_AssociationRelation<Notificaion>] Array or database query of filtered notifications
-    scope :opened_index_group_members_only,   ->(limit) { where(group_owner_id: opened_index(limit).map(&:id)) }
-
-    # Selects filtered notifications by target instance.
-    #   ActivityNotification::Notification.filtered_by_target(@user)
-    # is the same as
-    #   @user.notifications
-    # @scope class
-    # @param [Object] target Target instance for filter
-    # @return [ActiveRecord_AssociationRelation<Notificaion>] Array or database query of filtered notifications
-    scope :filtered_by_target,                ->(target) { where(target: target) }
-
-    # Selects filtered notifications 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 [ActiveRecord_AssociationRelation<Notificaion>] Array or database query of filtered notifications
-    scope :filtered_by_target_type,           ->(target_type) { where(target_type: target_type) }
-
-    # Selects filtered notifications by notifiable instance.
-    # @example Get filtered unopened notificatons of the @user for @comment as notifiable
-    #   @notifications = @user.notifications.unopened_only.filtered_by_instance(@comment)
-    # @scope class
-    # @param [Object] notifiable Notifiable instance for filter
-    # @return [ActiveRecord_AssociationRelation<Notificaion>] Array or 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>] Array or database query of filtered notifications
-    scope :filtered_by_type,                  ->(notifiable_type) { where(notifiable_type: notifiable_type) }
-
-    # Selects filtered notifications by group instance.
-    # @example Get filtered unopened notificatons of the @user for @article as group
-    #   @notifications = @user.notifications.unopened_only.filtered_by_group(@article)
-    # @scope class
-    # @param [Object] group Group instance for filter
-    # @return [ActiveRecord_AssociationRelation<Notificaion>] Array or database query of filtered notifications
-    scope :filtered_by_group,                 ->(group) { where(group: group) }
-
-    # Selects filtered notifications 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 [ActiveRecord_AssociationRelation<Notificaion>] Array or database query of filtered notifications
-    scope :filtered_by_key,                   ->(key) { where(key: key) }
-
-    # Selects filtered notifications 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 >= ?", time.hour.ago])
-    # @return [ActiveRecord_AssociationRelation<Notificaion>] Array or database query of filtered notifications
-    scope :filtered_by_options,               ->(options = {}) {
-      options = ActivityNotification.cast_to_indifferent_hash(options)
-      filtered_notifications = all
-      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
-                                 .where(group_type: options[:filtered_by_group_type], group_id: 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
-    }
-
-    # Includes target instance with query for notifications.
-    # @return [ActiveRecord_AssociationRelation<Notificaion>] Database query of notifications with target
-    scope :with_target,                       -> { includes(:target) }
-
-    # Includes notifiable instance with query for notifications.
-    # @return [ActiveRecord_AssociationRelation<Notificaion>] Database query of notifications with notifiable
-    scope :with_notifiable,                   -> { includes(:notifiable) }
-
-    # Includes group instance with query for notifications.
-    # @return [ActiveRecord_AssociationRelation<Notificaion>] Database query of notifications with group
-    scope :with_group,                        -> { includes(:group) }
-
-    # Includes group owner instances with query for notifications.
-    # @return [ActiveRecord_AssociationRelation<Notificaion>] Database query of notifications with group owner
-    scope :with_group_owner,                 -> { includes(:group_owner) }
-
-    # Includes group member instances with query for notifications.
-    # @return [ActiveRecord_AssociationRelation<Notificaion>] Database query of notifications with group members
-    scope :with_group_members,                -> { includes(:group_members) }
-
-    # Includes notifier instance with query for notifications.
-    # @return [ActiveRecord_AssociationRelation<Notificaion>] Database query of notifications with notifier
-    scope :with_notifier,                     -> { includes(:notifier) }
-
-    # Orders by latest (newest) first as created_at: :desc.
-    # @return [ActiveRecord_AssociationRelation<Notificaion>] Database query of notifications ordered by latest first
-    scope :latest_order,                      -> { order(created_at: :desc) }
-
-    # Orders by earliest (older) first as created_at: :asc.
-    # @return [ActiveRecord_AssociationRelation<Notificaion>] Database query of notifications ordered by earliest first
-    scope :earliest_order,                    -> { order(created_at: :asc) }
-
-    # Returns latest notification instance.
-    # @return [Notification] Latest notification instance
-    scope :latest,                            -> { latest_order.first }
-
-    # Returns earliest notification instance.
-    # @return [Notification] Earliest notification instance
-    scope :earliest,                          -> { earliest_order.first }
-
+  # Notification model implementation with ORM.
+  class Notification < inherit_orm("Notification")
   end
 end

data/lib/activity_notification/models/subscription.rb

@@ -1,104 +1,6 @@
 module ActivityNotification
-  # Subscription model implementation generated by ActivityNotification.
-  class Subscription < ActiveRecord::Base
-    include SubscriptionApi
-    self.table_name = ActivityNotification.config.subscription_table_name
-
-    # Belongs to target instance of this subscription as polymorphic association.
-    # @scope instance
-    # @return [Object] Target instance of this subscription
-    belongs_to :target,               polymorphic: true
-
-    # Serialize parameters Hash
-    serialize  :optional_targets, Hash
-
-    validates  :target,               presence: true
-    validates  :key,                  presence: true
-    validates_inclusion_of :subscribing,          in: [true, false]
-    validates_inclusion_of :subscribing_to_email, in: [true, false]
-    validate   :subscribing_to_email_cannot_be_true_when_subscribing_is_false
-    validates  :subscribed_at,            presence: true, if:     :subscribing
-    validates  :unsubscribed_at,          presence: true, unless: :subscribing
-    validates  :subscribed_to_email_at,   presence: true, if:     :subscribing_to_email
-    validates  :unsubscribed_to_email_at, presence: true, unless: :subscribing_to_email
-    validate   :subscribing_to_optional_target_cannot_be_true_when_subscribing_is_false
-
-    # Selects filtered subscriptions by target instance.
-    #   ActivityNotification::Subscription.filtered_by_target(@user)
-    # is the same as
-    #   @user.subscriptions
-    # @scope class
-    # @param [Object] target Target instance for filter
-    # @return [ActiveRecord_AssociationRelation<Subscription>] Array or database query of filtered subscriptions
-    scope :filtered_by_target,  ->(target)       { where(target: target) }
-
-    # Selects filtered subscriptions by key.
-    # @example Get filtered subscriptions of the @user with key 'comment.reply'
-    #   @subscriptions = @user.subscriptions.filtered_by_key('comment.reply')
-    # @scope class
-    # @param [String] key Key of the subscription for filter
-    # @return [ActiveRecord_AssociationRelation<Subscription>] Array or database query of filtered subscriptions
-    scope :filtered_by_key,     ->(key)          { where(key: key) }
-
-    # Selects filtered subscriptions by key with filter options.
-    # @example Get filtered subscriptions of the @user with key 'comment.reply'
-    #   @subscriptions = @user.subscriptions.filtered_by_key('comment.reply')
-    # @example Get custom filtered subscriptions of the @user
-    #   @subscriptions = @user.subscriptions.filtered_by_options({ custom_filter: ["created_at >= ?", time.hour.ago] })
-    # @scope class
-    # @param [Hash] options Options for filter
-    # @option options [String]     :filtered_by_key        (nil) Key of the subscription for filter 
-    # @option options [Array|Hash] :custom_filter          (nil) Custom subscription filter (e.g. ["created_at >= ?", time.hour.ago])
-    # @return [ActiveRecord_AssociationRelation<Notificaion>] Array or database query of filtered subscriptions
-    scope :filtered_by_options, ->(options = {}) {
-      options = ActivityNotification.cast_to_indifferent_hash(options)
-      filtered_subscriptions = all
-      if options.has_key?(:filtered_by_key)
-        filtered_subscriptions = filtered_subscriptions.filtered_by_key(options[:filtered_by_key])
-      end
-      if options.has_key?(:custom_filter)
-        filtered_subscriptions = filtered_subscriptions.where(options[:custom_filter])
-      end
-      filtered_subscriptions
-    }
-
-    # Orders by latest (newest) first as created_at: :desc.
-    # @return [ActiveRecord_AssociationRelation<Subscription>] Database query of subscriptions ordered by latest first
-    scope :latest_order,              -> { order(created_at: :desc) }
-
-    # Orders by earliest (older) first as created_at: :asc.
-    # @return [ActiveRecord_AssociationRelation<Subscription>] Database query of subscriptions ordered by earliest first
-    scope :earliest_order,            -> { order(created_at: :asc) }
-
-    # Orders by latest (newest) first as subscribed_at: :desc.
-    # @return [ActiveRecord_AssociationRelation<Subscription>] Database query of subscriptions ordered by latest subscribed_at first
-    scope :latest_subscribed_order,   -> { order(subscribed_at: :desc) }
-
-    # Orders by earliest (older) first as subscribed_at: :asc.
-    # @return [ActiveRecord_AssociationRelation<Subscription>] Database query of subscriptions ordered by earliest subscribed_at first
-    scope :earliest_subscribed_order, -> { order(subscribed_at: :asc) }
-
-    # Orders by key name as key: :asc.
-    # @return [ActiveRecord_AssociationRelation<Subscription>] Database query of subscriptions ordered by key name
-    scope :key_order,                 -> { order(key: :asc) }
-
-    private
-
-      # Validates subscribing_to_email cannot be true when subscribing isfalse.
-      def subscribing_to_email_cannot_be_true_when_subscribing_is_false
-        if !subscribing && subscribing_to_email?
-          errors.add(:subscribing_to_email, "cannot be true when subscribing is false")
-        end
-      end
-
-      # Validates subscribing_to_optional_target cannot be true when subscribing isfalse.
-      def subscribing_to_optional_target_cannot_be_true_when_subscribing_is_false
-        optional_target_names.each do |optional_target_name|
-          if !subscribing && subscribing_to_optional_target?(optional_target_name)
-            errors.add(:optional_targets, "#Subscription.to_optional_target_key(optional_target_name) cannot be true when subscribing is false")
-          end
-        end
-      end
-
+  # Subscription model implementation with ORM.
+  class Subscription < inherit_orm("Subscription")
   end
 end
+