Class: Meeting

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

Overview

This model save the clinical meetings of the users

Relations

scope

  • scope :deletable, ->(date: Time.zone.today-10.days) { proposed.where(‘sended_at < ?’, date) }

Validations

before_validation

#check_stop_at

after_destroy

#check_event

Instance Attribute Summary collapse

Instance Method Summary collapse

Methods inherited from ApplicationRecord

#div

Instance Attribute Details

#active ⇒ Object

Da definire



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
 
# File 'app/models/meeting.rb', line 61

class Meeting < ApplicationRecord
  belongs_to :audit
  belongs_to :event
  has_one :user, through: :audit
  has_one :category, through: :audit

  attr_accessor :active

  enum status: { blocked: 0, proposed: 1, waiting: 2, confirmed: 3 }

  scope :deletables, ->(date: Time.zone.today-(Settings.events.meetings.deletable.days).days) { proposed.where('sended_at < ?', date) }

  validates :event, presence: true, uniqueness: { scope: :audit }
  validates :audit, presence: true
  validates :start_at, presence: true

  before_validation :check_stop_at
  after_destroy :check_event

  # @return [Object] return an ICAL object with meeting data
  def ical
    require 'icalendar'
    require 'icalendar/tzinfo'
    cal = Icalendar::Calendar.new
    event_start = DateTime.parse(I18n.l(event.date_on, format: :date).to_s + "T#{I18n.l(start_at, format: :time)}")

    tzid = 'Europe/Rome'
    tz = TZInfo::Timezone.get tzid
    timezone = tz.ical_timezone Time.zone.now
    cal.add_timezone timezone

    cal.event do |e|
      e.dtstart = Icalendar::Values::DateTime.new event_start, 'tzid' => tzid
      e.dtend   = Icalendar::Values::DateTime.new event_start, 'tzid' => tzid
      e.summary = "Prenotazione #{I18n.t(event.gender, scope: 'event.gender').downcase} del #{I18n.l(event.date_on)} alle ore #{I18n.l(start_at, format: :time)}"
      e.organizer = "mailto:#{Settings.email}"
      e.organizer = Icalendar::Values::CalAddress.new("mailto:#{Settings.email}", cn: user.label)
      e.description = Settings.events[event.gender]['description']
      e.location = Settings.events[event.gender]['location']
    end
  end

  private

  # @return [Time] start_at + 20 minutes if stop_at is empty and start_at is present
  # @return [Null] if stop_at if is present
  def check_stop_at
    self.stop_at = start_at.in_time_zone + 20.minutes if stop_at.blank? && start_at.present?
  end

  # @return [True] if {Event.meetings} is empty and the event is destroyed
  # @return [False] if {Event.meetings} is empty and the event isn't destroyed
  # @return [Null] if {Event.meetings} isn't empty
  def check_event
    event.destroy if event.reload.meetings.blank?
  end
end

#audit_id ⇒ Integer

Returns reference id for Audit.

Returns:

  • (Integer) —

    reference id for Audit



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
 
# File 'app/models/meeting.rb', line 61

class Meeting < ApplicationRecord
  belongs_to :audit
  belongs_to :event
  has_one :user, through: :audit
  has_one :category, through: :audit

  attr_accessor :active

  enum status: { blocked: 0, proposed: 1, waiting: 2, confirmed: 3 }

  scope :deletables, ->(date: Time.zone.today-(Settings.events.meetings.deletable.days).days) { proposed.where('sended_at < ?', date) }

  validates :event, presence: true, uniqueness: { scope: :audit }
  validates :audit, presence: true
  validates :start_at, presence: true

  before_validation :check_stop_at
  after_destroy :check_event

  # @return [Object] return an ICAL object with meeting data
  def ical
    require 'icalendar'
    require 'icalendar/tzinfo'
    cal = Icalendar::Calendar.new
    event_start = DateTime.parse(I18n.l(event.date_on, format: :date).to_s + "T#{I18n.l(start_at, format: :time)}")

    tzid = 'Europe/Rome'
    tz = TZInfo::Timezone.get tzid
    timezone = tz.ical_timezone Time.zone.now
    cal.add_timezone timezone

    cal.event do |e|
      e.dtstart = Icalendar::Values::DateTime.new event_start, 'tzid' => tzid
      e.dtend   = Icalendar::Values::DateTime.new event_start, 'tzid' => tzid
      e.summary = "Prenotazione #{I18n.t(event.gender, scope: 'event.gender').downcase} del #{I18n.l(event.date_on)} alle ore #{I18n.l(start_at, format: :time)}"
      e.organizer = "mailto:#{Settings.email}"
      e.organizer = Icalendar::Values::CalAddress.new("mailto:#{Settings.email}", cn: user.label)
      e.description = Settings.events[event.gender]['description']
      e.location = Settings.events[event.gender]['location']
    end
  end

  private

  # @return [Time] start_at + 20 minutes if stop_at is empty and start_at is present
  # @return [Null] if stop_at if is present
  def check_stop_at
    self.stop_at = start_at.in_time_zone + 20.minutes if stop_at.blank? && start_at.present?
  end

  # @return [True] if {Event.meetings} is empty and the event is destroyed
  # @return [False] if {Event.meetings} is empty and the event isn't destroyed
  # @return [Null] if {Event.meetings} isn't empty
  def check_event
    event.destroy if event.reload.meetings.blank?
  end
end

#body ⇒ String

Returns Description.

Returns:

  • (String) —

    Description



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
 
# File 'app/models/meeting.rb', line 61

class Meeting < ApplicationRecord
  belongs_to :audit
  belongs_to :event
  has_one :user, through: :audit
  has_one :category, through: :audit

  attr_accessor :active

  enum status: { blocked: 0, proposed: 1, waiting: 2, confirmed: 3 }

  scope :deletables, ->(date: Time.zone.today-(Settings.events.meetings.deletable.days).days) { proposed.where('sended_at < ?', date) }

  validates :event, presence: true, uniqueness: { scope: :audit }
  validates :audit, presence: true
  validates :start_at, presence: true

  before_validation :check_stop_at
  after_destroy :check_event

  # @return [Object] return an ICAL object with meeting data
  def ical
    require 'icalendar'
    require 'icalendar/tzinfo'
    cal = Icalendar::Calendar.new
    event_start = DateTime.parse(I18n.l(event.date_on, format: :date).to_s + "T#{I18n.l(start_at, format: :time)}")

    tzid = 'Europe/Rome'
    tz = TZInfo::Timezone.get tzid
    timezone = tz.ical_timezone Time.zone.now
    cal.add_timezone timezone

    cal.event do |e|
      e.dtstart = Icalendar::Values::DateTime.new event_start, 'tzid' => tzid
      e.dtend   = Icalendar::Values::DateTime.new event_start, 'tzid' => tzid
      e.summary = "Prenotazione #{I18n.t(event.gender, scope: 'event.gender').downcase} del #{I18n.l(event.date_on)} alle ore #{I18n.l(start_at, format: :time)}"
      e.organizer = "mailto:#{Settings.email}"
      e.organizer = Icalendar::Values::CalAddress.new("mailto:#{Settings.email}", cn: user.label)
      e.description = Settings.events[event.gender]['description']
      e.location = Settings.events[event.gender]['location']
    end
  end

  private

  # @return [Time] start_at + 20 minutes if stop_at is empty and start_at is present
  # @return [Null] if stop_at if is present
  def check_stop_at
    self.stop_at = start_at.in_time_zone + 20.minutes if stop_at.blank? && start_at.present?
  end

  # @return [True] if {Event.meetings} is empty and the event is destroyed
  # @return [False] if {Event.meetings} is empty and the event isn't destroyed
  # @return [Null] if {Event.meetings} isn't empty
  def check_event
    event.destroy if event.reload.meetings.blank?
  end
end

#created_at ⇒ DateTime

Returns the date when the record was created.

Returns:

  • (DateTime) —

    the date when the record was created



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
 
# File 'app/models/meeting.rb', line 61

class Meeting < ApplicationRecord
  belongs_to :audit
  belongs_to :event
  has_one :user, through: :audit
  has_one :category, through: :audit

  attr_accessor :active

  enum status: { blocked: 0, proposed: 1, waiting: 2, confirmed: 3 }

  scope :deletables, ->(date: Time.zone.today-(Settings.events.meetings.deletable.days).days) { proposed.where('sended_at < ?', date) }

  validates :event, presence: true, uniqueness: { scope: :audit }
  validates :audit, presence: true
  validates :start_at, presence: true

  before_validation :check_stop_at
  after_destroy :check_event

  # @return [Object] return an ICAL object with meeting data
  def ical
    require 'icalendar'
    require 'icalendar/tzinfo'
    cal = Icalendar::Calendar.new
    event_start = DateTime.parse(I18n.l(event.date_on, format: :date).to_s + "T#{I18n.l(start_at, format: :time)}")

    tzid = 'Europe/Rome'
    tz = TZInfo::Timezone.get tzid
    timezone = tz.ical_timezone Time.zone.now
    cal.add_timezone timezone

    cal.event do |e|
      e.dtstart = Icalendar::Values::DateTime.new event_start, 'tzid' => tzid
      e.dtend   = Icalendar::Values::DateTime.new event_start, 'tzid' => tzid
      e.summary = "Prenotazione #{I18n.t(event.gender, scope: 'event.gender').downcase} del #{I18n.l(event.date_on)} alle ore #{I18n.l(start_at, format: :time)}"
      e.organizer = "mailto:#{Settings.email}"
      e.organizer = Icalendar::Values::CalAddress.new("mailto:#{Settings.email}", cn: user.label)
      e.description = Settings.events[event.gender]['description']
      e.location = Settings.events[event.gender]['location']
    end
  end

  private

  # @return [Time] start_at + 20 minutes if stop_at is empty and start_at is present
  # @return [Null] if stop_at if is present
  def check_stop_at
    self.stop_at = start_at.in_time_zone + 20.minutes if stop_at.blank? && start_at.present?
  end

  # @return [True] if {Event.meetings} is empty and the event is destroyed
  # @return [False] if {Event.meetings} is empty and the event isn't destroyed
  # @return [Null] if {Event.meetings} isn't empty
  def check_event
    event.destroy if event.reload.meetings.blank?
  end
end

#event_id ⇒ Integer

Returns reference id for Event.

Returns:

  • (Integer) —

    reference id for Event



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
 
# File 'app/models/meeting.rb', line 61

class Meeting < ApplicationRecord
  belongs_to :audit
  belongs_to :event
  has_one :user, through: :audit
  has_one :category, through: :audit

  attr_accessor :active

  enum status: { blocked: 0, proposed: 1, waiting: 2, confirmed: 3 }

  scope :deletables, ->(date: Time.zone.today-(Settings.events.meetings.deletable.days).days) { proposed.where('sended_at < ?', date) }

  validates :event, presence: true, uniqueness: { scope: :audit }
  validates :audit, presence: true
  validates :start_at, presence: true

  before_validation :check_stop_at
  after_destroy :check_event

  # @return [Object] return an ICAL object with meeting data
  def ical
    require 'icalendar'
    require 'icalendar/tzinfo'
    cal = Icalendar::Calendar.new
    event_start = DateTime.parse(I18n.l(event.date_on, format: :date).to_s + "T#{I18n.l(start_at, format: :time)}")

    tzid = 'Europe/Rome'
    tz = TZInfo::Timezone.get tzid
    timezone = tz.ical_timezone Time.zone.now
    cal.add_timezone timezone

    cal.event do |e|
      e.dtstart = Icalendar::Values::DateTime.new event_start, 'tzid' => tzid
      e.dtend   = Icalendar::Values::DateTime.new event_start, 'tzid' => tzid
      e.summary = "Prenotazione #{I18n.t(event.gender, scope: 'event.gender').downcase} del #{I18n.l(event.date_on)} alle ore #{I18n.l(start_at, format: :time)}"
      e.organizer = "mailto:#{Settings.email}"
      e.organizer = Icalendar::Values::CalAddress.new("mailto:#{Settings.email}", cn: user.label)
      e.description = Settings.events[event.gender]['description']
      e.location = Settings.events[event.gender]['location']
    end
  end

  private

  # @return [Time] start_at + 20 minutes if stop_at is empty and start_at is present
  # @return [Null] if stop_at if is present
  def check_stop_at
    self.stop_at = start_at.in_time_zone + 20.minutes if stop_at.blank? && start_at.present?
  end

  # @return [True] if {Event.meetings} is empty and the event is destroyed
  # @return [False] if {Event.meetings} is empty and the event isn't destroyed
  # @return [Null] if {Event.meetings} isn't empty
  def check_event
    event.destroy if event.reload.meetings.blank?
  end
end

#id ⇒ Integer

Returns the unique identifier for Meeting.

Returns:

  • (Integer) —

    the unique identifier for Meeting



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
 
# File 'app/models/meeting.rb', line 61

class Meeting < ApplicationRecord
  belongs_to :audit
  belongs_to :event
  has_one :user, through: :audit
  has_one :category, through: :audit

  attr_accessor :active

  enum status: { blocked: 0, proposed: 1, waiting: 2, confirmed: 3 }

  scope :deletables, ->(date: Time.zone.today-(Settings.events.meetings.deletable.days).days) { proposed.where('sended_at < ?', date) }

  validates :event, presence: true, uniqueness: { scope: :audit }
  validates :audit, presence: true
  validates :start_at, presence: true

  before_validation :check_stop_at
  after_destroy :check_event

  # @return [Object] return an ICAL object with meeting data
  def ical
    require 'icalendar'
    require 'icalendar/tzinfo'
    cal = Icalendar::Calendar.new
    event_start = DateTime.parse(I18n.l(event.date_on, format: :date).to_s + "T#{I18n.l(start_at, format: :time)}")

    tzid = 'Europe/Rome'
    tz = TZInfo::Timezone.get tzid
    timezone = tz.ical_timezone Time.zone.now
    cal.add_timezone timezone

    cal.event do |e|
      e.dtstart = Icalendar::Values::DateTime.new event_start, 'tzid' => tzid
      e.dtend   = Icalendar::Values::DateTime.new event_start, 'tzid' => tzid
      e.summary = "Prenotazione #{I18n.t(event.gender, scope: 'event.gender').downcase} del #{I18n.l(event.date_on)} alle ore #{I18n.l(start_at, format: :time)}"
      e.organizer = "mailto:#{Settings.email}"
      e.organizer = Icalendar::Values::CalAddress.new("mailto:#{Settings.email}", cn: user.label)
      e.description = Settings.events[event.gender]['description']
      e.location = Settings.events[event.gender]['location']
    end
  end

  private

  # @return [Time] start_at + 20 minutes if stop_at is empty and start_at is present
  # @return [Null] if stop_at if is present
  def check_stop_at
    self.stop_at = start_at.in_time_zone + 20.minutes if stop_at.blank? && start_at.present?
  end

  # @return [True] if {Event.meetings} is empty and the event is destroyed
  # @return [False] if {Event.meetings} is empty and the event isn't destroyed
  # @return [Null] if {Event.meetings} isn't empty
  def check_event
    event.destroy if event.reload.meetings.blank?
  end
end

#sended_at ⇒ DateTime

Returns the date when the Meeting is sended to the #user.

Returns:

  • (DateTime) —

    the date when the Meeting is sended to the #user



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
 
# File 'app/models/meeting.rb', line 61

class Meeting < ApplicationRecord
  belongs_to :audit
  belongs_to :event
  has_one :user, through: :audit
  has_one :category, through: :audit

  attr_accessor :active

  enum status: { blocked: 0, proposed: 1, waiting: 2, confirmed: 3 }

  scope :deletables, ->(date: Time.zone.today-(Settings.events.meetings.deletable.days).days) { proposed.where('sended_at < ?', date) }

  validates :event, presence: true, uniqueness: { scope: :audit }
  validates :audit, presence: true
  validates :start_at, presence: true

  before_validation :check_stop_at
  after_destroy :check_event

  # @return [Object] return an ICAL object with meeting data
  def ical
    require 'icalendar'
    require 'icalendar/tzinfo'
    cal = Icalendar::Calendar.new
    event_start = DateTime.parse(I18n.l(event.date_on, format: :date).to_s + "T#{I18n.l(start_at, format: :time)}")

    tzid = 'Europe/Rome'
    tz = TZInfo::Timezone.get tzid
    timezone = tz.ical_timezone Time.zone.now
    cal.add_timezone timezone

    cal.event do |e|
      e.dtstart = Icalendar::Values::DateTime.new event_start, 'tzid' => tzid
      e.dtend   = Icalendar::Values::DateTime.new event_start, 'tzid' => tzid
      e.summary = "Prenotazione #{I18n.t(event.gender, scope: 'event.gender').downcase} del #{I18n.l(event.date_on)} alle ore #{I18n.l(start_at, format: :time)}"
      e.organizer = "mailto:#{Settings.email}"
      e.organizer = Icalendar::Values::CalAddress.new("mailto:#{Settings.email}", cn: user.label)
      e.description = Settings.events[event.gender]['description']
      e.location = Settings.events[event.gender]['location']
    end
  end

  private

  # @return [Time] start_at + 20 minutes if stop_at is empty and start_at is present
  # @return [Null] if stop_at if is present
  def check_stop_at
    self.stop_at = start_at.in_time_zone + 20.minutes if stop_at.blank? && start_at.present?
  end

  # @return [True] if {Event.meetings} is empty and the event is destroyed
  # @return [False] if {Event.meetings} is empty and the event isn't destroyed
  # @return [Null] if {Event.meetings} isn't empty
  def check_event
    event.destroy if event.reload.meetings.blank?
  end
end

#start_at ⇒ Time

Returns Start time for Meeting, can’t be null.

Returns:

  • (Time) —

    Start time for Meeting, can’t be null



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
 
# File 'app/models/meeting.rb', line 61

class Meeting < ApplicationRecord
  belongs_to :audit
  belongs_to :event
  has_one :user, through: :audit
  has_one :category, through: :audit

  attr_accessor :active

  enum status: { blocked: 0, proposed: 1, waiting: 2, confirmed: 3 }

  scope :deletables, ->(date: Time.zone.today-(Settings.events.meetings.deletable.days).days) { proposed.where('sended_at < ?', date) }

  validates :event, presence: true, uniqueness: { scope: :audit }
  validates :audit, presence: true
  validates :start_at, presence: true

  before_validation :check_stop_at
  after_destroy :check_event

  # @return [Object] return an ICAL object with meeting data
  def ical
    require 'icalendar'
    require 'icalendar/tzinfo'
    cal = Icalendar::Calendar.new
    event_start = DateTime.parse(I18n.l(event.date_on, format: :date).to_s + "T#{I18n.l(start_at, format: :time)}")

    tzid = 'Europe/Rome'
    tz = TZInfo::Timezone.get tzid
    timezone = tz.ical_timezone Time.zone.now
    cal.add_timezone timezone

    cal.event do |e|
      e.dtstart = Icalendar::Values::DateTime.new event_start, 'tzid' => tzid
      e.dtend   = Icalendar::Values::DateTime.new event_start, 'tzid' => tzid
      e.summary = "Prenotazione #{I18n.t(event.gender, scope: 'event.gender').downcase} del #{I18n.l(event.date_on)} alle ore #{I18n.l(start_at, format: :time)}"
      e.organizer = "mailto:#{Settings.email}"
      e.organizer = Icalendar::Values::CalAddress.new("mailto:#{Settings.email}", cn: user.label)
      e.description = Settings.events[event.gender]['description']
      e.location = Settings.events[event.gender]['location']
    end
  end

  private

  # @return [Time] start_at + 20 minutes if stop_at is empty and start_at is present
  # @return [Null] if stop_at if is present
  def check_stop_at
    self.stop_at = start_at.in_time_zone + 20.minutes if stop_at.blank? && start_at.present?
  end

  # @return [True] if {Event.meetings} is empty and the event is destroyed
  # @return [False] if {Event.meetings} is empty and the event isn't destroyed
  # @return [Null] if {Event.meetings} isn't empty
  def check_event
    event.destroy if event.reload.meetings.blank?
  end
end

#status ⇒ Symbol

Is an enum, can’t be null, default is 1

Returns:

  • (Symbol) —

    :blocked when 0

  • (Symbol) —

    :proposed when 1

  • (Symbol) —

    :waiting when 2

  • (Symbol) —

    :confirmed when 3



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
 
# File 'app/models/meeting.rb', line 61

class Meeting < ApplicationRecord
  belongs_to :audit
  belongs_to :event
  has_one :user, through: :audit
  has_one :category, through: :audit

  attr_accessor :active

  enum status: { blocked: 0, proposed: 1, waiting: 2, confirmed: 3 }

  scope :deletables, ->(date: Time.zone.today-(Settings.events.meetings.deletable.days).days) { proposed.where('sended_at < ?', date) }

  validates :event, presence: true, uniqueness: { scope: :audit }
  validates :audit, presence: true
  validates :start_at, presence: true

  before_validation :check_stop_at
  after_destroy :check_event

  # @return [Object] return an ICAL object with meeting data
  def ical
    require 'icalendar'
    require 'icalendar/tzinfo'
    cal = Icalendar::Calendar.new
    event_start = DateTime.parse(I18n.l(event.date_on, format: :date).to_s + "T#{I18n.l(start_at, format: :time)}")

    tzid = 'Europe/Rome'
    tz = TZInfo::Timezone.get tzid
    timezone = tz.ical_timezone Time.zone.now
    cal.add_timezone timezone

    cal.event do |e|
      e.dtstart = Icalendar::Values::DateTime.new event_start, 'tzid' => tzid
      e.dtend   = Icalendar::Values::DateTime.new event_start, 'tzid' => tzid
      e.summary = "Prenotazione #{I18n.t(event.gender, scope: 'event.gender').downcase} del #{I18n.l(event.date_on)} alle ore #{I18n.l(start_at, format: :time)}"
      e.organizer = "mailto:#{Settings.email}"
      e.organizer = Icalendar::Values::CalAddress.new("mailto:#{Settings.email}", cn: user.label)
      e.description = Settings.events[event.gender]['description']
      e.location = Settings.events[event.gender]['location']
    end
  end

  private

  # @return [Time] start_at + 20 minutes if stop_at is empty and start_at is present
  # @return [Null] if stop_at if is present
  def check_stop_at
    self.stop_at = start_at.in_time_zone + 20.minutes if stop_at.blank? && start_at.present?
  end

  # @return [True] if {Event.meetings} is empty and the event is destroyed
  # @return [False] if {Event.meetings} is empty and the event isn't destroyed
  # @return [Null] if {Event.meetings} isn't empty
  def check_event
    event.destroy if event.reload.meetings.blank?
  end
end

#stop_at ⇒ Time

Returns Stop time for Meeting, can’t be null.

Returns:

  • (Time) —

    Stop time for Meeting, can’t be null



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
 
# File 'app/models/meeting.rb', line 61

class Meeting < ApplicationRecord
  belongs_to :audit
  belongs_to :event
  has_one :user, through: :audit
  has_one :category, through: :audit

  attr_accessor :active

  enum status: { blocked: 0, proposed: 1, waiting: 2, confirmed: 3 }

  scope :deletables, ->(date: Time.zone.today-(Settings.events.meetings.deletable.days).days) { proposed.where('sended_at < ?', date) }

  validates :event, presence: true, uniqueness: { scope: :audit }
  validates :audit, presence: true
  validates :start_at, presence: true

  before_validation :check_stop_at
  after_destroy :check_event

  # @return [Object] return an ICAL object with meeting data
  def ical
    require 'icalendar'
    require 'icalendar/tzinfo'
    cal = Icalendar::Calendar.new
    event_start = DateTime.parse(I18n.l(event.date_on, format: :date).to_s + "T#{I18n.l(start_at, format: :time)}")

    tzid = 'Europe/Rome'
    tz = TZInfo::Timezone.get tzid
    timezone = tz.ical_timezone Time.zone.now
    cal.add_timezone timezone

    cal.event do |e|
      e.dtstart = Icalendar::Values::DateTime.new event_start, 'tzid' => tzid
      e.dtend   = Icalendar::Values::DateTime.new event_start, 'tzid' => tzid
      e.summary = "Prenotazione #{I18n.t(event.gender, scope: 'event.gender').downcase} del #{I18n.l(event.date_on)} alle ore #{I18n.l(start_at, format: :time)}"
      e.organizer = "mailto:#{Settings.email}"
      e.organizer = Icalendar::Values::CalAddress.new("mailto:#{Settings.email}", cn: user.label)
      e.description = Settings.events[event.gender]['description']
      e.location = Settings.events[event.gender]['location']
    end
  end

  private

  # @return [Time] start_at + 20 minutes if stop_at is empty and start_at is present
  # @return [Null] if stop_at if is present
  def check_stop_at
    self.stop_at = start_at.in_time_zone + 20.minutes if stop_at.blank? && start_at.present?
  end

  # @return [True] if {Event.meetings} is empty and the event is destroyed
  # @return [False] if {Event.meetings} is empty and the event isn't destroyed
  # @return [Null] if {Event.meetings} isn't empty
  def check_event
    event.destroy if event.reload.meetings.blank?
  end
end

#updated_at ⇒ DateTime

Returns the date when the record was updated.

Returns:

  • (DateTime) —

    the date when the record was updated



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
 
# File 'app/models/meeting.rb', line 61

class Meeting < ApplicationRecord
  belongs_to :audit
  belongs_to :event
  has_one :user, through: :audit
  has_one :category, through: :audit

  attr_accessor :active

  enum status: { blocked: 0, proposed: 1, waiting: 2, confirmed: 3 }

  scope :deletables, ->(date: Time.zone.today-(Settings.events.meetings.deletable.days).days) { proposed.where('sended_at < ?', date) }

  validates :event, presence: true, uniqueness: { scope: :audit }
  validates :audit, presence: true
  validates :start_at, presence: true

  before_validation :check_stop_at
  after_destroy :check_event

  # @return [Object] return an ICAL object with meeting data
  def ical
    require 'icalendar'
    require 'icalendar/tzinfo'
    cal = Icalendar::Calendar.new
    event_start = DateTime.parse(I18n.l(event.date_on, format: :date).to_s + "T#{I18n.l(start_at, format: :time)}")

    tzid = 'Europe/Rome'
    tz = TZInfo::Timezone.get tzid
    timezone = tz.ical_timezone Time.zone.now
    cal.add_timezone timezone

    cal.event do |e|
      e.dtstart = Icalendar::Values::DateTime.new event_start, 'tzid' => tzid
      e.dtend   = Icalendar::Values::DateTime.new event_start, 'tzid' => tzid
      e.summary = "Prenotazione #{I18n.t(event.gender, scope: 'event.gender').downcase} del #{I18n.l(event.date_on)} alle ore #{I18n.l(start_at, format: :time)}"
      e.organizer = "mailto:#{Settings.email}"
      e.organizer = Icalendar::Values::CalAddress.new("mailto:#{Settings.email}", cn: user.label)
      e.description = Settings.events[event.gender]['description']
      e.location = Settings.events[event.gender]['location']
    end
  end

  private

  # @return [Time] start_at + 20 minutes if stop_at is empty and start_at is present
  # @return [Null] if stop_at if is present
  def check_stop_at
    self.stop_at = start_at.in_time_zone + 20.minutes if stop_at.blank? && start_at.present?
  end

  # @return [True] if {Event.meetings} is empty and the event is destroyed
  # @return [False] if {Event.meetings} is empty and the event isn't destroyed
  # @return [Null] if {Event.meetings} isn't empty
  def check_event
    event.destroy if event.reload.meetings.blank?
  end
end

Instance Method Details

#audit ⇒ Object

Returns related Audit.

Returns:

  • (Object) —

    related Audit



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
 
# File 'app/models/meeting.rb', line 61

class Meeting < ApplicationRecord
  belongs_to :audit
  belongs_to :event
  has_one :user, through: :audit
  has_one :category, through: :audit

  attr_accessor :active

  enum status: { blocked: 0, proposed: 1, waiting: 2, confirmed: 3 }

  scope :deletables, ->(date: Time.zone.today-(Settings.events.meetings.deletable.days).days) { proposed.where('sended_at < ?', date) }

  validates :event, presence: true, uniqueness: { scope: :audit }
  validates :audit, presence: true
  validates :start_at, presence: true

  before_validation :check_stop_at
  after_destroy :check_event

  # @return [Object] return an ICAL object with meeting data
  def ical
    require 'icalendar'
    require 'icalendar/tzinfo'
    cal = Icalendar::Calendar.new
    event_start = DateTime.parse(I18n.l(event.date_on, format: :date).to_s + "T#{I18n.l(start_at, format: :time)}")

    tzid = 'Europe/Rome'
    tz = TZInfo::Timezone.get tzid
    timezone = tz.ical_timezone Time.zone.now
    cal.add_timezone timezone

    cal.event do |e|
      e.dtstart = Icalendar::Values::DateTime.new event_start, 'tzid' => tzid
      e.dtend   = Icalendar::Values::DateTime.new event_start, 'tzid' => tzid
      e.summary = "Prenotazione #{I18n.t(event.gender, scope: 'event.gender').downcase} del #{I18n.l(event.date_on)} alle ore #{I18n.l(start_at, format: :time)}"
      e.organizer = "mailto:#{Settings.email}"
      e.organizer = Icalendar::Values::CalAddress.new("mailto:#{Settings.email}", cn: user.label)
      e.description = Settings.events[event.gender]['description']
      e.location = Settings.events[event.gender]['location']
    end
  end

  private

  # @return [Time] start_at + 20 minutes if stop_at is empty and start_at is present
  # @return [Null] if stop_at if is present
  def check_stop_at
    self.stop_at = start_at.in_time_zone + 20.minutes if stop_at.blank? && start_at.present?
  end

  # @return [True] if {Event.meetings} is empty and the event is destroyed
  # @return [False] if {Event.meetings} is empty and the event isn't destroyed
  # @return [Null] if {Event.meetings} isn't empty
  def check_event
    event.destroy if event.reload.meetings.blank?
  end
end

#category ⇒ Object

Returns related Category through Audit.

Returns:



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
 
# File 'app/models/meeting.rb', line 61

class Meeting < ApplicationRecord
  belongs_to :audit
  belongs_to :event
  has_one :user, through: :audit
  has_one :category, through: :audit

  attr_accessor :active

  enum status: { blocked: 0, proposed: 1, waiting: 2, confirmed: 3 }

  scope :deletables, ->(date: Time.zone.today-(Settings.events.meetings.deletable.days).days) { proposed.where('sended_at < ?', date) }

  validates :event, presence: true, uniqueness: { scope: :audit }
  validates :audit, presence: true
  validates :start_at, presence: true

  before_validation :check_stop_at
  after_destroy :check_event

  # @return [Object] return an ICAL object with meeting data
  def ical
    require 'icalendar'
    require 'icalendar/tzinfo'
    cal = Icalendar::Calendar.new
    event_start = DateTime.parse(I18n.l(event.date_on, format: :date).to_s + "T#{I18n.l(start_at, format: :time)}")

    tzid = 'Europe/Rome'
    tz = TZInfo::Timezone.get tzid
    timezone = tz.ical_timezone Time.zone.now
    cal.add_timezone timezone

    cal.event do |e|
      e.dtstart = Icalendar::Values::DateTime.new event_start, 'tzid' => tzid
      e.dtend   = Icalendar::Values::DateTime.new event_start, 'tzid' => tzid
      e.summary = "Prenotazione #{I18n.t(event.gender, scope: 'event.gender').downcase} del #{I18n.l(event.date_on)} alle ore #{I18n.l(start_at, format: :time)}"
      e.organizer = "mailto:#{Settings.email}"
      e.organizer = Icalendar::Values::CalAddress.new("mailto:#{Settings.email}", cn: user.label)
      e.description = Settings.events[event.gender]['description']
      e.location = Settings.events[event.gender]['location']
    end
  end

  private

  # @return [Time] start_at + 20 minutes if stop_at is empty and start_at is present
  # @return [Null] if stop_at if is present
  def check_stop_at
    self.stop_at = start_at.in_time_zone + 20.minutes if stop_at.blank? && start_at.present?
  end

  # @return [True] if {Event.meetings} is empty and the event is destroyed
  # @return [False] if {Event.meetings} is empty and the event isn't destroyed
  # @return [Null] if {Event.meetings} isn't empty
  def check_event
    event.destroy if event.reload.meetings.blank?
  end
end

#event ⇒ Object

Returns related Event.

Returns:

  • (Object) —

    related Event



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
 
# File 'app/models/meeting.rb', line 61

class Meeting < ApplicationRecord
  belongs_to :audit
  belongs_to :event
  has_one :user, through: :audit
  has_one :category, through: :audit

  attr_accessor :active

  enum status: { blocked: 0, proposed: 1, waiting: 2, confirmed: 3 }

  scope :deletables, ->(date: Time.zone.today-(Settings.events.meetings.deletable.days).days) { proposed.where('sended_at < ?', date) }

  validates :event, presence: true, uniqueness: { scope: :audit }
  validates :audit, presence: true
  validates :start_at, presence: true

  before_validation :check_stop_at
  after_destroy :check_event

  # @return [Object] return an ICAL object with meeting data
  def ical
    require 'icalendar'
    require 'icalendar/tzinfo'
    cal = Icalendar::Calendar.new
    event_start = DateTime.parse(I18n.l(event.date_on, format: :date).to_s + "T#{I18n.l(start_at, format: :time)}")

    tzid = 'Europe/Rome'
    tz = TZInfo::Timezone.get tzid
    timezone = tz.ical_timezone Time.zone.now
    cal.add_timezone timezone

    cal.event do |e|
      e.dtstart = Icalendar::Values::DateTime.new event_start, 'tzid' => tzid
      e.dtend   = Icalendar::Values::DateTime.new event_start, 'tzid' => tzid
      e.summary = "Prenotazione #{I18n.t(event.gender, scope: 'event.gender').downcase} del #{I18n.l(event.date_on)} alle ore #{I18n.l(start_at, format: :time)}"
      e.organizer = "mailto:#{Settings.email}"
      e.organizer = Icalendar::Values::CalAddress.new("mailto:#{Settings.email}", cn: user.label)
      e.description = Settings.events[event.gender]['description']
      e.location = Settings.events[event.gender]['location']
    end
  end

  private

  # @return [Time] start_at + 20 minutes if stop_at is empty and start_at is present
  # @return [Null] if stop_at if is present
  def check_stop_at
    self.stop_at = start_at.in_time_zone + 20.minutes if stop_at.blank? && start_at.present?
  end

  # @return [True] if {Event.meetings} is empty and the event is destroyed
  # @return [False] if {Event.meetings} is empty and the event isn't destroyed
  # @return [Null] if {Event.meetings} isn't empty
  def check_event
    event.destroy if event.reload.meetings.blank?
  end
end

#ical ⇒ Object

Return an ICAL object with meeting data

Returns:

  • (Object) —

    return an ICAL object with meeting data



81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
 
# File 'app/models/meeting.rb', line 81

def ical
  require 'icalendar'
  require 'icalendar/tzinfo'
  cal = Icalendar::Calendar.new
  event_start = DateTime.parse(I18n.l(event.date_on, format: :date).to_s + "T#{I18n.l(start_at, format: :time)}")

  tzid = 'Europe/Rome'
  tz = TZInfo::Timezone.get tzid
  timezone = tz.ical_timezone Time.zone.now
  cal.add_timezone timezone

  cal.event do |e|
    e.dtstart = Icalendar::Values::DateTime.new event_start, 'tzid' => tzid
    e.dtend   = Icalendar::Values::DateTime.new event_start, 'tzid' => tzid
    e.summary = "Prenotazione #{I18n.t(event.gender, scope: 'event.gender').downcase} del #{I18n.l(event.date_on)} alle ore #{I18n.l(start_at, format: :time)}"
    e.organizer = "mailto:#{Settings.email}"
    e.organizer = Icalendar::Values::CalAddress.new("mailto:#{Settings.email}", cn: user.label)
    e.description = Settings.events[event.gender]['description']
    e.location = Settings.events[event.gender]['location']
  end
end

#user ⇒ Object

Returns related User through Audit.

Returns:



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
 
# File 'app/models/meeting.rb', line 61

class Meeting < ApplicationRecord
  belongs_to :audit
  belongs_to :event
  has_one :user, through: :audit
  has_one :category, through: :audit

  attr_accessor :active

  enum status: { blocked: 0, proposed: 1, waiting: 2, confirmed: 3 }

  scope :deletables, ->(date: Time.zone.today-(Settings.events.meetings.deletable.days).days) { proposed.where('sended_at < ?', date) }

  validates :event, presence: true, uniqueness: { scope: :audit }
  validates :audit, presence: true
  validates :start_at, presence: true

  before_validation :check_stop_at
  after_destroy :check_event

  # @return [Object] return an ICAL object with meeting data
  def ical
    require 'icalendar'
    require 'icalendar/tzinfo'
    cal = Icalendar::Calendar.new
    event_start = DateTime.parse(I18n.l(event.date_on, format: :date).to_s + "T#{I18n.l(start_at, format: :time)}")

    tzid = 'Europe/Rome'
    tz = TZInfo::Timezone.get tzid
    timezone = tz.ical_timezone Time.zone.now
    cal.add_timezone timezone

    cal.event do |e|
      e.dtstart = Icalendar::Values::DateTime.new event_start, 'tzid' => tzid
      e.dtend   = Icalendar::Values::DateTime.new event_start, 'tzid' => tzid
      e.summary = "Prenotazione #{I18n.t(event.gender, scope: 'event.gender').downcase} del #{I18n.l(event.date_on)} alle ore #{I18n.l(start_at, format: :time)}"
      e.organizer = "mailto:#{Settings.email}"
      e.organizer = Icalendar::Values::CalAddress.new("mailto:#{Settings.email}", cn: user.label)
      e.description = Settings.events[event.gender]['description']
      e.location = Settings.events[event.gender]['location']
    end
  end

  private

  # @return [Time] start_at + 20 minutes if stop_at is empty and start_at is present
  # @return [Null] if stop_at if is present
  def check_stop_at
    self.stop_at = start_at.in_time_zone + 20.minutes if stop_at.blank? && start_at.present?
  end

  # @return [True] if {Event.meetings} is empty and the event is destroyed
  # @return [False] if {Event.meetings} is empty and the event isn't destroyed
  # @return [Null] if {Event.meetings} isn't empty
  def check_event
    event.destroy if event.reload.meetings.blank?
  end
end