Class: Dynamoid::Criteria::Chain

Inherits:
Object
  • Object
show all
Defined in:
lib/activity_notification/orm/dynamoid/extension.rb,
lib/activity_notification/orm/dynamoid.rb

Overview

github.com/Dynamoid/dynamoid/blob/master/lib/dynamoid/criteria/chain.rb

Direct Known Subclasses

None

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

.all_index!(reverse = false, with_group_members = false) ⇒ Dynamoid::Criteria::Chain

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:

  • (defaults to: false)

    If notification index will be ordered as earliest first

  • (defaults to: false)

    If notification index will include group members

Returns:

  • Database query of filtered notifications



140
141
142
143
 
# File 'lib/activity_notification/orm/dynamoid.rb', line 140

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

.earlier_than(created_time) ⇒ ActiveRecord_AssociationRelation<Notificaion>, Mongoid::Criteria<Notificaion>

Selects filtered notifications earlier than specified time.

Examples:

Get filtered unopened notificatons of the @user earlier than @notification

@notifications = @user.notifications.unopened_only.earlier_than(@notification.created_at)

Parameters:

  • time of the notifications for filter

Returns:

  • Database query of filtered notifications



285
286
287
 
# File 'lib/activity_notification/orm/dynamoid.rb', line 285

def earlier_than(created_time)
  where('created_at.lt': created_time)
end

.exists? ⇒ Boolean

Return if records exist

Returns:

  • If records exist



51
52
53
 
# File 'lib/activity_notification/orm/dynamoid/extension.rb', line 51

def exists?
  record_limit(1).count > 0
end

.filtered_by_association(name, instance) ⇒ Dynamoid::Criteria::Chain

Selects filtered notifications or subscriptions by associated instance.

Parameters:

  • Association name

  • Associated instance

Returns:

  • Database query of filtered notifications or subscriptions



183
184
185
 
# File 'lib/activity_notification/orm/dynamoid.rb', line 183

def filtered_by_association(name, instance)
  instance.present? ? where("#{name}_key" => "#{instance.class.name}#{ActivityNotification.config.composite_key_delimiter}#{instance.id}") : where("#{name}_key.null" => true)
end

.filtered_by_association_type(name, type) ⇒ Dynamoid::Criteria::Chain

Selects filtered notifications or subscriptions by association type.

Parameters:

  • Association name

  • Association type (can be class name string or object instance)

Returns:

  • Database query of filtered notifications or subscriptions



192
193
194
195
196
 
# File 'lib/activity_notification/orm/dynamoid.rb', line 192

def filtered_by_association_type(name, type)
  # Handle both string class names and object instances
  type_name = type.is_a?(String) ? type : type.class.name
  where("#{name}_key.begins_with" => "#{type_name}#{ActivityNotification.config.composite_key_delimiter}")
end

.filtered_by_association_type_and_id(name, type, id) ⇒ Dynamoid::Criteria::Chain

Selects filtered notifications or subscriptions by association type and id.

Parameters:

  • Association name

  • Association type

  • Association id

Returns:

  • Database query of filtered notifications or subscriptions



204
205
206
 
# File 'lib/activity_notification/orm/dynamoid.rb', line 204

def filtered_by_association_type_and_id(name, type, id)
  type.present? && id.present? ? where("#{name}_key" => "#{type}#{ActivityNotification.config.composite_key_delimiter}#{id}") : none
end

.filtered_by_group(group) ⇒ Dynamoid::Criteria::Chain

Selects filtered notifications by group instance.

Examples:

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

@notifications = @user.notifications.unopened_only.filtered_by_group(@article)

Parameters:

  • Group instance for filter

Returns:

  • Database query of filtered notifications



235
236
237
 
# File 'lib/activity_notification/orm/dynamoid.rb', line 235

def filtered_by_group(group)
  filtered_by_association("group", group)
end

.filtered_by_instance(notifiable) ⇒ Dynamoid::Criteria::Chain

Selects filtered notifications by notifiable instance.

Examples:

Get filtered unopened notificatons of the @user for @comment as notifiable

@notifications = @user.notifications.unopened_only.filtered_by_instance(@comment)

Parameters:

  • Notifiable instance for filter

Returns:

  • Database query of filtered notifications



225
226
227
 
# File 'lib/activity_notification/orm/dynamoid.rb', line 225

def filtered_by_instance(notifiable)
  filtered_by_association("notifiable", notifiable)
end

.filtered_by_key(key) ⇒ Dynamoid::Criteria::Chain

Selects filtered notifications or subscriptions 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 of the notification for filter

Returns:

  • Database query of filtered notifications or subscriptions



265
266
267
 
# File 'lib/activity_notification/orm/dynamoid.rb', line 265

def filtered_by_key(key)
  where(key: key)
end

.filtered_by_options(options = {}) ⇒ Dynamoid::Criteria::Chain

Selects filtered notifications or subscriptions 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:

  • (defaults to: {})

    Options for filter

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 notification index later than specified time

  • :earlier_than (String) — default: nil —

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

  • :custom_filter (Array|Hash) — default: nil —

    Custom notification filter (e.g. [‘created_at.gt’: time.hour.ago])

Returns:

  • Database query of filtered notifications or subscriptions



313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
 
# File 'lib/activity_notification/orm/dynamoid.rb', line 313

def filtered_by_options(options = {})
  options = ActivityNotification.cast_to_indifferent_hash(options)
  filtered_notifications = self
  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.filtered_by_association_type_and_id("group", options[:filtered_by_group_type], 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
end

.filtered_by_target(target) ⇒ Dynamoid::Criteria::Chain

Selects filtered notifications or subscriptions by target instance.

ActivityNotification::Notification.filtered_by_target(@user)

is the same as

@user.notifications

Parameters:

  • Target instance for filter

Returns:

  • Database query of filtered notifications or subscriptions



215
216
217
 
# File 'lib/activity_notification/orm/dynamoid.rb', line 215

def filtered_by_target(target)
  filtered_by_association("target", target)
end

.filtered_by_target_type(target_type) ⇒ Dynamoid::Criteria::Chain

Selects filtered notifications or subscriptions 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 for filter

Returns:

  • Database query of filtered notifications or subscriptions



245
246
247
 
# File 'lib/activity_notification/orm/dynamoid.rb', line 245

def filtered_by_target_type(target_type)
  filtered_by_association_type("target", target_type)
end

.filtered_by_type(notifiable_type) ⇒ Dynamoid::Criteria::Chain

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

Returns:

  • Database query of filtered notifications



255
256
257
 
# File 'lib/activity_notification/orm/dynamoid.rb', line 255

def filtered_by_type(notifiable_type)
  filtered_by_association_type("notifiable", notifiable_type)
end

.group_members_of_owner_ids_only(owner_ids) ⇒ Dynamoid::Criteria::Chain

Selects group member notifications with specified group owner ids.

Parameters:

  • Array of group owner ids

Returns:

  • Database query of filtered notifications



485
486
487
 
# File 'lib/activity_notification/orm/dynamoid.rb', line 485

def group_members_of_owner_ids_only(owner_ids)
  owner_ids.present? ? where('group_owner_id.in': owner_ids) : none
end

.group_members_only ⇒ Dynamoid::Criteria::Chain

Selects group member notifications only.

Returns:

  • Database query of filtered notifications



403
404
405
406
407
408
409
410
411
412
413
414
415
 
# File 'lib/activity_notification/orm/dynamoid.rb', line 403

def group_members_only
  # Create a new chain to avoid state issues
  new_chain = @source.where('group_owner_id.not_null': true)
  # Apply existing conditions from current chain
  if instance_variable_defined?(:@where_conditions) && @where_conditions
    @where_conditions.instance_variable_get(:@hash_conditions).each do |condition|
      # Skip conflicting group_owner_id conditions
      next if condition.key?(:"group_owner_id.null") || condition.key?(:"group_owner_id.not_null")
      new_chain = new_chain.where(condition)
    end
  end
  new_chain
end

.group_owners_only ⇒ Dynamoid::Criteria::Chain

Selects group owner notifications only.

Returns:

  • Database query of filtered notifications



396
397
398
 
# File 'lib/activity_notification/orm/dynamoid.rb', line 396

def group_owners_only
  where('group_owner_id.null': true)
end

.later_than(created_time) ⇒ ActiveRecord_AssociationRelation<Notificaion>, Mongoid::Criteria<Notificaion>

Selects filtered notifications later than specified time.

Examples:

Get filtered unopened notificatons of the @user later than @notification

@notifications = @user.notifications.unopened_only.later_than(@notification.created_at)

Parameters:

  • time of the notifications for filter

Returns:

  • Database query of filtered notifications



275
276
277
 
# File 'lib/activity_notification/orm/dynamoid.rb', line 275

def later_than(created_time)
  where('created_at.gt': created_time)
end

.limit(limit) ⇒ Dynamoid::Criteria::Chain

Set query result limit as record_limit of Dynamoid

Parameters:

  • Query result limit as record_limit

Returns:

  • Database query of filtered notifications or subscriptions



44
45
46
 
# File 'lib/activity_notification/orm/dynamoid/extension.rb', line 44

def limit(limit)
  record_limit(limit)
end

.opened_index(limit, reverse = false, with_group_members = false) ⇒ Dynamoid::Criteria::Chain

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 to query for opened notifications

  • (defaults to: false)

    If notification index will be ordered as earliest first

  • (defaults to: false)

    If notification index will include group members

Returns:

  • Database query of filtered notifications



173
174
175
176
 
# File 'lib/activity_notification/orm/dynamoid.rb', line 173

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

.opened_index_group_members_only(limit) ⇒ Dynamoid::Criteria::Chain

Selects group member notifications in opened_index.

Parameters:

  • Limit to query for opened notifications

Returns:

  • Database query of filtered notifications



468
469
470
471
 
# File 'lib/activity_notification/orm/dynamoid.rb', line 468

def opened_index_group_members_only(limit)
  group_owner_ids = opened_index(limit).map(&:id)
  group_owner_ids.empty? ? none : where('group_owner_id.in': group_owner_ids)
end

.opened_only(limit) ⇒ Dynamoid::Criteria::Chain

Selects opened notifications only with limit.

Parameters:

  • Limit to query for opened notifications

Returns:

  • Database query of filtered notifications



452
453
454
 
# File 'lib/activity_notification/orm/dynamoid.rb', line 452

def opened_only(limit)
  limit == 0 ? none : opened_only!.limit(limit)
end

.opened_only! ⇒ Dynamoid::Criteria::Chain

Selects opened notifications only without limit. Be careful to get too many records with this method.

Returns:

  • Database query of filtered notifications



436
437
438
439
440
441
442
443
444
445
446
 
# File 'lib/activity_notification/orm/dynamoid.rb', line 436

def opened_only!
  # Create a new chain to avoid state issues
  new_chain = @source.where('opened_at.not_null': true)
  # Apply existing conditions from current chain
  if instance_variable_defined?(:@where_conditions) && @where_conditions
    @where_conditions.instance_variable_get(:@hash_conditions).each do |condition|
      new_chain = new_chain.where(condition)
    end
  end
  new_chain
end

.size ⇒ Integer

Return size of records as count

Returns:

  • Size of records



58
59
60
 
# File 'lib/activity_notification/orm/dynamoid/extension.rb', line 58

def size
  count
end

.unopened_index(reverse = false, with_group_members = false) ⇒ Dynamoid::Criteria::Chain

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:

  • (defaults to: false)

    If notification index will be ordered as earliest first

  • (defaults to: false)

    If notification index will include group members

Returns:

  • Database query of filtered notifications



156
157
158
159
 
# File 'lib/activity_notification/orm/dynamoid.rb', line 156

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

.unopened_index_group_members_only ⇒ Dynamoid::Criteria::Chain

Selects group member notifications in unopened_index.

Returns:

  • Database query of filtered notifications



459
460
461
462
 
# File 'lib/activity_notification/orm/dynamoid.rb', line 459

def unopened_index_group_members_only
  group_owner_ids = unopened_index.map(&:id)
  group_owner_ids.empty? ? none : where('group_owner_id.in': group_owner_ids)
end

.unopened_only ⇒ Dynamoid::Criteria::Chain

Selects unopened notifications only.

Returns:

  • Database query of filtered notifications



420
421
422
423
424
425
426
427
428
429
430
 
# File 'lib/activity_notification/orm/dynamoid.rb', line 420

def unopened_only
  # Create a new chain to avoid state issues
  new_chain = @source.where('opened_at.null': true)
  # Apply existing conditions from current chain
  if instance_variable_defined?(:@where_conditions) && @where_conditions
    @where_conditions.instance_variable_get(:@hash_conditions).each do |condition|
      new_chain = new_chain.where(condition)
    end
  end
  new_chain
end

.within_expiration_only(expiry_delay) ⇒ Dynamoid::Criteria::Chain

Selects notifications within expiration.

Parameters:

  • Expiry period of notifications

Returns:

  • Database query of filtered notifications



477
478
479
 
# File 'lib/activity_notification/orm/dynamoid.rb', line 477

def within_expiration_only(expiry_delay)
  where('created_at.gt': expiry_delay.ago)
end

Instance Method Details

#earliest ⇒ Notification

Returns earliest notification instance.

Returns:

  • Earliest notification instance



538
539
540
 
# File 'lib/activity_notification/orm/dynamoid.rb', line 538

def earliest
  earliest_order.first
end

#earliest! ⇒ Notification

Returns earliest notification instance. It does not use sort key in DynamoDB tables.

Returns:

  • Earliest notification instance



552
553
554
 
# File 'lib/activity_notification/orm/dynamoid.rb', line 552

def earliest!
  earliest_order!.first
end

#earliest_order ⇒ Dynamoid::Criteria::Chain

Orders by earliest (older) first as created_at: :asc. It uses sort key of Global Secondary Index in DynamoDB tables.

Returns:

  • Database query of notifications or subscriptions ordered by earliest first



351
352
353
354
 
# File 'lib/activity_notification/orm/dynamoid.rb', line 351

def earliest_order
  # order(created_at: :asc)
  scan_index_forward(true)
end

#earliest_order! ⇒ Array

Orders by earliest (older) first as created_at: :asc and returns as array. It does not use sort key in DynamoDB tables.

Returns:

  • Array of notifications or subscriptions ordered by earliest first



367
368
369
370
 
# File 'lib/activity_notification/orm/dynamoid.rb', line 367

def earliest_order!
  # order(created_at: :asc)
  all.to_a.sort_by {|n| n.created_at }
end

#earliest_subscribed_order ⇒ Array

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

Returns:

  • Array of subscriptions ordered by earliest subscribed_at first



381
382
383
384
 
# File 'lib/activity_notification/orm/dynamoid.rb', line 381

def earliest_subscribed_order
  # order(subscribed_at: :asc)
  all.to_a.sort_by {|n| n.subscribed_at }
end

#key_order ⇒ Array

Orders by key name as key: :asc.

Returns:

  • Array of subscriptions ordered by key name



388
389
390
391
 
# File 'lib/activity_notification/orm/dynamoid.rb', line 388

def key_order
  # order(key: :asc)
  all.to_a.sort_by {|n| n.key }
end

#latest ⇒ Notification

Returns latest notification instance.

Returns:

  • Latest notification instance



532
533
534
 
# File 'lib/activity_notification/orm/dynamoid.rb', line 532

def latest
  latest_order.first
end

#latest! ⇒ Notification

Returns latest notification instance. It does not use sort key in DynamoDB tables.

Returns:

  • Latest notification instance



545
546
547
 
# File 'lib/activity_notification/orm/dynamoid.rb', line 545

def latest!
  latest_order!.first
end

#latest_order ⇒ Dynamoid::Criteria::Chain

Orders by latest (newest) first as created_at: :desc. It uses sort key of Global Secondary Index in DynamoDB tables.

Returns:

  • Database query of notifications or subscriptions ordered by latest first



343
344
345
346
 
# File 'lib/activity_notification/orm/dynamoid.rb', line 343

def latest_order
  # order(created_at: :desc)
  scan_index_forward(false)
end

#latest_order!(reverse = false) ⇒ Array

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

Parameters:

  • (defaults to: false)

    If notifications or subscriptions will be ordered as earliest first

Returns:

  • Array of notifications or subscriptions ordered by latest first



359
360
361
362
 
# File 'lib/activity_notification/orm/dynamoid.rb', line 359

def latest_order!(reverse = false)
  # order(created_at: :desc)
  reverse ? earliest_order! : earliest_order!.reverse
end

#latest_subscribed_order ⇒ Array

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

Returns:

  • Array of subscriptions ordered by latest subscribed_at first



374
375
376
377
 
# File 'lib/activity_notification/orm/dynamoid.rb', line 374

def latest_subscribed_order
  # order(subscribed_at: :desc)
  earliest_subscribed_order.reverse
end

#none ⇒ Object

Return new none object



36
37
38
 
# File 'lib/activity_notification/orm/dynamoid/extension.rb', line 36

def none
  None.new(self.source)
end

#reload ⇒ Object

Dummy reload method for test of notifications or subscriptions.



526
527
528
 
# File 'lib/activity_notification/orm/dynamoid.rb', line 526

def reload
  self
end

#serializable_hash(options = {}) ⇒ Object

Return serializable_hash as array



70
71
72
 
# File 'lib/activity_notification/orm/dynamoid/extension.rb', line 70

def serializable_hash(options = {})
  all.to_a.map { |r| r.serializable_hash(options) }
end

#uniq_keys ⇒ Array<String>

Selects unique keys from query for notifications or subscriptions.

Returns:

  • Array of notification unique keys



558
559
560
 
# File 'lib/activity_notification/orm/dynamoid.rb', line 558

def uniq_keys
  all.to_a.collect {|n| n.key }.uniq
end

#update_all(conditions = {}) ⇒ Object

TODO Make this batch



63
64
65
66
67
 
# File 'lib/activity_notification/orm/dynamoid/extension.rb', line 63

def update_all(conditions = {})
  each do |document|
    document.update_attributes(conditions)
  end
end

#with_group ⇒ Dynamoid::Criteria::Chain

Includes group instance with query for notifications.

Returns:

  • Database query of notifications with group



503
504
505
 
# File 'lib/activity_notification/orm/dynamoid.rb', line 503

def with_group
  self
end

#with_group_members ⇒ Dynamoid::Criteria::Chain

Includes group member instances with query for notifications.

Returns:

  • Database query of notifications with group members



515
516
517
 
# File 'lib/activity_notification/orm/dynamoid.rb', line 515

def with_group_members
  self
end

#with_group_owner ⇒ Dynamoid::Criteria::Chain

Includes group owner instances with query for notifications.

Returns:

  • Database query of notifications with group owner



509
510
511
 
# File 'lib/activity_notification/orm/dynamoid.rb', line 509

def with_group_owner
  self
end

#with_notifiable ⇒ Dynamoid::Criteria::Chain

Includes notifiable instance with query for notifications.

Returns:

  • Database query of notifications with notifiable



497
498
499
 
# File 'lib/activity_notification/orm/dynamoid.rb', line 497

def with_notifiable
  self
end

#with_notifier ⇒ Dynamoid::Criteria::Chain

Includes notifier instance with query for notifications.

Returns:

  • Database query of notifications with notifier



521
522
523
 
# File 'lib/activity_notification/orm/dynamoid.rb', line 521

def with_notifier
  self
end

#with_target ⇒ Dynamoid::Criteria::Chain

Includes target instance with query for notifications or subscriptions.

Returns:

  • Database query of notifications with target



491
492
493
 
# File 'lib/activity_notification/orm/dynamoid.rb', line 491

def with_target
  self
end