FlpSelection.js

/**
 * @license
 * Copyright 2019-2020 CERN and copyright holders of ALICE O2.
 * See http://alice-o2.web.cern.ch/copyright for details of the copyright holders.
 * All rights not expressly granted are reserved.
 *
 * This software is distributed under the terms of the GNU General Public
 * License v3 (GPL Version 3), copied verbatim in the file "COPYING".
 *
 * In applying this license CERN does not waive the privileges and immunities
 * granted to it by virtue of its status as an Intergovernmental Organization
 * or submit itself to any jurisdiction.
*/

import {Observable, RemoteData} from '/js/src/index.js';

/**
 * Model representing Workflow
 */
export default class FlpSelection extends Observable {
  /**
   * Initialize FLPs Selection Component
   * @param {Object} workflow
   * @param {Lock} lockModel - model of the lock state which will be used to automatically unselect detectors that are no longer locked by the current user
   */
  constructor(workflow, lockModel) {
    super();
    this.loader = workflow.model.loader;
    this.workflow = workflow;

    this.list = RemoteData.notAsked();
    this.firstFlpSelection = -1;

    this.hostsByDetectors = {};

    this.detectors = RemoteData.notAsked();
    this.activeDetectors = RemoteData.notAsked();
    this.selectedDetectors = [];
    this.unavailableDetectors = []; // detectors which are loaded from configuration but active in AliECS
    this.missingHosts = [];
    this.detectorViewConfigurationError = false;

    // Observe lock changes to automatically unselect detectors when locks are released
    lockModel.observe(() => this._handleLockChanges());
  }

  /**
   * Initialize detectors and hosts panels with empty selection
   */
  async init() {
    this.selectedDetectors = [];
    this.list = RemoteData.notAsked();
    this.hostsByDetectors = {};
    this.workflow.form.setHosts([]);
    this.unavailableDetectors = [];
    this.missingHosts = [];
    this.detectorViewConfigurationError = false;
    this.notify();

    await this.getAndSetDetectors();
  }

  /**
   * Method to request a list of detectors from AliECS and initialized the user form accordingly
   * @return {Promise<void>}
   */
  async getAndSetDetectors() {
    this.detectors = this.workflow.model.detectors.listRemote;
    await this.getActiveDetectors();
  }

  /**
   * Method to retrieve the detectors that are active as per AliECS
   * @return {Promise<void>}
   */
  async getActiveDetectors() {
    this.activeDetectors = RemoteData.loading();
    this.notify();
    const {result, ok} = await this.workflow.model.loader.post('/api/GetActiveDetectors', {});
    this.activeDetectors = ok ? RemoteData.success(result) : RemoteData.failure(result.message);
    this.notify();
  }

  /**
   * Given a list of detectors and hosts:
   * * update the data from AliECS with available detectors
   * * make the selection of the detectors based on passed values
   * * make the selection of the hosts based on passed values
   * * inform the user if some are unavailable anymore
   * @param {Array<String>} detectors 
   * @param {Array<String>} hosts 
   */
  async setDetectorsAndHosts(detectors, hosts) {
    this.init();

    await this.getAndSetDetectors(); // get the latest information on detectors

    detectors.map((detector) => {
      if (this.activeDetectors.isSuccess() && !this.activeDetectors.payload.detectors.includes(detector)) {
        this.selectedDetectors.push(detector);
        this.setHostsForDetector(detector);
        hosts.forEach((host) => {
          if (this.hostsByDetectors[detector].includes(host)) {
            this.workflow.form.addHost(host);
          }
        });
      }
      if (this.activeDetectors.isSuccess() && this.activeDetectors.payload.detectors.includes(detector)) {
        this.unavailableDetectors.push(detector);
      }
    });
    hosts.filter((host) => !this.workflow.form.hosts.includes(host))
      .forEach((host) => this.missingHosts.push(host));
    this.notify();
  }

  /**
   * Toggle selection of a detector. A detector can have one of the states taken/released:
   * This toggle will also notify the observer by default unless specified otherwise via shouldNotify
   * @param {String} name
   * @param {boolean} shouldNotify - specify if the method should trigger a notification at the end of the process. 
   */
  toggleDetectorSelection(name, shouldNotify = true) {
    const indexUnavailable = this.unavailableDetectors.indexOf(name)
    if (indexUnavailable >= 0) {
      this.unavailableDetectors.splice(indexUnavailable, 1);
    } else {
      const index = this.selectedDetectors.indexOf(name);
      if (index >= 0) {
        this.selectedDetectors.splice(index, 1);
        this.removeHostsByDetector(name);
      } else if (!this.isDetectorActive(name)) {
        this.selectedDetectors.push(name);
        this.setHostsForDetector(name, true);
      }
    }
    if (shouldNotify) {
      this.notify();
    }
  }

  /**
   * Method which checks if a detector is available and current user has the lock for it. 
   * If so, it will select the detector and all its associated FLPs
   * @param {Array<String>} detectorsToSelect - list of detectors to select
   * @returns {Promise<void>}
   */
  selectAllAvailableDetectors(detectorsToSelect) {
    this.selectedDetectors = [];
    const activeDetectors = this.activeDetectors.isSuccess() ? this.activeDetectors.payload.detectors : [];
    detectorsToSelect.filter((detector) =>
      !activeDetectors.includes(detector) && this.workflow.model.lock.isLockedByCurrentUser(detector)
    )
      .forEach((detector) => {
        this.selectedDetectors.push(detector);
        this.setHostsForDetector(detector, true);

      });
    this.notify();
  }

  /**
   * Given a name of a detector, it checks if it is part of the active list
   * @param {String} name 
   * @returns {boolean}
   */
  isDetectorActive(name) {
    return this.activeDetectors.isSuccess() && this.activeDetectors.payload.detectors.includes(name)
  }

  /**
   * Toggle the selection of an FLP from the form host
   * The user can also use SHIFT key to select between 2 FLP machines, thus
   * selecting all machines between the 2 selected
   * @param {string} name
   * @param {Event} e
   */
  toggleFLPSelection(name, e) {
    if (e.shiftKey && this.list.isSuccess()) {
      if (this.firstFlpSelection === -1) {
        this.firstFlpSelection = this.list.payload.indexOf(name);
      } else {
        let secondFlpSelection = this.list.payload.indexOf(name);
        if (this.firstFlpSelection > secondFlpSelection) {
          [this.firstFlpSelection, secondFlpSelection] = [secondFlpSelection, this.firstFlpSelection];
        }
        for (let flpIndex = this.firstFlpSelection; flpIndex <= secondFlpSelection; ++flpIndex) {
          const flpName = this.list.payload[flpIndex];
          const hostFormIndex = this.workflow.form.getHosts().indexOf(flpName);
          if (hostFormIndex < 0) {
            this.workflow.form.addHost(flpName);
          }
        }
        this.firstFlpSelection = -1;
      }
    } else {
      this.firstFlpSelection = -1;
      const index = this.workflow.form.hosts.indexOf(name);
      if (index < 0) {
        this.workflow.form.addHost(name);
      } else {
        this.workflow.form.removeHostByIndex(index);
      }
    }
    this.notify();
  }

  /**
   * If all FLPs are selected than deselect them
   * Else select all FLPs
   */
  toggleAllFLPSelection() {
    this.workflow.form.hosts = this.areAllFLPsSelected() ? [] : JSON.parse(JSON.stringify(this.list.payload));
    this.notify();
  }

  /**
   * Check if all FLPs are selected
   * @return {boolean}
   */
  areAllFLPsSelected() {
    return this.list.isSuccess() && this.workflow.form.hosts.length === this.list.payload.length;
  }

  /**
   * Remove a detector and its corresponding hosts
   * @param {String} detector
   */
  removeHostsByDetector(detector) {
    if (this.hostsByDetectors[detector]) {
      this.hostsByDetectors[detector].forEach((host) => {
        // Delete hosts of the detector from form selection
        const index = this.workflow.form.hosts.indexOf(host);
        if (index >= 0) {
          this.workflow.form.hosts.splice(index, 1);
        }
      })
      delete this.hostsByDetectors[detector];

      let temp = []
      // update list of displayed hosts with remaining ones
      Object.keys(this.hostsByDetectors).forEach((detector) => temp = temp.concat(this.hostsByDetectors[detector]))
      this.list = RemoteData.success(temp);
      this.notify();
    }
  }

  /**
   * Method to return the name of the detector to which a given host name belongs to
   * @param {String} host 
   */
  getDetectorForHost(host) {
    let detectorForHost = '';
    Object.keys(this.hostsByDetectors).forEach((detector) => {
      const hosts = this.hostsByDetectors[detector];
      if (hosts.includes(host)) {
        detectorForHost = detector;
      }
    });
    return detectorForHost;
  }

  /**
   * Given a detector name, build a string containing the name and number of selected hosts
   * and available hosts for that detector
   * @param {String} detector
   * @returns {String}
   */
  getDetectorWithIndexes(detector) {
    const hostsByDetectorRemote = this.workflow.model.detectors.hostsByDetectorRemote;
    if (hostsByDetectorRemote.isSuccess() && hostsByDetectorRemote.payload[detector]) {
      const hosts = hostsByDetectorRemote.payload[detector];
      const selectedHosts = this.workflow.form.hosts;
      const totalSelected = selectedHosts.filter((host) => hosts.includes(host)).length;

      return detector + ' (' + totalSelected + '/' + hosts.length + ')'
    }
    return detector;
  }

  /**
   * Given a detector name, if hosts were successfully loaded on page load,
   * update the list of hosts by adding the ones for the given detector
   * If specified via shouldSelect, it will also add the hosts to the form so that they appeared
   * as selected for the user
   * @param {String} detector
   */
  setHostsForDetector(detector, shouldSelect = false) {
    const hostsByDetectorRemote = this.workflow.model.detectors.hostsByDetectorRemote;
    if (!hostsByDetectorRemote.isSuccess()) {
      this.list = RemoteData.failure(hostsByDetectorRemote.message);
    } else {
      this.hostsByDetectors[detector] = hostsByDetectorRemote.payload[detector];
      let temp = [];
      Object.keys(this.hostsByDetectors).forEach((detector) => temp = temp.concat(this.hostsByDetectors[detector]));
      this.list = RemoteData.success(temp);
      if (shouldSelect) {
        this.hostsByDetectors[detector].forEach((hostname) => this.workflow.form.addHost(hostname));
      }
    }
    this.notify();
  }

  /**
   * Handler for lock state changes so that it automatically unselects detectors that are no longer locked by the current user.
   * This method will be called either by:
   * * changes triggered by the user on the lock button of a detector panel/locks page
   * * changes triggered by a different user and received via websocket subscription to lock changes
   * In all cases, if a detector is no longer locked by the current user, it will be unselected from the workflow and its hosts will be removed from the form selection.
   * @private
   * @returns {void}
   */
  _handleLockChanges() {
    this.selectedDetectors
      .filter((detector) => !this.workflow.model.lock.isLockedByCurrentUser(detector))
      .forEach((detector) => {
        if (this.selectedDetectors.includes(detector)) {
          this.toggleDetectorSelection(detector, false);
        }
      });
    this.notify();
  }
}