spina-admin-conferences-fork 2.1.1

data/app/jobs/spina/admin/conferences/delegate_import_job.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Spina
+  module Admin
+    module Conferences
+      # Job for importing {Delegate} objects.
+      # @see Delegate
+      class DelegateImportJob < ImportJob
+        queue_as :default
+
+        # Performs the job.
+        # @param csv [String] the UTF-8-encoded string to parse as a CSV
+        #   == Columns
+        #   The CSV should has the following columns. Make sure to include the column names in the header row.
+        #   +first_name+:: The first name of the delegate.
+        #   +last_name+:: The last name of the delegate.
+        #   +email_address+:: The email address of the delegate.
+        #   +institution_id+:: The id of the current institution of the delegate.
+        #   +dietary_requirement_ids+:: The ids of the dietary requirements of the delegate.
+        #
+        # @return [void]
+        def perform(csv)
+          Delegate.transaction do
+            import(csv) { |row| Delegate.create! delegate_params(row.to_h) }
+          end
+        end
+
+        private
+
+        def delegate_params(params)
+          params = ActionController::Parameters.new(params)
+          params.permit :first_name, :last_name, :email_address, :institution_id, conference_ids: [], dietary_requirement_ids: []
+        end
+      end
+    end
+  end
+end

data/app/jobs/spina/admin/conferences/import_job.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'csv'
+
+module Spina
+  module Admin
+    module Conferences
+      # Job for importing CSV files.
+      class ImportJob < ApplicationJob
+        CSV::Converters[:json] = lambda do |field|
+          JSON.parse field, symbolize_names: true
+        rescue JSON::ParserError
+          field
+        end
+
+        # Performs the job.
+        # @param file [String] the UTF-8-encoded string to parse as a CSV
+        # @yieldparam row [Hash] the current row of the CSV
+        def import(file)
+          csv_rows = CSV.parse file, encoding: 'UTF-8', headers: true, header_converters: :symbol, converters: [:json]
+          csv_rows.each { |row| yield(row) }
+        end
+      end
+    end
+  end
+end

data/app/jobs/spina/admin/conferences/presentation_import_job.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Spina
+  module Admin
+    module Conferences
+      # Job for importing {Presentation} objects
+      # @see Presentation
+      class PresentationImportJob < ImportJob
+        queue_as :default
+
+        # Performs the job.
+        # @param csv [String] the UTF-8-encoded string to parse as a CSV
+        #   == Columns
+        #   The CSV should has the following columns. Make sure to include the column names in the header row.
+        #   +session_id+:: The id of the associated session.
+        #   +start_datetime+:: The start time of the presentation, in ISO 8601 format.
+        #   +title+:: The title of the presentation for the default locale.
+        #   +abstract+:: The presentation's abstract.
+        #   +presenter_ids+:: The ids of the presenters.
+        #
+        # @return [void]
+        def perform(csv)
+          Presentation.transaction do
+            import(csv) { |row| Presentation.create! presentation_params(row.to_h) }
+          end
+        end
+
+        private
+
+        def presentation_params(params)
+          params = ActionController::Parameters.new(params)
+          params.permit :title, :start_datetime, :abstract, :session_id, presenter_ids: []
+        end
+      end
+    end
+  end
+end

data/app/mailers/spina/admin/conferences/application_mailer.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Spina
+  module Admin
+    module Conferences
+      # @abstract Abstract mailer from which all others inherit.
+      class ApplicationMailer < ActionMailer::Base
+        default from: 'from@example.com'
+        layout 'mailer'
+      end
+    end
+  end
+end

data/app/models/spina/admin/conferences/application_record.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Spina
+  module Admin
+    module Conferences
+      # @abstract Subclass to implement a custom record.
+      class ApplicationRecord < ActiveRecord::Base
+        extend Mobility
+
+        self.abstract_class = true
+      end
+    end
+  end
+end

data/app/models/spina/admin/conferences/conference.rb

@@ -0,0 +1,269 @@
+# frozen_string_literal: true
+
+module Spina
+  module Admin
+    module Conferences
+      # Conference records.
+      #
+      # = Validators
+      # Presence:: {#name}, {#start_date}, {#finish_date}, {#year}.
+      # Conference date (using {FinishDateValidator}):: {#finish_date}.
+      # @see FinishDateValidator
+      #
+      # = Translations
+      # - {#name}
+      class Conference < ApplicationRecord # rubocop:disable Metrics/ClassLength
+        include AttrJson::Record
+        include AttrJson::NestedAttributes
+        include Spina::Partable
+        include Spina::TranslatedContent
+
+        default_scope { includes(:translations) }
+
+        # @!attribute [rw] dates
+        #   @return [Range<Date>, nil] the dates of the conference
+
+        # @!attribute [rw] name
+        #   @return [String, nil] the translated name of the conference
+        translates :name, fallbacks: true
+
+        # @return [ActiveRecord::Relation] all conferences, ordered by date
+        scope :sorted, -> { order dates: :desc }
+
+        # @!attribute [rw] presentation_types
+        #   @return [ActiveRecord::Relation] directly associated presentation types
+        #   @note A conference cannot be destroyed if it has dependent presentation types.
+        #   @see PresentationType
+        has_many :presentation_types, -> { includes(:translations) }, inverse_of: :conference, dependent: :restrict_with_error
+        # @!attribute [rw] events
+        #   @return [ActiveRecord::Relation] directly associated events
+        #   @note Destroying a conference destroys dependent events.
+        #   @see Event
+        has_many :events, -> { includes(:translations) }, inverse_of: :conference, dependent: :destroy
+        # @!attribute [rw] sessions
+        #   @return [ActiveRecord::Relation] Sessions associated with {#presentation_types}
+        #   @see Session
+        #   @see PresentationType#sessions
+        has_many :sessions, -> { distinct.includes(:translations) }, through: :presentation_types
+        # @!attribute [rw] presentations
+        #   @return [ActiveRecord::Relation] Presentations associated with {#sessions}
+        #   @see Presentation
+        #   @see Session#presentations
+        has_many :presentations, -> { distinct.includes(:translations) }, through: :sessions
+        # @!attribute [rw] rooms
+        #   @return [ActiveRecord::Relation] Rooms associated with {#sessions}
+        #   @see Room
+        #   @see Session#rooms
+        has_many :rooms, -> { distinct.includes(:translations) }, through: :sessions
+        # @!attribute [rw] institutions
+        #   @return [ActiveRecord::Relation] Institutions associated with {#rooms}
+        #   @see Institution
+        #   @see Room#institutions
+        has_many :institutions, -> { distinct.includes(:translations) }, through: :rooms
+        # @!attribute [rw] delegates
+        #   @return [ActiveRecord::Relation] directly associated delegates
+        #   @see Delegate
+        has_and_belongs_to_many :delegates, foreign_key: :spina_conferences_conference_id, # rubocop:disable Rails/HasAndBelongsToMany
+                                            association_foreign_key: :spina_conferences_delegate_id
+        accepts_nested_attributes_for :events, allow_destroy: true
+
+        validates :name, :start_date, :finish_date, :year, presence: true
+        validates :finish_date, 'spina/admin/conferences/finish_date': true, unless: proc { |conference| conference.start_date.blank? }
+
+        class << self
+          # @return [Array<TZInfo::TimezonePeriod>] the time zone periods for the conferences
+          def time_zone_periods
+            pluck(:dates).compact.collect(&:begin).collect(&:at_beginning_of_day).collect(&:period)
+          end
+
+          # @return [String] a set of conferences as an iCalendar
+          def to_ics
+            Rails.cache.fetch [all, 'calendar'] do
+              calendar = Icalendar::Calendar.new
+              calendar.x_wr_calname = (Current.account || Spina::Account.first).name
+              calendar.add_timezone(ical_timezone)
+              conference_events.each { |event| calendar.add_event(event) }
+              calendar.publish
+              calendar.to_ical
+            end
+          end
+
+          private
+
+          def conference_events
+            Rails.cache.fetch [all, 'events'] do
+              all.in_batches.each_record.collect do |conference|
+                Rails.cache.fetch([conference, 'event']) { conference.to_event }
+              end
+            end
+          end
+
+          def ical_timezone
+            Rails.cache.fetch [self, 'time_zone'] do
+              Icalendar::Timezone.new do |timezone|
+                timezone.tzid = Time.zone.name
+                daylight_periods.each { |daylight_period| timezone.add_daylight(daylight_period) }
+                standard_periods.each { |standard_period| timezone.add_daylight(standard_period) }
+              end
+            end
+          end
+
+          def daylight_periods
+            time_zone_periods.select(&:dst?).each do |period|
+              Icalendar::Timezone::Daylight.new do |ical_period|
+                ical_period.tzoffsetfrom = period.offset.ical_offset
+                ical_period.tzoffsetto = period.offset.ical_offset
+                ical_period.tzname = period.abbreviation
+                ical_period.dtstart = period.starts_at.to_datetime
+              end
+            end
+          end
+
+          def standard_periods
+            time_zone_periods.reject(&:dst?).each do |period|
+              Icalendar::Timezone::Standard.new do |ical_period|
+                ical_period.tzoffsetfrom = period.offset.ical_offset
+                ical_period.tzoffsetto = period.offset.ical_offset
+                ical_period.tzname = period.abbreviation
+                ical_period.dtstart = period.starts_at.to_datetime
+              end
+            end
+          end
+        end
+
+        # @return [Date, nil] the start date of the conference. Nil if the conference has no dates
+        def start_date
+          return if dates.blank?
+
+          dates.begin
+        end
+
+        # Sets the start date of the conference.
+        # @param date [Date] the new start date
+        # @return [void]
+        def start_date=(date)
+          self.dates = date.try(:to_date)..finish_date
+        end
+
+        # @return [Date, nil] the finish date of the conference. Nil if the conference has no dates
+        def finish_date
+          return if dates.blank?
+
+          if dates.exclude_end?
+            dates.end - 1.day if dates.end.is_a? Date
+          else
+            dates.end
+          end
+        end
+
+        # Sets the finish date of the conference.
+        # @param date [Date] the new finish date
+        # @return [void]
+        def finish_date=(date)
+          self.dates = start_date..date.try(:to_date)
+        end
+
+        # @return [Integer, nil] the year of the conference. Nil if the conference has no dates
+        def year
+          return if start_date.blank?
+
+          start_date.try(:year)
+        end
+
+        # @return [Array<Hash{Symbol=>String}>, nil] an array of hashes containing the date in ISO 8601 format and as a localised string
+        #   Nil if the conference has no dates.
+        def localized_dates
+          return if dates.blank?
+
+          dates.entries.collect { |date| { date: date.to_formatted_s(:iso8601), localization: I18n.l(date, format: :long) } }
+        end
+
+        # @return [String] the names of each institution associated with the conference
+        def location
+          institutions.collect(&:name).to_sentence
+        end
+
+        # @return [Icalendar::Event] the conference as an iCal event
+        def to_event # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+          event = Icalendar::Event.new
+          return event if invalid?
+
+          event.dtstart = Icalendar::Values::Date.new(dates.begin)
+          event.dtend = Icalendar::Values::Date.new(dates.exclude_end? ? dates.end : dates.end + 1.day)
+          event.location = location
+          event.contact = Spina::Account.first.email
+          event.categories = Conference.model_name.human(count: 0)
+          event.summary = name
+          event
+        end
+
+        # @return [TZInfo::TimezonePeriod, nil] the time zone period for the conference event
+        def time_zone_period
+          return if start_date.blank?
+
+          start_date.at_beginning_of_day.period
+        end
+
+        # @return [String, nil] the conference as an iCalendar
+        def to_ics
+          Rails.cache.fetch [self, presentations, 'calendar'] do
+            calendar = Icalendar::Calendar.new
+            return if invalid?
+
+            calendar.x_wr_calname = name
+            calendar.add_timezone(ical_timezone)
+            eventables_events.each { |event| calendar.add_event(event) }
+            calendar.publish
+            calendar.to_ical
+          end
+        end
+
+        private
+
+        def eventables
+          [self, *events, *presentations]
+        end
+
+        def eventables_events
+          Rails.cache.fetch [self, *presentations, 'events'] do
+            eventables.collect do |eventable|
+              Rails.cache.fetch([eventable, 'event']) { eventable.to_event }
+            end
+          end
+        end
+
+        def ical_timezone
+          Rails.cache.fetch [self, presentations, 'time_zone'] do
+            Icalendar::Timezone.new do |timezone|
+              timezone.tzid = Time.zone.name
+              daylight_periods.each { |daylight_period| timezone.add_daylight(daylight_period) }
+              standard_periods.each { |standard_period| timezone.add_daylight(standard_period) }
+            end
+          end
+        end
+
+        def daylight_periods
+          time_zone_periods.select(&:dst?).each do |period|
+            Icalendar::Timezone::Daylight.new do |ical_period|
+              ical_period.tzoffsetfrom = period.offset.ical_offset
+              ical_period.tzoffsetto = period.offset.ical_offset
+              ical_period.tzname = period.abbreviation
+              ical_period.dtstart = period.starts_at.to_datetime
+            end
+          end
+        end
+
+        def standard_periods
+          time_zone_periods.reject(&:dst?).each do |period|
+            Icalendar::Timezone::Standard.new do |ical_period|
+              ical_period.tzoffsetfrom = period.offset.ical_offset
+              ical_period.tzoffsetto = period.offset.ical_offset
+              ical_period.tzname = period.abbreviation
+              ical_period.dtstart = period.starts_at.to_datetime
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/app/models/spina/admin/conferences/delegate.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module Spina
+  module Admin
+    module Conferences
+      # Delegate records.
+      #
+      # = Validators
+      # Presence:: {#first_name}, {#last_name}.
+      # Email address (using {EmailAddressValidator}):: {#email_address}.
+      # HTTP(S) URL (using {HttpUrlValidator}):: {#url}.
+      # @see EmailAddressValidator
+      # @see HttpUrlValidator
+      class Delegate < ApplicationRecord
+        # @!attribute [rw] first_name
+        #   @return [String, nil] the first name of the delegate
+        # @!attribute [rw] last_name
+        #   @return [String, nil] the last name of the delegate
+        # @!attribute [rw] email_address
+        #   @return [String, nil] the email address of the delegate
+        # @!attribute [rw] url
+        #   @return [String, nil] the website belonging to the delegate
+
+        # @return [ActiveRecord::Relation] all delegates, ordered by last name and first name
+        scope :sorted, -> { order :last_name, :first_name }
+
+        # @!attribute [rw] institution
+        #   @return [Institution, nil] directly associated institution
+        #   @see Institution
+        belongs_to :institution, inverse_of: :delegates, touch: true
+        # @!attribute [rw] conferences
+        #   @return [ActiveRecord::Relation] directly associated conferences
+        #   @see Conference
+        has_and_belongs_to_many :conferences, -> { includes(:translations) }, foreign_key: :spina_conferences_delegate_id, # rubocop:disable Rails/HasAndBelongsToMany
+                                              association_foreign_key: :spina_conferences_conference_id
+        # @!attribute [rw] presentations
+        #   @return [ActiveRecord::Relation] directly associated presentations
+        #   @see Presentation
+        has_and_belongs_to_many :presentations, -> { includes(:translations) }, foreign_key: :spina_conferences_delegate_id, # rubocop:disable Rails/HasAndBelongsToMany
+                                                association_foreign_key: :spina_conferences_presentation_id
+        # @!attribute [rw] dietary_requirements
+        #   @return [ActiveRecord::Relation] directly associated dietary requirements
+        #   @see DietaryRequirement
+        has_and_belongs_to_many :dietary_requirements, -> { includes(:translations) }, foreign_key: :spina_conferences_delegate_id, # rubocop:disable Rails/HasAndBelongsToMany
+                                                       association_foreign_key: :spina_conferences_dietary_requirement_id
+
+        validates :first_name, :last_name, presence: true
+        validates :email_address, 'spina/admin/conferences/email_address': true
+        validates :url, 'spina/admin/conferences/http_url': true
+
+        # Imports a conference from CSV.
+        # @param file [String] the CSV file to be read
+        # @return [void]
+        # @see DelegateImportJob
+        def self.import(file)
+          DelegateImportJob.perform_later Pathname.new(file).read
+        end
+
+        # @return [String] the first name and last name of the delegate
+        def full_name
+          return if first_name.blank? || last_name.blank?
+
+          Delegate.human_attribute_name :full_name, first_name: first_name, last_name: last_name
+        end
+
+        # @return [String] the full name and institution of the delegate
+        def full_name_and_institution
+          return if full_name.blank? || institution.blank?
+
+          Delegate.human_attribute_name :name_and_institution, name: full_name, institution: institution.name
+        end
+
+        # @return [String] the last name and first name of the delegate
+        def reversed_name
+          return if first_name.blank? || last_name.blank?
+
+          Delegate.human_attribute_name :reversed_name, first_name: first_name, last_name: last_name
+        end
+
+        # @return [String] the reversed name and institution of the delegate
+        def reversed_name_and_institution
+          return if reversed_name.blank? || institution.blank?
+
+          Delegate.human_attribute_name :name_and_institution, name: reversed_name, institution: institution.name
+        end
+      end
+    end
+  end
+end

data/app/models/spina/admin/conferences/dietary_requirement.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Spina
+  module Admin
+    module Conferences
+      # Dietary requirement records.
+      #
+      # = Validators
+      # Presence:: {#name}.
+      #
+      # = Translations
+      # - {#name}
+      class DietaryRequirement < ApplicationRecord
+        default_scope { includes(:translations) }
+
+        # @!attribute [rw] name
+        #   @return [String, nil] the name of the dietary requirement
+        translates :name, fallbacks: true
+
+        # @return [ActiveRecord::Relation] all dietary requirements, ordered by name
+        scope :sorted, -> { i18n.order :name }
+
+        # @!attribute [rw] delegates
+        #   @return [ActiveRecord::Relation] directly associated delegates
+        #   @see Delegate
+        has_and_belongs_to_many :delegates, foreign_key: :spina_conferences_dietary_requirement_id, # rubocop:disable Rails/HasAndBelongsToMany
+                                            association_foreign_key: :spina_conferences_delegate_id
+
+        validates :name, presence: true
+      end
+    end
+  end
+end

data/app/models/spina/admin/conferences/event.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module Spina
+  module Admin
+    module Conferences
+      # Events during conferences.
+      #
+      # = Validators
+      # Presence:: {#name}, {#:start_datetime}, {#:finish_datetime}, {#:location}.
+      # Conference date (using {ConferenceDateValidator}):: {#start_datetime}, {#finish_datetime}.
+      # @see ConferenceDateValidator
+      #
+      # = Translations
+      # - {#name}
+      # - {#description}
+      # - {#location}
+      class Event < ApplicationRecord
+        default_scope { includes(:translations) }
+
+        # @!attribute [rw] name
+        #   @return [String, nil] the translated name of the event
+        # @!attribute [rw] description
+        #   @return [ActionText::RichText, nil] the translated description of the event
+        # @!attribute [rw] start_datetime
+        #   @return [ActiveSupport::TimeWithZone, nil] the start time of the event
+        # @!attribute [rw] finish_datetime
+        #   @return [ActiveSupport::TimeWithZone, nil] the finish time of the event
+        # @!attribute [rw] location
+        #   @return [String, nil] the translated location of the event
+        translates :name, :location, fallbacks: true
+        translates :description, backend: :action_text, fallbacks: true
+
+        # @return [ActiveRecord::Relation] all events, ordered by name
+        scope :sorted, -> { i18n.order :name }
+
+        # @!attribute [rw] start_time
+        #   @return [ActiveSupport::TimeWithZone, nil] the start time (alias)
+        #   @see #start_datetime
+        alias_attribute :start_time, :start_datetime
+        # @!attribute [rw] :finish_time
+        #   @return [ActiveSupport::TimeWithZone, nil] the finish time (alias)
+        #   @see #finish_datetime
+        alias_attribute :finish_time, :finish_datetime
+
+        # @!attribute [rw] conference
+        #   @return [Conference, nil] directly associated conferences
+        belongs_to :conference, -> { includes(:translations) }, inverse_of: :events, touch: true
+
+        validates :name, :start_datetime, :finish_datetime, :location, presence: true
+        validates :start_datetime, :finish_datetime, 'spina/admin/conferences/conference_date': true
+        validates :finish_datetime, 'spina/admin/conferences/finish_time': true
+
+        # @return [Date, nil] the start date of the event. Nil if the event has no start date and time
+        def date
+          return if start_datetime.blank?
+
+          start_datetime.to_date
+        end
+
+        # @return [TZInfo::TimezonePeriod, nil] the time zone period for the event
+        def time_zone_period
+          return if start_datetime.blank?
+
+          start_datetime.period
+        end
+
+        # @return [Icalendar::Event] the event as an iCal event
+        def to_event # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+          event = Icalendar::Event.new
+          return event if invalid?
+
+          event.dtstart = Icalendar::Values::DateTime.new(start_datetime, tzid: start_datetime.time_zone.tzinfo.name)
+          event.dtend = Icalendar::Values::DateTime.new(finish_datetime, tzid: start_datetime.time_zone.tzinfo.name)
+          event.location = location
+          event.contact = Spina::Account.first.email
+          event.categories = Event.model_name.human(count: 0)
+          event.summary = name
+          event.append_custom_property('alt_description', description.to_s)
+          event.description = description.try(:to_plain_text)
+          event
+        end
+      end
+    end
+  end
+end

data/app/models/spina/admin/conferences/institution.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Spina
+  module Admin
+    module Conferences
+      # Institution records.
+      #
+      # = Validators
+      # Presence:: {#name}, {#city}.
+      #
+      # = Translations
+      # - {#name}
+      # - {#city}
+      class Institution < ApplicationRecord
+        default_scope { includes(:translations) }
+
+        # @!attribute [rw] name
+        #   @return [String, nil] the name of the institution
+        # @!attribute [rw] city
+        #   @return [String, nil] the city of the institution
+        translates :name, :city, fallbacks: true
+
+        # @return [ActiveRecord::Relation] all institutions, ordered by name
+        scope :sorted, -> { i18n.order :name }
+
+        # @!attribute [rw] logo
+        #   @return [Spina::Image, nil] directly associated image
+        belongs_to :logo, class_name: 'Spina::Image', optional: true
+        # @!attribute [rw] rooms
+        #   @return [ActiveRecord::Relation] directly associated rooms
+        #   @note An institution cannot be destroyed if it has dependent rooms.
+        #   @see Room
+        has_many :rooms, -> { includes(:translations) }, inverse_of: :institution, dependent: :restrict_with_error
+        # @!attribute [rw] delegates
+        #   @return [ActiveRecord::Relation] directly associated delegates
+        #   @note This relation accepts nested attributes.
+        #   @note An institution cannot be destroyed if it has dependent delegates.
+        #   @see Delegate
+        has_many :delegates, inverse_of: :institution, dependent: :restrict_with_error
+        accepts_nested_attributes_for :rooms
+
+        validates :name, :city, presence: true
+      end
+    end
+  end
+end