Class: Effective::Event

Inherits:
ActiveRecord::Base
  • Object
show all
Includes:
PgSearch::Model
Defined in:
app/models/effective/event.rb

Instance Attribute Summary collapse

Instance Method Summary collapse

Instance Attribute Details

#mailer_preview ⇒ Object

Set by the mailer preview. Disabled delayed payment validations



51
52
53
 
# File 'app/models/effective/event.rb', line 51

def mailer_preview
  @mailer_preview
end

Instance Method Details

#any_waitlist? ⇒ Boolean

Returns:

  • (Boolean) 


197
198
199
 
# File 'app/models/effective/event.rb', line 197

def any_waitlist?
  event_tickets.any? { |et| et.waitlist? }
end

#body ⇒ Object 



189
190
191
 
# File 'app/models/effective/event.rb', line 189

def body
  rich_text_body
end

#capacity_available(event_ticket:, event_registration: nil) ⇒ Object

The amount of tickets that can be purchased except ones from an event registration



333
334
335
 
# File 'app/models/effective/event.rb', line 333

def capacity_available(event_ticket:, event_registration: nil)
  event_ticket.capacity_available(except: event_registration)
end

#capacity_selectable(event_ticket:, event_registration: nil) ⇒ Object

The amount of tickets that can be purchased except ones from an event registration



324
325
326
327
328
329
330
 
# File 'app/models/effective/event.rb', line 324

def capacity_selectable(event_ticket:, event_registration: nil)
  return 0 if event_ticket.archived?
  return 100 if event_ticket.capacity.blank?
  return 100 if event_ticket.waitlist?

  event_ticket.capacity_selectable(except: event_registration)
end

#capacity_taken(event_ticket:, event_registration: nil) ⇒ Object

Just used in tests so far



338
339
340
 
# File 'app/models/effective/event.rb', line 338

def capacity_taken(event_ticket:, event_registration: nil)
  event_ticket.capacity_taken(except: event_registration)
end

#closed? ⇒ Boolean

Returns:

  • (Boolean) 


219
220
221
222
 
# File 'app/models/effective/event.rb', line 219

def closed?
  return false if registration_end_at.blank?
  registration_end_at < Time.zone.now
end

#delayed? ⇒ Boolean

Returns:

  • (Boolean) 


371
372
373
 
# File 'app/models/effective/event.rb', line 371

def delayed?
  delayed_payment? && delayed_payment_date.present?
end

#delayed_orders ⇒ Object

When an event payment date is changed, all pending orders should also be updated



389
390
391
392
393
394
395
396
 
# File 'app/models/effective/event.rb', line 389

def delayed_orders
  order_ids = (
    Effective::OrderItem.where(purchasable_id: event_registrants, purchasable_type: 'Effective::EventRegistrant').pluck(:order_id) +
    Effective::OrderItem.where(purchasable_id: event_addons, purchasable_type: 'Effective::EventAddon').pluck(:order_id)
  ).uniq

  Effective::Order.where.not(status: [:purchased, :declined, :voided]).delayed.where(id: order_ids) # deferred delayed orders
end

#delayed_payment_date_upcoming? ⇒ Boolean

Returns:

  • (Boolean) 


375
376
377
378
 
# File 'app/models/effective/event.rb', line 375

def delayed_payment_date_upcoming?
  return false unless delayed?
  delayed_payment_date > Time.zone.now.to_date
end

#duplicate ⇒ Object

Returns a duplicated event object, or throws an exception



272
273
274
275
276
277
278
279
280
281
282
 
# File 'app/models/effective/event.rb', line 272

def duplicate
  Event.new(attributes.except('id', 'updated_at', 'created_at')).tap do |event|
    event.title = event.title + ' (Copy)'
    event.slug = event.slug + '-copy'

    event.rich_text_body = rich_text_body
    event.rich_text_excerpt = rich_text_excerpt

    event.assign_attributes(published_start_at: nil, published_end_at: nil)
  end
end

#duplicate! ⇒ Object 



284
285
286
 
# File 'app/models/effective/event.rb', line 284

def duplicate!
  duplicate.tap { |event| event.save! }
end

#early_bird? ⇒ Boolean

Returns:

  • (Boolean) 


251
252
253
254
 
# File 'app/models/effective/event.rb', line 251

def early_bird?
  return false if early_bird_end_at.blank?
  early_bird_end_at > Time.zone.now
end

#early_bird_past? ⇒ Boolean

Returns:

  • (Boolean) 


256
257
258
259
 
# File 'app/models/effective/event.rb', line 256

def early_bird_past?
  return false if early_bird_end_at.blank?
  early_bird_end_at <= Time.zone.now
end

#early_bird_status ⇒ Object 



261
262
263
264
265
266
267
268
269
 
# File 'app/models/effective/event.rb', line 261

def early_bird_status
  if early_bird?
    'Early Bird Pricing'
  elsif early_bird_past?
    'Expired'
  else
    'None'
  end
end

#event_product_available?(event_product, quantity: 1) ⇒ Boolean

Can I register/purchase this many new event products?

Returns:

  • (Boolean) 


357
358
359
360
361
362
363
364
365
366
367
368
369
 
# File 'app/models/effective/event.rb', line 357

def event_product_available?(event_product, quantity: 1)
  raise('expected an EventProduct') unless event_product.kind_of?(Effective::EventProduct)
  raise('expected quantity to be greater than 0') unless quantity.to_i > 0

  return false if event_product.archived?
  return true if event_product.capacity.blank?   # No capacity enforced for this product

  # Total number already sold
  registered = registered_event_addons.count { |r| r.event_product_id == event_product.id }

  # If there's capacity for this many more
  (registered + quantity) <= event_product.capacity
end

#event_ticket_available?(event_ticket, except: nil, quantity: 1) ⇒ Boolean

Can I register/purchase this many new event tickets?

Returns:

  • (Boolean) 


343
344
345
346
347
348
349
350
351
352
353
354
 
# File 'app/models/effective/event.rb', line 343

def event_ticket_available?(event_ticket, except: nil, quantity: 1)
  raise('expected an EventTicket') unless event_ticket.kind_of?(Effective::EventTicket)
  raise('expected except to be an EventRegistration') if except && !except.class.try(:effective_events_event_registration?)
  raise('expected quantity to be greater than 0') unless quantity.to_i > 0

  return false if event_ticket.archived?
  return true if event_ticket.capacity.blank? # No capacity enforced
  return true if event_ticket.waitlist?       # Always available for waitlist

  # Do we have any tickets available left?
  event_ticket.capacity_available(except: except) >= quantity.to_i
end

#event_tickets_with_capacity ⇒ Object

For Events#index column



293
294
295
 
# File 'app/models/effective/event.rb', line 293

def event_tickets_with_capacity
  event_tickets.select { |et| et.capacity.present? }
end

#event_tickets_with_waitlist ⇒ Object 



297
298
299
 
# File 'app/models/effective/event.rb', line 297

def event_tickets_with_waitlist
  event_tickets_with_capacity.select { |et| et.waitlist? }
end

#excerpt ⇒ Object 



193
194
195
 
# File 'app/models/effective/event.rb', line 193

def excerpt
  rich_text_excerpt
end

#past? ⇒ Boolean

Returns:

  • (Boolean) 


247
248
249
 
# File 'app/models/effective/event.rb', line 247

def past?
  end_at < Time.zone.now
end

#qb_item_names ⇒ Object 



398
399
400
 
# File 'app/models/effective/event.rb', line 398

def qb_item_names
  (event_tickets + event_products).map(&:qb_item_name).uniq - ['', nil]
end

#registerable? ⇒ Boolean

No longer includes sold_out? we check that separately

Returns:

  • (Boolean) 


202
203
204
205
206
 
# File 'app/models/effective/event.rb', line 202

def registerable?
  return false unless published?
  return false unless registration_available?
  (external_registration? && external_registration_url.present?) || event_tickets.present?
end

#registerable_when_impersonating? ⇒ Boolean

Returns:

  • (Boolean) 


208
209
210
 
# File 'app/models/effective/event.rb', line 208

def registerable_when_impersonating?
  (external_registration? && external_registration_url.present?) || event_tickets.present?
end

#registration_available? ⇒ Boolean

Returns:

  • (Boolean) 


212
213
214
215
216
217
 
# File 'app/models/effective/event.rb', line 212

def registration_available?
  return false if closed?

  return false if registration_start_at.blank?
  registration_start_at <= Time.zone.now
end

#sold_out?(except: nil) ⇒ Boolean

Returns:

  • (Boolean) 


224
225
226
227
228
229
230
231
 
# File 'app/models/effective/event.rb', line 224

def sold_out?(except: nil)
  raise('expected except to be an EventRegistration') if except && !except.class.try(:effective_events_event_registration?)

  return false unless event_tickets.present?
  return false if any_waitlist?

  event_tickets.none? { |event_ticket| event_ticket_available?(event_ticket, except: except, quantity: 1) }
end

#start_time ⇒ Object 



288
289
290
 
# File 'app/models/effective/event.rb', line 288

def start_time
  start_at
end

#to_s ⇒ Object 



185
186
187
 
# File 'app/models/effective/event.rb', line 185

def to_s
  title.presence || model_name.human
end

#total_capacity ⇒ Object 



311
312
313
 
# File 'app/models/effective/event.rb', line 311

def total_capacity
  event_tickets_with_capacity.sum { |et| et.capacity }
end

#total_capacity_available ⇒ Object 



319
320
321
 
# File 'app/models/effective/event.rb', line 319

def total_capacity_available
  total_capacity - total_registered_non_waitlisted_count
end

#total_registered ⇒ Object 



315
316
317
 
# File 'app/models/effective/event.rb', line 315

def total_registered
  event_tickets.sum { |et| et.registered_count }
end

#total_registered_non_waitlisted_count ⇒ Object

Total Registered and not waitlisted count



302
303
304
 
# File 'app/models/effective/event.rb', line 302

def total_registered_non_waitlisted_count
  event_tickets_with_capacity.sum { |et| et.registered_non_waitlisted_count }
end

#total_registered_waitlisted_count ⇒ Object

Total Registered and waitlisted count



307
308
309
 
# File 'app/models/effective/event.rb', line 307

def total_registered_waitlisted_count
  event_tickets_with_capacity.sum { |et| et.registered_waitlisted_count }
end

#upcoming? ⇒ Boolean

Returns:

  • (Boolean) 


243
244
245
 
# File 'app/models/effective/event.rb', line 243

def upcoming?
  end_at > Time.zone.now
end

#update_delayed_orders_delayed_payment_date! ⇒ Object 



380
381
382
383
384
385
386
 
# File 'app/models/effective/event.rb', line 380

def update_delayed_orders_delayed_payment_date!
  raise('expected delayed payment date to be present') unless delayed_payment_date.present?

  transaction do
    delayed_orders.find_each { |order| order.update!(delayed_payment_date: delayed_payment_date) }
  end
end

#waitlist_only? ⇒ Boolean

it should say join waitlist if: there are no tickets with capacity remaining OR ALL tickets have at least 1 waitlist registration

Returns:

  • (Boolean) 


234
235
236
237
238
239
240
241
 
# File 'app/models/effective/event.rb', line 234

def waitlist_only?
  return false unless any_waitlist?

  return true if event_tickets.reject(&:archived?).none? { |et| et.capacity.blank? || et.capacity_available > 0 }
  return true if event_tickets.reject(&:archived?).all? { |et| et.registered_waitlisted_count > 0 }

  false
end