Class: Ticket

Inherits:
ApplicationRecord show all
Defined in:
app/models/ticket.rb

Overview

This model manage the Happening Ticket for each User

Relations

belongs to Happening belongs to User

Validates

Instance Attribute Summary collapse

Instance Method Summary collapse

Instance Attribute Details

#by_editor ⇒ Any

Returns attr_accessor, valorized if action is executed by an editor.

Returns:

  • (Any) —

    attr_accessor, valorized if action is executed by an editor



23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
 
# File 'app/models/ticket.rb', line 23

class Ticket < ApplicationRecord
  belongs_to :happening, counter_cache: true
  belongs_to :user
  delegate :event, :event_id, :max_tickets, :max_tickets_for_user, :saleable?, :start_at, to: :happening,
                                                                                          allow_nil: true

  attr_accessor :by_editor

  validates :happening, presence: true
  validates :user, presence: true
  with_options unless: :by_editor do
    validates :saleable?, inclusion: [ true ]
    validates :tickets_count, numericality: { only_integer: true, less_than_or_equal_to: :max_tickets }
    validates :tickets_for_user_count,
              numericality: { only_integer: true, less_than_or_equal_to: :max_tickets_for_user }
    validate  :validate_frequency
  end

  scope :with_user, ->(user) { where user: }

  # check if exists {Event}'s {Ticket} for {User} in a time period
  # @return [Boolean] true if exist a ticket in the time range
  def event_ticket_exist?(period = nil)
    @when = { happenings: { start_at: period } } if period.present?
    event.tickets.where(@when).where(user:).exists?
  end

  # count total of each other happening ticket self included
  # @return [Integer] number of tickets
  def tickets_count
    total = happening.tickets_count
    total += 1 unless persisted?
    total
  end

  # count total of each other happening ticket from {user} self included
  # @return [Integer] number of tickets
  def tickets_for_user_count
    total = happening.tickets.where(user:).count
    total += 1 unless persisted?
    total
  end

  private

  # check {User}'s ticket presence based of {Event#tickets_frequency}
  def validate_frequency
    exist, message = case event.tickets_frequency
    when "single"
                       [ event_ticket_exist?, I18n.t("site.ticket.errors.single") ]
    when "daily"
                       [ event_ticket_exist?(start_at.beginning_of_day..start_at.end_of_day),
                        I18n.t("site.ticket.errors.daily") ]
    when "weekly"
                       [ event_ticket_exist?(start_at.-(7.days)..start_at.+(7.days)),
                        I18n.t("site.ticket.errors.weekly") ]
    when "monthly"
                       [ event_ticket_exist?(start_at.-(30.days)..start_at.+(30.days)),
                        I18n.t("site.ticket.errors.montly") ]
    else
                       return true
    end
    errors.add(:seats, message) if exist
  end
end

#created_at ⇒ DateTime

Returns when the record was created.

Returns:

  • (DateTime) —

    when the record was created



23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
 
# File 'app/models/ticket.rb', line 23

class Ticket < ApplicationRecord
  belongs_to :happening, counter_cache: true
  belongs_to :user
  delegate :event, :event_id, :max_tickets, :max_tickets_for_user, :saleable?, :start_at, to: :happening,
                                                                                          allow_nil: true

  attr_accessor :by_editor

  validates :happening, presence: true
  validates :user, presence: true
  with_options unless: :by_editor do
    validates :saleable?, inclusion: [ true ]
    validates :tickets_count, numericality: { only_integer: true, less_than_or_equal_to: :max_tickets }
    validates :tickets_for_user_count,
              numericality: { only_integer: true, less_than_or_equal_to: :max_tickets_for_user }
    validate  :validate_frequency
  end

  scope :with_user, ->(user) { where user: }

  # check if exists {Event}'s {Ticket} for {User} in a time period
  # @return [Boolean] true if exist a ticket in the time range
  def event_ticket_exist?(period = nil)
    @when = { happenings: { start_at: period } } if period.present?
    event.tickets.where(@when).where(user:).exists?
  end

  # count total of each other happening ticket self included
  # @return [Integer] number of tickets
  def tickets_count
    total = happening.tickets_count
    total += 1 unless persisted?
    total
  end

  # count total of each other happening ticket from {user} self included
  # @return [Integer] number of tickets
  def tickets_for_user_count
    total = happening.tickets.where(user:).count
    total += 1 unless persisted?
    total
  end

  private

  # check {User}'s ticket presence based of {Event#tickets_frequency}
  def validate_frequency
    exist, message = case event.tickets_frequency
    when "single"
                       [ event_ticket_exist?, I18n.t("site.ticket.errors.single") ]
    when "daily"
                       [ event_ticket_exist?(start_at.beginning_of_day..start_at.end_of_day),
                        I18n.t("site.ticket.errors.daily") ]
    when "weekly"
                       [ event_ticket_exist?(start_at.-(7.days)..start_at.+(7.days)),
                        I18n.t("site.ticket.errors.weekly") ]
    when "monthly"
                       [ event_ticket_exist?(start_at.-(30.days)..start_at.+(30.days)),
                        I18n.t("site.ticket.errors.montly") ]
    else
                       return true
    end
    errors.add(:seats, message) if exist
  end
end

#happening_id ⇒ Integer

Returns identifier of related Happening.

Returns:

  • (Integer) —

    identifier of related Happening



23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
 
# File 'app/models/ticket.rb', line 23

class Ticket < ApplicationRecord
  belongs_to :happening, counter_cache: true
  belongs_to :user
  delegate :event, :event_id, :max_tickets, :max_tickets_for_user, :saleable?, :start_at, to: :happening,
                                                                                          allow_nil: true

  attr_accessor :by_editor

  validates :happening, presence: true
  validates :user, presence: true
  with_options unless: :by_editor do
    validates :saleable?, inclusion: [ true ]
    validates :tickets_count, numericality: { only_integer: true, less_than_or_equal_to: :max_tickets }
    validates :tickets_for_user_count,
              numericality: { only_integer: true, less_than_or_equal_to: :max_tickets_for_user }
    validate  :validate_frequency
  end

  scope :with_user, ->(user) { where user: }

  # check if exists {Event}'s {Ticket} for {User} in a time period
  # @return [Boolean] true if exist a ticket in the time range
  def event_ticket_exist?(period = nil)
    @when = { happenings: { start_at: period } } if period.present?
    event.tickets.where(@when).where(user:).exists?
  end

  # count total of each other happening ticket self included
  # @return [Integer] number of tickets
  def tickets_count
    total = happening.tickets_count
    total += 1 unless persisted?
    total
  end

  # count total of each other happening ticket from {user} self included
  # @return [Integer] number of tickets
  def tickets_for_user_count
    total = happening.tickets.where(user:).count
    total += 1 unless persisted?
    total
  end

  private

  # check {User}'s ticket presence based of {Event#tickets_frequency}
  def validate_frequency
    exist, message = case event.tickets_frequency
    when "single"
                       [ event_ticket_exist?, I18n.t("site.ticket.errors.single") ]
    when "daily"
                       [ event_ticket_exist?(start_at.beginning_of_day..start_at.end_of_day),
                        I18n.t("site.ticket.errors.daily") ]
    when "weekly"
                       [ event_ticket_exist?(start_at.-(7.days)..start_at.+(7.days)),
                        I18n.t("site.ticket.errors.weekly") ]
    when "monthly"
                       [ event_ticket_exist?(start_at.-(30.days)..start_at.+(30.days)),
                        I18n.t("site.ticket.errors.montly") ]
    else
                       return true
    end
    errors.add(:seats, message) if exist
  end
end

#id ⇒ Integer

Returns unique identifier for Ticket.

Returns:

  • (Integer) —

    unique identifier for Ticket



23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
 
# File 'app/models/ticket.rb', line 23

class Ticket < ApplicationRecord
  belongs_to :happening, counter_cache: true
  belongs_to :user
  delegate :event, :event_id, :max_tickets, :max_tickets_for_user, :saleable?, :start_at, to: :happening,
                                                                                          allow_nil: true

  attr_accessor :by_editor

  validates :happening, presence: true
  validates :user, presence: true
  with_options unless: :by_editor do
    validates :saleable?, inclusion: [ true ]
    validates :tickets_count, numericality: { only_integer: true, less_than_or_equal_to: :max_tickets }
    validates :tickets_for_user_count,
              numericality: { only_integer: true, less_than_or_equal_to: :max_tickets_for_user }
    validate  :validate_frequency
  end

  scope :with_user, ->(user) { where user: }

  # check if exists {Event}'s {Ticket} for {User} in a time period
  # @return [Boolean] true if exist a ticket in the time range
  def event_ticket_exist?(period = nil)
    @when = { happenings: { start_at: period } } if period.present?
    event.tickets.where(@when).where(user:).exists?
  end

  # count total of each other happening ticket self included
  # @return [Integer] number of tickets
  def tickets_count
    total = happening.tickets_count
    total += 1 unless persisted?
    total
  end

  # count total of each other happening ticket from {user} self included
  # @return [Integer] number of tickets
  def tickets_for_user_count
    total = happening.tickets.where(user:).count
    total += 1 unless persisted?
    total
  end

  private

  # check {User}'s ticket presence based of {Event#tickets_frequency}
  def validate_frequency
    exist, message = case event.tickets_frequency
    when "single"
                       [ event_ticket_exist?, I18n.t("site.ticket.errors.single") ]
    when "daily"
                       [ event_ticket_exist?(start_at.beginning_of_day..start_at.end_of_day),
                        I18n.t("site.ticket.errors.daily") ]
    when "weekly"
                       [ event_ticket_exist?(start_at.-(7.days)..start_at.+(7.days)),
                        I18n.t("site.ticket.errors.weekly") ]
    when "monthly"
                       [ event_ticket_exist?(start_at.-(30.days)..start_at.+(30.days)),
                        I18n.t("site.ticket.errors.montly") ]
    else
                       return true
    end
    errors.add(:seats, message) if exist
  end
end

#updated_at ⇒ DateTime

Returns when the record was created.

Returns:

  • (DateTime) —

    when the record was created



23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
 
# File 'app/models/ticket.rb', line 23

class Ticket < ApplicationRecord
  belongs_to :happening, counter_cache: true
  belongs_to :user
  delegate :event, :event_id, :max_tickets, :max_tickets_for_user, :saleable?, :start_at, to: :happening,
                                                                                          allow_nil: true

  attr_accessor :by_editor

  validates :happening, presence: true
  validates :user, presence: true
  with_options unless: :by_editor do
    validates :saleable?, inclusion: [ true ]
    validates :tickets_count, numericality: { only_integer: true, less_than_or_equal_to: :max_tickets }
    validates :tickets_for_user_count,
              numericality: { only_integer: true, less_than_or_equal_to: :max_tickets_for_user }
    validate  :validate_frequency
  end

  scope :with_user, ->(user) { where user: }

  # check if exists {Event}'s {Ticket} for {User} in a time period
  # @return [Boolean] true if exist a ticket in the time range
  def event_ticket_exist?(period = nil)
    @when = { happenings: { start_at: period } } if period.present?
    event.tickets.where(@when).where(user:).exists?
  end

  # count total of each other happening ticket self included
  # @return [Integer] number of tickets
  def tickets_count
    total = happening.tickets_count
    total += 1 unless persisted?
    total
  end

  # count total of each other happening ticket from {user} self included
  # @return [Integer] number of tickets
  def tickets_for_user_count
    total = happening.tickets.where(user:).count
    total += 1 unless persisted?
    total
  end

  private

  # check {User}'s ticket presence based of {Event#tickets_frequency}
  def validate_frequency
    exist, message = case event.tickets_frequency
    when "single"
                       [ event_ticket_exist?, I18n.t("site.ticket.errors.single") ]
    when "daily"
                       [ event_ticket_exist?(start_at.beginning_of_day..start_at.end_of_day),
                        I18n.t("site.ticket.errors.daily") ]
    when "weekly"
                       [ event_ticket_exist?(start_at.-(7.days)..start_at.+(7.days)),
                        I18n.t("site.ticket.errors.weekly") ]
    when "monthly"
                       [ event_ticket_exist?(start_at.-(30.days)..start_at.+(30.days)),
                        I18n.t("site.ticket.errors.montly") ]
    else
                       return true
    end
    errors.add(:seats, message) if exist
  end
end

#user_id ⇒ Integer

Returns identifier of related User.

Returns:

  • (Integer) —

    identifier of related User



23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
 
# File 'app/models/ticket.rb', line 23

class Ticket < ApplicationRecord
  belongs_to :happening, counter_cache: true
  belongs_to :user
  delegate :event, :event_id, :max_tickets, :max_tickets_for_user, :saleable?, :start_at, to: :happening,
                                                                                          allow_nil: true

  attr_accessor :by_editor

  validates :happening, presence: true
  validates :user, presence: true
  with_options unless: :by_editor do
    validates :saleable?, inclusion: [ true ]
    validates :tickets_count, numericality: { only_integer: true, less_than_or_equal_to: :max_tickets }
    validates :tickets_for_user_count,
              numericality: { only_integer: true, less_than_or_equal_to: :max_tickets_for_user }
    validate  :validate_frequency
  end

  scope :with_user, ->(user) { where user: }

  # check if exists {Event}'s {Ticket} for {User} in a time period
  # @return [Boolean] true if exist a ticket in the time range
  def event_ticket_exist?(period = nil)
    @when = { happenings: { start_at: period } } if period.present?
    event.tickets.where(@when).where(user:).exists?
  end

  # count total of each other happening ticket self included
  # @return [Integer] number of tickets
  def tickets_count
    total = happening.tickets_count
    total += 1 unless persisted?
    total
  end

  # count total of each other happening ticket from {user} self included
  # @return [Integer] number of tickets
  def tickets_for_user_count
    total = happening.tickets.where(user:).count
    total += 1 unless persisted?
    total
  end

  private

  # check {User}'s ticket presence based of {Event#tickets_frequency}
  def validate_frequency
    exist, message = case event.tickets_frequency
    when "single"
                       [ event_ticket_exist?, I18n.t("site.ticket.errors.single") ]
    when "daily"
                       [ event_ticket_exist?(start_at.beginning_of_day..start_at.end_of_day),
                        I18n.t("site.ticket.errors.daily") ]
    when "weekly"
                       [ event_ticket_exist?(start_at.-(7.days)..start_at.+(7.days)),
                        I18n.t("site.ticket.errors.weekly") ]
    when "monthly"
                       [ event_ticket_exist?(start_at.-(30.days)..start_at.+(30.days)),
                        I18n.t("site.ticket.errors.montly") ]
    else
                       return true
    end
    errors.add(:seats, message) if exist
  end
end

Instance Method Details

#event_ticket_exist?(period = nil) ⇒ Boolean

check if exists Event‘s Ticket for User in a time period

Returns:

  • (Boolean) —

    true if exist a ticket in the time range



45
46
47
48
 
# File 'app/models/ticket.rb', line 45

def event_ticket_exist?(period = nil)
  @when = { happenings: { start_at: period } } if period.present?
  event.tickets.where(@when).where(user:).exists?
end

#tickets_count ⇒ Integer

count total of each other happening ticket self included

Returns:

  • (Integer) —

    number of tickets



52
53
54
55
56
 
# File 'app/models/ticket.rb', line 52

def tickets_count
  total = happening.tickets_count
  total += 1 unless persisted?
  total
end

#tickets_for_user_count ⇒ Integer

count total of each other happening ticket from user self included

Returns:

  • (Integer) —

    number of tickets



60
61
62
63
64
 
# File 'app/models/ticket.rb', line 60

def tickets_for_user_count
  total = happening.tickets.where(user:).count
  total += 1 unless persisted?
  total
end

#validate_frequency ⇒ Object (private)

check User‘s ticket presence based of Event#tickets_frequency



69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
 
# File 'app/models/ticket.rb', line 69

def validate_frequency
  exist, message = case event.tickets_frequency
  when "single"
                     [ event_ticket_exist?, I18n.t("site.ticket.errors.single") ]
  when "daily"
                     [ event_ticket_exist?(start_at.beginning_of_day..start_at.end_of_day),
                      I18n.t("site.ticket.errors.daily") ]
  when "weekly"
                     [ event_ticket_exist?(start_at.-(7.days)..start_at.+(7.days)),
                      I18n.t("site.ticket.errors.weekly") ]
  when "monthly"
                     [ event_ticket_exist?(start_at.-(30.days)..start_at.+(30.days)),
                      I18n.t("site.ticket.errors.montly") ]
  else
                     return true
  end
  errors.add(:seats, message) if exist
end