Class: Happening

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

Overview

This model manage the happenings for each Event

Relations

belongs to Event has many Ticket

Validates

Returns:

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Instance Attribute Details

#created_at ⇒ DateTime

Returns when the record was created.

Returns:

  • (DateTime) —

    when the record was created



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
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
 
# File 'app/models/happening.rb', line 37

class Happening < ApplicationRecord
  has_rich_text :body
  belongs_to :event, counter_cache: true
  has_many   :tickets, dependent: :destroy
  has_many   :users, through: :tickets
  has_many   :questions, dependent: :destroy
  has_one_attached :image do |attachable|
    attachable.variant :card, resize_to_limit: [ 417, 278 ]
    attachable.variant :aside, resize_to_limit: [ 318, 318 ]
    attachable.variant :ticket, resize_to_limit: [ 150, 68 ]
  end

  accepts_nested_attributes_for :questions, reject_if: :all_blank, allow_destroy: true

  validates  :event, presence: true
  validates  :start_at, presence: true
  validates  :start_sale_at, presence: true
  validates  :stop_sale_at, presence: true
  validates  :max_tickets, presence: true
  validates  :max_tickets_for_user, presence: true
  after_save :update_event_data

  delegate :group_id, :reserved?, to: :event

  default_scope { includes(:event).order("start_at asc") }
  scope :searchable, ->(from: nil, to: nil, event_id: nil, group_id: nil, text: nil, soldout: nil, reserved: false) do
    search_event = {}
    search_event[:reserved] = false unless reserved
    search_event[:group_id] = group_id if group_id.present?
    by_keys = { start_at: (from.try(:to_date) || Date.today)..to.try(:to_date).try(:end_of_day) }
    by_keys[:event_id] = event_id if event_id.present?
    by_keys[:events] = search_event if search_event.present?
    by_text = text.present? ? [ "happenings.title ilike :text or events.title ilike :text", { text: "%#{text}%" } ] : nil
    @soldout = [ "happenings.tickets_count < happenings.max_tickets" ] if soldout == "1"
    @soldout = [ "happenings.tickets_count >= happenings.max_tickets" ] if soldout == "2"
    where(by_keys).where(by_text).where(@soldout)
  end


  # @return [Boolean] check seaelability time
  def saleable?
    active? && tickets_available?
  end

  # @return [Boolean] check if the happening is bookable
  def active?
    Time.zone.now >= start_sale_at && Time.zone.now <= stop_sale_at
  end

  # @return [Boolean] Check if there are tickets available
  def tickets_available?
    max_tickets > tickets_count
  end

  def tickets_available
    max_tickets - tickets_count
  end

  # @return [String] unique code to identify the {Happening}
  def code
    [ event_id, id ].join(" - ")
  end

  def self.massive_create(from:, to:, start_sale_before:, stop_sale_before:, template_id: nil, repeat_in: [], minutes: [], **opts)
    ary = []
    (from.to_date..to.to_date).map do |day|
      next unless repeat_in.include?(day.wday.to_s)
      minutes.reject(&:blank?).map do |minute|
        start_at          = day + minute.to_i.minutes
        start_sale_at     = day - start_sale_before.to_i.days
        stop_sale_at      = day.end_of_day - stop_sale_before.to_i.days
        questions_attributes = Template.find_by(id: template_id).try(:data) || []
        ary << opts.merge(start_at:, start_sale_at:, stop_sale_at:, questions_attributes:)
      end
    end
    create ary
  end

  def update_event_data
    event.stop_on  = start_at if event.stop_on.blank? || start_at.to_date > event.stop_on
    event.start_on = start_at if event.start_on.blank? || start_at.to_date < event.start_on
    event.happenings_count = event.happenings.count
    event.save if event.changed?
  end

  def image_url(_variant = :card)
    image.present? ? image.variant(:card) : event.image_url
  end
end

#event_id ⇒ Integer

Returns identifier of related Event.

Returns:

  • (Integer) —

    identifier of related Event



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
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
 
# File 'app/models/happening.rb', line 37

class Happening < ApplicationRecord
  has_rich_text :body
  belongs_to :event, counter_cache: true
  has_many   :tickets, dependent: :destroy
  has_many   :users, through: :tickets
  has_many   :questions, dependent: :destroy
  has_one_attached :image do |attachable|
    attachable.variant :card, resize_to_limit: [ 417, 278 ]
    attachable.variant :aside, resize_to_limit: [ 318, 318 ]
    attachable.variant :ticket, resize_to_limit: [ 150, 68 ]
  end

  accepts_nested_attributes_for :questions, reject_if: :all_blank, allow_destroy: true

  validates  :event, presence: true
  validates  :start_at, presence: true
  validates  :start_sale_at, presence: true
  validates  :stop_sale_at, presence: true
  validates  :max_tickets, presence: true
  validates  :max_tickets_for_user, presence: true
  after_save :update_event_data

  delegate :group_id, :reserved?, to: :event

  default_scope { includes(:event).order("start_at asc") }
  scope :searchable, ->(from: nil, to: nil, event_id: nil, group_id: nil, text: nil, soldout: nil, reserved: false) do
    search_event = {}
    search_event[:reserved] = false unless reserved
    search_event[:group_id] = group_id if group_id.present?
    by_keys = { start_at: (from.try(:to_date) || Date.today)..to.try(:to_date).try(:end_of_day) }
    by_keys[:event_id] = event_id if event_id.present?
    by_keys[:events] = search_event if search_event.present?
    by_text = text.present? ? [ "happenings.title ilike :text or events.title ilike :text", { text: "%#{text}%" } ] : nil
    @soldout = [ "happenings.tickets_count < happenings.max_tickets" ] if soldout == "1"
    @soldout = [ "happenings.tickets_count >= happenings.max_tickets" ] if soldout == "2"
    where(by_keys).where(by_text).where(@soldout)
  end


  # @return [Boolean] check seaelability time
  def saleable?
    active? && tickets_available?
  end

  # @return [Boolean] check if the happening is bookable
  def active?
    Time.zone.now >= start_sale_at && Time.zone.now <= stop_sale_at
  end

  # @return [Boolean] Check if there are tickets available
  def tickets_available?
    max_tickets > tickets_count
  end

  def tickets_available
    max_tickets - tickets_count
  end

  # @return [String] unique code to identify the {Happening}
  def code
    [ event_id, id ].join(" - ")
  end

  def self.massive_create(from:, to:, start_sale_before:, stop_sale_before:, template_id: nil, repeat_in: [], minutes: [], **opts)
    ary = []
    (from.to_date..to.to_date).map do |day|
      next unless repeat_in.include?(day.wday.to_s)
      minutes.reject(&:blank?).map do |minute|
        start_at          = day + minute.to_i.minutes
        start_sale_at     = day - start_sale_before.to_i.days
        stop_sale_at      = day.end_of_day - stop_sale_before.to_i.days
        questions_attributes = Template.find_by(id: template_id).try(:data) || []
        ary << opts.merge(start_at:, start_sale_at:, stop_sale_at:, questions_attributes:)
      end
    end
    create ary
  end

  def update_event_data
    event.stop_on  = start_at if event.stop_on.blank? || start_at.to_date > event.stop_on
    event.start_on = start_at if event.start_on.blank? || start_at.to_date < event.start_on
    event.happenings_count = event.happenings.count
    event.save if event.changed?
  end

  def image_url(_variant = :card)
    image.present? ? image.variant(:card) : event.image_url
  end
end

#id ⇒ Integer

Returns unique identifier for Happening.

Returns:

  • (Integer) —

    unique identifier for Happening



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
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
 
# File 'app/models/happening.rb', line 37

class Happening < ApplicationRecord
  has_rich_text :body
  belongs_to :event, counter_cache: true
  has_many   :tickets, dependent: :destroy
  has_many   :users, through: :tickets
  has_many   :questions, dependent: :destroy
  has_one_attached :image do |attachable|
    attachable.variant :card, resize_to_limit: [ 417, 278 ]
    attachable.variant :aside, resize_to_limit: [ 318, 318 ]
    attachable.variant :ticket, resize_to_limit: [ 150, 68 ]
  end

  accepts_nested_attributes_for :questions, reject_if: :all_blank, allow_destroy: true

  validates  :event, presence: true
  validates  :start_at, presence: true
  validates  :start_sale_at, presence: true
  validates  :stop_sale_at, presence: true
  validates  :max_tickets, presence: true
  validates  :max_tickets_for_user, presence: true
  after_save :update_event_data

  delegate :group_id, :reserved?, to: :event

  default_scope { includes(:event).order("start_at asc") }
  scope :searchable, ->(from: nil, to: nil, event_id: nil, group_id: nil, text: nil, soldout: nil, reserved: false) do
    search_event = {}
    search_event[:reserved] = false unless reserved
    search_event[:group_id] = group_id if group_id.present?
    by_keys = { start_at: (from.try(:to_date) || Date.today)..to.try(:to_date).try(:end_of_day) }
    by_keys[:event_id] = event_id if event_id.present?
    by_keys[:events] = search_event if search_event.present?
    by_text = text.present? ? [ "happenings.title ilike :text or events.title ilike :text", { text: "%#{text}%" } ] : nil
    @soldout = [ "happenings.tickets_count < happenings.max_tickets" ] if soldout == "1"
    @soldout = [ "happenings.tickets_count >= happenings.max_tickets" ] if soldout == "2"
    where(by_keys).where(by_text).where(@soldout)
  end


  # @return [Boolean] check seaelability time
  def saleable?
    active? && tickets_available?
  end

  # @return [Boolean] check if the happening is bookable
  def active?
    Time.zone.now >= start_sale_at && Time.zone.now <= stop_sale_at
  end

  # @return [Boolean] Check if there are tickets available
  def tickets_available?
    max_tickets > tickets_count
  end

  def tickets_available
    max_tickets - tickets_count
  end

  # @return [String] unique code to identify the {Happening}
  def code
    [ event_id, id ].join(" - ")
  end

  def self.massive_create(from:, to:, start_sale_before:, stop_sale_before:, template_id: nil, repeat_in: [], minutes: [], **opts)
    ary = []
    (from.to_date..to.to_date).map do |day|
      next unless repeat_in.include?(day.wday.to_s)
      minutes.reject(&:blank?).map do |minute|
        start_at          = day + minute.to_i.minutes
        start_sale_at     = day - start_sale_before.to_i.days
        stop_sale_at      = day.end_of_day - stop_sale_before.to_i.days
        questions_attributes = Template.find_by(id: template_id).try(:data) || []
        ary << opts.merge(start_at:, start_sale_at:, stop_sale_at:, questions_attributes:)
      end
    end
    create ary
  end

  def update_event_data
    event.stop_on  = start_at if event.stop_on.blank? || start_at.to_date > event.stop_on
    event.start_on = start_at if event.start_on.blank? || start_at.to_date < event.start_on
    event.happenings_count = event.happenings.count
    event.save if event.changed?
  end

  def image_url(_variant = :card)
    image.present? ? image.variant(:card) : event.image_url
  end
end

#max_seats ⇒ integer

Returns number of seats for the Happening. If is null hasn’t limit.

Returns:

  • (integer) —

    number of seats for the Happening. If is null hasn’t limit



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
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
 
# File 'app/models/happening.rb', line 37

class Happening < ApplicationRecord
  has_rich_text :body
  belongs_to :event, counter_cache: true
  has_many   :tickets, dependent: :destroy
  has_many   :users, through: :tickets
  has_many   :questions, dependent: :destroy
  has_one_attached :image do |attachable|
    attachable.variant :card, resize_to_limit: [ 417, 278 ]
    attachable.variant :aside, resize_to_limit: [ 318, 318 ]
    attachable.variant :ticket, resize_to_limit: [ 150, 68 ]
  end

  accepts_nested_attributes_for :questions, reject_if: :all_blank, allow_destroy: true

  validates  :event, presence: true
  validates  :start_at, presence: true
  validates  :start_sale_at, presence: true
  validates  :stop_sale_at, presence: true
  validates  :max_tickets, presence: true
  validates  :max_tickets_for_user, presence: true
  after_save :update_event_data

  delegate :group_id, :reserved?, to: :event

  default_scope { includes(:event).order("start_at asc") }
  scope :searchable, ->(from: nil, to: nil, event_id: nil, group_id: nil, text: nil, soldout: nil, reserved: false) do
    search_event = {}
    search_event[:reserved] = false unless reserved
    search_event[:group_id] = group_id if group_id.present?
    by_keys = { start_at: (from.try(:to_date) || Date.today)..to.try(:to_date).try(:end_of_day) }
    by_keys[:event_id] = event_id if event_id.present?
    by_keys[:events] = search_event if search_event.present?
    by_text = text.present? ? [ "happenings.title ilike :text or events.title ilike :text", { text: "%#{text}%" } ] : nil
    @soldout = [ "happenings.tickets_count < happenings.max_tickets" ] if soldout == "1"
    @soldout = [ "happenings.tickets_count >= happenings.max_tickets" ] if soldout == "2"
    where(by_keys).where(by_text).where(@soldout)
  end


  # @return [Boolean] check seaelability time
  def saleable?
    active? && tickets_available?
  end

  # @return [Boolean] check if the happening is bookable
  def active?
    Time.zone.now >= start_sale_at && Time.zone.now <= stop_sale_at
  end

  # @return [Boolean] Check if there are tickets available
  def tickets_available?
    max_tickets > tickets_count
  end

  def tickets_available
    max_tickets - tickets_count
  end

  # @return [String] unique code to identify the {Happening}
  def code
    [ event_id, id ].join(" - ")
  end

  def self.massive_create(from:, to:, start_sale_before:, stop_sale_before:, template_id: nil, repeat_in: [], minutes: [], **opts)
    ary = []
    (from.to_date..to.to_date).map do |day|
      next unless repeat_in.include?(day.wday.to_s)
      minutes.reject(&:blank?).map do |minute|
        start_at          = day + minute.to_i.minutes
        start_sale_at     = day - start_sale_before.to_i.days
        stop_sale_at      = day.end_of_day - stop_sale_before.to_i.days
        questions_attributes = Template.find_by(id: template_id).try(:data) || []
        ary << opts.merge(start_at:, start_sale_at:, stop_sale_at:, questions_attributes:)
      end
    end
    create ary
  end

  def update_event_data
    event.stop_on  = start_at if event.stop_on.blank? || start_at.to_date > event.stop_on
    event.start_on = start_at if event.start_on.blank? || start_at.to_date < event.start_on
    event.happenings_count = event.happenings.count
    event.save if event.changed?
  end

  def image_url(_variant = :card)
    image.present? ? image.variant(:card) : event.image_url
  end
end

#max_seats_for_ticket ⇒ Integer

Returns Max seats for each ticket, default is 1.

Returns:

  • (Integer) —

    Max seats for each ticket, default is 1



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
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
 
# File 'app/models/happening.rb', line 37

class Happening < ApplicationRecord
  has_rich_text :body
  belongs_to :event, counter_cache: true
  has_many   :tickets, dependent: :destroy
  has_many   :users, through: :tickets
  has_many   :questions, dependent: :destroy
  has_one_attached :image do |attachable|
    attachable.variant :card, resize_to_limit: [ 417, 278 ]
    attachable.variant :aside, resize_to_limit: [ 318, 318 ]
    attachable.variant :ticket, resize_to_limit: [ 150, 68 ]
  end

  accepts_nested_attributes_for :questions, reject_if: :all_blank, allow_destroy: true

  validates  :event, presence: true
  validates  :start_at, presence: true
  validates  :start_sale_at, presence: true
  validates  :stop_sale_at, presence: true
  validates  :max_tickets, presence: true
  validates  :max_tickets_for_user, presence: true
  after_save :update_event_data

  delegate :group_id, :reserved?, to: :event

  default_scope { includes(:event).order("start_at asc") }
  scope :searchable, ->(from: nil, to: nil, event_id: nil, group_id: nil, text: nil, soldout: nil, reserved: false) do
    search_event = {}
    search_event[:reserved] = false unless reserved
    search_event[:group_id] = group_id if group_id.present?
    by_keys = { start_at: (from.try(:to_date) || Date.today)..to.try(:to_date).try(:end_of_day) }
    by_keys[:event_id] = event_id if event_id.present?
    by_keys[:events] = search_event if search_event.present?
    by_text = text.present? ? [ "happenings.title ilike :text or events.title ilike :text", { text: "%#{text}%" } ] : nil
    @soldout = [ "happenings.tickets_count < happenings.max_tickets" ] if soldout == "1"
    @soldout = [ "happenings.tickets_count >= happenings.max_tickets" ] if soldout == "2"
    where(by_keys).where(by_text).where(@soldout)
  end


  # @return [Boolean] check seaelability time
  def saleable?
    active? && tickets_available?
  end

  # @return [Boolean] check if the happening is bookable
  def active?
    Time.zone.now >= start_sale_at && Time.zone.now <= stop_sale_at
  end

  # @return [Boolean] Check if there are tickets available
  def tickets_available?
    max_tickets > tickets_count
  end

  def tickets_available
    max_tickets - tickets_count
  end

  # @return [String] unique code to identify the {Happening}
  def code
    [ event_id, id ].join(" - ")
  end

  def self.massive_create(from:, to:, start_sale_before:, stop_sale_before:, template_id: nil, repeat_in: [], minutes: [], **opts)
    ary = []
    (from.to_date..to.to_date).map do |day|
      next unless repeat_in.include?(day.wday.to_s)
      minutes.reject(&:blank?).map do |minute|
        start_at          = day + minute.to_i.minutes
        start_sale_at     = day - start_sale_before.to_i.days
        stop_sale_at      = day.end_of_day - stop_sale_before.to_i.days
        questions_attributes = Template.find_by(id: template_id).try(:data) || []
        ary << opts.merge(start_at:, start_sale_at:, stop_sale_at:, questions_attributes:)
      end
    end
    create ary
  end

  def update_event_data
    event.stop_on  = start_at if event.stop_on.blank? || start_at.to_date > event.stop_on
    event.start_on = start_at if event.start_on.blank? || start_at.to_date < event.start_on
    event.happenings_count = event.happenings.count
    event.save if event.changed?
  end

  def image_url(_variant = :card)
    image.present? ? image.variant(:card) : event.image_url
  end
end

#start_at ⇒ DateTime

This model manage the happenings for each Event

Relations

belongs to Event has many Ticket

Validates

Returns:



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
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
 
# File 'app/models/happening.rb', line 37

class Happening < ApplicationRecord
  has_rich_text :body
  belongs_to :event, counter_cache: true
  has_many   :tickets, dependent: :destroy
  has_many   :users, through: :tickets
  has_many   :questions, dependent: :destroy
  has_one_attached :image do |attachable|
    attachable.variant :card, resize_to_limit: [ 417, 278 ]
    attachable.variant :aside, resize_to_limit: [ 318, 318 ]
    attachable.variant :ticket, resize_to_limit: [ 150, 68 ]
  end

  accepts_nested_attributes_for :questions, reject_if: :all_blank, allow_destroy: true

  validates  :event, presence: true
  validates  :start_at, presence: true
  validates  :start_sale_at, presence: true
  validates  :stop_sale_at, presence: true
  validates  :max_tickets, presence: true
  validates  :max_tickets_for_user, presence: true
  after_save :update_event_data

  delegate :group_id, :reserved?, to: :event

  default_scope { includes(:event).order("start_at asc") }
  scope :searchable, ->(from: nil, to: nil, event_id: nil, group_id: nil, text: nil, soldout: nil, reserved: false) do
    search_event = {}
    search_event[:reserved] = false unless reserved
    search_event[:group_id] = group_id if group_id.present?
    by_keys = { start_at: (from.try(:to_date) || Date.today)..to.try(:to_date).try(:end_of_day) }
    by_keys[:event_id] = event_id if event_id.present?
    by_keys[:events] = search_event if search_event.present?
    by_text = text.present? ? [ "happenings.title ilike :text or events.title ilike :text", { text: "%#{text}%" } ] : nil
    @soldout = [ "happenings.tickets_count < happenings.max_tickets" ] if soldout == "1"
    @soldout = [ "happenings.tickets_count >= happenings.max_tickets" ] if soldout == "2"
    where(by_keys).where(by_text).where(@soldout)
  end


  # @return [Boolean] check seaelability time
  def saleable?
    active? && tickets_available?
  end

  # @return [Boolean] check if the happening is bookable
  def active?
    Time.zone.now >= start_sale_at && Time.zone.now <= stop_sale_at
  end

  # @return [Boolean] Check if there are tickets available
  def tickets_available?
    max_tickets > tickets_count
  end

  def tickets_available
    max_tickets - tickets_count
  end

  # @return [String] unique code to identify the {Happening}
  def code
    [ event_id, id ].join(" - ")
  end

  def self.massive_create(from:, to:, start_sale_before:, stop_sale_before:, template_id: nil, repeat_in: [], minutes: [], **opts)
    ary = []
    (from.to_date..to.to_date).map do |day|
      next unless repeat_in.include?(day.wday.to_s)
      minutes.reject(&:blank?).map do |minute|
        start_at          = day + minute.to_i.minutes
        start_sale_at     = day - start_sale_before.to_i.days
        stop_sale_at      = day.end_of_day - stop_sale_before.to_i.days
        questions_attributes = Template.find_by(id: template_id).try(:data) || []
        ary << opts.merge(start_at:, start_sale_at:, stop_sale_at:, questions_attributes:)
      end
    end
    create ary
  end

  def update_event_data
    event.stop_on  = start_at if event.stop_on.blank? || start_at.to_date > event.stop_on
    event.start_on = start_at if event.start_on.blank? || start_at.to_date < event.start_on
    event.happenings_count = event.happenings.count
    event.save if event.changed?
  end

  def image_url(_variant = :card)
    image.present? ? image.variant(:card) : event.image_url
  end
end

#stop_sale_at ⇒ DateTime

Returns since Ticket can no longer be sold.

Returns:

  • (DateTime) —

    since Ticket can no longer be sold



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
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
 
# File 'app/models/happening.rb', line 37

class Happening < ApplicationRecord
  has_rich_text :body
  belongs_to :event, counter_cache: true
  has_many   :tickets, dependent: :destroy
  has_many   :users, through: :tickets
  has_many   :questions, dependent: :destroy
  has_one_attached :image do |attachable|
    attachable.variant :card, resize_to_limit: [ 417, 278 ]
    attachable.variant :aside, resize_to_limit: [ 318, 318 ]
    attachable.variant :ticket, resize_to_limit: [ 150, 68 ]
  end

  accepts_nested_attributes_for :questions, reject_if: :all_blank, allow_destroy: true

  validates  :event, presence: true
  validates  :start_at, presence: true
  validates  :start_sale_at, presence: true
  validates  :stop_sale_at, presence: true
  validates  :max_tickets, presence: true
  validates  :max_tickets_for_user, presence: true
  after_save :update_event_data

  delegate :group_id, :reserved?, to: :event

  default_scope { includes(:event).order("start_at asc") }
  scope :searchable, ->(from: nil, to: nil, event_id: nil, group_id: nil, text: nil, soldout: nil, reserved: false) do
    search_event = {}
    search_event[:reserved] = false unless reserved
    search_event[:group_id] = group_id if group_id.present?
    by_keys = { start_at: (from.try(:to_date) || Date.today)..to.try(:to_date).try(:end_of_day) }
    by_keys[:event_id] = event_id if event_id.present?
    by_keys[:events] = search_event if search_event.present?
    by_text = text.present? ? [ "happenings.title ilike :text or events.title ilike :text", { text: "%#{text}%" } ] : nil
    @soldout = [ "happenings.tickets_count < happenings.max_tickets" ] if soldout == "1"
    @soldout = [ "happenings.tickets_count >= happenings.max_tickets" ] if soldout == "2"
    where(by_keys).where(by_text).where(@soldout)
  end


  # @return [Boolean] check seaelability time
  def saleable?
    active? && tickets_available?
  end

  # @return [Boolean] check if the happening is bookable
  def active?
    Time.zone.now >= start_sale_at && Time.zone.now <= stop_sale_at
  end

  # @return [Boolean] Check if there are tickets available
  def tickets_available?
    max_tickets > tickets_count
  end

  def tickets_available
    max_tickets - tickets_count
  end

  # @return [String] unique code to identify the {Happening}
  def code
    [ event_id, id ].join(" - ")
  end

  def self.massive_create(from:, to:, start_sale_before:, stop_sale_before:, template_id: nil, repeat_in: [], minutes: [], **opts)
    ary = []
    (from.to_date..to.to_date).map do |day|
      next unless repeat_in.include?(day.wday.to_s)
      minutes.reject(&:blank?).map do |minute|
        start_at          = day + minute.to_i.minutes
        start_sale_at     = day - start_sale_before.to_i.days
        stop_sale_at      = day.end_of_day - stop_sale_before.to_i.days
        questions_attributes = Template.find_by(id: template_id).try(:data) || []
        ary << opts.merge(start_at:, start_sale_at:, stop_sale_at:, questions_attributes:)
      end
    end
    create ary
  end

  def update_event_data
    event.stop_on  = start_at if event.stop_on.blank? || start_at.to_date > event.stop_on
    event.start_on = start_at if event.start_on.blank? || start_at.to_date < event.start_on
    event.happenings_count = event.happenings.count
    event.save if event.changed?
  end

  def image_url(_variant = :card)
    image.present? ? image.variant(:card) : event.image_url
  end
end

#ticketss_count ⇒ Integer

Returns counter cache for Ticket.

Returns:

  • (Integer) —

    counter cache for Ticket



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
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
 
# File 'app/models/happening.rb', line 37

class Happening < ApplicationRecord
  has_rich_text :body
  belongs_to :event, counter_cache: true
  has_many   :tickets, dependent: :destroy
  has_many   :users, through: :tickets
  has_many   :questions, dependent: :destroy
  has_one_attached :image do |attachable|
    attachable.variant :card, resize_to_limit: [ 417, 278 ]
    attachable.variant :aside, resize_to_limit: [ 318, 318 ]
    attachable.variant :ticket, resize_to_limit: [ 150, 68 ]
  end

  accepts_nested_attributes_for :questions, reject_if: :all_blank, allow_destroy: true

  validates  :event, presence: true
  validates  :start_at, presence: true
  validates  :start_sale_at, presence: true
  validates  :stop_sale_at, presence: true
  validates  :max_tickets, presence: true
  validates  :max_tickets_for_user, presence: true
  after_save :update_event_data

  delegate :group_id, :reserved?, to: :event

  default_scope { includes(:event).order("start_at asc") }
  scope :searchable, ->(from: nil, to: nil, event_id: nil, group_id: nil, text: nil, soldout: nil, reserved: false) do
    search_event = {}
    search_event[:reserved] = false unless reserved
    search_event[:group_id] = group_id if group_id.present?
    by_keys = { start_at: (from.try(:to_date) || Date.today)..to.try(:to_date).try(:end_of_day) }
    by_keys[:event_id] = event_id if event_id.present?
    by_keys[:events] = search_event if search_event.present?
    by_text = text.present? ? [ "happenings.title ilike :text or events.title ilike :text", { text: "%#{text}%" } ] : nil
    @soldout = [ "happenings.tickets_count < happenings.max_tickets" ] if soldout == "1"
    @soldout = [ "happenings.tickets_count >= happenings.max_tickets" ] if soldout == "2"
    where(by_keys).where(by_text).where(@soldout)
  end


  # @return [Boolean] check seaelability time
  def saleable?
    active? && tickets_available?
  end

  # @return [Boolean] check if the happening is bookable
  def active?
    Time.zone.now >= start_sale_at && Time.zone.now <= stop_sale_at
  end

  # @return [Boolean] Check if there are tickets available
  def tickets_available?
    max_tickets > tickets_count
  end

  def tickets_available
    max_tickets - tickets_count
  end

  # @return [String] unique code to identify the {Happening}
  def code
    [ event_id, id ].join(" - ")
  end

  def self.massive_create(from:, to:, start_sale_before:, stop_sale_before:, template_id: nil, repeat_in: [], minutes: [], **opts)
    ary = []
    (from.to_date..to.to_date).map do |day|
      next unless repeat_in.include?(day.wday.to_s)
      minutes.reject(&:blank?).map do |minute|
        start_at          = day + minute.to_i.minutes
        start_sale_at     = day - start_sale_before.to_i.days
        stop_sale_at      = day.end_of_day - stop_sale_before.to_i.days
        questions_attributes = Template.find_by(id: template_id).try(:data) || []
        ary << opts.merge(start_at:, start_sale_at:, stop_sale_at:, questions_attributes:)
      end
    end
    create ary
  end

  def update_event_data
    event.stop_on  = start_at if event.stop_on.blank? || start_at.to_date > event.stop_on
    event.start_on = start_at if event.start_on.blank? || start_at.to_date < event.start_on
    event.happenings_count = event.happenings.count
    event.save if event.changed?
  end

  def image_url(_variant = :card)
    image.present? ? image.variant(:card) : event.image_url
  end
end

#title ⇒ String

Returns Is an optional description for Happening.

Returns:

  • (String) —

    Is an optional description for Happening



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
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
 
# File 'app/models/happening.rb', line 37

class Happening < ApplicationRecord
  has_rich_text :body
  belongs_to :event, counter_cache: true
  has_many   :tickets, dependent: :destroy
  has_many   :users, through: :tickets
  has_many   :questions, dependent: :destroy
  has_one_attached :image do |attachable|
    attachable.variant :card, resize_to_limit: [ 417, 278 ]
    attachable.variant :aside, resize_to_limit: [ 318, 318 ]
    attachable.variant :ticket, resize_to_limit: [ 150, 68 ]
  end

  accepts_nested_attributes_for :questions, reject_if: :all_blank, allow_destroy: true

  validates  :event, presence: true
  validates  :start_at, presence: true
  validates  :start_sale_at, presence: true
  validates  :stop_sale_at, presence: true
  validates  :max_tickets, presence: true
  validates  :max_tickets_for_user, presence: true
  after_save :update_event_data

  delegate :group_id, :reserved?, to: :event

  default_scope { includes(:event).order("start_at asc") }
  scope :searchable, ->(from: nil, to: nil, event_id: nil, group_id: nil, text: nil, soldout: nil, reserved: false) do
    search_event = {}
    search_event[:reserved] = false unless reserved
    search_event[:group_id] = group_id if group_id.present?
    by_keys = { start_at: (from.try(:to_date) || Date.today)..to.try(:to_date).try(:end_of_day) }
    by_keys[:event_id] = event_id if event_id.present?
    by_keys[:events] = search_event if search_event.present?
    by_text = text.present? ? [ "happenings.title ilike :text or events.title ilike :text", { text: "%#{text}%" } ] : nil
    @soldout = [ "happenings.tickets_count < happenings.max_tickets" ] if soldout == "1"
    @soldout = [ "happenings.tickets_count >= happenings.max_tickets" ] if soldout == "2"
    where(by_keys).where(by_text).where(@soldout)
  end


  # @return [Boolean] check seaelability time
  def saleable?
    active? && tickets_available?
  end

  # @return [Boolean] check if the happening is bookable
  def active?
    Time.zone.now >= start_sale_at && Time.zone.now <= stop_sale_at
  end

  # @return [Boolean] Check if there are tickets available
  def tickets_available?
    max_tickets > tickets_count
  end

  def tickets_available
    max_tickets - tickets_count
  end

  # @return [String] unique code to identify the {Happening}
  def code
    [ event_id, id ].join(" - ")
  end

  def self.massive_create(from:, to:, start_sale_before:, stop_sale_before:, template_id: nil, repeat_in: [], minutes: [], **opts)
    ary = []
    (from.to_date..to.to_date).map do |day|
      next unless repeat_in.include?(day.wday.to_s)
      minutes.reject(&:blank?).map do |minute|
        start_at          = day + minute.to_i.minutes
        start_sale_at     = day - start_sale_before.to_i.days
        stop_sale_at      = day.end_of_day - stop_sale_before.to_i.days
        questions_attributes = Template.find_by(id: template_id).try(:data) || []
        ary << opts.merge(start_at:, start_sale_at:, stop_sale_at:, questions_attributes:)
      end
    end
    create ary
  end

  def update_event_data
    event.stop_on  = start_at if event.stop_on.blank? || start_at.to_date > event.stop_on
    event.start_on = start_at if event.start_on.blank? || start_at.to_date < event.start_on
    event.happenings_count = event.happenings.count
    event.save if event.changed?
  end

  def image_url(_variant = :card)
    image.present? ? image.variant(:card) : event.image_url
  end
end

#updated_at ⇒ DateTime

Returns when the record was updated.

Returns:

  • (DateTime) —

    when the record was updated



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
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
 
# File 'app/models/happening.rb', line 37

class Happening < ApplicationRecord
  has_rich_text :body
  belongs_to :event, counter_cache: true
  has_many   :tickets, dependent: :destroy
  has_many   :users, through: :tickets
  has_many   :questions, dependent: :destroy
  has_one_attached :image do |attachable|
    attachable.variant :card, resize_to_limit: [ 417, 278 ]
    attachable.variant :aside, resize_to_limit: [ 318, 318 ]
    attachable.variant :ticket, resize_to_limit: [ 150, 68 ]
  end

  accepts_nested_attributes_for :questions, reject_if: :all_blank, allow_destroy: true

  validates  :event, presence: true
  validates  :start_at, presence: true
  validates  :start_sale_at, presence: true
  validates  :stop_sale_at, presence: true
  validates  :max_tickets, presence: true
  validates  :max_tickets_for_user, presence: true
  after_save :update_event_data

  delegate :group_id, :reserved?, to: :event

  default_scope { includes(:event).order("start_at asc") }
  scope :searchable, ->(from: nil, to: nil, event_id: nil, group_id: nil, text: nil, soldout: nil, reserved: false) do
    search_event = {}
    search_event[:reserved] = false unless reserved
    search_event[:group_id] = group_id if group_id.present?
    by_keys = { start_at: (from.try(:to_date) || Date.today)..to.try(:to_date).try(:end_of_day) }
    by_keys[:event_id] = event_id if event_id.present?
    by_keys[:events] = search_event if search_event.present?
    by_text = text.present? ? [ "happenings.title ilike :text or events.title ilike :text", { text: "%#{text}%" } ] : nil
    @soldout = [ "happenings.tickets_count < happenings.max_tickets" ] if soldout == "1"
    @soldout = [ "happenings.tickets_count >= happenings.max_tickets" ] if soldout == "2"
    where(by_keys).where(by_text).where(@soldout)
  end


  # @return [Boolean] check seaelability time
  def saleable?
    active? && tickets_available?
  end

  # @return [Boolean] check if the happening is bookable
  def active?
    Time.zone.now >= start_sale_at && Time.zone.now <= stop_sale_at
  end

  # @return [Boolean] Check if there are tickets available
  def tickets_available?
    max_tickets > tickets_count
  end

  def tickets_available
    max_tickets - tickets_count
  end

  # @return [String] unique code to identify the {Happening}
  def code
    [ event_id, id ].join(" - ")
  end

  def self.massive_create(from:, to:, start_sale_before:, stop_sale_before:, template_id: nil, repeat_in: [], minutes: [], **opts)
    ary = []
    (from.to_date..to.to_date).map do |day|
      next unless repeat_in.include?(day.wday.to_s)
      minutes.reject(&:blank?).map do |minute|
        start_at          = day + minute.to_i.minutes
        start_sale_at     = day - start_sale_before.to_i.days
        stop_sale_at      = day.end_of_day - stop_sale_before.to_i.days
        questions_attributes = Template.find_by(id: template_id).try(:data) || []
        ary << opts.merge(start_at:, start_sale_at:, stop_sale_at:, questions_attributes:)
      end
    end
    create ary
  end

  def update_event_data
    event.stop_on  = start_at if event.stop_on.blank? || start_at.to_date > event.stop_on
    event.start_on = start_at if event.start_on.blank? || start_at.to_date < event.start_on
    event.happenings_count = event.happenings.count
    event.save if event.changed?
  end

  def image_url(_variant = :card)
    image.present? ? image.variant(:card) : event.image_url
  end
end

Class Method Details

.future ⇒ Array

Returns list of [Event] with stop_on egual or greather than Time.zone.today, ordered by pinnes, stop_on.

Returns:

  • (Array) —

    list of [Event] with stop_on egual or greather than Time.zone.today, ordered by pinnes, stop_on



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
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
 
# File 'app/models/happening.rb', line 37

class Happening < ApplicationRecord
  has_rich_text :body
  belongs_to :event, counter_cache: true
  has_many   :tickets, dependent: :destroy
  has_many   :users, through: :tickets
  has_many   :questions, dependent: :destroy
  has_one_attached :image do |attachable|
    attachable.variant :card, resize_to_limit: [ 417, 278 ]
    attachable.variant :aside, resize_to_limit: [ 318, 318 ]
    attachable.variant :ticket, resize_to_limit: [ 150, 68 ]
  end

  accepts_nested_attributes_for :questions, reject_if: :all_blank, allow_destroy: true

  validates  :event, presence: true
  validates  :start_at, presence: true
  validates  :start_sale_at, presence: true
  validates  :stop_sale_at, presence: true
  validates  :max_tickets, presence: true
  validates  :max_tickets_for_user, presence: true
  after_save :update_event_data

  delegate :group_id, :reserved?, to: :event

  default_scope { includes(:event).order("start_at asc") }
  scope :searchable, ->(from: nil, to: nil, event_id: nil, group_id: nil, text: nil, soldout: nil, reserved: false) do
    search_event = {}
    search_event[:reserved] = false unless reserved
    search_event[:group_id] = group_id if group_id.present?
    by_keys = { start_at: (from.try(:to_date) || Date.today)..to.try(:to_date).try(:end_of_day) }
    by_keys[:event_id] = event_id if event_id.present?
    by_keys[:events] = search_event if search_event.present?
    by_text = text.present? ? [ "happenings.title ilike :text or events.title ilike :text", { text: "%#{text}%" } ] : nil
    @soldout = [ "happenings.tickets_count < happenings.max_tickets" ] if soldout == "1"
    @soldout = [ "happenings.tickets_count >= happenings.max_tickets" ] if soldout == "2"
    where(by_keys).where(by_text).where(@soldout)
  end


  # @return [Boolean] check seaelability time
  def saleable?
    active? && tickets_available?
  end

  # @return [Boolean] check if the happening is bookable
  def active?
    Time.zone.now >= start_sale_at && Time.zone.now <= stop_sale_at
  end

  # @return [Boolean] Check if there are tickets available
  def tickets_available?
    max_tickets > tickets_count
  end

  def tickets_available
    max_tickets - tickets_count
  end

  # @return [String] unique code to identify the {Happening}
  def code
    [ event_id, id ].join(" - ")
  end

  def self.massive_create(from:, to:, start_sale_before:, stop_sale_before:, template_id: nil, repeat_in: [], minutes: [], **opts)
    ary = []
    (from.to_date..to.to_date).map do |day|
      next unless repeat_in.include?(day.wday.to_s)
      minutes.reject(&:blank?).map do |minute|
        start_at          = day + minute.to_i.minutes
        start_sale_at     = day - start_sale_before.to_i.days
        stop_sale_at      = day.end_of_day - stop_sale_before.to_i.days
        questions_attributes = Template.find_by(id: template_id).try(:data) || []
        ary << opts.merge(start_at:, start_sale_at:, stop_sale_at:, questions_attributes:)
      end
    end
    create ary
  end

  def update_event_data
    event.stop_on  = start_at if event.stop_on.blank? || start_at.to_date > event.stop_on
    event.start_on = start_at if event.start_on.blank? || start_at.to_date < event.start_on
    event.happenings_count = event.happenings.count
    event.save if event.changed?
  end

  def image_url(_variant = :card)
    image.present? ? image.variant(:card) : event.image_url
  end
end

.history ⇒ Array

Returns list of [Event] with stop_on minor than Time.zone.today, ordered by start_on desc.

Returns:

  • (Array) —

    list of [Event] with stop_on minor than Time.zone.today, ordered by start_on desc



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
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
 
# File 'app/models/happening.rb', line 37

class Happening < ApplicationRecord
  has_rich_text :body
  belongs_to :event, counter_cache: true
  has_many   :tickets, dependent: :destroy
  has_many   :users, through: :tickets
  has_many   :questions, dependent: :destroy
  has_one_attached :image do |attachable|
    attachable.variant :card, resize_to_limit: [ 417, 278 ]
    attachable.variant :aside, resize_to_limit: [ 318, 318 ]
    attachable.variant :ticket, resize_to_limit: [ 150, 68 ]
  end

  accepts_nested_attributes_for :questions, reject_if: :all_blank, allow_destroy: true

  validates  :event, presence: true
  validates  :start_at, presence: true
  validates  :start_sale_at, presence: true
  validates  :stop_sale_at, presence: true
  validates  :max_tickets, presence: true
  validates  :max_tickets_for_user, presence: true
  after_save :update_event_data

  delegate :group_id, :reserved?, to: :event

  default_scope { includes(:event).order("start_at asc") }
  scope :searchable, ->(from: nil, to: nil, event_id: nil, group_id: nil, text: nil, soldout: nil, reserved: false) do
    search_event = {}
    search_event[:reserved] = false unless reserved
    search_event[:group_id] = group_id if group_id.present?
    by_keys = { start_at: (from.try(:to_date) || Date.today)..to.try(:to_date).try(:end_of_day) }
    by_keys[:event_id] = event_id if event_id.present?
    by_keys[:events] = search_event if search_event.present?
    by_text = text.present? ? [ "happenings.title ilike :text or events.title ilike :text", { text: "%#{text}%" } ] : nil
    @soldout = [ "happenings.tickets_count < happenings.max_tickets" ] if soldout == "1"
    @soldout = [ "happenings.tickets_count >= happenings.max_tickets" ] if soldout == "2"
    where(by_keys).where(by_text).where(@soldout)
  end


  # @return [Boolean] check seaelability time
  def saleable?
    active? && tickets_available?
  end

  # @return [Boolean] check if the happening is bookable
  def active?
    Time.zone.now >= start_sale_at && Time.zone.now <= stop_sale_at
  end

  # @return [Boolean] Check if there are tickets available
  def tickets_available?
    max_tickets > tickets_count
  end

  def tickets_available
    max_tickets - tickets_count
  end

  # @return [String] unique code to identify the {Happening}
  def code
    [ event_id, id ].join(" - ")
  end

  def self.massive_create(from:, to:, start_sale_before:, stop_sale_before:, template_id: nil, repeat_in: [], minutes: [], **opts)
    ary = []
    (from.to_date..to.to_date).map do |day|
      next unless repeat_in.include?(day.wday.to_s)
      minutes.reject(&:blank?).map do |minute|
        start_at          = day + minute.to_i.minutes
        start_sale_at     = day - start_sale_before.to_i.days
        stop_sale_at      = day.end_of_day - stop_sale_before.to_i.days
        questions_attributes = Template.find_by(id: template_id).try(:data) || []
        ary << opts.merge(start_at:, start_sale_at:, stop_sale_at:, questions_attributes:)
      end
    end
    create ary
  end

  def update_event_data
    event.stop_on  = start_at if event.stop_on.blank? || start_at.to_date > event.stop_on
    event.start_on = start_at if event.start_on.blank? || start_at.to_date < event.start_on
    event.happenings_count = event.happenings.count
    event.save if event.changed?
  end

  def image_url(_variant = :card)
    image.present? ? image.variant(:card) : event.image_url
  end
end

.massive_create(from:, to:, start_sale_before:, stop_sale_before:, template_id: nil, repeat_in: [], minutes: [], **opts) ⇒ Object 



100
101
102
103
104
105
106
107
108
109
110
111
112
113
 
# File 'app/models/happening.rb', line 100

def self.massive_create(from:, to:, start_sale_before:, stop_sale_before:, template_id: nil, repeat_in: [], minutes: [], **opts)
  ary = []
  (from.to_date..to.to_date).map do |day|
    next unless repeat_in.include?(day.wday.to_s)
    minutes.reject(&:blank?).map do |minute|
      start_at          = day + minute.to_i.minutes
      start_sale_at     = day - start_sale_before.to_i.days
      stop_sale_at      = day.end_of_day - stop_sale_before.to_i.days
      questions_attributes = Template.find_by(id: template_id).try(:data) || []
      ary << opts.merge(start_at:, start_sale_at:, stop_sale_at:, questions_attributes:)
    end
  end
  create ary
end

Instance Method Details

#active? ⇒ Boolean

Returns check if the happening is bookable.

Returns:

  • (Boolean) —

    check if the happening is bookable



82
83
84
 
# File 'app/models/happening.rb', line 82

def active?
  Time.zone.now >= start_sale_at && Time.zone.now <= stop_sale_at
end

#code ⇒ String

Returns unique code to identify the Happening.

Returns:

  • (String) —

    unique code to identify the Happening



96
97
98
 
# File 'app/models/happening.rb', line 96

def code
  [ event_id, id ].join(" - ")
end

#image_url(_variant = :card) ⇒ Object 



122
123
124
 
# File 'app/models/happening.rb', line 122

def image_url(_variant = :card)
  image.present? ? image.variant(:card) : event.image_url
end

#saleable? ⇒ Boolean

Returns check seaelability time.

Returns:

  • (Boolean) —

    check seaelability time



77
78
79
 
# File 'app/models/happening.rb', line 77

def saleable?
  active? && tickets_available?
end

#tickets_available ⇒ Object 



91
92
93
 
# File 'app/models/happening.rb', line 91

def tickets_available
  max_tickets - tickets_count
end

#tickets_available? ⇒ Boolean

Returns Check if there are tickets available.

Returns:

  • (Boolean) —

    Check if there are tickets available



87
88
89
 
# File 'app/models/happening.rb', line 87

def tickets_available?
  max_tickets > tickets_count
end

#update_event_data ⇒ Object 



115
116
117
118
119
120
 
# File 'app/models/happening.rb', line 115

def update_event_data
  event.stop_on  = start_at if event.stop_on.blank? || start_at.to_date > event.stop_on
  event.start_on = start_at if event.start_on.blank? || start_at.to_date < event.start_on
  event.happenings_count = event.happenings.count
  event.save if event.changed?
end