spina-admin-conferences 1.3.3

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

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Spina
+  module Admin
+    module Conferences
+      # Join records between partables and pageables.
+      class Part < ApplicationRecord
+        include Spina::Part
+        include Spina::Optionable
+
+        belongs_to :pageable, inverse_of: :parts, polymorphic: true, touch: true
+        belongs_to :partable, polymorphic: true, optional: true
+
+        accepts_nested_attributes_for :partable
+
+        validates :name, uniqueness: { scope: :pageable_id }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+module Spina
+  module Admin
+    module Conferences
+      # Presentation records.
+      #
+      # = Validators
+      # Presence:: {#title}, {#date}, {#start_time}, {#start_datetime}, {#abstract}, {#presenters}.
+      # Conference date (using {ConferenceDateValidator}):: {#date}.
+      # @see ConferenceDateValidator
+      #
+      # = Translations
+      # - {#name}
+      # - {#title}
+      # - {#abstract}
+      class Presentation < ApplicationRecord
+        default_scope { includes(:translations) }
+
+        # @!attribute [rw] title
+        #   @return [String, nil] the presentation title
+        # @!attribute [rw] abstract
+        #   @return [String, nil] the presentation abstract
+        translates :title, :abstract, fallbacks: true
+
+        # @return [ActiveRecord::Relation] all conferences, ordered by date
+        scope :sorted, -> { order start_datetime: :desc }
+
+        # @!attribute [rw] name
+        #   @return [String, nil] the presentation title (alias)
+        #   @see #title
+        alias_attribute :name, :title
+
+        # @!attribute [rw] session
+        #   @return [Session, nil] directly associated session
+        #   @see Session
+        belongs_to :session, -> { includes(:translations) }, inverse_of: :presentations, touch: true
+        # @!attribute [rw] presentation_type
+        #   @return [PresentationType, nil] Presentation type associated with {#session}
+        #   @see PresentationType
+        #   @see Session#presentation_type
+        has_one :presentation_type, -> { includes(:translations) }, through: :session
+        # @!attribute [rw] room
+        #   @return [Room, nil] Room associated with {#session}
+        #   @see Session
+        #   @see Session#room
+        has_one :room, -> { includes(:translations) }, through: :session
+        # @!attribute [rw] conference
+        #   @return [Conference, nil] Conference associated with {#presentation_type}
+        #   @see Conference
+        #   @see PresentationType#conference
+        has_one :conference, -> { includes(:translations) }, through: :presentation_type
+        # @!attribute [rw] attachments
+        #   @return [ActiveRecord::Relation] directly associated presentation attachments
+        #   @note This relation accepts nested attributes.
+        #   @note Destroying a presentation destroys associated attachments.
+        #   @see Attachment
+        has_many :attachments, class_name: 'Spina::Admin::Conferences::PresentationAttachment', dependent: :destroy,
+                               inverse_of: :presentation
+        # @!attribute [rw] presenters
+        #   @return [ActiveRecord::Relation] directly associated delegates
+        #   @see Delegate
+        has_and_belongs_to_many :presenters, class_name: 'Spina::Admin::Conferences::Delegate', # rubocop:disable Rails/HasAndBelongsToMany
+                                             foreign_key: :spina_conferences_presentation_id,
+                                             association_foreign_key: :spina_conferences_delegate_id
+        accepts_nested_attributes_for :attachments, allow_destroy: true
+
+        validates :title, :date, :start_time, :start_datetime, :abstract, :presenters, presence: true
+        validates :date, 'spina/admin/conferences/conference_date': true
+        validates_associated :presenters
+        validates_associated :attachments
+
+        # Imports a presentation from CSV.
+        # @param file [String] the CSV file to be read
+        # @return [void]
+        # @see PresentationImportJob#perform
+        def self.import(file)
+          PresentationImportJob.perform_later IO.read(file)
+        end
+
+        # @return [Date, nil] the start date of the presentation. Nil if the presentation has no start date and time
+        def date
+          return if start_datetime.blank?
+
+          start_datetime.to_date
+        end
+
+        # Sets the date of the presentation.
+        # @param date [Date] the new date
+        # @return [void]
+        def date=(date)
+          if date.blank? || date.to_date.blank?
+            self.start_datetime = nil
+            return
+          end
+
+          self.start_datetime = date.to_date + (start_datetime.try(:seconds_since_midnight) || 0).seconds
+        end
+
+        # @return [ActiveSupport::TimeWithZone, nil] the start time of the presentation. Nil if the presentation has no start date and time
+        def start_time
+          return if start_datetime.blank?
+
+          start_datetime
+        end
+
+        # Sets the start time of the presentation.
+        # @param start_time [ActiveSupport::TimeWithZone] the new start time
+        # @return [void]
+        def start_time=(start_time)
+          if start_time.blank?
+            self.start_datetime = nil
+            return
+          end
+
+          self.start_datetime = Time.parse(start_time, date).to_datetime.in_time_zone
+        end
+
+        # @return [Icalendar::Event] the presentation as an iCal event
+        def to_event # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+          event = Icalendar::Event.new
+          return event if invalid?
+
+          event.dtstart = start_datetime
+          event.dtend = start_datetime + presentation_type.duration
+          event.location = session.room_name
+          presenters.each { |presenter| event.contact = presenter.full_name_and_institution }
+          event.categories = Presentation.model_name.human(count: 0)
+          event.summary = title
+          event.append_custom_property('alt_description', abstract.try(:html_safe))
+          event.description = abstract.try(:gsub, %r{</?[^>]*>}, '')
+          event
+        end
+
+        # @param (see #to_event)
+        # @deprecated Use {#to_event} instead
+        def to_ics
+          to_event
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Spina
+  module Admin
+    module Conferences
+      # Presentation attachment records.
+      class PresentationAttachment < ApplicationRecord
+        # @!attribute [rw] presentation
+        #   @return [Presentation, nil] directly associated presentation
+        belongs_to :presentation, -> { includes(:translations) }, inverse_of: :attachments, touch: true
+        # @!attribute [rw] presentation_attachment_type
+        #   @return [PresentationAttachmentType, nil] directly associated presentation attachment type
+        belongs_to :attachment_type, -> { includes(:translations) }, class_name: 'Spina::Admin::Conferences::PresentationAttachmentType',
+                                                                     inverse_of: :presentation_attachments,
+                                                                     touch: true
+        # @!attribute [rw] attachment
+        #   @return [Spina::Attachment, nil] directly associated attachment
+        belongs_to :attachment, class_name: 'Spina::Attachment'
+
+        # @!method name
+        #   @return [String, nil] name of associated presentation attachment type
+        #   @note Delegated to {#presentation_attachment_type}.
+        delegate :name, to: :attachment_type, allow_nil: true
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Spina
+  module Admin
+    module Conferences
+      # Presentation attachment type records.
+      #
+      # = Validators
+      # Presence:: {#name}.
+      #
+      # = Translations
+      # - {#name}
+      class PresentationAttachmentType < ApplicationRecord
+        default_scope { includes(:translations) }
+
+        # @!attribute [rw] name
+        #   @return [String, nil] the name of the presentation attachment type
+        translates :name, fallbacks: true
+
+        # @return [ActiveRecord::Relation] all presentation attachment types, ordered by name
+        scope :sorted, -> { i18n.order :name }
+
+        # @!attribute [rw] presentation_attachments
+        #   @return [ActiveRecord::Relation] directly associated presentation attachments
+        #   @see PresentationAttachment
+        has_many :presentation_attachments, class_name: 'Spina::Admin::Conferences::PresentationAttachment',
+                                            foreign_key: 'attachment_type_id',
+                                            dependent: :destroy,
+                                            inverse_of: :attachment_type
+
+        validates :name, presence: true
+      end
+    end
+  end
+end

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

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Spina
+  module Admin
+    module Conferences
+      # Presentation type records.
+      #
+      # = Validators
+      # Presence:: {#name}, {#minutes}. {#duration}.
+      #
+      # = Translations
+      # - {#name}
+      class PresentationType < ApplicationRecord
+        default_scope { includes(:translations) }
+
+        # @!attribute [rw] name
+        #   @return [String, nil] the name of the presentation type
+        translates :name, fallbacks: true
+
+        # @return [ActiveRecord::Relation] all presentation types, ordered by name
+        scope :sorted, -> { i18n.order :name }
+
+        # @!attribute [rw] duration
+        #   @return [ActiveSupport::Duration, nil] the duration of dependent presentations
+        attribute :duration, :interval
+
+        # @!attribute [rw] conference
+        #   @return [Conference, nil] directly associated conference
+        belongs_to :conference, -> { includes(:translations) }, inverse_of: :presentation_types, touch: true
+        # @!attribute [rw] sessions
+        #   @return [ActiveRecord::Relation] directly associated sessions
+        #   @note A presentation type cannot be destroyed if it has dependent sessions.
+        #   @see Session
+        has_many :sessions, -> { includes(:translations) }, inverse_of: :presentation_type, dependent: :restrict_with_error
+        # @!attribute [rw] presentations
+        #   @return [ActiveRecord::Relation] Presentations associated with {#sessions}
+        #   @see Presentation
+        #   @see Session#presentations
+        has_many :presentations, -> { distinct.includes(:translations) }, through: :sessions
+
+        validates :name, :minutes, :duration, presence: true
+        validates :minutes, numericality: { greater_than_or_equal_to: 1 }
+
+        # @return [Integer, nil] duration in minutes. Nil if the conference has no duration
+        def minutes
+          return if duration.blank?
+
+          duration.to_i / ActiveSupport::Duration::PARTS_IN_SECONDS[:minutes]
+        end
+
+        # Sets the duration of the conference.
+        # @param minutes [#to_i] the new duration in minutes
+        # @return [void]
+        def minutes=(minutes)
+          self.duration = minutes.to_i.minutes
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Spina
+  module Admin
+    module Conferences
+      # Room records.
+      #
+      # = Validators
+      # Presence:: {#number}, {#building}.
+      #
+      # = Translations
+      # - {#number}
+      # - {#building}
+      class Room < ApplicationRecord
+        default_scope { includes(:translations) }
+
+        # @!attribute [rw] number
+        #   @return [String, nil] the number of the room
+        # @!attribute [rw] building
+        #   @return [String, nil] the building of the room
+        translates :building, :number, fallbacks: true
+
+        # @return [ActiveRecord::Relation] all rooms, ordered by building and number
+        scope :sorted, -> { i18n.order :building, :number }
+
+        # @!attribute [rw] institution
+        #   @return [Institution, nil] directly associated institution
+        #   @see Institution
+        belongs_to :institution, -> { includes(:translations) }, inverse_of: :rooms, autosave: true, touch: true
+        # @!attribute [rw] sessions
+        #   @return [ActiveRecord::Relation] directly associated sessions
+        #   @note A room cannot be destroyed if it has dependent sessions.
+        #   @see Session
+        has_many :sessions, -> { includes(:translations) }, inverse_of: :room, dependent: :restrict_with_error
+        # @!attribute [rw] presentations
+        #   @return [ActiveRecord::Relation] Presentations associated with {#sessions}
+        #   @see Presentation
+        #   @see Session#presentations
+        has_many :presentations, -> { distinct.includes(:translations) }, through: :sessions
+
+        validates :number, :building, presence: true
+
+        # @return [String] the building and number of the room
+        def name
+          return if building.blank? || number.blank?
+
+          Room.human_attribute_name :name, building: building, number: number
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Spina
+  module Admin
+    module Conferences
+      # Session records.
+      #
+      # = Validators
+      # Presence:: {#name}.
+      #
+      # = Translations
+      # - {#name}
+      class Session < ApplicationRecord
+        default_scope { includes(:translations) }
+
+        # @!attribute [rw] name
+        #   @return [String, nil] the name of the session
+        translates :name, fallbacks: true
+
+        # @!attribute [rw] room
+        #   @return [Room, nil] directly associated room
+        belongs_to :room, -> { includes(:translations) }, inverse_of: :sessions, touch: true
+        # @!attribute [rw] room
+        #   @return [PresentationType, nil] directly associated presentation type
+        #   @see PresentationType
+        belongs_to :presentation_type, -> { includes(:translations) }, inverse_of: :sessions, touch: true
+        # @!attribute [rw] conference
+        #   @return [Conference, nil] Conference associated with {#presentation_type}
+        #   @see Conference
+        #   @see PresentationType#conference
+        has_one :conference, -> { includes(:translations) }, through: :presentation_type
+        # @!attribute [rw] institution
+        #   @return [Institution, nil] Institution associated with {#room}
+        #   @see Institution
+        #   @see Room#institution
+        has_one :institution, -> { includes(:translations) }, through: :room
+        # @!attribute [rw] presentations
+        #   @return [ActiveRecord::Relation] directly associated presentations
+        #   @note A session cannot be destroyed if it has dependent presentations.
+        #   @see Presentation
+        has_many :presentations, inverse_of: :session, dependent: :restrict_with_error
+
+        validates :name, presence: true
+
+        # @!method room_name
+        #   @return [String, nil] name of associated room
+        #   @note Delegated to {#room}.
+        delegate :name, to: :room, prefix: true, allow_nil: true
+        # @!method presentation_type_name
+        #   @return [String, nil] name of associated presentation type
+        #   @note Delegated to {#presentation_type}.
+        delegate :name, to: :presentation_type, prefix: true, allow_nil: true
+      end
+    end
+  end
+end