spina-admin-conferences-fork 2.1.1

data/app/assets/javascripts/controllers/spina/admin/conferences/select_options_controller.js

@@ -0,0 +1,215 @@
+/**
+ * @external Controller
+ * @see {@link https://stimulusjs.org}
+ */
+import { Controller } from 'stimulus'
+
+/**
+ * @classdesc Controller that links related select elements.
+ */
+export default class SelectOptionsController extends Controller {
+  // noinspection JSUnusedGlobalSymbols
+  static get targets() {
+    return [
+      /**
+       * @private
+       * @property {HTMLElement[]} selectTargets - The select elements.
+       */
+      'select'
+    ]
+  }
+  // noinspection JSUnusedGlobalSymbols
+  static get values() {
+    return {
+      /**
+       * @private
+       * @property {Array} recordValue - The record values.
+       */
+      record: Array,
+    }
+  }
+
+  // noinspection JSUnusedGlobalSymbols
+  /**
+   * Hook to ensure that the initial value of each select element is used to set visibility of the corresponding records.
+   * @private
+   */
+  connect() {
+    this.selectTargets.forEach(target => target.dispatchEvent(new Event('change')))
+  }
+
+  // noinspection JSUnusedGlobalSymbols
+  /**
+   * Hook to update select targets when record values change.
+   * @private
+   */
+  recordValueChanged() {
+    this.selectTargets.forEach(target => {
+      if (!(target instanceof HTMLSelectElement)) return
+      this.updateOptions(target)
+    })
+  }
+
+  // noinspection JSUnusedGlobalSymbols
+  /**
+   * Updates the visibility of records according to the selected option of a select element.
+   * @param {Event} event - The event fired by the select element.
+   */
+  setVisibility(event) {
+    const target = event.currentTarget
+    if (!(target instanceof HTMLSelectElement)) return
+    const recordFilter = new SelectOptionsController.RecordFilter(this.recordValue, target)
+    this.recordValue = recordFilter.setVisibility()
+  }
+
+  /**
+   * Updates the options of a select element.
+   * @private
+   * @param {HTMLSelectElement} target - The select element to update the options of.
+   */
+  updateOptions(target) {
+    let newRecords = this.recordValue
+    if ('keyPath' in target.dataset) {
+      const keyPath = new SelectOptionsController.KeyPath(target.dataset.keyPath)
+      newRecords = keyPath.visibleObjectsAtKeyPath(newRecords)
+    }
+    const textKey = target.dataset.textKey
+    if (!('valueKey' in target.dataset)) target.dataset.valueKey = 'id'
+    const valueKey = target.dataset.valueKey
+    const newOptions = newRecords.map(record => new Option(record[textKey], record[valueKey] ))
+    const oldOptions = Array.from(target.options).filter(option => option.value !== '')
+    oldOptions.filter(option => !newOptions.some(newOption => newOption.value === option.value))
+      .forEach(option => target.remove(option.index))
+    newOptions.filter(newOption => !oldOptions.some(option => option.value === newOption.value)).forEach(option => target.add(option))
+  }
+}
+
+/**
+ * @private
+ * @classdesc A series of property keys, used to traverse objects. A parent object or array of objects is recursively mapped to child
+ * objects identified by each property key.
+ */
+SelectOptionsController.KeyPath = class {
+  /**
+   * Creates a new key path.
+   * @private
+   * @constructor
+   * @param {String} string - The string used to create the key path. Should be in the format 'segment:segment:segment'.
+   */
+  constructor(string) {
+    if (typeof string !== 'string') throw TypeError(`${string} is not a string`)
+    /**
+     * @property {string[]} segments - The segments of the key path.
+     */
+    this.segments = string.split(':')
+  }
+
+  /**
+   * Traverses an object or array of objects by recursively mapping objects to the objects identified by the series of key path segments.
+   * @private
+   * @param {Object|Object[]} object - The object or array of objects to be traversed.
+   * @param {Boolean} filter - Whether, when encountering an array within the top-level object or array,
+   * elements marked as invisible should be ignored.
+   * @return Any
+   */
+  traverseObject(object, filter = false) {
+    let childObject = object
+    this.segments.forEach(key => {
+      switch (childObject.constructor) {
+      case Array:
+        if (filter) childObject = childObject.filter(object => object.hidden !== true)
+        childObject = childObject.flatMap(object => object[key])
+        break
+      case String:
+      case Number:
+      case Boolean:
+        break
+      case Object:
+        childObject = childObject[key]
+        break
+      }
+    })
+    return childObject ? childObject : []
+  }
+
+  /**
+   * Traverses an object or array of objects by recursively mapping objects to the objects identified by the series of key path segments.
+   * When encountering an array within the top-level object or array, elements marked as invisible are ignored.
+   * @private
+   * @param {Object|Object[]} object - The object or array of objects to be traversed.
+   * @return Any
+   */
+  visibleObjectsAtKeyPath(object) {
+    return this.traverseObject(object, true)
+  }
+
+  /**
+   * Traverses an object or array of objects by recursively mapping objects to the objects identified by the series of key path segments.
+   * @private
+   * @param {Object|Object[]} object - The object or array of objects to be traversed.
+   * @return Any
+   */
+  objectsAtKeyPath(object) {
+    return this.traverseObject(object)
+  }
+}
+
+/**
+ * @private
+ * @classdesc Identifies a set of records presented as options by a select element target within a possibly larger set of records.
+ * The visibility of each target record can be set by comparing the value of the target to the value of some property of each target record.
+ */
+SelectOptionsController.RecordFilter = class {
+  /**
+   * @private
+   * @property {Object[]} targetRecords - If a key path exists, the records within the raw records identified by the key path.
+   * Else the raw records.
+   */
+  get targetRecords() {
+    return this.keyPath ? this.keyPath.objectsAtKeyPath(this.rawRecords) : this.rawRecords
+  }
+
+  /**
+   * Creates a new record filter.
+   * @private
+   * @constructor
+   * @param {Object[]} rawRecords - The records to be filtered.
+   * @param {HTMLSelectElement} target - The target providing the value.
+   * @param {String} [target.dataset.keyPath] - The key path.
+   * @param {String} [target.dataset.valueKey=id] - The value key.
+   */
+  constructor(rawRecords, target) {
+    /**
+     * @private
+     * @property {Object[]} rawRecords - The entire set of records.
+     */
+    this.rawRecords = Array.from(rawRecords)
+    if ('keyPath' in target.dataset) {
+      /**
+       * @private
+       * @property {KeyPath} [keyPath] - The key path used to filter records.
+       */
+      this.keyPath = new SelectOptionsController.KeyPath(target.dataset.keyPath)
+    } 
+    if (!('valueKey' in target.dataset)) target.dataset.valueKey = 'id'
+    /**
+     * @private
+     * @property {String} valueKey - The property of the target records to be compared to the target value.
+     */
+    this.valueKey = target.dataset.valueKey
+    /**
+     * @private
+     * @property {String} targetValue - The value of the target.
+     */
+    this.targetValue = target.value
+  }
+
+  /**
+   * Marks the target record whose property value matches the value of the target as visible and others as invisible.
+   * @returns {Object[]} The raw records, with the target records marked for visibility.
+   */
+  setVisibility() {
+    this.targetRecords.forEach(record => record.hidden = record[this.valueKey].toString() !== this.targetValue)
+    return this.rawRecords
+  }
+}

data/app/assets/javascripts/importmap.json.erb

@@ -0,0 +1,6 @@
+{
+  "imports": {
+    "turbo": "<%= asset_path "turbo" %>",
+    <%= importmap_list_with_stimulus_from Spina::Admin::Conferences::Engine.root.join('app/assets/javascripts/controllers').relative_path_from(Rails.root) %>
+  }
+}

data/app/assets/javascripts/spina/admin/conferences/application.js

@@ -0,0 +1,4 @@
+document.addEventListener('turbo:load', (event) => {
+  const customEvent = new CustomEvent('turbolinks:load', { cancelable: event.cancelable, bubbles: true, detail: event.detail })
+  document.documentElement.dispatchEvent(customEvent)
+})

data/app/assets/stylesheets/spina/admin/conferences/application.sass

@@ -0,0 +1,3 @@
+.turbo-progress-bar
+  @import spina/configuration
+  background-color: $primary-color

data/app/controllers/spina/admin/conferences/application_controller.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Spina
+  module Admin
+    module Conferences
+      # @abstract Subclass to implement a custom controller.
+      class ApplicationController < ::Spina::Admin::AdminController
+        helper ::Spina::Engine.routes.url_helpers
+
+        add_flash_types :success
+
+        layout 'spina/admin/conferences/application', only: %i[new edit]
+        before_action :set_locale
+
+        private
+
+        def set_locale
+          @locale = params[:locale] || I18n.default_locale
+        end
+      end
+    end
+  end
+end

data/app/controllers/spina/admin/conferences/conferences_controller.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+module Spina
+  module Admin
+    module Conferences
+      # Controller for {Conference} objects.
+      # @see Conference
+      class ConferencesController < ApplicationController
+        PARTS_PARAMS = [
+          :name, :title, :type, :content, :filename, :signed_blob_id, :alt, :attachment_id, :image_id,
+          images_attributes: %i[filename signed_blob_id image_id alt],
+          content_attributes: [
+            :name, :title,
+            parts_attributes: [
+              :name, :title, :type, :content, :filename, :signed_blob_id, :alt, :attachment_id, :image_id,
+              images_attributes: %i[filename signed_blob_id image_id alt]
+            ]
+          ]
+        ].freeze
+        CONTENT_PARAMS = Spina.config.locales.inject({}) { |params, locale| params.merge("#{locale}_content_attributes": [*PARTS_PARAMS]) }
+        PARAMS = [:start_date, :finish_date, :name, **CONTENT_PARAMS,
+          events_attributes: %i[id name start_datetime finish_datetime description location] ].freeze
+        PARTS = %w[text submission_url submission_email_address submission_date submission_text gallery sponsors].freeze
+
+        before_action :set_conference, only: %i[edit update destroy]
+        before_action :set_conferences_breadcrumb
+        before_action :set_tabs
+        before_action :set_institutions, :set_parts_attributes, only: %i[new edit]
+        before_action :build_parts, only: :edit
+
+        # @!group Actions
+
+        # Renders a list of conferences.
+        # @return [void]
+        def index
+          @conferences = Conference.sorted.page(params[:page])
+        end
+
+        # Renders a form for a new conference.
+        # @return [void]
+        def new
+          @conference = Conference.new
+          build_parts
+          add_breadcrumb t('.new')
+        end
+
+        # Renders a form for an existing conference.
+        # @return [void]
+        def edit
+          add_breadcrumb @conference.name
+        end
+
+        # Creates a conference.
+        # @return [void]
+        def create # rubocop:disable Metrics/MethodLength
+          @conference = Conference.new(conference_params)
+
+          if @conference.save
+            redirect_to admin_conferences_conferences_path, success: t('.saved')
+          else
+            respond_to do |format|
+              format.html do
+                add_breadcrumb t('.new')
+                render :new
+              end
+              format.turbo_stream { render partial: 'errors', locals: { errors: @conference.errors } }
+            end
+          end
+        end
+
+        # Updates a conference.
+        # @return [void]
+        def update # rubocop:disable Metrics/MethodLength
+          if @conference.update(conference_params)
+            redirect_to admin_conferences_conferences_path, success: t('.saved')
+          else
+            respond_to do |format|
+              format.html do
+                add_breadcrumb @conference.name
+                render :edit
+              end
+              format.turbo_stream { render partial: 'errors', locals: { errors: @conference.errors } }
+            end
+          end
+        end
+
+        # Destroys a conference.
+        # @return [void]
+        def destroy # rubocop:disable Metrics/MethodLength
+          if @conference.destroy
+            redirect_to admin_conferences_conferences_path, success: t('.destroyed')
+          else
+            respond_to do |format|
+              format.html do
+                add_breadcrumb @conference.name
+                render :edit
+              end
+              format.turbo_stream { render partial: 'errors', locals: { errors: @conference.errors } }
+            end
+          end
+        end
+
+        # @!endgroup
+
+        private
+
+        def set_conference
+          @conference = Conference.find params[:id]
+        end
+
+        def set_institutions
+          @institutions = Institution.all.to_json include: { rooms: { methods: [:name] } }
+        end
+
+        def set_conferences_breadcrumb
+          add_breadcrumb Conference.model_name.human(count: 0), admin_conferences_conferences_path
+        end
+
+        def set_tabs
+          @tabs = %w[conference_details parts delegates presentation_types rooms presentations]
+        end
+
+        def set_parts_attributes
+          @parts_attributes = current_theme.parts.select { |part| PARTS.include? part[:name] }
+        end
+
+        def build_parts
+          return unless @parts_attributes.is_a? Array
+
+          @parts = @parts_attributes.collect { |part_attributes| @conference.part(part_attributes) }
+        end
+
+        def conference_params
+          params.require(:conference).permit(PARAMS)
+        end
+      end
+    end
+  end
+end

data/app/controllers/spina/admin/conferences/delegates_controller.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module Spina
+  module Admin
+    module Conferences
+      # Controller for {Delegate} objects.
+      # @see Delegate
+      class DelegatesController < ApplicationController
+        before_action :set_delegate, only: %i[edit update destroy]
+        before_action :set_breadcrumb
+        before_action :set_tabs
+
+        # @!group Actions
+
+        # Renders a list of delegates.
+        # @return [void]
+        def index
+          @delegates = Delegate.sorted.page(params[:page])
+        end
+
+        # Renders a form for a new delegate.
+        # @return [void]
+        def new
+          @delegate = Delegate.new
+          add_breadcrumb t('.new')
+        end
+
+        # Renders a form for an existing delegate.
+        # @return [void]
+        def edit
+          add_breadcrumb @delegate.full_name
+        end
+
+        # Creates a delegate.
+        # @return [void]
+        def create # rubocop:disable Metrics/MethodLength
+          @delegate = Delegate.new(delegate_params)
+
+          if @delegate.save
+            redirect_to admin_conferences_delegates_path, success: t('.saved')
+          else
+            respond_to do |format|
+              format.html do
+                add_breadcrumb t('.new')
+                render :new
+              end
+              format.turbo_stream { render partial: 'errors', locals: { errors: @delegate.errors } }
+            end
+          end
+        end
+
+        # Updates a delegate.
+        # @return [void]
+        def update # rubocop:disable Metrics/MethodLength
+          if @delegate.update(delegate_params)
+            redirect_to admin_conferences_delegates_path, success: t('.saved')
+          else
+            respond_to do |format|
+              format.html do
+                add_breadcrumb @delegate.full_name
+                render :edit
+              end
+              format.turbo_stream { render partial: 'errors', locals: { errors: @delegate.errors } }
+            end
+          end
+        end
+
+        # Destroys a delegate.
+        # @return [void]
+        def destroy # rubocop:disable Metrics/MethodLength
+          if @delegate.destroy
+            redirect_to admin_conferences_delegates_path, success: t('.destroyed')
+          else
+            respond_to do |format|
+              format.html do
+                add_breadcrumb @delegate.full_name
+                render :edit
+              end
+              format.turbo_stream { render partial: 'errors', locals: { errors: @delegate.errors } }
+            end
+          end
+        end
+
+        # Imports a delegate.
+        # @return [void]
+        # @see Delegate#import
+        def import
+          Delegate.import params[:file]
+        end
+
+        # @!endgroup
+
+        private
+
+        def set_delegate
+          @delegate = Delegate.find params[:id]
+        end
+
+        def set_breadcrumb
+          add_breadcrumb Delegate.model_name.human(count: 0), admin_conferences_delegates_path
+        end
+
+        def set_tabs
+          @tabs = %w[delegate_details conferences presentations]
+        end
+
+        def delegate_params
+          params.require(:delegate).permit(:first_name, :last_name, :email_address, :url, :institution_id,
+                                           conference_ids: [], dietary_requirement_ids: [])
+        end
+      end
+    end
+  end
+end

data/app/controllers/spina/admin/conferences/dietary_requirements_controller.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module Spina
+  module Admin
+    module Conferences
+      # Controller for {DietaryRequirement} objects.
+      # @see DietaryRequirement
+      class DietaryRequirementsController < ApplicationController
+        before_action :set_dietary_requirement, only: %i[edit update destroy]
+        before_action :set_breadcrumb
+        before_action :set_tabs
+
+        # @!group Actions
+
+        # Renders a list of dietary requirements.
+        # @return [void]
+        def index
+          @dietary_requirements = DietaryRequirement.sorted.page(params[:page])
+        end
+
+        # Renders a form for a new dietary requirement.
+        # @return [void]
+        def new
+          @dietary_requirement = DietaryRequirement.new
+          add_breadcrumb t('.new')
+        end
+
+        # Renders a form for an existing dietary requirement.
+        # @return [void]
+        def edit
+          add_breadcrumb @dietary_requirement.name
+        end
+
+        # Creates a dietary requirement.
+        # @return [void]
+        def create # rubocop:disable Metrics/MethodLength
+          @dietary_requirement = DietaryRequirement.new dietary_requirement_params
+
+          if @dietary_requirement.save
+            redirect_to admin_conferences_dietary_requirements_path, success: t('.saved')
+          else
+            respond_to do |format|
+              format.html do
+                add_breadcrumb t('.new')
+                render :new
+              end
+              format.turbo_stream { render partial: 'errors', locals: { errors: @dietary_requirement.errors } }
+            end
+          end
+        end
+
+        # Updates a dietary requirement.
+        # @return [void]
+        def update # rubocop:disable Metrics/MethodLength
+          if @dietary_requirement.update(dietary_requirement_params)
+            redirect_to admin_conferences_dietary_requirements_path, success: t('.saved')
+          else
+            respond_to do |format|
+              format.html do
+                add_breadcrumb @dietary_requirement.name
+                render :edit
+              end
+              format.turbo_stream { render partial: 'errors', locals: { errors: @dietary_requirement.errors } }
+            end
+          end
+        end
+
+        # Destroys a dietary requirement.
+        # @return [void]
+        def destroy # rubocop:disable Metrics/MethodLength
+          if @dietary_requirement.destroy
+            redirect_to admin_conferences_dietary_requirements_path, success: t('.destroyed')
+          else
+            respond_to do |format|
+              format.html do
+                add_breadcrumb @dietary_requirement.name
+                render :edit
+              end
+              format.turbo_stream { render partial: 'errors', locals: { errors: @dietary_requirement.errors } }
+            end
+          end
+        end
+
+        # @!endgroup
+
+        private
+
+        def set_dietary_requirement
+          @dietary_requirement = DietaryRequirement.find params[:id]
+        end
+
+        def set_breadcrumb
+          add_breadcrumb DietaryRequirement.model_name.human(count: 0), admin_conferences_dietary_requirements_path
+        end
+
+        def set_tabs
+          @tabs = %w[dietary_requirement_details delegates]
+        end
+
+        def dietary_requirement_params
+          params.require(:dietary_requirement).permit(:name)
+        end
+      end
+    end
+  end
+end

data/app/controllers/spina/admin/conferences/events_controller.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Spina
+  module Admin
+    module Conferences
+      # Controller for {Event} objects.
+      # @see Event
+      class EventsController < ApplicationController
+        # @!group Actions
+
+        # Renders a form for an {Event}.
+        # @return [void]
+        def new
+          @conference = Conference.find_by(id: params[:conference]) || Conference.new
+          @event = @conference.events.build
+          respond_to :js
+          render locals: { index: params[:index].to_i, active: params[:active] == 'true' }
+        end
+
+        # @!endgroup
+      end
+    end
+  end
+end