activity_notification 1.2.1 → 1.3.0

data/lib/activity_notification.rb

@@ -7,9 +7,7 @@ module ActivityNotification
   extend ActiveSupport::Autoload
 
   autoload :Notification,     'activity_notification/models/notification'
-  autoload :NotificationApi,  'activity_notification/apis/notification_api'
   autoload :Subscription,     'activity_notification/models/subscription'
-  autoload :SubscriptionApi,  'activity_notification/apis/subscription_api'
   autoload :Target,           'activity_notification/models/concerns/target'
   autoload :Subscriber,       'activity_notification/models/concerns/subscriber'
   autoload :Notifiable,       'activity_notification/models/concerns/notifiable'
@@ -44,8 +42,17 @@ module ActivityNotification
   #   end
   def self.configure
     yield(config) if block_given?
+    autoload :Association, "activity_notification/orm/#{ActivityNotification.config.orm}"
   end
 
+  # Method used to choose which ORM to load
+  # when ActivityNotification::Notification class or ActivityNotification::Subscription class
+  # are being autoloaded
+  def self.inherit_orm(model)
+    orm = ActivityNotification.config.orm
+    require "activity_notification/orm/#{orm}"
+    "ActivityNotification::ORM::#{orm.to_s.classify}::#{model}".constantize
+  end
 end
 
 # Load ActivityNotification helpers

data/lib/activity_notification/apis/notification_api.rb

@@ -6,6 +6,131 @@ module ActivityNotification
     included do
       # Defines store_notification as private clas method
       private_class_method :store_notification
+
+      # 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>, Mongoid::Criteria<Notificaion>] 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 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>, Mongoid::Criteria<Notificaion>] 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 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>, Mongoid::Criteria<Notificaion>] 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 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>, Mongoid::Criteria<Notificaion>] Database query of filtered notifications
+      scope :filtered_by_target_type,           ->(target_type) { where(target_type: target_type) }
+
+      # 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>, Mongoid::Criteria<Notificaion>] Database query of filtered notifications
+      scope :filtered_by_type,                  ->(notifiable_type) { where(notifiable_type: notifiable_type) }
+
+      # 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>, Mongoid::Criteria<Notificaion>] 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>, Mongoid::Criteria<Notificaion>] 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
+      }
+
+      # Orders by latest (newest) first as created_at: :desc.
+      # @return [Mongoid::Criteria<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 [Mongoid::Criteria<Notificaion>] Database query of notifications ordered by earliest first
+      scope :earliest_order,                    -> { order(created_at: :asc) }
     end
 
     class_methods do
@@ -129,16 +254,19 @@ module ActivityNotification
       # @todo Add filter option
       def open_all_of(target, options = {})
         opened_at = options[:opened_at] || Time.current
-        target.notifications.unopened_only.filtered_by_options(options).update_all(opened_at: opened_at)
+        target_unopened_notifications = target.notifications.unopened_only.filtered_by_options(options)
+        unopened_notification_count = target_unopened_notifications.count
+        target_unopened_notifications.update_all(opened_at: opened_at)
+        unopened_notification_count
       end
   
       # Returns if group member of the notifications exists.
       # This method is designed to be called from controllers or views to avoid N+1.
       #
-      # @param [Array<Notificaion>, ActiveRecord_AssociationRelation<Notificaion>] notifications Array or database query of the notifications to test member exists
+      # @param [Array<Notificaion>, ActiveRecord_AssociationRelation<Notificaion>, Mongoid::Criteria<Notificaion>] notifications Array or database query of the notifications to test member exists
       # @return [Boolean] If group member of the notifications exists
       def group_member_exists?(notifications)
-        notifications.present? && where(group_owner_id: notifications.map(&:id)).exists?
+        notifications.present? && group_members_of_owner_ids_only(notifications.map(&:id)).exists?
       end
 
       # Sends batch notification email to the target.
@@ -181,16 +309,15 @@ module ActivityNotification
         parameters.merge!(notifiable.notification_parameters(target_type, key))
 
         # Bundle notification group by target, notifiable_type, group and key
-        # Defferent notifiable.id can be made in a same group
+        # Different notifiable.id can be made in a same group
         group_owner_notifications = filtered_by_target(target).filtered_by_type(notifiable.to_class_name).filtered_by_key(key)
                                    .filtered_by_group(group).group_owners_only.unopened_only
         group_owner = group_expiry_delay.present? ?
-                        group_owner_notifications.where("created_at > ?", group_expiry_delay.ago).earliest :
+                        group_owner_notifications.within_expiration_only(group_expiry_delay).earliest :
                         group_owner_notifications.earliest
         notification_fields = { target: target, notifiable: notifiable, key: key, group: group, parameters: parameters, notifier: notifier }
-        group.present? && group_owner.present? ?
-          create(notification_fields.merge(group_owner: group_owner)) :
-          create(notification_fields)
+        notification_fields = notification_fields.merge(group_owner: group_owner) if group.present? && group_owner.present?
+        create(notification_fields)
       end
     end
 
@@ -235,10 +362,13 @@ module ActivityNotification
     # @option options [Boolean] :with_members (true)         If it opens notifications including group members
     # @return [Integer] Number of opened notification records
     def open!(options = {})
-      opened_at = options[:opened_at] || Time.current
+      opened? and return 0
+      opened_at    = options[:opened_at] || Time.current
       with_members = options.has_key?(:with_members) ? options[:with_members] : true
+      unopened_member_count = with_members ? group_members.unopened_only.count : 0
+      group_members.update_all(opened_at: opened_at) if with_members
       update(opened_at: opened_at)
-      with_members ? group_members.update_all(opened_at: opened_at) + 1 : 1
+      unopened_member_count + 1
     end
 
     # Returns if the notification is unopened.
@@ -259,7 +389,7 @@ module ActivityNotification
     #
     # @return [Boolean] If the notification is group owner
     def group_owner?
-      group_owner_id.blank?
+      !group_member?
     end
 
     # Returns if the notification is group member belonging to owner.
@@ -345,7 +475,7 @@ module ActivityNotification
       new_group_owner = group_members.earliest
       if new_group_owner.present?
         new_group_owner.update(group_owner_id: nil)
-        group_members.update_all(group_owner_id: new_group_owner)
+        group_members.update_all(group_owner_id: new_group_owner.id)
       end
       new_group_owner
     end
@@ -391,70 +521,6 @@ module ActivityNotification
 
     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
-      #
-      # @return [Integer] Count of group members of the unopened notification
-      def unopened_group_member_count
-        # Cache group by query result to avoid N+1 call
-        unopened_group_member_counts = target.notifications
-                                             .unopened_index_group_members_only
-                                             .group(:group_owner_id)
-                                             .count
-        unopened_group_member_counts[id] || 0
-      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
-      #
-      # @return [Integer] Count of group members of the opened notification
-      def opened_group_member_count(limit = ActivityNotification.config.opened_index_limit)
-        # Cache group by query result to avoid N+1 call
-        opened_group_member_counts   = target.notifications
-                                             .opened_index_group_members_only(limit)
-                                             .group(:group_owner_id)
-                                             .count
-        opened_group_member_counts[id] || 0
-      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
-      #
-      # @return [Integer] Count of group member notifiers of the unopened notification
-      def unopened_group_member_notifier_count
-        # Cache group by query result to avoid N+1 call
-        unopened_group_member_notifier_counts = target.notifications
-                                                      .unopened_index_group_members_only
-                                                      .includes(:group_owner)
-                                                      .where('group_owners_notifications.notifier_type = notifications.notifier_type')
-                                                      .where.not('group_owners_notifications.notifier_id = notifications.notifier_id')
-                                                      .references(:group_owner)
-                                                      .group(:group_owner_id, :notifier_type)
-                                                      .count('distinct notifications.notifier_id')
-        unopened_group_member_notifier_counts[[id, notifier_type]] || 0
-      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
-      #
-      # @return [Integer] Count of group member notifiers of the opened notification
-      def opened_group_member_notifier_count(limit = ActivityNotification.config.opened_index_limit)
-        # Cache group by query result to avoid N+1 call
-        opened_group_member_notifier_counts   = target.notifications
-                                                      .opened_index_group_members_only(limit)
-                                                      .includes(:group_owner)
-                                                      .where('group_owners_notifications.notifier_type = notifications.notifier_type')
-                                                      .where.not('group_owners_notifications.notifier_id = notifications.notifier_id')
-                                                      .references(:group_owner)
-                                                      .group(:group_owner_id, :notifier_type)
-                                                      .count('distinct notifications.notifier_id')
-        opened_group_member_notifier_counts[[id, notifier_type]] || 0
-      end
-
       # Returns count of various members of the notification.
       # This method is designed to cache group by query result to avoid N+1 call.
       # @api protected

data/lib/activity_notification/apis/subscription_api.rb

@@ -3,6 +3,58 @@ module ActivityNotification
   module SubscriptionApi
     extend ActiveSupport::Concern
 
+    included do
+      # 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>] 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 [Mongoid::Criteria<Notificaion>] 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) }
+    end
+
     class_methods do
       # Returns key of optional_targets hash from symbol class name of the optional target implementation.
       # @param [String, Symbol] optional_target_name Class name of the optional target implementation (e.g. :amazon_sns, :slack)
@@ -132,5 +184,25 @@ module ActivityNotification
     def optional_target_names
       optional_targets.keys.select { |key| key.to_s.start_with?("subscribing_to_") }.map { |key| key.slice(15..-1) }
     end
+
+
+    protected
+
+      # 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
+
   end
 end

data/lib/activity_notification/config.rb

@@ -110,6 +110,11 @@ module ActivityNotification
     #   @return [Integer] Default limit to query for opened notifications.
     attr_accessor :opened_index_limit
 
+    # @overload :orm
+    #   Returns ORM name for ActivityNotification (:active_record or :mongoid)
+    #   @return [Boolean] ORM name for ActivityNotification (:active_record or :mongoid).
+    attr_reader :orm
+
     # Initialize configuration for ActivityNotification.
     # These configuration can be overriden in initializer.
     # @return [Config] A new instance of Config
@@ -125,7 +130,14 @@ module ActivityNotification
       @parent_mailer           = 'ActionMailer::Base'
       @parent_controller       = 'ApplicationController'
       @opened_index_limit      = 10
+      @orm                     = :active_record
     end
 
+    # Sets ORM name for ActivityNotification (:active_record or :mongoid)
+    # @param [Symbol, String] orm The new ORM name for ActivityNotification (:active_record or :mongoid)
+    # @return [Symbol] ORM name for ActivityNotification (:active_record or :mongoid).
+    def orm=(orm)
+      @orm = orm.to_sym
+    end
   end
 end

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

@@ -7,14 +7,15 @@ module ActivityNotification
 
     included do
       include Common
+      include Association
       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,
+      # @return [Array<Notificaion>, Mongoid::Criteria<Notificaion>] Array or database query of notifications for this notifiable
+      has_many_records :generated_notifications_as_notifiable,
         class_name: "::ActivityNotification::Notification",
         as: :notifiable
 
@@ -207,8 +208,14 @@ module ActivityNotification
       optional_targets(target_type, key).map { |optional_target| optional_target.to_optional_target_name }
     end
 
+    # overriding_notification_template_key is the method to override key definition for Renderable
+    # When respond_to?(:overriding_notification_template_key) returns true,
+    # Renderable uses overriding_notification_template_key instead of original key.
+    #
+    # overriding_notification_template_key(target, key)
+
     # overriding_notification_email_key is the method to override key definition for Mailer
-    # When respond_to?(overriding_notification_email_key) returns true,
+    # When respond_to?(:overriding_notification_email_key) returns true,
     # Mailer uses overriding_notification_email_key instead of original key.
     #
     # overriding_notification_email_key(target, key)
@@ -303,11 +310,54 @@ module ActivityNotification
         end
       end
 
-      # Remove generated notifications from notification group to new group owner.
+      # Gets generated notifications for specified target type.
+      # @api private
+      # @param [String] target_type Target type of generated notifications
+      def generated_notifications_as_notifiable_for(target_type = nil)
+        target_type.nil? ?
+          generated_notifications_as_notifiable.all :
+          generated_notifications_as_notifiable.filtered_by_target_type(target_type.to_s.to_model_name)
+      end
+
+      # Destroies generated notifications for specified target type with dependency.
+      # This method is intended to be called before destroy this notifiable as dependent configuration.
+      # @api private
+      # @param [Symbol]  dependent         Has_many dependency, [:delete_all, :destroy, :restrict_with_error, :restrict_with_exception] are available
+      # @param [String]  target_type       Target type of generated notifications
+      # @param [Boolean] remove_from_group Whether it removes generated notifications from notification group before destroy
+      def destroy_generated_notifications_with_dependency(dependent = :delete_all, target_type = nil, remove_from_group = false)
+        remove_generated_notifications_from_group(target_type) if remove_from_group
+        generated_notifications = generated_notifications_as_notifiable_for(target_type)
+        case dependent
+        when :restrict_with_exception
+          raise ActiveRecord::DeleteRestrictionError.new("generated_notifications_as_notifiable_for_#{target_type.to_s.pluralize.underscore}") unless generated_notifications.empty?
+        when :restrict_with_error
+          unless generated_notifications.empty?
+            record = self.class.human_attribute_name("generated_notifications_as_notifiable_for_#{target_type.to_s.pluralize.underscore}").downcase
+            self.errors.add(:base, :'restrict_dependent_destroy.has_many', record: record)
+            # :skip-rails4:
+            if Rails::VERSION::MAJOR >= 5
+              throw(:abort)
+            # :skip-rails4:
+            # :skip-rails5:
+            else
+              false
+            end
+            # :skip-rails5:
+          end
+        when :destroy
+          generated_notifications.each { |n| n.destroy }
+        when :delete_all
+          generated_notifications.delete_all
+        end
+      end
+
+      # Removes generated notifications from notification group to new group owner.
       # This method is intended to be called before destroy this notifiable as dependent configuration.
       # @api private
-      def remove_generated_notifications_from_group
-        generated_notifications_as_notifiable.group_owners_only.each { |n| n.remove_from_group }
+      # @param [String]  target_type       Target type of generated notifications
+      def remove_generated_notifications_from_group(target_type = nil)
+        generated_notifications_as_notifiable_for(target_type).group_owners_only.each { |n| n.remove_from_group }
       end
 
       # Casts to resources name.