ExternalVendorCode/openmct
1
0
Fork 0
mirror of https://github.com/nasa/openmct.git synced 2025-02-24 18:50:47 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Removed conditions as domain objects

Browse Source
This commit is contained in:
Joshi 2020-03-12 12:33:04 -07:00
parent a7e57c62f4
commit 02cd3048c8
11 changed files with 177 additions and 247 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
src/plugins/condition/Condition.js
View File

@ -28,10 +28,7 @@ import {computeCondition} from "./utils/evaluator";
/* /*
* conditionConfiguration = { * conditionConfiguration = {
* identifier: { * id: uuid,
* key: '',
* namespace: ''
* },
* trigger: 'any'/'all', * trigger: 'any'/'all',
* criteria: [ * criteria: [
* { * {
@ -48,14 +45,14 @@ export default class ConditionClass extends EventEmitter {
/** /**
* Manages criteria and emits the result of - true or false - based on criteria evaluated. * Manages criteria and emits the result of - true or false - based on criteria evaluated.
* @constructor * @constructor
* @param conditionConfiguration: {identifier: {domainObject.identifier},trigger: enum, criteria: Array of {id: uuid, operation: enum, input: Array, metaDataKey: string, key: {domainObject.identifier} } * @param conditionConfiguration: {id: uuid,trigger: enum, criteria: Array of {id: uuid, operation: enum, input: Array, metaDataKey: string, key: {domainObject.identifier} }
* @param openmct * @param openmct
*/ */
constructor(conditionConfiguration, openmct) { constructor(conditionConfiguration, openmct) {
super(); super();
this.openmct = openmct; this.openmct = openmct;
this.id = this.openmct.objects.makeKeyString(conditionConfiguration.identifier); this.id = conditionConfiguration.id;
this.criteria = []; this.criteria = [];
this.criteriaResults = {}; this.criteriaResults = {};
this.result = undefined; this.result = undefined;
@ -63,16 +60,11 @@ export default class ConditionClass extends EventEmitter {
this.createCriteria(conditionConfiguration.configuration.criteria); this.createCriteria(conditionConfiguration.configuration.criteria);
} }
this.trigger = conditionConfiguration.configuration.trigger; this.trigger = conditionConfiguration.configuration.trigger;
this.openmct.objects.get(this.id).then(obj => this.observeForChanges(obj));
} }
observeForChanges(conditionDO) { update(conditionConfiguration) {
this.stopObservingForChanges = this.openmct.objects.observe(conditionDO, '*', this.update.bind(this)); this.updateTrigger(conditionConfiguration.configuration.trigger);
} this.updateCriteria(conditionConfiguration.configuration.criteria);
update(newDomainObject) {
this.updateTrigger(newDomainObject.configuration.trigger);
this.updateCriteria(newDomainObject.configuration.criteria);
} }
updateTrigger(trigger) { updateTrigger(trigger) {

200
src/plugins/condition/ConditionManager.js
View File

@ -25,10 +25,10 @@ import uuid from "uuid";
import EventEmitter from 'EventEmitter'; import EventEmitter from 'EventEmitter';
export default class ConditionManager extends EventEmitter { export default class ConditionManager extends EventEmitter {
constructor(domainObject, openmct) { constructor(conditionSetDomainObject, openmct) {
super(); super();
this.openmct = openmct; this.openmct = openmct;
this.domainObject = domainObject; this.conditionSetDomainObject = conditionSetDomainObject;
this.timeAPI = this.openmct.time; this.timeAPI = this.openmct.time;
this.latestTimestamp = {}; this.latestTimestamp = {};
this.instantiate = this.openmct.$injector.get('instantiate'); this.instantiate = this.openmct.$injector.get('instantiate');
@ -37,59 +37,61 @@ export default class ConditionManager extends EventEmitter {
initialize() { initialize() {
this.conditionResults = {}; this.conditionResults = {};
this.observeForChanges(this.domainObject); this.conditionClassCollection = [];
this.conditionCollection = []; if (this.conditionSetDomainObject.configuration.conditionCollection.length) {
if (this.domainObject.configuration.conditionCollection.length) { this.conditionSetDomainObject.configuration.conditionCollection.forEach((conditionConfiguration, index) => {
this.domainObject.configuration.conditionCollection.forEach((conditionConfigurationId, index) => { this.initCondition(conditionConfiguration, index);
this.openmct.objects.get(conditionConfigurationId).then((conditionConfiguration) => {
this.initCondition(conditionConfiguration, index)
}); });
});
} else {
this.addCondition(true);
} }
} }
observeForChanges(domainObject) { // observeForChanges(conditionSetDomainObject) {
//TODO: Observe only the conditionCollection property instead of the whole domainObject // this.stopObservingForChanges = this.openmct.objects.observe(conditionSetDomainObject, 'configuration.conditionCollection', this.handleConditionCollectionUpdated.bind(this));
this.stopObservingForChanges = this.openmct.objects.observe(domainObject, '*', this.handleConditionCollectionUpdated.bind(this)); // }
} //
// handleConditionCollectionUpdated(newConditionCollection) {
handleConditionCollectionUpdated(newDomainObject) { // // let oldConditionIds = this.conditionSetDomainObject.configuration.conditionCollection.map((conditionConfiguration) => {
let oldConditionIdentifiers = this.domainObject.configuration.conditionCollection.map((conditionConfigurationId) => { // // return conditionConfiguration.id;
return this.openmct.objects.makeKeyString(conditionConfigurationId); // // });
}); // // let newConditionIds = newConditionCollection.map((conditionConfiguration) => {
let newConditionIdentifiers = newDomainObject.configuration.conditionCollection.map((conditionConfigurationId) => { // // return conditionConfiguration.id;
return this.openmct.objects.makeKeyString(conditionConfigurationId); // // });
}); //
// this.conditionSetDomainObject.configuration.conditionCollection = newConditionCollection;
this.domainObject = newDomainObject; //
// // //check for removed conditions
//check for removed conditions // // oldConditionIds.forEach((id, index) => {
oldConditionIdentifiers.forEach((identifier, index) => { // // if (newConditionIds.indexOf(id) < 0) {
if (newConditionIdentifiers.indexOf(identifier) < 0) { // // this.removeCondition(id);
this.removeCondition(identifier); // // }
} // // });
}); //
// // const conditionSetDOConditionCollection = this.conditionSetDomainObject.configuration.conditionCollection;
let newConditionCount = this.domainObject.configuration.conditionCollection.length - this.conditionCollection.length; // //should not need to check for removed conditions since this happens from the ConditionManager itself
//
for (let i = 0; i < newConditionCount; i++) { // for (let i = 0; i < newConditionCollection.length; i++) {
let conditionConfigurationId = this.domainObject.configuration.conditionCollection[i]; // const conditionConfiguration = newConditionCollection[i];
this.openmct.objects.get(conditionConfigurationId).then((conditionConfiguration) => { // const found = this.findConditionById(conditionConfiguration.id);
this.initCondition(conditionConfiguration, i); // if (!found) {
}); // this.initCondition(conditionConfiguration, i);
} // }
// }
// }
updateCondition(conditionConfiguration, index) {
let condition = this.conditionClassCollection[index];
condition.update(conditionConfiguration);
this.conditionSetDomainObject.configuration.conditionCollection[index] = conditionConfiguration;
this.persistConditions();
} }
initCondition(conditionConfiguration, index) { initCondition(conditionConfiguration, index) {
let condition = new Condition(conditionConfiguration, this.openmct); let condition = new Condition(conditionConfiguration, this.openmct);
condition.on('conditionResultUpdated', this.handleConditionResult.bind(this)); condition.on('conditionResultUpdated', this.handleConditionResult.bind(this));
if (index !== undefined) { if (index !== undefined) {
this.conditionCollection.splice(index + 1, 0, condition); this.conditionClassCollection.splice(index + 1, 0, condition);
} else { } else {
this.conditionCollection.unshift(condition); this.conditionClassCollection.unshift(condition);
} }
//There are no criteria for a default condition and hence no subscriptions. //There are no criteria for a default condition and hence no subscriptions.
//Hence the conditionResult must be manually triggered for it. //Hence the conditionResult must be manually triggered for it.
@ -98,30 +100,23 @@ export default class ConditionManager extends EventEmitter {
} }
} }
createConditionDomainObject(isDefault, conditionConfiguration) { createCondition(conditionConfiguration) {
let conditionObj; let conditionObj;
if (conditionConfiguration) { if (conditionConfiguration) {
conditionObj = { conditionObj = {
...conditionConfiguration, ...conditionConfiguration,
name: `Copy of ${conditionConfiguration.name}`, name: `Copy of ${conditionConfiguration.name}`,
identifier: { id: uuid()
...this.domainObject.identifier,
key: uuid()
}
}; };
} else { } else {
conditionObj = { conditionObj = {
isDefault: isDefault,
type: 'condition', type: 'condition',
identifier: { id: uuid(),
...this.domainObject.identifier,
key: uuid()
},
configuration: { configuration: {
name: isDefault ? 'Default' : 'Unnamed Condition', name: 'Unnamed Condition',
output: 'false', output: 'false',
trigger: 'all', trigger: 'all',
criteria: isDefault ? [] : [{ criteria: [{
telemetry: '', telemetry: '',
operation: '', operation: '',
input: [], input: [],
@ -131,58 +126,52 @@ export default class ConditionManager extends EventEmitter {
summary: '' summary: ''
}; };
} }
let conditionDomainObjectKeyString = this.openmct.objects.makeKeyString(conditionObj.identifier);
let newDomainObject = this.instantiate(conditionObj, conditionDomainObjectKeyString);
return newDomainObject.useCapability('adapter'); return conditionObj;
} }
addCondition(isDefault, index) { addCondition() {
this.createAndSaveConditionDomainObject(!!isDefault, index); this.createAndSaveCondition();
} }
cloneCondition(conditionConfigurationId, index) { cloneCondition(conditionConfiguration, index) {
this.openmct.objects.get(conditionConfigurationId).then((conditionConfiguration) => { this.createAndSaveCondition(false, index, conditionConfiguration);
this.createAndSaveConditionDomainObject(false, index, conditionConfiguration);
});
} }
createAndSaveConditionDomainObject(isDefault, index, conditionConfiguration) { createAndSaveCondition(index, conditionConfiguration) {
let newConditionDomainObject = this.createConditionDomainObject(isDefault, conditionConfiguration); let newCondition = this.createCondition(conditionConfiguration);
//persist the condition domain object so that we can do an openmct.objects.get on it and only persist the identifier in the conditionCollection of conditionSet
this.openmct.objects.mutate(newConditionDomainObject, 'created', new Date());
if (index !== undefined) { if (index !== undefined) {
this.domainObject.configuration.conditionCollection.splice(index + 1, 0, newConditionDomainObject.identifier); this.conditionSetDomainObject.configuration.conditionCollection.splice(index + 1, 0, newCondition);
} else { } else {
this.domainObject.configuration.conditionCollection.unshift(newConditionDomainObject.identifier); this.conditionSetDomainObject.configuration.conditionCollection.unshift(newCondition);
} }
this.persist(); this.initCondition(newCondition, index);
this.persistConditions();
} }
removeCondition(identifier) { removeCondition(condition, index) {
let found = this.findConditionById(identifier); // const found = this.findConditionById(id);
if (found) { // if (found) {
let index = found.index; // const index = found.index;
let condition = this.conditionCollection[index]; // let condition = this.conditionClassCollection[index];
let conditionIdAsString = condition.id;
condition.destroyCriteria(); condition.destroyCriteria();
condition.off('conditionResultUpdated', this.handleConditionResult.bind(this)); condition.off('conditionResultUpdated', this.handleConditionResult.bind(this));
this.conditionCollection.splice(index, 1); this.conditionClassCollection.splice(index, 1);
this.domainObject.configuration.conditionCollection.splice(index, 1); this.conditionSetDomainObject.configuration.conditionCollection.splice(index, 1);
if (this.conditionResults[conditionIdAsString] !== undefined) { if (this.conditionResults[condition.id] !== undefined) {
delete this.conditionResults[conditionIdAsString]; delete this.conditionResults[condition.id];
} }
this.persist(); this.persistConditions();
this.handleConditionResult(); this.handleConditionResult();
} // }
} }
findConditionById(identifier) { findConditionById(id) {
let found; let found;
for (let i=0, ii=this.conditionCollection.length; i < ii; i++) { for (let i=0, ii=this.conditionClassCollection.length; i < ii; i++) {
if (this.conditionCollection[i].id === this.openmct.objects.makeKeyString(identifier)) { if (this.conditionClassCollection[i].id === id) {
found = { found = {
item: this.conditionCollection[i], item: this.conditionClassCollection[i],
index: i index: i
}; };
break; break;
@ -192,51 +181,48 @@ export default class ConditionManager extends EventEmitter {
return found; return found;
} }
//this.$set(this.conditionCollection, reorderEvent.newIndex, oldConditions[reorderEvent.oldIndex]); //this.$set(this.conditionClassCollection, reorderEvent.newIndex, oldConditions[reorderEvent.oldIndex]);
reorderConditions(reorderPlan) { reorderConditions(reorderPlan) {
let oldConditions = Array.from(this.domainObject.configuration.conditionCollection); let oldConditions = Array.from(this.conditionSetDomainObject.configuration.conditionCollection);
let newCollection = []; let newCollection = [];
reorderPlan.forEach((reorderEvent) => { reorderPlan.forEach((reorderEvent) => {
let item = oldConditions[reorderEvent.oldIndex]; let item = oldConditions[reorderEvent.oldIndex];
newCollection.push(item); newCollection.push(item);
this.domainObject.configuration.conditionCollection = newCollection; this.conditionSetDomainObject.configuration.conditionCollection = newCollection;
}); });
this.persist(); this.persistConditions();
} }
handleConditionResult(resultObj) { handleConditionResult(resultObj) {
let conditionCollection = this.domainObject.configuration.conditionCollection; const conditionCollection = this.conditionSetDomainObject.configuration.conditionCollection;
let currentConditionIdentifier = conditionCollection[conditionCollection.length-1]; let currentCondition = conditionCollection[conditionCollection.length-1];
if (resultObj) { if (resultObj) {
let idAsString = this.openmct.objects.makeKeyString(resultObj.id); const id = resultObj.id;
if (this.findConditionById(idAsString)) { if (this.findConditionById(id)) {
this.conditionResults[idAsString] = resultObj.data.result; this.conditionResults[id] = resultObj.data.result;
} }
this.updateTimestamp(resultObj.data); this.updateTimestamp(resultObj.data);
} }
for (let i = 0; i < conditionCollection.length - 1; i++) { for (let i = 0; i < conditionCollection.length - 1; i++) {
let conditionIdAsString = this.openmct.objects.makeKeyString(conditionCollection[i]); if (this.conditionResults[conditionCollection[i].id]) {
if (this.conditionResults[conditionIdAsString]) {
//first condition to be true wins //first condition to be true wins
currentConditionIdentifier = conditionCollection[i]; currentCondition = conditionCollection[i];
break; break;
} }
} }
this.openmct.objects.get(currentConditionIdentifier).then((obj) => {
this.emit('conditionSetResultUpdated', this.emit('conditionSetResultUpdated',
Object.assign( Object.assign(
{ {
output: obj.configuration.output, output: currentCondition.configuration.output,
id: this.domainObject.identifier, id: this.conditionSetDomainObject.identifier,
conditionId: currentConditionIdentifier conditionId: currentCondition.id
}, },
this.latestTimestamp this.latestTimestamp
) )
) )
});
} }
updateTimestamp(timestamp) { updateTimestamp(timestamp) {
@ -249,15 +235,15 @@ export default class ConditionManager extends EventEmitter {
}); });
} }
persist() { persistConditions() {
this.openmct.objects.mutate(this.domainObject, 'configuration.conditionCollection', this.domainObject.configuration.conditionCollection); this.openmct.objects.mutate(this.conditionSetDomainObject, 'configuration.conditionCollection', this.conditionSetDomainObject.configuration.conditionCollection);
} }
destroy() { destroy() {
if (typeof this.stopObservingForChanges === 'function') { if (typeof this.stopObservingForChanges === 'function') {
this.stopObservingForChanges(); this.stopObservingForChanges();
} }
this.conditionCollection.forEach((condition) => { this.conditionClassCollection.forEach((condition) => {
condition.off('conditionResultUpdated', this.handleConditionResult); condition.off('conditionResultUpdated', this.handleConditionResult);
condition.destroy(); condition.destroy();
}) })

15
src/plugins/condition/ConditionManagerSpec.js
View File

@ -38,13 +38,10 @@ describe('ConditionManager', () => {
conditionCollection: [] conditionCollection: []
} }
}; };
let mockConditionDomainObject = { let mockCondition = {
isDefault: true, isDefault: true,
type: 'condition', type: 'condition',
identifier: { id: '1234-5678'
namespace: '',
key: '1234-5678'
}
}; };
function mockAngularComponents() { function mockAngularComponents() {
@ -55,7 +52,7 @@ describe('ConditionManager', () => {
let mockDomainObject = { let mockDomainObject = {
useCapability: function () { useCapability: function () {
return mockConditionDomainObject; return mockCondition;
} }
}; };
mockInstantiate.and.callFake(function () { mockInstantiate.and.callFake(function () {
@ -78,7 +75,7 @@ describe('ConditionManager', () => {
openmct.objects.get.and.returnValues(new Promise(function (resolve, reject) { openmct.objects.get.and.returnValues(new Promise(function (resolve, reject) {
resolve(conditionSetDomainObject); resolve(conditionSetDomainObject);
}), new Promise(function (resolve, reject) { }), new Promise(function (resolve, reject) {
resolve(mockConditionDomainObject); resolve(mockCondition);
})); }));
openmct.objects.makeKeyString.and.returnValue(conditionSetDomainObject.identifier.key); openmct.objects.makeKeyString.and.returnValue(conditionSetDomainObject.identifier.key);
openmct.objects.observe.and.returnValue(function () {}); openmct.objects.observe.and.returnValue(function () {});
@ -91,8 +88,8 @@ describe('ConditionManager', () => {
it('creates a conditionCollection with a default condition', function () { it('creates a conditionCollection with a default condition', function () {
expect(conditionMgr.domainObject.configuration.conditionCollection.length).toEqual(1); expect(conditionMgr.domainObject.configuration.conditionCollection.length).toEqual(1);
let defaultConditionIdentifier = conditionMgr.domainObject.configuration.conditionCollection[0]; let defaultCondition = conditionMgr.domainObject.configuration.conditionCollection[0];
expect(defaultConditionIdentifier).toEqual(mockConditionDomainObject.identifier); expect(defaultCondition).toEqual(mockCondition);
}); });
}); });

6
src/plugins/condition/StyleRuleManager.js
View File

@ -64,15 +64,13 @@ export default class StyleRuleManager extends EventEmitter {
updateConditionStylesMap(conditionStyles) { updateConditionStylesMap(conditionStyles) {
let conditionStyleMap = {}; let conditionStyleMap = {};
conditionStyles.forEach((conditionStyle) => { conditionStyles.forEach((conditionStyle) => {
const identifier = this.openmct.objects.makeKeyString(conditionStyle.conditionIdentifier); conditionStyleMap[conditionStyle.conditionId] = conditionStyle.style;
conditionStyleMap[identifier] = conditionStyle.style;
}); });
this.conditionalStyleMap = conditionStyleMap; this.conditionalStyleMap = conditionStyleMap;
} }
handleConditionSetResultUpdated(resultData) { handleConditionSetResultUpdated(resultData) {
let identifier = this.openmct.objects.makeKeyString(resultData.conditionId); let foundStyle = this.conditionalStyleMap[resultData.conditionId];
let foundStyle = this.conditionalStyleMap[identifier];
if (foundStyle) { if (foundStyle) {
if (foundStyle !== this.currentStyle) { if (foundStyle !== this.currentStyle) {
this.currentStyle = foundStyle; this.currentStyle = foundStyle;

30
src/plugins/condition/components/Condition.vue
View File

@ -23,7 +23,6 @@
<template> <template>
<div v-if="isEditing" <div v-if="isEditing"
class="c-condition c-condition--edit js-condition-drag-wrapper" class="c-condition c-condition--edit js-condition-drag-wrapper"
:class="{ 'c-condition--current-match': currentConditionIdentifier && (currentConditionIdentifier.key === conditionIdentifier.key) }"
> >
<!-- Edit view --> <!-- Edit view -->
<div class="c-condition__header"> <div class="c-condition__header">
@ -150,7 +149,6 @@
</div> </div>
<div v-else <div v-else
class="c-condition c-condition--browse" class="c-condition c-condition--browse"
:class="{ 'c-condition--current': currentConditionIdentifier && (currentConditionIdentifier.key === conditionIdentifier.key) }"
> >
<!-- Browse view --> <!-- Browse view -->
<div class="c-condition__header"> <div class="c-condition__header">
@ -176,11 +174,7 @@ export default {
Criterion Criterion
}, },
props: { props: {
conditionIdentifier: { condition: {
type: Object,
required: true
},
currentConditionIdentifier: {
type: Object, type: Object,
required: true required: true
}, },
@ -215,10 +209,8 @@ export default {
this.destroy(); this.destroy();
}, },
mounted() { mounted() {
this.openmct.objects.get(this.conditionIdentifier).then((domainObject => { this.domainObject = this.condition;
this.domainObject = domainObject;
this.initialize(); this.initialize();
}));
}, },
methods: { methods: {
initialize() { initialize() {
@ -263,12 +255,15 @@ export default {
destroy() { destroy() {
}, },
removeCondition(ev) { removeCondition(ev) {
this.$emit('removeCondition', this.conditionIdentifier); this.$emit('removeCondition', {
condition: this.condition,
index: this.conditionIndex
});
}, },
cloneCondition(ev) { cloneCondition(ev) {
this.$emit('cloneCondition', { this.$emit('cloneCondition', {
identifier: this.conditionIdentifier, condition: this.condition,
index: Number(ev.target.closest('.widget-condition').getAttribute('data-condition-index')) index: this.conditionIndex
}); });
}, },
removeCriterion(index) { removeCriterion(index) {
@ -285,10 +280,13 @@ export default {
return this.currentCriteria && identifier; return this.currentCriteria && identifier;
}, },
persist() { persist() {
this.openmct.objects.mutate(this.domainObject, 'configuration', this.domainObject.configuration); this.$emit('updateCondition', {
condition: this.domainObject,
index: this.conditionIndex
});
}, },
initCap: function (string) { initCap: function (sentence) {
return string.charAt(0).toUpperCase() + string.slice(1) return sentence.charAt(0).toUpperCase() + sentence.slice(1)
} }
} }
} }

32
src/plugins/condition/components/ConditionCollection.vue
View File

@ -54,8 +54,8 @@
</button> </button>
<div class="c-cs__conditions-h"> <div class="c-cs__conditions-h">
<div v-for="(conditionIdentifier, index) in conditionCollection" <div v-for="(condition, index) in conditionCollection"
:key="conditionIdentifier.key" :key="condition.id"
class="c-condition-h" class="c-condition-h"
> >
<div v-if="isEditing" <div v-if="isEditing"
@ -65,11 +65,11 @@
@dragleave="dragLeave" @dragleave="dragLeave"
@dragover.prevent @dragover.prevent
></div> ></div>
<Condition :condition-identifier="conditionIdentifier" <Condition :condition="condition"
:current-condition-identifier="currentConditionIdentifier"
:condition-index="index" :condition-index="index"
:telemetry="telemetryObjs" :telemetry="telemetryObjs"
:is-editing="isEditing" :is-editing="isEditing"
@updateCondition="updateCondition"
@removeCondition="removeCondition" @removeCondition="removeCondition"
@cloneCondition="cloneCondition" @cloneCondition="cloneCondition"
@setMoveIndex="setMoveIndex" @setMoveIndex="setMoveIndex"
@ -95,11 +95,9 @@ export default {
data() { data() {
return { return {
expanded: true, expanded: true,
parentKeyString: this.openmct.objects.makeKeyString(this.domainObject.identifier),
conditionCollection: [], conditionCollection: [],
conditionResults: {}, conditionResults: {},
conditions: [], conditions: [],
currentConditionIdentifier: this.currentConditionIdentifier || {},
telemetryObjs: [], telemetryObjs: [],
moveIndex: Number, moveIndex: Number,
isDragging: false isDragging: false
@ -121,13 +119,13 @@ export default {
this.composition.on('remove', this.removeTelemetryObject); this.composition.on('remove', this.removeTelemetryObject);
this.composition.load(); this.composition.load();
this.conditionCollection = this.domainObject.configuration.conditionCollection; this.conditionCollection = this.domainObject.configuration.conditionCollection;
this.conditionManager = new ConditionManager(this.domainObject, this.openmct);
this.observeForChanges(); this.observeForChanges();
this.conditionManager = new ConditionManager(this.domainObject, this.openmct);
}, },
methods: { methods: {
observeForChanges() { observeForChanges() {
this.stopObservingForChanges = this.openmct.objects.observe(this.domainObject, '*', (newDomainObject) => { this.stopObservingForChanges = this.openmct.objects.observe(this.domainObject, 'configuration.conditionCollection', (newConditionCollection) => {
this.conditionCollection = newDomainObject.configuration.conditionCollection; this.conditionCollection = newConditionCollection;
}); });
}, },
setMoveIndex(index) { setMoveIndex(index) {
@ -189,20 +187,20 @@ export default {
this.telemetryObjs.splice(index, 1); this.telemetryObjs.splice(index, 1);
} }
}, },
addCondition(event, isDefault, index) { addCondition() {
this.conditionManager.addCondition(!!isDefault, index); this.conditionManager.addCondition();
}, },
updateCurrentCondition(identifier) { updateCondition(data) {
this.currentConditionIdentifier = identifier; this.conditionManager.updateCondition(data.condition, data.index);
}, },
removeCondition(identifier) { removeCondition(data) {
this.conditionManager.removeCondition(identifier); this.conditionManager.removeCondition(data.condition, data.index);
}, },
reorder(reorderPlan) { reorder(reorderPlan) {
this.conditionManager.reorderConditions(reorderPlan); this.conditionManager.reorderConditions(reorderPlan);
}, },
cloneCondition(condition) { cloneCondition(data) {
this.conditionManager.cloneCondition(condition.identifier, condition.index); this.conditionManager.cloneCondition(data.condition, data.index);
} }
} }
} }

1
src/plugins/condition/components/ConditionSet.vue
View File

@ -67,6 +67,7 @@ export default {
}, },
methods: { methods: {
updateCurrentOutput(currentConditionResult) { updateCurrentOutput(currentConditionResult) {
console.log(currentConditionResult);
this.currentConditionOutput = currentConditionResult.output; this.currentConditionOutput = currentConditionResult.output;
}, },
provideTelemetry() { provideTelemetry() {

18
src/plugins/condition/components/inspector/ConditionalStyle.vue
View File

@ -1,9 +1,9 @@
<template> <template>
<div> <div>
<div v-if="condition" <div v-if="conditionName"
class="holder c-c-button-wrapper align-left" class="holder c-c-button-wrapper align-left"
> >
<div>{{ condition.configuration.name }}</div> <div>{{ conditionName }}</div>
</div> </div>
</div> </div>
</template> </template>
@ -17,22 +17,12 @@ export default {
'openmct' 'openmct'
], ],
props: { props: {
conditionIdentifier: { conditionName: {
type: Object, type: String,
required: true required: true
} }
}, },
data() {
return {
condition: null
}
},
destroyed() { destroyed() {
},
mounted() {
this.openmct.objects.get(this.conditionIdentifier).then((conditionDomainObject) => {
this.condition = conditionDomainObject;
});
} }
} }
</script> </script>

15
src/plugins/condition/components/inspector/ConditionalStylesView.vue
View File

@ -21,9 +21,9 @@
</div> </div>
<ul> <ul>
<li v-for="conditionStyle in conditionalStyles" <li v-for="conditionStyle in conditionalStyles"
:key="conditionStyle.conditionIdentifier.key" :key="conditionStyle.conditionId"
> >
<conditional-style :condition-identifier="conditionStyle.conditionIdentifier" <conditional-style :condition-name="conditionStyle.conditionName"
:condition-style="conditionStyle.style" :condition-style="conditionStyle.style"
/> />
</li> </li>
@ -77,9 +77,10 @@ export default {
initializeConditionalStyles() { initializeConditionalStyles() {
const backgroundColors = [{backgroundColor: 'red'},{backgroundColor: 'orange'}, {backgroundColor: 'blue'}]; const backgroundColors = [{backgroundColor: 'red'},{backgroundColor: 'orange'}, {backgroundColor: 'blue'}];
this.openmct.objects.get(this.conditionSetIdentifier).then((conditionSetDomainObject) => { this.openmct.objects.get(this.conditionSetIdentifier).then((conditionSetDomainObject) => {
conditionSetDomainObject.configuration.conditionCollection.forEach((identifier, index) => { conditionSetDomainObject.configuration.conditionCollection.forEach((conditionConfiguration, index) => {
this.conditionalStyles.push({ this.conditionalStyles.push({
conditionIdentifier: identifier, conditionId: conditionConfiguration.id,
conditionName: conditionConfiguration.name,
style: backgroundColors[index] style: backgroundColors[index]
}); });
}); });
@ -92,7 +93,7 @@ export default {
}, },
findStyleByConditionId(id) { findStyleByConditionId(id) {
for(let i=0, ii=this.conditionalStyles.length; i < ii; i++) { for(let i=0, ii=this.conditionalStyles.length; i < ii; i++) {
if (this.openmct.objects.makeKeyString(this.conditionalStyles[i].conditionIdentifier) === this.openmct.objects.makeKeyString(id)) { if (this.conditionalStyles[i].conditionId === id) {
return { return {
index: i, index: i,
item: this.conditionalStyles[i] item: this.conditionalStyles[i]
@ -100,8 +101,8 @@ export default {
} }
} }
}, },
updateConditionalStyle(conditionIdentifier, style) { updateConditionalStyle(conditionId, style) {
let found = this.findStyleByConditionId(conditionIdentifier); let found = this.findStyleByConditionId(conditionId);
if (found) { if (found) {
this.conditionalStyles[found.index].style = style; this.conditionalStyles[found.index].style = style;
} }

23
src/plugins/condition/plugin.js
View File

@ -23,19 +23,11 @@ import ConditionSetViewProvider from './ConditionSetViewProvider.js';
import ConditionSetCompositionPolicy from "./ConditionSetCompositionPolicy"; import ConditionSetCompositionPolicy from "./ConditionSetCompositionPolicy";
import ConditionSetMetadataProvider from './ConditionSetMetadataProvider'; import ConditionSetMetadataProvider from './ConditionSetMetadataProvider';
import ConditionSetTelemetryProvider from './ConditionSetTelemetryProvider'; import ConditionSetTelemetryProvider from './ConditionSetTelemetryProvider';
import uuid from "uuid";
export default function ConditionPlugin() { export default function ConditionPlugin() {
return function install(openmct) { return function install(openmct) {
openmct.types.addType('condition', {
name: 'Condition',
key: 'condition',
description: 'A list of criteria which will be evaluated based on a trigger',
creatable: false,
initialize: function (domainObject) {
domainObject.composition = [];
}
});
openmct.types.addType('conditionSet', { openmct.types.addType('conditionSet', {
name: 'Condition Set', name: 'Condition Set',
@ -45,7 +37,18 @@ export default function ConditionPlugin() {
cssClass: 'icon-conditional', // TODO: replace with class for new icon cssClass: 'icon-conditional', // TODO: replace with class for new icon
initialize: function (domainObject) { initialize: function (domainObject) {
domainObject.configuration = { domainObject.configuration = {
conditionCollection: [] conditionCollection: [{
isDefault: true,
type: 'condition',
id: uuid(),
configuration: {
name: 'Default',
output: 'false',
trigger: 'all',
criteria: []
},
summary: 'Default condition'
}]
}; };
domainObject.composition = []; domainObject.composition = [];
domainObject.telemetry = {}; domainObject.telemetry = {};

44
src/plugins/condition/pluginSpec.js
View File

@ -26,26 +26,14 @@ import ConditionPlugin from "./plugin";
let openmct = createOpenMct(); let openmct = createOpenMct();
openmct.install(new ConditionPlugin()); openmct.install(new ConditionPlugin());
let conditionDefinition;
let conditionSetDefinition; let conditionSetDefinition;
let mockDomainObject; let mockConditionSetDomainObject;
let mockDomainObject2;
let element; let element;
let child; let child;
describe('the plugin', function () { describe('the plugin', function () {
beforeAll((done) => { beforeAll((done) => {
conditionDefinition = openmct.types.get('condition').definition;
mockDomainObject = {
identifier: {
key: 'testConditionKey',
namespace: ''
},
type: 'condition'
};
conditionDefinition.initialize(mockDomainObject);
conditionSetDefinition = openmct.types.get('conditionSet').definition; conditionSetDefinition = openmct.types.get('conditionSet').definition;
const appHolder = document.createElement('div'); const appHolder = document.createElement('div');
@ -56,7 +44,7 @@ describe('the plugin', function () {
child = document.createElement('div'); child = document.createElement('div');
element.appendChild(child); element.appendChild(child);
mockDomainObject2 = { mockConditionSetDomainObject = {
identifier: { identifier: {
key: 'testConditionSetKey', key: 'testConditionSetKey',
namespace: '' namespace: ''
@ -64,22 +52,12 @@ describe('the plugin', function () {
type: 'conditionSet' type: 'conditionSet'
}; };
conditionSetDefinition.initialize(mockDomainObject2); conditionSetDefinition.initialize(mockConditionSetDomainObject);
openmct.on('start', done); openmct.on('start', done);
openmct.start(appHolder); openmct.start(appHolder);
}); });
let mockConditionObject = {
name: 'Condition',
key: 'condition',
creatable: false
};
it('defines a condition object type with the correct key', () => {
expect(conditionDefinition.key).toEqual(mockConditionObject.key);
});
let mockConditionSetObject = { let mockConditionSetObject = {
name: 'Condition Set', name: 'Condition Set',
key: 'conditionSet', key: 'conditionSet',
@ -90,18 +68,6 @@ describe('the plugin', function () {
expect(conditionSetDefinition.key).toEqual(mockConditionSetObject.key); expect(conditionSetDefinition.key).toEqual(mockConditionSetObject.key);
}); });
describe('the condition object', () => {
it('is not creatable', () => {
expect(conditionDefinition.creatable).toEqual(mockConditionObject.creatable);
});
it('initializes with an empty composition list', () => {
expect(mockDomainObject.composition instanceof Array).toBeTrue();
expect(mockDomainObject.composition.length).toEqual(0);
});
});
describe('the conditionSet object', () => { describe('the conditionSet object', () => {
it('is creatable', () => { it('is creatable', () => {
@ -109,8 +75,8 @@ describe('the plugin', function () {
}); });
it('initializes with an empty composition list', () => { it('initializes with an empty composition list', () => {
expect(mockDomainObject2.composition instanceof Array).toBeTrue(); expect(mockConditionSetDomainObject.composition instanceof Array).toBeTrue();
expect(mockDomainObject2.composition.length).toEqual(0); expect(mockConditionSetDomainObject.composition.length).toEqual(0);
}); });
it('provides a view', () => { it('provides a view', () => {