Module: ActivityNotification::NotificationApi

Extended by:
ActiveSupport::Concern
Included in:
ORM::ActiveRecord::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



21
22
23
24
 
# File 'lib/activity_notification/apis/notification_api.rb', line 21

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



296
297
298
 
# File 'lib/activity_notification/apis/notification_api.rb', line 296

def available_options
  [:key, :group, :parameters, :notifier, :send_email, :send_later].freeze
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



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

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



105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
 
# File 'lib/activity_notification/apis/notification_api.rb', line 105

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
}

.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



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

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



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

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



235
236
237
238
239
240
241
 
# File 'lib/activity_notification/apis/notification_api.rb', line 235

def generate_notification(target, notifiable, options = {})
  key = options[:key] || notifiable.default_notification_key
  if target.subscribes_to_notification?(key)
    # Store 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



268
269
270
 
# File 'lib/activity_notification/apis/notification_api.rb', line 268

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

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

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

  • :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



162
163
164
165
166
167
 
# File 'lib/activity_notification/apis/notification_api.rb', line 162

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

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

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

  • :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



187
188
189
 
# File 'lib/activity_notification/apis/notification_api.rb', line 187

def notify_all(targets, notifiable, options = {})
  targets.map { |target| target.notify_to(notifiable, options) }
end

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

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

  • :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:



209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
 
# File 'lib/activity_notification/apis/notification_api.rb', line 209

def notify_to(target, notifiable, options = {})
  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

.open_all_of(target, options = {}) ⇒ Integer

TODO:

Add filter option

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

Returns:

  • (Integer) —

    Number of opened notification records



255
256
257
258
259
260
261
 
# File 'lib/activity_notification/apis/notification_api.rb', line 255

def open_all_of(target, options = {})
  opened_at = options[:opened_at] || Time.current
  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

.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



54
55
56
57
 
# File 'lib/activity_notification/apis/notification_api.rb', line 54

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



281
282
283
284
285
286
287
288
289
290
291
 
# File 'lib/activity_notification/apis/notification_api.rb', line 281

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 ?
      Mailer.send_batch_notification_email(target, notifications, batch_key, options).deliver_later :
      Mailer.send_batch_notification_email(target, notifications, batch_key, options).deliver_now
  end
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



37
38
39
40
 
# File 'lib/activity_notification/apis/notification_api.rb', line 37

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
}

Instance Method Details

#earliest_order ⇒ Mongoid::Criteria<Notificaion>

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

Returns:

  • (Mongoid::Criteria<Notificaion>) —

    Database query of notifications ordered by earliest first



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

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

#email_subscribed? ⇒ Boolean

Returns if the target subscribes this notification email.

Returns:

  • (Boolean) —

    If the target subscribes the notification



499
500
501
 
# File 'lib/activity_notification/apis/notification_api.rb', line 499

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



398
399
400
 
# File 'lib/activity_notification/apis/notification_api.rb', line 398

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



427
428
429
 
# File 'lib/activity_notification/apis/notification_api.rb', line 427

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



407
408
409
 
# File 'lib/activity_notification/apis/notification_api.rb', line 407

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



447
448
449
 
# File 'lib/activity_notification/apis/notification_api.rb', line 447

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



418
419
420
 
# File 'lib/activity_notification/apis/notification_api.rb', line 418

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



436
437
438
 
# File 'lib/activity_notification/apis/notification_api.rb', line 436

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



457
458
459
460
 
# File 'lib/activity_notification/apis/notification_api.rb', line 457

def group_notifier_count(limit = ActivityNotification.config.opened_index_limit)
  notification = group_member? ? 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



391
392
393
 
# File 'lib/activity_notification/apis/notification_api.rb', line 391

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



466
467
468
469
 
# File 'lib/activity_notification/apis/notification_api.rb', line 466

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

#latest_order ⇒ Mongoid::Criteria<Notificaion>

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

Returns:

  • (Mongoid::Criteria<Notificaion>) —

    Database query of notifications ordered by latest first



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

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

#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



486
487
488
489
 
# File 'lib/activity_notification/apis/notification_api.rb', line 486

def notifiable_path
  notifiable.present? or raise ActiveRecord::RecordNotFound.new("Couldn't find notifiable #{notifiable_type}")
  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

Returns:

  • (Integer) —

    Number of opened notification records



364
365
366
367
368
369
370
371
372
 
# File 'lib/activity_notification/apis/notification_api.rb', line 364

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
  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



384
385
386
 
# File 'lib/activity_notification/apis/notification_api.rb', line 384

def opened?
  opened_at.present?
end

#optional_target_names ⇒ Array<Symbol>

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

Returns:

  • (Array<Symbol>) —

    Array of optional target names



518
519
520
 
# File 'lib/activity_notification/apis/notification_api.rb', line 518

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



506
507
508
 
# File 'lib/activity_notification/apis/notification_api.rb', line 506

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 overriden method.

Returns:



512
513
514
 
# File 'lib/activity_notification/apis/notification_api.rb', line 512

def optional_targets
  notifiable.optional_targets(target.to_resources_name, 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



346
347
348
349
350
351
352
353
354
355
356
 
# File 'lib/activity_notification/apis/notification_api.rb', line 346

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)
      optional_target.notify(self, options[optional_target_name] || {})
      [optional_target_name, true]
    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



474
475
476
477
478
479
480
481
 
# File 'lib/activity_notification/apis/notification_api.rb', line 474

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, ActionMailer::DeliveryJob

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) —

    Email message or its delivery job



331
332
333
334
335
336
337
338
339
340
 
# File 'lib/activity_notification/apis/notification_api.rb', line 331

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 ?
      Mailer.send_notification_email(self, options).deliver_later :
      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



493
494
495
 
# File 'lib/activity_notification/apis/notification_api.rb', line 493

def subscribed?
  target.subscribes_to_notification?(key)
end

#unopened? ⇒ Boolean

Returns if the notification is unopened.

Returns:

  • (Boolean) —

    If the notification is unopened



377
378
379
 
# File 'lib/activity_notification/apis/notification_api.rb', line 377

def unopened?
  !opened?
end