policies.ts

/* eslint-disable comma-dangle */
/* eslint-disable prefer-const */
/* eslint-disable no-invalid-this */
/* eslint-disable require-jsdoc */
import * as Utils from '../utils.js';
import * as API from '../api.js';
import * as Things from '../things/things.js';
import {TabHandler} from '../utils/tabHandler.js';
import policyTemplates from './policyTemplates.json';
import policyHTML from './policies.html';
import * as ace from 'ace-builds/src-noconflict/ace';


let thePolicy;
let selectedEntry;
let selectedSubject;
let selectedResource;

let tabHandler;

let dom = {
  inputPolicyId: null,
  inputPolicyEntry: null,
  inputSubjectId: null,
  inputResourceId: null,
  tbodyPolicyEntries: null,
  tbodyPolicySubjects: null,
  tbodyPolicyResources: null,
  tbodyWhoami: null,
  buttonLoadPolicy: null,
  buttonCreatePolicyEntry: null,
  buttonDeletePolicyEntry: null,
  buttonCreatePolicySubject: null,
  buttonDeletePolicySubject: null,
  buttonSavePolicySubject: null,
  buttonCreatePolicyResource: null,
  buttonDeletePolicyResource: null,
  buttonSavePolicyResource: null,
  tableValidationEntries: null,
  tableValidationSubjects: null,
  tableValidationResources: null,
  collapsePolicies: null,
  ulResourceTemplates: null,
  tabPolicies: null,
};

let subjectEditor: ace.Editor;
let resourceEditor: ace.Editor;

document.getElementById('policyHTML').innerHTML = policyHTML;

export function ready() {
  Utils.getAllElementsById(dom);
  tabHandler = TabHandler(dom.tabPolicies, dom.collapsePolicies, refreshAll, 'disablePolicies');

  Utils.addDropDownEntries(dom.ulResourceTemplates, Object.keys(policyTemplates.resources));

  Utils.addValidatorToTable(dom.tbodyPolicyEntries, dom.tableValidationEntries);
  Utils.addValidatorToTable(dom.tbodyPolicySubjects, dom.tableValidationSubjects);
  Utils.addValidatorToTable(dom.tbodyPolicySubjects, dom.tableValidationResources);

  subjectEditor = Utils.createAceEditor('subjectEditor', 'ace/mode/json');
  resourceEditor = Utils.createAceEditor('resourceEditor', 'ace/mode/json');

  dom.buttonLoadPolicy.onclick = () => {
    Utils.assert(dom.inputPolicyId.value, 'Please enter a policyId', dom.inputPolicyId);
    refreshPolicy(dom.inputPolicyId.value);
  };

  // Entries

  dom.tbodyPolicyEntries.onclick = (event) => {
    if (selectedEntry === event.target.textContent) {
      selectedEntry = null;
      selectedResource = null;
      selectedSubject = null;
      Utils.tableAdjustSelection(dom.tbodyWhoami, () => false);
      setEntry(null);
    } else {
      selectedEntry = event.target.textContent;
      setEntry(thePolicy, selectedEntry);
    }
  };

  dom.buttonCreatePolicyEntry.onclick = () => {
    validations(true);
    Utils.assert(!Object.keys(thePolicy.entries).includes(dom.inputPolicyEntry.value),
        `Entry with label ${dom.inputPolicyEntry.value} already exists`, dom.inputPolicyEntry);
    selectedEntry = dom.inputPolicyEntry.value;
    putOrDeletePolicyEntry(dom.inputPolicyEntry.value, {subjects: {}, resources: {}});
  };

  dom.buttonDeletePolicyEntry.onclick = () => {
    validations(false, true);
    putOrDeletePolicyEntry(selectedEntry);
  };

  // Subjects --------

  dom.tbodyPolicySubjects.onclick = (event) => {
    if (selectedSubject === event.target.parentNode.id) {
      selectedSubject = null;
      Utils.tableAdjustSelection(dom.tbodyWhoami, () => false);
      subjectEditor.setValue('');
    } else {
      selectedSubject = event.target.parentNode.id;
      Utils.tableAdjustSelection(dom.tbodyWhoami, (row) => row.id === selectedSubject);
      subjectEditor.setValue(
          JSON.stringify(thePolicy.entries[selectedEntry].subjects[selectedSubject], null, 2), -1);
    }
    dom.inputSubjectId.value = selectedSubject;
  };

  dom.buttonCreatePolicySubject.onclick = () => {
    validations(false, true, true);
    Utils.assert(!Object.keys(thePolicy.entries[selectedEntry].subjects).includes(dom.inputSubjectId.value),
        `Subject already exists`, dom.inputSubjectId);
    selectedSubject = dom.inputSubjectId.value;
    modifyPolicyEntry('/subjects/', dom.inputSubjectId.value,
        subjectEditor.getValue() !== '' ?
        JSON.parse(subjectEditor.getValue()) :
        {type: 'generated'});
  };

  dom.buttonSavePolicySubject.onclick = () => {
    validations(false, true, false, true);
    if (dom.inputSubjectId.value === selectedSubject) {
      modifyPolicyEntry('/subjects/', selectedSubject, JSON.parse(subjectEditor.getValue()));
    } else {
      modifyPolicyEntry('/subjects/', selectedSubject);
      selectedSubject = dom.inputSubjectId.value;
      modifyPolicyEntry('/subjects/', dom.inputSubjectId.value,
          subjectEditor.getValue() !== '' ?
          JSON.parse(subjectEditor.getValue()) :
          {type: 'generated'});
    }
  };

  dom.buttonDeletePolicySubject.onclick = () => {
    validations(false, true, false, true);
    modifyPolicyEntry('/subjects/', selectedSubject);
  };

  // Resources -----------

  dom.tbodyPolicyResources.onclick = (event) => {
    if (selectedResource === event.target.parentNode.id) {
      selectedResource = null;
      resourceEditor.setValue('');
    } else {
      selectedResource = event.target.parentNode.id;
      resourceEditor.setValue(
          JSON.stringify(thePolicy.entries[selectedEntry].resources[selectedResource], null, 2), -1);
    }
    dom.inputResourceId.value = selectedResource;
  };

  dom. buttonCreatePolicyResource.onclick = () => {
    validations(false, true, false, false, true);
    Utils.assert(!Object.keys(thePolicy.entries[selectedEntry].resources).includes(dom.inputResourceId.value),
        `Resource already exists`, dom.inputResourceId);
    selectedResource = dom.inputResourceId.value;
    modifyPolicyEntry('/resources/', dom.inputResourceId.value,
        resourceEditor.getValue() !== '' ?
        JSON.parse(resourceEditor.getValue()) :
        {grant: ['READ', 'WRITE'], revoke: []});
  };

  dom.buttonSavePolicyResource.onclick = () => {
    validations(false, true, false, false, false, true);
    if (dom.inputResourceId.value === selectedResource) {
      modifyPolicyEntry('/resources/', selectedResource, JSON.parse(resourceEditor.getValue()));
    } else {
      modifyPolicyEntry('/resources/', selectedResource);
      selectedResource = dom.inputResourceId.value;
      modifyPolicyEntry('/resources/', dom.inputResourceId.value,
          resourceEditor.getValue() !== '' ?
          JSON.parse(resourceEditor.getValue()) :
          {grant: ['READ', 'WRITE'], revoke: []});
    }
  };

  dom.buttonDeletePolicyResource.onclick = () => {
    validations(false, true, false, false, false, true);
    modifyPolicyEntry('/resources/', selectedResource);
  };

  dom.ulResourceTemplates.addEventListener('click', (event) => {
    dom.inputResourceId.value = event.target.textContent;
    resourceEditor.setValue(JSON.stringify(policyTemplates.resources[dom.inputResourceId.value], null, 2), -1);
  });

  // WhoAmI -------------

  dom.tbodyWhoami.onclick = (event) => {
    dom.inputSubjectId.value = event.target.parentNode.id;
  };

  Things.addChangeListener(onThingChanged);
}

function validations(entryFilled, entrySelected = false, subjectFilled = false, subjectSelected = false, resourceFilled = false, resourceSelected = false) {
  Utils.assert(thePolicy, 'Please load a policy', dom.inputPolicyId);
  if (entryFilled) {
    Utils.assert(dom.inputPolicyEntry.value, 'Please enter a label for the entry', dom.inputPolicyEntry);
  }
  if (entrySelected) {
    Utils.assert(selectedEntry, 'Please select an entry', dom.tableValidationEntries);
  }
  if (subjectFilled) {
    Utils.assert(dom.inputSubjectId.value, 'Please enter a subject or select one above', dom.inputSubjectId);
  };
  if (subjectSelected) {
    Utils.assert(selectedSubject, 'Please select a subject', dom.tableValidationSubjects);
  };
  if (resourceFilled) {
    Utils.assert(dom.inputResourceId.value, 'Please enter a resource', dom.inputResourceId);
  };
  if (resourceSelected) {
    Utils.assert(selectedResource, 'Please select a resource', dom.tableValidationResources);
  };
}

function onThingChanged(thing) {
  dom.inputPolicyId.value = (thing && thing.policyId) ? thing.policyId : null;
  tabHandler.viewDirty = true;
}

function refreshWhoAmI() {
  dom.tbodyWhoami.innerHTML = '';
  API.callDittoREST('GET', '/whoami')
      .then((whoamiResult) => {
        whoamiResult.subjects.forEach((subject) => {
          Utils.addTableRow(dom.tbodyWhoami, subject, subject === selectedSubject, false,
            subject === whoamiResult.defaultSubject ? 'default' : '');
        });
      })
      .catch((error) => {
      });
};

function refreshPolicy(policyId) {
  API.callDittoREST('GET', '/policies/' + policyId)
      .then((policy) => setThePolicy(policy))
      .catch(() => setThePolicy(null));
};

function setThePolicy(policy) {
  thePolicy = policy;

  dom.tbodyPolicyEntries.innerHTML = '';
  dom.inputPolicyEntry.value = null;

  if (thePolicy) {
    let policyHasEntry = false;
    Object.keys(thePolicy.entries).forEach((key) => {
      Utils.addTableRow(dom.tbodyPolicyEntries, key, key === selectedEntry);
      if (key === selectedEntry) {
        dom.inputPolicyEntry.value = key;
        setEntry(thePolicy, key);
        policyHasEntry = true;
      }
    });
    if (!policyHasEntry) {
      selectedEntry = null;
      setEntry(null);
    }
  } else {
    dom.inputPolicyId.value = null;
    setEntry(null);
  }
};

function setEntry(policy, entryLabel = null) {
  dom.tbodyPolicySubjects.innerHTML = '';
  dom.tbodyPolicyResources.innerHTML = '';
  dom.inputSubjectId.value = null;
  dom.inputResourceId.value = null;
  subjectEditor.setValue('');
  resourceEditor.setValue('');
  if (policy) {
    dom.inputPolicyEntry.value = entryLabel;
    Object.keys(policy.entries[entryLabel].subjects).forEach((key) => {
      Utils.addTableRow(dom.tbodyPolicySubjects, key, key === selectedSubject, false,
          JSON.stringify(policy.entries[entryLabel].subjects[key])
      );
      if (key === selectedSubject) {
        dom.inputSubjectId.value = key;
        subjectEditor.setValue(JSON.stringify(policy.entries[entryLabel].subjects[key], null, 2), -1);
      }
    });
    Object.keys(policy.entries[entryLabel].resources).forEach((key) => {
      Utils.addTableRow(dom.tbodyPolicyResources, key, key === selectedResource, false,
          JSON.stringify(policy.entries[entryLabel].resources[key])
      );
      if (key === selectedResource) {
        dom.inputResourceId.value = key;
        resourceEditor.setValue(JSON.stringify(policy.entries[entryLabel].resources[key], null, 2), -1);
      }
    });
  }
};

function putOrDeletePolicyEntry(entry, value = null) {
  API.callDittoREST(value ? 'PUT' : 'DELETE',
      `/policies/${thePolicy.policyId}/entries/${entry}`,
      value
  ).then(() => refreshPolicy(thePolicy.policyId));
};

function modifyPolicyEntry(type, key, value = null) {
  API.callDittoREST(value ? 'PUT' : 'DELETE',
      `/policies/${thePolicy.policyId}/entries/${selectedEntry}${type}${key}`, value
  ).then(() => refreshPolicy(thePolicy.policyId));
};

function refreshAll(otherEnvironment) {
  refreshWhoAmI();
  if (otherEnvironment) {
    setThePolicy(null);
  }
  if (dom.inputPolicyId.value) {
    refreshPolicy(dom.inputPolicyId.value);
  }
}