spina-admin-conferences 1.3.3

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

@@ -0,0 +1,216 @@
+/* global Stimulus */
+
+/**
+ * @external Stimulus
+ * @see {@link https://stimulusjs.org}
+ */
+
+/**
+ * @classdesc Controller that links related select elements.
+ */
+class SelectOptionsController extends Stimulus.Controller { // eslint-disable-line no-unused-vars
+  // noinspection JSUnusedGlobalSymbols
+  static get targets() {
+    return [
+      /**
+       * @private
+       * @property {HTMLElement[]} selectTargets - The select elements.
+       */
+      'select'
+    ]
+  }
+  // noinspection JSUnusedGlobalSymbols
+  static get values() {
+    return {
+      /**
+       * @private
+       * @property {Array} recordValues - 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
+   */
+  recordValuesChanged() {
+    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.recordValues, target)
+    this.recordValues = 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.recordValues
+    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/stylesheets/spina/admin/conferences/application.sass

@@ -0,0 +1,14 @@
+input::-webkit-calendar-picker-indicator
+  display: none
+input[type="date"]::-webkit-outer-spin-button, input[type="date"]::-webkit-inner-spin-button, input[type="time"]::-webkit-inner-spin-button, input[type="time"]::-webkit-inner-spin-button
+  display: none
+input[type="date"]
+  padding-right: 30px
+
+.multiple.select-dropdown
+  z-index: 0
+  &:before
+    content: none
+  select
+    padding: 11px 10px
+    width: 100%

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Spina
+  module Admin
+    module Conferences
+      # @abstract Subclass to implement a custom controller.
+      class ApplicationController < ::Spina::Admin::AdminController
+        add_flash_types :success
+
+        layout :admin_layout, only: %i[new edit]
+
+        private
+
+        def admin_layout
+          'spina/admin/admin'
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+module Spina
+  module Admin
+    module Conferences
+      # Controller for {Conference} objects.
+      # @see Conference
+      class ConferencesController < ApplicationController
+        PARTS = [
+          { name: 'text', title: 'Text', partable_type: 'Spina::Text' },
+          { name: 'submission_url', title: 'Submission URL', partable_type: 'Spina::Admin::Conferences::UrlPart' },
+          { name: 'submission_email_address', title: 'Submission email address',
+            partable_type: 'Spina::Admin::Conferences::EmailAddressPart' },
+          { name: 'submission_date', title: 'Submission date', partable_type: 'Spina::Admin::Conferences::DatePart' },
+          { name: 'submission_text', title: 'Submission text', partable_type: 'Spina::Line' },
+          { name: 'gallery', title: 'Gallery', partable_type: 'Spina::ImageCollection' },
+          { name: 'sponsors', title: 'Sponsors', partable_type: 'Spina::Structure' }
+        ].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
+        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.js { 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.js { 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.js { 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 = PARTS
+        end
+
+        def build_parts
+          return unless @parts_attributes.is_a? Array
+
+          @conference.parts = @parts_attributes.collect do |part_attributes|
+            @conference.parts.where(name: part_attributes[:name]).first_or_initialize(**part_attributes)
+                       .tap { |part| part.partable ||= part.partable_type.constantize.new }
+          end
+        end
+
+        def conference_params # rubocop:disable Metrics/MethodLength
+          params.require(:admin_conferences_conference).permit(:start_date, :finish_date, :name,
+                                                               events_attributes:
+                                                                 %i[id name date start_time finish_time description location],
+                                                               parts_attributes:
+                                                                 [:id, :title, :name, :partable_type, :partable_id,
+                                                                  { partable_attributes:
+                                                                      [:id, :content, :image_tokens, :image_positions, :date, :time,
+                                                                       { structure_items_attributes:
+                                                                           [:id, :position, :_destroy,
+                                                                            { structure_parts_attributes:
+                                                                                [:id, :title, :structure_partable_type, :name, :partable_id,
+                                                                                 { partable_attributes: {} }] }] }] }])
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,116 @@
+# 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
+        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.js { 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.js { 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.js { 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(:admin_conferences_delegate).permit(:first_name, :last_name, :email_address, :url,
+                                                             :institution_id,
+                                                             conference_ids: [],
+                                                             dietary_requirement_ids: [])
+        end
+      end
+    end
+  end
+end