activity_notification 0.0.10 → 1.0.0

data/lib/activity_notification/models.rb

@@ -1,14 +1,18 @@
+require 'activity_notification/roles/acts_as_common'
 require 'activity_notification/roles/acts_as_target'
 require 'activity_notification/roles/acts_as_notifiable'
 require 'activity_notification/roles/acts_as_notifier'
+require 'activity_notification/roles/acts_as_group'
 
 module ActivityNotification
   module Models
     extend ActiveSupport::Concern
     included do
+      include ActivityNotification::ActsAsCommon
       include ActivityNotification::ActsAsTarget
       include ActivityNotification::ActsAsNotifiable
       include ActivityNotification::ActsAsNotifier
+      include ActivityNotification::ActsAsGroup
     end
   end
 end

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

@@ -0,0 +1,32 @@
+module ActivityNotification
+  # Notification group implementation included in group model to bundle notification.
+  module Group
+    extend ActiveSupport::Concern
+    included do
+      include Common
+      class_attribute :_printable_notification_group_name
+      set_group_class_defaults
+    end
+
+    class_methods do
+      # Checks if the model includes notification group methods are available.
+      # @return [Boolean] Always true
+      def available_as_group?
+        true
+      end
+
+      # Sets default values to group class fields.
+      # @return [NilClass] nil
+      def set_group_class_defaults
+        self._printable_notification_group_name = :printable_name
+        nil
+      end
+    end
+
+    # Returns printable group model name to show in view or email.
+    # @return [String] Printable group model name
+    def printable_group_name
+      resolve_value(_printable_notification_group_name)
+    end
+  end
+end

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

@@ -9,21 +9,31 @@ module ActivityNotification
       include Common
       include ActionDispatch::Routing::PolymorphicRoutes
       include Rails.application.routes.url_helpers
+
+      # Has many notification instances for this notifiable.
+      # Dependency for these notifications can be overriden from acts_as_notifiable.
+      # @scope instance
+      # @return [Array<Notificaion>] Array or database query of notifications for this notifiable
+      has_many :generated_notifications_as_notifiable,
+        class_name: "::ActivityNotification::Notification",
+        as: :notifiable
+
       class_attribute  :_notification_targets,
                        :_notification_group,
                        :_notifier,
                        :_notification_parameters,
                        :_notification_email_allowed,
-                       :_notifiable_path
+                       :_notifiable_path,
+                       :_printable_notifiable_name
       set_notifiable_class_defaults
     end
-  
+
     # Returns default_url_options for polymorphic_path.
     # @return [Hash] Rails.application.routes.default_url_options
     def default_url_options
       Rails.application.routes.default_url_options
     end
-    
+
     class_methods do
       # Checks if the model includes notifiable and notifiable methods are available.
       # @return [Boolean] Always true
@@ -32,7 +42,7 @@ module ActivityNotification
       end
 
       # Sets default values to notifiable class fields.
-      # @return [Nil] nil
+      # @return [NilClass] nil
       def set_notifiable_class_defaults
         self._notification_targets        = {}
         self._notification_group          = {}
@@ -40,6 +50,7 @@ module ActivityNotification
         self._notification_parameters     = {}
         self._notification_email_allowed  = {}
         self._notifiable_path             = {}
+        self._printable_notifiable_name   = {}
         nil
       end
     end
@@ -50,13 +61,12 @@ module ActivityNotification
     # @param [String] target_type Target type to notify
     # @param [String] key Key of the notification
     # @return [Array<Notificaion> | ActiveRecord_AssociationRelation<Notificaion>] Array or database query of the notification targets
-    def notification_targets(target_type, key)
-      target_typed_method_name = "notification_#{target_type.to_s.to_resources_name}"
+    def notification_targets(target_type, key = nil)
+      target_typed_method_name = "notification_#{cast_to_resources_name(target_type)}"
       resolved_parameter = resolve_parameter(
         target_typed_method_name,
-        _notification_targets[target_type.to_s.to_resources_name.to_sym],
-        nil,
-        key)
+        _notification_targets[cast_to_resources_sym(target_type)],
+        nil, key)
       unless resolved_parameter
         raise NotImplementedError, "You have to implement #{self.class}##{target_typed_method_name} "\
                                    "or set :targets in acts_as_notifiable"
@@ -70,12 +80,11 @@ module ActivityNotification
     # @param [String] target_type Target type to notify
     # @param [String] key Key of the notification
     # @return [Object] Group owner of the notification
-    def notification_group(target_type, key)
+    def notification_group(target_type, key = nil)
       resolve_parameter(
-        "notification_group_for_#{target_type.to_s.to_resources_name}",
-        _notification_group[target_type.to_s.to_resources_name.to_sym],
-        nil,
-        key)
+        "notification_group_for_#{cast_to_resources_name(target_type)}",
+        _notification_group[cast_to_resources_sym(target_type)],
+        nil, key)
     end
 
     # Returns additional notification parameters from configured field or overriden method.
@@ -84,12 +93,11 @@ module ActivityNotification
     # @param [String] target_type Target type to notify
     # @param [String] key Key of the notification
     # @return [Hash] Additional notification parameters
-    def notification_parameters(target_type, key)
+    def notification_parameters(target_type, key = nil)
       resolve_parameter(
-        "notification_parameters_for_#{target_type.to_s.to_resources_name}",
-        _notification_parameters[target_type.to_s.to_resources_name.to_sym],
-        {},
-        key)
+        "notification_parameters_for_#{cast_to_resources_name(target_type)}",
+        _notification_parameters[cast_to_resources_sym(target_type)],
+        {}, key)
     end
 
     # Returns notifier of the notification from configured field or overriden method.
@@ -98,12 +106,11 @@ module ActivityNotification
     # @param [String] target_type Target type to notify
     # @param [String] key Key of the notification
     # @return [Object] Notifier of the notification
-    def notifier(target_type, key)
+    def notifier(target_type, key = nil)
       resolve_parameter(
-        "notifier_for_#{target_type.to_s.to_resources_name}",
-        _notifier[target_type.to_s.to_resources_name.to_sym],
-        nil,
-        key)
+        "notifier_for_#{cast_to_resources_name(target_type)}",
+        _notifier[cast_to_resources_sym(target_type)],
+        nil, key)
     end
 
     # Returns if sending notification email is allowed for the notifiable from configured field or overriden method.
@@ -112,10 +119,10 @@ module ActivityNotification
     # @param [Object] target Target instance to notify
     # @param [String] key Key of the notification
     # @return [Boolean] If sending notification email is allowed for the notifiable
-    def notification_email_allowed?(target, key)
+    def notification_email_allowed?(target, key = nil)
       resolve_parameter(
-        "notification_email_allowed_for_#{target.class.to_s.to_resources_name}?",
-        _notification_email_allowed[target.class.to_s.to_resources_name.to_sym],
+        "notification_email_allowed_for_#{cast_to_resources_name(target.class)}?",
+        _notification_email_allowed[cast_to_resources_sym(target.class)],
         ActivityNotification.config.email_enabled,
         target, key)
     end
@@ -126,12 +133,11 @@ module ActivityNotification
     # @param [String] target_type Target type to notify
     # @param [String] key Key of the notification
     # @return [String] Notifiable path URL to move after opening notification
-    def notifiable_path(target_type, key)
+    def notifiable_path(target_type, key = nil)
       resolved_parameter = resolve_parameter(
-        "notifiable_path_for_#{target_type.to_s.to_resources_name}",
-        _notifiable_path[target_type.to_s.to_resources_name.to_sym],
-        nil,
-        key)
+        "notifiable_path_for_#{cast_to_resources_name(target_type)}",
+        _notifiable_path[cast_to_resources_sym(target_type)],
+        nil, key)
       unless resolved_parameter
         begin
           resolved_parameter = polymorphic_path(self)
@@ -144,6 +150,16 @@ module ActivityNotification
       resolved_parameter
     end
 
+    # Returns printable notifiable model name to show in view or email.
+    # @return [String] Printable notifiable model name
+    def printable_notifiable_name(target, key = nil)
+      resolve_parameter(
+        "printable_notifiable_name_for_#{cast_to_resources_name(target.class)}?",
+        _printable_notifiable_name[cast_to_resources_sym(target.class)],
+        printable_name,
+        target, key)
+    end
+
     # overriding_notification_email_key is the method to override key definition for Mailer
     # When respond_to?(overriding_notification_email_key) returns true,
     # Mailer uses overriding_notification_email_key instead of original key.
@@ -230,5 +246,17 @@ module ActivityNotification
           default_value
         end
       end
+
+      # Casts to resources name.
+      # @api private
+      def cast_to_resources_name(target_type)
+        target_type.to_s.to_resources_name
+      end
+
+      # Casts to symbol of resources name.
+      # @api private
+      def cast_to_resources_sym(target_type)
+        target_type.to_s.to_resources_name.to_sym
+      end
   end
 end

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

@@ -1,4 +1,5 @@
 module ActivityNotification
+  # Notifier implementation included in notifier model to be notified, like users or administrators.
   module Notifier
     extend ActiveSupport::Concern
     included do
@@ -6,14 +7,29 @@ module ActivityNotification
       has_many :sent_notifications,
         class_name: "::ActivityNotification::Notification",
         as: :notifier
+      class_attribute :_printable_notifier_name
+      set_notifier_class_defaults
     end
 
     class_methods do
-      # Checks if the model includes notifier and notifier methods are available.
+      # Checks if the model includes notifier methods are available.
       # @return [Boolean] Always true
       def available_as_notifier?
         true
       end
+
+      # Sets default values to notifier class fields.
+      # @return [NilClass] nil
+      def set_notifier_class_defaults
+        self._printable_notifier_name = :printable_name
+        nil
+      end
+    end
+
+    # Returns printable notifier model name to show in view or email.
+    # @return [String] Printable notifier model name
+    def printable_notifier_name
+      resolve_value(_printable_notifier_name)
     end
   end
 end

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

@@ -10,9 +10,13 @@ module ActivityNotification
       # @return [Array<Notificaion>] Array or database query of notifications of this target
       has_many :notifications,
         class_name: "::ActivityNotification::Notification",
-        as: :target
+        as: :target,
+        dependent: :delete_all
 
-      class_attribute :_notification_email, :_notification_email_allowed, :_notification_devise_resource
+      class_attribute :_notification_email,
+                      :_notification_email_allowed,
+                      :_notification_devise_resource,
+                      :_printable_notification_target_name
       set_target_class_defaults
     end
 
@@ -24,11 +28,12 @@ module ActivityNotification
       end
 
       # Sets default values to target class fields.
-      # @return [Nil] nil
+      # @return [NilClass] nil
       def set_target_class_defaults
-        self._notification_email            = nil
-        self._notification_email_allowed    = ActivityNotification.config.email_enabled
-        self._notification_devise_resource  = ->(model) { model }
+        self._notification_email                 = nil
+        self._notification_email_allowed         = ActivityNotification.config.email_enabled
+        self._notification_devise_resource       = ->(model) { model }
+        self._printable_notification_target_name = :printable_name
         nil
       end
     end
@@ -58,48 +63,58 @@ 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.instance_of? devise_resource.class
+      unless current_resource.blank? or current_resource.instance_of? devise_resource.class
         raise TypeError,
           "Defferent 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
-      current_resource == devise_resource
+      current_resource.present? and current_resource == devise_resource
+    end
+
+    # Returns printable target model name to show in view or email.
+    # @return [String] Printable target model name
+    def printable_target_name
+      resolve_value(_printable_notification_target_name)
     end
 
     # Returns count of unopened notifications of the target.
     #
+    # @param [Hash] options Options for notification index
+    # @option options [Integer] :limit                  (nil) Limit to query for notifications
     # @return [Integer] Count of unopened notifications of the target
-    def unopened_notification_count
-      unopened_notification_index.count
+    # @todo Add filter and reverse options
+    def unopened_notification_count(options = {})
+      unopened_notification_index(options).count
     end
 
     # Returns if the target has unopened notifications.
     #
+    # @param [Hash] options Options for notification index
+    # @option options [Integer] :limit                  (nil) Limit to query for notifications
     # @return [Boolean] If the target has unopened notifications
-    def has_unopened_notifications?
-      unopened_notification_index.exists?
+    # @todo Add filter and reverse options
+    def has_unopened_notifications?(options = {})
+      unopened_notification_index(options).present?
     end
 
     # Gets automatically arranged notification index of the target.
-    # When the target has unopened notifications, returns unopened index with unopened_notification_index.
-    # Otherwise, returns opened index with opened_notification_index.
+    # This method is the typical way to get notifications index from controller of view.
+    # When the target have unopened notifications, it returns unopened notifications first.
+    # Additionaly, it returns opened notifications unless unopened index size overs the limit.
     # @todo Is this switching the best solution?
     #
     # @example Get automatically arranged notification index of the @user
     #   @notifications = @user.notification_index
     #
-    # @param [Integer] limit Limit to query for notifications
+    # @param [Hash] options Options for notification index
+    # @option options [Integer] :limit                  (nil) Limit to query for notifications
     # @return [Array<Notificaion>] Notification index of the target
-    def notification_index(limit = nil)
-      # When the target have unopened notifications
-      notifications.unopened_index.exists? ?
-        # Return unopened notifications
-        unopened_notification_index(limit) :
-        # Otherwise, return opened notifications
-        limit.present? ?
-          opened_notification_index(limit) :
-          opened_notification_index
+    # @todo Add filter and reverse options
+    def notification_index(options = {})
+      arrange_notification_index(method(:unopened_notification_index),
+                                 method(:opened_notification_index),
+                                 options)
     end
 
     # Gets unopened notification index of the target.
@@ -107,11 +122,13 @@ module ActivityNotification
     # @example Get unopened notification index of the @user
     #   @notifications = @user.unopened_notification_index
     #
-    # @param [Integer] limit Limit to query for notifications
+    # @param [Hash] options Options for notification index
+    # @option options [Integer] :limit                  (nil) Limit to query for notifications
     # @return [Array<Notificaion>] Unopened notification index of the target
-    def unopened_notification_index(limit = nil)
-      limit.present? ?
-        notifications.unopened_index.limit(limit) :
+    # @todo Add filter and reverse options
+    def unopened_notification_index(options = {})
+      options[:limit].present? ?
+        notifications.unopened_index.limit(options[:limit]) :
         notifications.unopened_index
     end
 
@@ -120,9 +137,12 @@ module ActivityNotification
     # @example Get opened notification index of the @user
     #   @notifications = @user.opened_notification_index(10)
     #
-    # @param [Integer] limit Limit to query for notifications
+    # @param [Hash] options Options for notification index
+    # @option options [Integer] :limit                  (ActivityNotification.config.opened_index_limit) Limit to query for notifications
     # @return [Array<Notificaion>] Opened notification index of the target
-    def opened_notification_index(limit = ActivityNotification.config.opened_limit)
+    # @todo Add filter and reverse options
+    def opened_notification_index(options = {})
+      limit = options[:limit] || ActivityNotification.config.opened_index_limit
       notifications.opened_index(limit)
     end
 
@@ -149,8 +169,12 @@ module ActivityNotification
     #
     # @param [Hash] options Options for opening notifications
     # @option options [DateTime] :opened_at (DateTime.now) Time to set to opened_at of the notification record
+    # @option options [String]   :filtered_by_type       (nil) Notifiable type for filter
+    # @option options [Object]   :filtered_by_group      (nil) Group instance for filter
+    # @option options [String]   :filtered_by_group_type (nil) Group type for filter, valid with :filtered_by_group_id
+    # @option options [String]   :filtered_by_group_id   (nil) Group instance id for filter, valid with :filtered_by_group_type
+    # @option options [String]   :filtered_by_key        (nil) Key of the notification for filter
     # @return [Integer] Number of opened notification records
-    # @todo Add filter option
     def open_all_notifications(options = {})
       Notification.open_all_of(self, options)
     end
@@ -158,21 +182,21 @@ module ActivityNotification
 
     # Gets automatically arranged notification index of the target with included attributes like target, notifiable, group and notifier.
     # This method is the typical way to get notifications index from controller of view.
+    # When the target have unopened notifications, it returns unopened notifications first.
+    # Additionaly, it returns opened notifications unless unopened index size overs the limit.
+    # @todo Is this switching the best solution?
     #
     # @example Get automatically arranged notification index of the @user with included attributes
     #   @notifications = @user.notification_index_with_attributes
     #
-    # @param [Integer] limit Limit to query for notifications
+    # @param [Hash] options Options for notification index
+    # @option options [Integer] :limit                  (nil) Limit to query for notifications
     # @return [Array<Notificaion>] Notification index of the target with attributes
-    def notification_index_with_attributes(limit = nil)
-      # When the target have unopened notifications
-      unopened_notification_index.exists? ?
-        # Return unopened notifications
-        unopened_notification_index_with_attributes(limit) :
-        # Otherwise, return opened notifications
-        limit.present? ?
-          opened_notification_index_with_attributes(limit) :
-          opened_notification_index_with_attributes
+    # @todo Add filter and reverse options
+    def notification_index_with_attributes(options = {})
+      arrange_notification_index(method(:unopened_notification_index_with_attributes),
+                                 method(:opened_notification_index_with_attributes),
+                                 options)
     end
 
     # Gets unopened notification index of the target with included attributes like target, notifiable, group and notifier.
@@ -180,10 +204,12 @@ module ActivityNotification
     # @example Get unopened notification index of the @user with included attributes
     #   @notifications = @user.unopened_notification_index_with_attributes
     #
-    # @param [Integer] limit Limit to query for notifications
+    # @param [Hash] options Options for notification index
+    # @option options [Integer] :limit                  (nil) Limit to query for notifications
     # @return [Array<Notificaion>] Unopened notification index of the target with attributes
-    def unopened_notification_index_with_attributes(limit = nil)
-      include_attributes unopened_notification_index(limit)
+    # @todo Add filter and reverse options
+    def unopened_notification_index_with_attributes(options = {})
+      include_attributes unopened_notification_index(options)
     end
 
     # Gets opened notification index of the target with including attributes like target, notifiable, group and notifier.
@@ -191,10 +217,12 @@ module ActivityNotification
     # @example Get opened notification index of the @user with included attributes
     #   @notifications = @user.opened_notification_index_with_attributes(10)
     #
-    # @param [Integer] limit Limit to query for notifications
+    # @param [Hash] options Options for notification index
+    # @option options [Integer] :limit                  (ActivityNotification.config.opened_index_limit) Limit to query for notifications
     # @return [Array<Notificaion>] Opened notification index of the target with attributes
-    def opened_notification_index_with_attributes(limit = ActivityNotification.config.opened_limit)
-      include_attributes opened_notification_index(limit)
+    # @todo Add filter and reverse options
+    def opened_notification_index_with_attributes(options = {})
+      include_attributes opened_notification_index(options)
     end
 
     private
@@ -204,15 +232,46 @@ module ActivityNotification
       # Otherwise, target, notifiable and or notifier will be include without group.
       # @api private
       #
-      # @param [Array<Notificaion>] notification_index Notification index
-      # @return [Array<Notificaion>] Notification index with attributes
-      def include_attributes(notification_index)
-        if notification_index.present?
-          Notification.group_member_exists?(notification_index) ?
-            notification_index.with_target.with_notifiable.with_group.with_notifier :
-            notification_index.with_target.with_notifiable.with_notifier
+      # @param [ActiveRecord_AssociationRelation<Notificaion>] target_index Notification index
+      # @return [ActiveRecord_AssociationRelation<Notificaion>] Notification index with attributes
+      def include_attributes(target_index)
+        if target_index.present?
+          Notification.group_member_exists?(target_index) ?
+            target_index.with_target.with_notifiable.with_group.with_notifier :
+            target_index.with_target.with_notifiable.with_notifier
+        else
+          Notification.none
+        end
+      end
+
+      # Gets automatically arranged notification index of the target.
+      # When the target have unopened notifications, it returns unopened notifications first.
+      # Additionaly, it returns opened notifications unless unopened index size overs the limit.
+      # @api private
+      # @todo Is this switching the best solution?
+      #
+      # @param [Method] loading_unopened_index_method Method to load unopened index
+      # @param [Method] loading_opened_index_method Method to load opened index
+      # @param [Hash] options Options for notification index
+      # @option options [Integer] :limit (nil) Limit to query for notifications
+      # @return [Array<Notificaion>] Notification index of the target
+      def arrange_notification_index(loading_unopened_index_method, loading_opened_index_method, options = {})
+        # When the target have unopened notifications
+        if has_unopened_notifications?(options)
+          # Return unopened notifications first
+          target_unopened_index = loading_unopened_index_method.call(options).to_a
+          # Total limit if 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
+            target_opened_index = loading_opened_index_method.call(options.merge(limit: opened_limit))
+            target_unopened_index.concat(target_opened_index.to_a)
+          else
+            target_unopened_index
+          end
         else
-          notifications.none
+          # Otherwise, return opened notifications
+          loading_opened_index_method.call(options)
         end
       end