Module: ActivityNotification::NotificationApi

Extended by:
ActiveSupport::Concern
Included in:
ORM::ActiveRecord::Notification, ORM::Dynamoid::Notification, ORM::Mongoid::Notification
Defined in:
lib/activity_notification/apis/notification_api.rb

Overview

Defines API for notification included in Notification model.

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

.all_index! ⇒ ActiveRecord_AssociationRelation<Notificaion>, Mongoid::Criteria<Notificaion>

Selects all notification index.

ActivityNotification::Notification.all_index!

is defined same as

ActivityNotification::Notification.group_owners_only.latest_order

Examples:

Get all notification index of the @user

@notifications = @user.notifications.all_index!
@notifications = @user.notifications.group_owners_only.latest_order

Parameters:

  • reverse (Boolean) —

    If notification index will be ordered as earliest first

  • with_group_members (Boolean) —

    If notification index will include group members

Returns:

  • (ActiveRecord_AssociationRelation<Notificaion>, Mongoid::Criteria<Notificaion>) —

    Database query of filtered notifications



26
27
28
29
 
# File 'lib/activity_notification/apis/notification_api.rb', line 26

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
}

.available_options ⇒ Array<Notificaion>

Returns available options for kinds of notify methods.

Returns:

  • (Array<Notificaion>) —

    Available options for kinds of notify methods



504
505
506
 
# File 'lib/activity_notification/apis/notification_api.rb', line 504

def available_options
  [:key, :group, :group_expiry_delay, :notifier, :parameters, :send_email, :send_later, :pass_full_options].freeze
end

.destroy_all_of(target, options = {}) ⇒ Array<Notification>

Destroys all notifications of the target matching the filter criteria.

Parameters:

  • target (Object) —

    Target of the notifications to destroy

  • options (Hash) (defaults to: {}) —

    Options for filtering notifications to destroy

Options Hash (options):

  • :filtered_by_type (String) — default: nil —

    Notifiable type for filter

  • :filtered_by_group (Object) — default: nil —

    Group instance for filter

  • :filtered_by_group_type (String) — default: nil —

    Group type for filter, valid with :filtered_by_group_id

  • :filtered_by_group_id (String) — default: nil —

    Group instance id for filter, valid with :filtered_by_group_type

  • :filtered_by_key (String) — default: nil —

    Key of the notification for filter

  • :later_than (String) — default: nil —

    ISO 8601 format time to filter notifications later than specified time

  • :earlier_than (String) — default: nil —

    ISO 8601 format time to filter notifications earlier than specified time

  • :ids (Array) — default: nil —

    Array of specific notification IDs to destroy

Returns:



450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
 
# File 'lib/activity_notification/apis/notification_api.rb', line 450

def destroy_all_of(target, options = {})
  target_notifications = target.notifications.filtered_by_options(options)
  # If specific IDs are provided, filter by them
  if options[:ids].present?
    # :nocov:
    case ActivityNotification.config.orm
    when :mongoid
      target_notifications = target_notifications.where(id: { '$in' => options[:ids] })
    when :dynamoid
      target_notifications = target_notifications.where('id.in': options[:ids])
    else # :active_record
      target_notifications = target_notifications.where(id: options[:ids])
    end
    # :nocov:
  end
  # Get the notifications before destroying them for return value
  destroyed_notifications = target_notifications.to_a
  target_notifications.destroy_all
  destroyed_notifications
end

.earliest ⇒ Notification

Returns earliest notification instance.

Returns:



167
168
169
 
# File 'lib/activity_notification/apis/notification_api.rb', line 167

def self.earliest
  earliest_order.first
end

.earliest! ⇒ Notification

Returns earliest notification instance. This method is to be overridden in implementation for each ORM.

Returns:



181
182
183
 
# File 'lib/activity_notification/apis/notification_api.rb', line 181

def self.earliest!
  earliest
end

.filtered_by_key ⇒ ActiveRecord_AssociationRelation<Notificaion>, Mongoid::Criteria<Notificaion>

Selects filtered notifications by key.

Examples:

Get filtered unopened notificatons of the @user with key ‘comment.reply’

@notifications = @user.notifications.unopened_only.filtered_by_key('comment.reply')

Parameters:

  • key (String) —

    Key of the notification for filter

Returns:

  • (ActiveRecord_AssociationRelation<Notificaion>, Mongoid::Criteria<Notificaion>) —

    Database query of filtered notifications



86
 
# File 'lib/activity_notification/apis/notification_api.rb', line 86

scope :filtered_by_key,                   ->(key) { where(key: key) }

.filtered_by_options ⇒ ActiveRecord_AssociationRelation<Notificaion>, Mongoid::Criteria<Notificaion>

Selects filtered notifications by notifiable_type, group or key with filter options.

Examples:

Get filtered unopened notificatons of the @user for Comment notifiable class

@notifications = @user.notifications.unopened_only.filtered_by_options({ filtered_by_type: 'Comment' })

Get filtered unopened notificatons of the @user for @article as group

@notifications = @user.notifications.unopened_only.filtered_by_options({ filtered_by_group: @article })

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' })

Get filtered unopened notificatons of the @user with key ‘comment.reply’

@notifications = @user.notifications.unopened_only.filtered_by_options({ filtered_by_key: 'comment.reply' })

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' })

Get custom filtered notificatons of the @user

@notifications = @user.notifications.unopened_only.filtered_by_options({ custom_filter: ["created_at >= ?", time.hour.ago] })

Parameters:

  • options (Hash) —

    Options for filter

Returns:

  • (ActiveRecord_AssociationRelation<Notificaion>, Mongoid::Criteria<Notificaion>) —

    Database query of filtered notifications



112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
 
# File 'lib/activity_notification/apis/notification_api.rb', line 112

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?(: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
  filtered_notifications
}

.filtered_by_target_type ⇒ ActiveRecord_AssociationRelation<Notificaion>, Mongoid::Criteria<Notificaion>

Selects filtered notifications by target_type.

Examples:

Get filtered unopened notificatons of User as target type

@notifications = ActivityNotification.Notification.unopened_only.filtered_by_target_type('User')

Parameters:

  • target_type (String) —

    Target type for filter

Returns:

  • (ActiveRecord_AssociationRelation<Notificaion>, Mongoid::Criteria<Notificaion>) —

    Database query of filtered notifications



70
 
# File 'lib/activity_notification/apis/notification_api.rb', line 70

scope :filtered_by_target_type,           ->(target_type) { where(target_type: target_type) }

.filtered_by_type ⇒ ActiveRecord_AssociationRelation<Notificaion>, Mongoid::Criteria<Notificaion>

Selects filtered notifications by notifiable_type.

Examples:

Get filtered unopened notificatons of the @user for Comment notifiable class

@notifications = @user.notifications.unopened_only.filtered_by_type('Comment')

Parameters:

  • notifiable_type (String) —

    Notifiable type for filter

Returns:

  • (ActiveRecord_AssociationRelation<Notificaion>, Mongoid::Criteria<Notificaion>) —

    Database query of filtered notifications



78
 
# File 'lib/activity_notification/apis/notification_api.rb', line 78

scope :filtered_by_type,                  ->(notifiable_type) { where(notifiable_type: notifiable_type) }

.generate_notification(target, notifiable, options = {}) ⇒ Object

Generates a notification

Parameters:

  • target (Object) —

    Target to send notification

  • notifiable (Object) —

    Notifiable instance

  • options (Hash) (defaults to: {}) —

    Options for notification

Options Hash (options):

  • :key (String) — default: notifiable.default_notification_key —

    Key of the notification

  • :group (Object) — default: nil —

    Group unit of the notifications

  • :notifier (Object) — default: nil —

    Notifier of the notifications

  • :parameters (Hash) — default: {} —

    Additional parameters of the notifications



394
395
396
397
398
399
400
 
# File 'lib/activity_notification/apis/notification_api.rb', line 394

def generate_notification(target, notifiable, options = {})
  key = options[:key] || notifiable.default_notification_key
  if target.subscribes_to_notification?(key)
    # Store notification
    notification = store_notification(target, notifiable, key, options)
  end
end

.group_member_exists?(notifications) ⇒ Boolean

Returns if group member of the notifications exists. This method is designed to be called from controllers or views to avoid N+1.

Parameters:

  • notifications (Array<Notificaion>, ActiveRecord_AssociationRelation<Notificaion>, Mongoid::Criteria<Notificaion>) —

    Array or database query of the notifications to test member exists

Returns:

  • (Boolean) —

    If group member of the notifications exists



476
477
478
 
# File 'lib/activity_notification/apis/notification_api.rb', line 476

def group_member_exists?(notifications)
  notifications.present? and group_members_of_owner_ids_only(notifications.map(&:id)).exists?
end

.latest ⇒ Notification

Returns latest notification instance.

Returns:



161
162
163
 
# File 'lib/activity_notification/apis/notification_api.rb', line 161

def self.latest
  latest_order.first
end

.latest! ⇒ Notification

Returns latest notification instance. This method is to be overridden in implementation for each ORM.

Returns:



174
175
176
 
# File 'lib/activity_notification/apis/notification_api.rb', line 174

def self.latest!
  latest
end

.notify(target_type, notifiable, options = {}) ⇒ Array<Notificaion> Also known as: notify_now

Generates notifications to configured targets with notifiable model.

Examples:

Use with target_type as Symbol

ActivityNotification::Notification.notify :users, @comment

Use with target_type as String

ActivityNotification::Notification.notify 'User', @comment

Use with target_type as Class

ActivityNotification::Notification.notify User, @comment

Use with options

ActivityNotification::Notification.notify :users, @comment, key: 'custom.comment', group: @comment.article
ActivityNotification::Notification.notify :users, @comment, parameters: { reply_to: @comment.reply_to }, send_later: false

Parameters:

  • target_type (Symbol, String, Class) —

    Type of target

  • notifiable (Object) —

    Notifiable instance

  • options (Hash) (defaults to: {}) —

    Options for notifications

Options Hash (options):

  • :key (String) — default: notifiable.default_notification_key —

    Key of the notification

  • :group (Object) — default: nil —

    Group unit of the notifications

  • :group_expiry_delay (ActiveSupport::Duration) — default: nil —

    Expiry period of a notification group

  • :notifier (Object) — default: nil —

    Notifier of the notifications

  • :parameters (Hash) — default: {} —

    Additional parameters of the notifications

  • :notify_later (Boolean) — default: false —

    Whether it generates notifications asynchronously

  • :send_email (Boolean) — default: true —

    Whether it sends notification email

  • :send_later (Boolean) — default: true —

    Whether it sends notification email asynchronously

  • :publish_optional_targets (Boolean) — default: true —

    Whether it publishes notification to optional targets

  • :pass_full_options (Boolean) — default: false —

    Whether it passes full options to notifiable.notification_targets, not a key only

  • :optional_targets (Hash<String, Hash>) — default: {} —

    Options for optional targets, keys are optional target name (:amazon_sns or :slack etc) and values are options

Returns:

  • (Array<Notificaion>) —

    Array of generated notifications



226
227
228
229
230
231
232
233
234
235
 
# File 'lib/activity_notification/apis/notification_api.rb', line 226

def notify(target_type, notifiable, options = {})
  if options[:notify_later]
    notify_later(target_type, notifiable, options)
  else
    targets = notifiable.notification_targets(target_type, options[:pass_full_options] ? options : options[:key])
    unless targets.blank?
      notify_all(targets, notifiable, options)
    end
  end
end

.notify_all(targets, notifiable, options = {}) ⇒ Array<Notificaion> Also known as: notify_all_now

Generates notifications to specified targets.

Examples:

Notify to all users

ActivityNotification::Notification.notify_all User.all, @comment

Parameters:

  • targets (Array<Object>) —

    Targets to send notifications

  • notifiable (Object) —

    Notifiable instance

  • options (Hash) (defaults to: {}) —

    Options for notifications

Options Hash (options):

  • :key (String) — default: notifiable.default_notification_key —

    Key of the notification

  • :group (Object) — default: nil —

    Group unit of the notifications

  • :group_expiry_delay (ActiveSupport::Duration) — default: nil —

    Expiry period of a notification group

  • :notifier (Object) — default: nil —

    Notifier of the notifications

  • :parameters (Hash) — default: {} —

    Additional parameters of the notifications

  • :notify_later (Boolean) — default: false —

    Whether it generates notifications asynchronously

  • :send_email (Boolean) — default: true —

    Whether it sends notification email

  • :send_later (Boolean) — default: true —

    Whether it sends notification email asynchronously

  • :publish_optional_targets (Boolean) — default: true —

    Whether it publishes notification to optional targets

  • :optional_targets (Hash<String, Hash>) — default: {} —

    Options for optional targets, keys are optional target name (:amazon_sns or :slack etc) and values are options

Returns:

  • (Array<Notificaion>) —

    Array of generated notifications



289
290
291
292
293
294
295
 
# File 'lib/activity_notification/apis/notification_api.rb', line 289

def notify_all(targets, notifiable, options = {})
  if options[:notify_later]
    notify_all_later(targets, notifiable, options)
  else
    targets.map { |target| notify_to(target, notifiable, options) }
  end
end

.notify_all_later(targets, notifiable, options = {}) ⇒ Array<Notificaion>

Generates notifications to specified targets later by ActiveJob queue.

Examples:

Notify to all users later

ActivityNotification::Notification.notify_all_later User.all, @comment

Parameters:

  • targets (Array<Object>) —

    Targets to send notifications

  • notifiable (Object) —

    Notifiable instance

  • options (Hash) (defaults to: {}) —

    Options for notifications

Options Hash (options):

  • :key (String) — default: notifiable.default_notification_key —

    Key of the notification

  • :group (Object) — default: nil —

    Group unit of the notifications

  • :group_expiry_delay (ActiveSupport::Duration) — default: nil —

    Expiry period of a notification group

  • :notifier (Object) — default: nil —

    Notifier of the notifications

  • :parameters (Hash) — default: {} —

    Additional parameters of the notifications

  • :send_email (Boolean) — default: true —

    Whether it sends notification email

  • :send_later (Boolean) — default: true —

    Whether it sends notification email asynchronously

  • :publish_optional_targets (Boolean) — default: true —

    Whether it publishes notification to optional targets

  • :optional_targets (Hash<String, Hash>) — default: {} —

    Options for optional targets, keys are optional target name (:amazon_sns or :slack etc) and values are options

Returns:

  • (Array<Notificaion>) —

    Array of generated notifications



316
317
318
319
 
# File 'lib/activity_notification/apis/notification_api.rb', line 316

def notify_all_later(targets, notifiable, options = {})
  options.delete(:notify_later)
  ActivityNotification::NotifyAllJob.perform_later(targets, notifiable, options)
end

.notify_later(target_type, notifiable, options = {}) ⇒ Array<Notificaion>

Generates notifications to configured targets with notifiable model later by ActiveJob queue.

Examples:

Use with target_type as Symbol

ActivityNotification::Notification.notify_later :users, @comment

Use with target_type as String

ActivityNotification::Notification.notify_later 'User', @comment

Use with target_type as Class

ActivityNotification::Notification.notify_later User, @comment

Use with options

ActivityNotification::Notification.notify_later :users, @comment, key: 'custom.comment', group: @comment.article
ActivityNotification::Notification.notify_later :users, @comment, parameters: { reply_to: @comment.reply_to }, send_later: false

Parameters:

  • target_type (Symbol, String, Class) —

    Type of target

  • notifiable (Object) —

    Notifiable instance

  • options (Hash) (defaults to: {}) —

    Options for notifications

Options Hash (options):

  • :key (String) — default: notifiable.default_notification_key —

    Key of the notification

  • :group (Object) — default: nil —

    Group unit of the notifications

  • :group_expiry_delay (ActiveSupport::Duration) — default: nil —

    Expiry period of a notification group

  • :notifier (Object) — default: nil —

    Notifier of the notifications

  • :parameters (Hash) — default: {} —

    Additional parameters of the notifications

  • :send_email (Boolean) — default: true —

    Whether it sends notification email

  • :send_later (Boolean) — default: true —

    Whether it sends notification email asynchronously

  • :publish_optional_targets (Boolean) — default: true —

    Whether it publishes notification to optional targets

  • :pass_full_options (Boolean) — default: false —

    Whether it passes full options to notifiable.notification_targets, not a key only

  • :optional_targets (Hash<String, Hash>) — default: {} —

    Options for optional targets, keys are optional target name (:amazon_sns or :slack etc) and values are options

Returns:

  • (Array<Notificaion>) —

    Array of generated notifications



264
265
266
267
268
 
# File 'lib/activity_notification/apis/notification_api.rb', line 264

def notify_later(target_type, notifiable, options = {})
  target_type = target_type.to_s if target_type.is_a? Symbol
  options.delete(:notify_later)
  ActivityNotification::NotifyJob.perform_later(target_type, notifiable, options)
end

.notify_later_to(target, notifiable, options = {}) ⇒ Notification

Generates notifications to one target later by ActiveJob queue.

Examples:

Notify to one user later

ActivityNotification::Notification.notify_later_to @comment.auther, @comment

Parameters:

  • target (Object) —

    Target to send notifications

  • notifiable (Object) —

    Notifiable instance

  • options (Hash) (defaults to: {}) —

    Options for notifications

Options Hash (options):

  • :key (String) — default: notifiable.default_notification_key —

    Key of the notification

  • :group (Object) — default: nil —

    Group unit of the notifications

  • :group_expiry_delay (ActiveSupport::Duration) — default: nil —

    Expiry period of a notification group

  • :notifier (Object) — default: nil —

    Notifier of the notifications

  • :parameters (Hash) — default: {} —

    Additional parameters of the notifications

  • :send_email (Boolean) — default: true —

    Whether it sends notification email

  • :send_later (Boolean) — default: true —

    Whether it sends notification email asynchronously

  • :publish_optional_targets (Boolean) — default: true —

    Whether it publishes notification to optional targets

  • :optional_targets (Hash<String, Hash>) — default: {} —

    Options for optional targets, keys are optional target name (:amazon_sns or :slack etc) and values are options

Returns:



381
382
383
384
 
# File 'lib/activity_notification/apis/notification_api.rb', line 381

def notify_later_to(target, notifiable, options = {})
  options.delete(:notify_later)
  ActivityNotification::NotifyToJob.perform_later(target, notifiable, options)
end

.notify_to(target, notifiable, options = {}) ⇒ Notification Also known as: notify_now_to

Generates notifications to one target.

Examples:

Notify to one user

ActivityNotification::Notification.notify_to @comment.auther, @comment

Parameters:

  • target (Object) —

    Target to send notifications

  • notifiable (Object) —

    Notifiable instance

  • options (Hash) (defaults to: {}) —

    Options for notifications

Options Hash (options):

  • :key (String) — default: notifiable.default_notification_key —

    Key of the notification

  • :group (Object) — default: nil —

    Group unit of the notifications

  • :group_expiry_delay (ActiveSupport::Duration) — default: nil —

    Expiry period of a notification group

  • :notifier (Object) — default: nil —

    Notifier of the notifications

  • :parameters (Hash) — default: {} —

    Additional parameters of the notifications

  • :notify_later (Boolean) — default: false —

    Whether it generates notifications asynchronously

  • :send_email (Boolean) — default: true —

    Whether it sends notification email

  • :send_later (Boolean) — default: true —

    Whether it sends notification email asynchronously

  • :publish_optional_targets (Boolean) — default: true —

    Whether it publishes notification to optional targets

  • :optional_targets (Hash<String, Hash>) — default: {} —

    Options for optional targets, keys are optional target name (:amazon_sns or :slack etc) and values are options

Returns:



340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
 
# File 'lib/activity_notification/apis/notification_api.rb', line 340

def notify_to(target, notifiable, options = {})
  if options[:notify_later]
    notify_later_to(target, notifiable, options)
  else
    send_email               = options.has_key?(:send_email)               ? options[:send_email]               : true
    send_later               = options.has_key?(:send_later)               ? options[:send_later]               : true
    publish_optional_targets = options.has_key?(:publish_optional_targets) ? options[:publish_optional_targets] : true
    # Generate notification
    notification = generate_notification(target, notifiable, options)
    # Send notification email
    if notification.present? && send_email
      notification.send_notification_email({ send_later: send_later })
    end
    # Publish to optional targets
    if notification.present? && publish_optional_targets
      notification.publish_to_optional_targets(options[:optional_targets] || {})
    end
    # Return generated notification
    notification
  end
end

.open_all_of(target, options = {}) ⇒ Array<Notification>

Opens all notifications of the target.

Parameters:

  • target (Object) —

    Target of the notifications to open

  • options (Hash) (defaults to: {}) —

    Options for opening notifications

Options Hash (options):

  • :opened_at (DateTime) — default: Time.current —

    Time to set to opened_at of the notification record

  • :filtered_by_type (String) — default: nil —

    Notifiable type for filter

  • :filtered_by_group (Object) — default: nil —

    Group instance for filter

  • :filtered_by_group_type (String) — default: nil —

    Group type for filter, valid with :filtered_by_group_id

  • :filtered_by_group_id (String) — default: nil —

    Group instance id for filter, valid with :filtered_by_group_type

  • :filtered_by_key (String) — default: nil —

    Key of the notification for filter

  • :later_than (String) — default: nil —

    ISO 8601 format time to filter notification index later than specified time

  • :earlier_than (String) — default: nil —

    ISO 8601 format time to filter notification index earlier than specified time

  • :ids (Array) — default: nil —

    Array of specific notification IDs to open

Returns:



416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
 
# File 'lib/activity_notification/apis/notification_api.rb', line 416

def open_all_of(target, options = {})
  opened_at = options[:opened_at] || Time.current
  target_unopened_notifications = target.notifications.unopened_only.filtered_by_options(options)
  # If specific IDs are provided, filter by them
  if options[:ids].present?
    # :nocov:
    case ActivityNotification.config.orm
    when :mongoid
      target_unopened_notifications = target_unopened_notifications.where(id: { '$in' => options[:ids] })
    when :dynamoid
      target_unopened_notifications = target_unopened_notifications.where('id.in': options[:ids])
    else # :active_record
      target_unopened_notifications = target_unopened_notifications.where(id: options[:ids])
    end
    # :nocov:
  end
  opened_notifications = target_unopened_notifications.to_a.map { |n| n.opened_at = opened_at; n }
  target_unopened_notifications.update_all(opened_at: opened_at)
  opened_notifications
end

.opened_index ⇒ ActiveRecord_AssociationRelation<Notificaion>, Mongoid::Criteria<Notificaion>

Selects unopened notification index.

ActivityNotification::Notification.opened_index(limit)

is defined same as

ActivityNotification::Notification.opened_only(limit).group_owners_only.latest_order

Examples:

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

Parameters:

  • limit (Integer) —

    Limit to query for opened notifications

  • reverse (Boolean) —

    If notification index will be ordered as earliest first

  • with_group_members (Boolean) —

    If notification index will include group members

Returns:

  • (ActiveRecord_AssociationRelation<Notificaion>, Mongoid::Criteria<Notificaion>) —

    Database query of filtered notifications



59
60
61
62
 
# File 'lib/activity_notification/apis/notification_api.rb', line 59

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
}

.send_batch_notification_email(target, notifications, options = {}) ⇒ Mail::Message, ActionMailer::DeliveryJob|NilClass

Sends batch notification email to the target.

Parameters:

  • target (Object) —

    Target of batch notification email

  • notifications (Array<Notification>) —

    Target notifications to send batch notification email

  • options (Hash) (defaults to: {}) —

    Options for notification email

Options Hash (options):

  • :send_later (Boolean) — default: false —

    If it sends notification email asynchronously

  • :fallback (String, Symbol) — default: :batch_default —

    Fallback template to use when MissingTemplate is raised

  • :batch_key (String) — default: nil —

    Key of the batch notification email, a key of the first notification will be used if not specified

Returns:

  • (Mail::Message, ActionMailer::DeliveryJob|NilClass) —

    Email message or its delivery job, return NilClass for wrong target



489
490
491
492
493
494
495
496
497
498
499
 
# File 'lib/activity_notification/apis/notification_api.rb', line 489

def send_batch_notification_email(target, notifications, options = {})
  notifications.blank? and return
  batch_key = options[:batch_key] || notifications.first.key
  if target.batch_notification_email_allowed?(batch_key) &&
     target.subscribes_to_notification_email?(batch_key)
    send_later = options.has_key?(:send_later) ? options[:send_later] : true
    send_later ?
      @@notification_mailer.send_batch_notification_email(target, notifications, batch_key, options).deliver_later :
      @@notification_mailer.send_batch_notification_email(target, notifications, batch_key, options).deliver_now
  end
end

.set_notification_mailer ⇒ Object

Defines mailer class to send notification



509
510
511
 
# File 'lib/activity_notification/apis/notification_api.rb', line 509

def set_notification_mailer
  @@notification_mailer = ActivityNotification.config.mailer.constantize
end

.uniq_keys ⇒ Array<String>

Selects unique keys from query for notifications.

Returns:

  • (Array<String>) —

    Array of notification unique keys



187
188
189
190
191
192
193
 
# File 'lib/activity_notification/apis/notification_api.rb', line 187

def self.uniq_keys
  ## select method cannot be chained with order by other columns like created_at
  # select(:key).distinct.pluck(:key)
  ## distinct method cannot keep original sort
  # distinct(:key)
  pluck(:key).uniq
end

.unopened_index ⇒ ActiveRecord_AssociationRelation<Notificaion>, Mongoid::Criteria<Notificaion>

Selects unopened notification index.

ActivityNotification::Notification.unopened_index

is defined same as

ActivityNotification::Notification.unopened_only.group_owners_only.latest_order

Examples:

Get unopened notificaton index of the @user

@notifications = @user.notifications.unopened_index
@notifications = @user.notifications.unopened_only.group_owners_only.latest_order

Parameters:

  • reverse (Boolean) —

    If notification index will be ordered as earliest first

  • with_group_members (Boolean) —

    If notification index will include group members

Returns:

  • (ActiveRecord_AssociationRelation<Notificaion>, Mongoid::Criteria<Notificaion>) —

    Database query of filtered notifications



42
43
44
45
 
# File 'lib/activity_notification/apis/notification_api.rb', line 42

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
}

.valid_group_owner(target, notifiable, key, group, group_expiry_delay) ⇒ Notificaion

Returns valid group owner within the expiration period

Parameters:

  • target (Object) —

    Target to send notifications

  • notifiable (Object) —

    Notifiable instance

  • key (String) —

    Key of the notification

  • group (Object) —

    Group unit of the notifications

  • group_expiry_delay (ActiveSupport::Duration) —

    Expiry period of a notification group

Returns:

  • (Notificaion) —

    Valid group owner within the expiration period



521
522
523
524
525
526
527
528
529
530
 
# File 'lib/activity_notification/apis/notification_api.rb', line 521

def valid_group_owner(target, notifiable, key, group, group_expiry_delay)
  return nil if group.blank?
  # Bundle notification group by target, notifiable_type, group and key
  # 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_expiry_delay.present? ?
    group_owner_notifications.within_expiration_only(group_expiry_delay).earliest :
    group_owner_notifications.earliest
end

Instance Method Details

#after_store ⇒ Object

Call after store action with stored notification



559
560
 
# File 'lib/activity_notification/apis/notification_api.rb', line 559

def after_store
end

#earliest_order ⇒ ActiveRecord_AssociationRelation<Notificaion>, Mongoid::Criteria<Notificaion>

Orders by earliest (older) first as created_at: :asc.

Returns:

  • (ActiveRecord_AssociationRelation<Notificaion>, Mongoid::Criteria<Notificaion>) —

    Database query of notifications ordered by earliest first



146
 
# File 'lib/activity_notification/apis/notification_api.rb', line 146

scope :earliest_order,                    -> { order(created_at: :asc) }

#earliest_order! ⇒ ActiveRecord_AssociationRelation<Notificaion>, Mongoid::Criteria<Notificaion>

Orders by earliest (older) first as created_at: :asc. This method is to be overridden in implementation for each ORM.

Returns:

  • (ActiveRecord_AssociationRelation<Notificaion>, Mongoid::Criteria<Notificaion>) —

    Database query of notifications ordered by earliest first



157
 
# File 'lib/activity_notification/apis/notification_api.rb', line 157

scope :earliest_order!,                   -> { earliest_order }

#email_subscribed? ⇒ Boolean

Returns if the target subscribes this notification email.

Returns:

  • (Boolean) —

    If the target subscribes the notification



753
754
755
 
# File 'lib/activity_notification/apis/notification_api.rb', line 753

def email_subscribed?
  target.subscribes_to_notification_email?(key)
end

#group_member? ⇒ Boolean

Returns if the notification is group member belonging to owner.

Returns:

  • (Boolean) —

    If the notification is group member



646
647
648
 
# File 'lib/activity_notification/apis/notification_api.rb', line 646

def group_member?
  group_owner_id.present?
end

#group_member_count(limit = ActivityNotification.config.opened_index_limit) ⇒ Integer

Returns count of group members of the notification. This method is designed to cache group by query result to avoid N+1 call.

Parameters:

  • limit (Integer) (defaults to: ActivityNotification.config.opened_index_limit) —

    Limit to query for opened notifications

Returns:

  • (Integer) —

    Count of group members of the notification



675
676
677
 
# File 'lib/activity_notification/apis/notification_api.rb', line 675

def group_member_count(limit = ActivityNotification.config.opened_index_limit)
  meta_group_member_count(:opened_group_member_count, :unopened_group_member_count, limit)
end

#group_member_exists?(limit = ActivityNotification.config.opened_index_limit) ⇒ Boolean

Returns if group member of the notification exists. This method is designed to cache group by query result to avoid N+1 call.

Parameters:

  • limit (Integer) (defaults to: ActivityNotification.config.opened_index_limit) —

    Limit to query for opened notifications

Returns:

  • (Boolean) —

    If group member of the notification exists



655
656
657
 
# File 'lib/activity_notification/apis/notification_api.rb', line 655

def group_member_exists?(limit = ActivityNotification.config.opened_index_limit)
  group_member_count(limit) > 0
end

#group_member_notifier_count(limit = ActivityNotification.config.opened_index_limit) ⇒ Integer

Returns count of group member notifiers of the notification not including group owner notifier. It always returns 0 if group owner notifier is blank. It counts only the member notifier of the same type with group owner notifier. This method is designed to cache group by query result to avoid N+1 call.

Parameters:

  • limit (Integer) (defaults to: ActivityNotification.config.opened_index_limit) —

    Limit to query for opened notifications

Returns:

  • (Integer) —

    Count of group member notifiers of the notification



695
696
697
 
# File 'lib/activity_notification/apis/notification_api.rb', line 695

def group_member_notifier_count(limit = ActivityNotification.config.opened_index_limit)
  meta_group_member_count(:opened_group_member_notifier_count, :unopened_group_member_notifier_count, limit)
end

#group_member_notifier_exists?(limit = ActivityNotification.config.opened_index_limit) ⇒ Boolean

Returns if group member notifier except group owner notifier exists. It always returns false if group owner notifier is blank. It counts only the member notifier of the same type with group owner notifier. This method is designed to cache group by query result to avoid N+1 call.

Parameters:

  • limit (Integer) (defaults to: ActivityNotification.config.opened_index_limit) —

    Limit to query for opened notifications

Returns:

  • (Boolean) —

    If group member of the notification exists



666
667
668
 
# File 'lib/activity_notification/apis/notification_api.rb', line 666

def group_member_notifier_exists?(limit = ActivityNotification.config.opened_index_limit)
  group_member_notifier_count(limit) > 0
end

#group_notification_count(limit = ActivityNotification.config.opened_index_limit) ⇒ Integer

Returns count of group notifications including owner and members. This method is designed to cache group by query result to avoid N+1 call.

Parameters:

  • limit (Integer) (defaults to: ActivityNotification.config.opened_index_limit) —

    Limit to query for opened notifications

Returns:

  • (Integer) —

    Count of group notifications including owner and members



684
685
686
 
# File 'lib/activity_notification/apis/notification_api.rb', line 684

def group_notification_count(limit = ActivityNotification.config.opened_index_limit)
  group_member_count(limit) + 1
end

#group_notifier_count(limit = ActivityNotification.config.opened_index_limit) ⇒ Integer

Returns count of group member notifiers including group owner notifier. It always returns 0 if group owner notifier is blank. This method is designed to cache group by query result to avoid N+1 call.

Parameters:

  • limit (Integer) (defaults to: ActivityNotification.config.opened_index_limit) —

    Limit to query for opened notifications

Returns:

  • (Integer) —

    Count of group notifications including owner and members



705
706
707
708
 
# File 'lib/activity_notification/apis/notification_api.rb', line 705

def group_notifier_count(limit = ActivityNotification.config.opened_index_limit)
  notification = group_member? && group_owner.present? ? group_owner : self
  notification.notifier.present? ? group_member_notifier_count(limit) + 1 : 0
end

#group_owner? ⇒ Boolean

Returns if the notification is group owner.

Returns:

  • (Boolean) —

    If the notification is group owner



639
640
641
 
# File 'lib/activity_notification/apis/notification_api.rb', line 639

def group_owner?
  !group_member?
end

#latest_group_member ⇒ Notificaion

Returns the latest group member notification instance of this notification. If this group owner has no group members, group owner instance self will be returned.

Returns:

  • (Notificaion) —

    Notification instance of the latest group member notification



714
715
716
717
 
# File 'lib/activity_notification/apis/notification_api.rb', line 714

def latest_group_member
  notification = group_member? && group_owner.present? ? group_owner : self
  notification.group_member_exists? ? notification.group_members.latest : self
end

#latest_order ⇒ ActiveRecord_AssociationRelation<Notificaion>, Mongoid::Criteria<Notificaion>

Orders by latest (newest) first as created_at: :desc.

Returns:

  • (ActiveRecord_AssociationRelation<Notificaion>, Mongoid::Criteria<Notificaion>) —

    Database query of notifications ordered by latest first



142
 
# File 'lib/activity_notification/apis/notification_api.rb', line 142

scope :latest_order,                      -> { order(created_at: :desc) }

#latest_order! ⇒ ActiveRecord_AssociationRelation<Notificaion>, Mongoid::Criteria<Notificaion>

Orders by latest (newest) first as created_at: :desc. This method is to be overridden in implementation for each ORM.

Parameters:

  • reverse (Boolean) —

    If notifications will be ordered as earliest first

Returns:

  • (ActiveRecord_AssociationRelation<Notificaion>, Mongoid::Criteria<Notificaion>) —

    Database query of ordered notifications



152
 
# File 'lib/activity_notification/apis/notification_api.rb', line 152

scope :latest_order!,                     ->(reverse = false) { reverse ? earliest_order : latest_order }

#notifiable_path ⇒ String

Returns notifiable_path to move after opening notification with notifiable.notifiable_path.

Returns:

  • (String) —

    Notifiable path URL to move after opening notification



734
735
736
737
 
# File 'lib/activity_notification/apis/notification_api.rb', line 734

def notifiable_path
  notifiable.blank? and raise ActivityNotification::NotifiableNotFoundError.new("Couldn't find associated notifiable (#{notifiable_type}) of #{self.class.name} with 'id'=#{id}")
  notifiable.notifiable_path(target_type, key)
end

#open!(options = {}) ⇒ Integer

Opens the notification.

Parameters:

  • options (Hash) (defaults to: {}) —

    Options for opening notifications

Options Hash (options):

  • :opened_at (DateTime) — default: Time.current —

    Time to set to opened_at of the notification record

  • :with_members (Boolean) — default: true —

    If it opens notifications including group members

  • :skip_validation (Boolean) — default: true —

    If it skips validation of the notification record

Returns:

  • (Integer) —

    Number of opened notification records



612
613
614
615
616
617
618
619
620
 
# File 'lib/activity_notification/apis/notification_api.rb', line 612

def open!(options = {})
  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
  options[:skip_validation] ? update_attribute(:opened_at, opened_at) : update(opened_at: opened_at)
  unopened_member_count + 1
end

#opened? ⇒ Boolean

Returns if the notification is opened.

Returns:

  • (Boolean) —

    If the notification is opened



632
633
634
 
# File 'lib/activity_notification/apis/notification_api.rb', line 632

def opened?
  opened_at.present?
end

#optional_target_names ⇒ Array<Symbol>

Returns optional_target names of the notification from configured field or overridden method.

Returns:

  • (Array<Symbol>) —

    Array of optional target names



772
773
774
 
# File 'lib/activity_notification/apis/notification_api.rb', line 772

def optional_target_names
  notifiable.optional_target_names(target.to_resources_name, key)
end

#optional_target_subscribed?(optional_target_name) ⇒ Boolean

Returns if the target subscribes this notification email.

Parameters:

  • optional_target_name (String, Symbol) —

    Class name of the optional target implementation (e.g. :amazon_sns, :slack)

Returns:

  • (Boolean) —

    If the target subscribes the specified optional target of the notification



760
761
762
 
# File 'lib/activity_notification/apis/notification_api.rb', line 760

def optional_target_subscribed?(optional_target_name)
  target.subscribes_to_optional_target?(key, optional_target_name)
end

#optional_targets ⇒ Array<ActivityNotification::OptionalTarget::Base>

Returns optional_targets of the notification from configured field or overridden method.

Returns:



766
767
768
 
# File 'lib/activity_notification/apis/notification_api.rb', line 766

def optional_targets
  notifiable.optional_targets(target.to_resources_name, key)
end

#prepare_to_store ⇒ Object

:nocov: Returns prepared notification object to store

Returns:

  • (Object) —

    prepared notification object to store



554
555
556
 
# File 'lib/activity_notification/apis/notification_api.rb', line 554

def prepare_to_store
  self
end

#printable_notifiable_name ⇒ String

Returns printable notifiable model name to show in view or email.

Returns:

  • (String) —

    Printable notifiable model name



741
742
743
 
# File 'lib/activity_notification/apis/notification_api.rb', line 741

def printable_notifiable_name
  notifiable.printable_notifiable_name(target, key)
end

#publish_to_optional_targets(options = {}) ⇒ Hash

Publishes notification to the optional targets.

Parameters:

  • options (Hash) (defaults to: {}) —

    Options for optional targets

Returns:

  • (Hash) —

    Result of publishing to optional target



584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
 
# File 'lib/activity_notification/apis/notification_api.rb', line 584

def publish_to_optional_targets(options = {})
  notifiable.optional_targets(target.to_resources_name, key).map { |optional_target|
    optional_target_name = optional_target.to_optional_target_name
    if optional_target_subscribed?(optional_target_name)
      begin
        optional_target.notify(self, options[optional_target_name] || {})
        [optional_target_name, true]
      rescue => e
        Rails.logger.error(e)
        if ActivityNotification.config.rescue_optional_target_errors
          [optional_target_name, e]
        else
          raise e
        end
      end
    else
      [optional_target_name, false]
    end
  }.to_h
end

#remove_from_group ⇒ Notificaion

Remove from notification group and make a new group owner.

Returns:

  • (Notificaion) —

    New group owner instance of the notification group



722
723
724
725
726
727
728
729
 
# File 'lib/activity_notification/apis/notification_api.rb', line 722

def remove_from_group
  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.id)
  end
  new_group_owner
end

#send_notification_email(options = {}) ⇒ Mail::Message, ...

Sends notification email to the target.

Parameters:

  • options (Hash) (defaults to: {}) —

    Options for notification email

Options Hash (options):

  • :send_later (Boolean) —

    If it sends notification email asynchronously

  • :fallback (String, Symbol) — default: :default —

    Fallback template to use when MissingTemplate is raised

Returns:

  • (Mail::Message, ActionMailer::DeliveryJob, NilClass) —

    Email message, its delivery job, or nil if notification not found



569
570
571
572
573
574
575
576
577
578
 
# File 'lib/activity_notification/apis/notification_api.rb', line 569

def send_notification_email(options = {})
  if target.notification_email_allowed?(notifiable, key) &&
     notifiable.notification_email_allowed?(target, key) &&
     email_subscribed?
    send_later = options.has_key?(:send_later) ? options[:send_later] : true
    send_later ?
      @@notification_mailer.send_notification_email(self, options).deliver_later :
      @@notification_mailer.send_notification_email(self, options).deliver_now
  end
end

#subscribed? ⇒ Boolean

Returns if the target subscribes this notification.

Returns:

  • (Boolean) —

    If the target subscribes the notification



747
748
749
 
# File 'lib/activity_notification/apis/notification_api.rb', line 747

def subscribed?
  target.subscribes_to_notification?(key)
end

#unopened? ⇒ Boolean

Returns if the notification is unopened.

Returns:

  • (Boolean) —

    If the notification is unopened



625
626
627
 
# File 'lib/activity_notification/apis/notification_api.rb', line 625

def unopened?
  !opened?
end