From 92737b43aff7ce35c5ed6fba9b199280d27f66b3 Mon Sep 17 00:00:00 2001 From: Andrew Henry Date: Sun, 17 Jan 2021 14:15:09 -0800 Subject: [PATCH] [API] Changes to mutation API (#3483) Changes how object mutation works behind the scenes in order to keep objects in sync automatically when their model changes. * The way that objects are mutated and observed has not changed, openmct.objects.mutate and openmct.objects.observe should still be used in the same way that they were before. * Behind the scenes, domain objects that are mutable are wrapped in a new MutableDomainObject that exposes mutator and observer functions that allow objects to be mutated in such a way that all instances can be kept in sync. * It is now possible to retrieve MutableDomainObjects from the API, instead of regular domain objects. These are automatically updated when mutation occurs on any instance of the object, replacing the need for "*" listeners. Note that the view API now provides objects in this form by default. Therefore, you do not need to do anything differently in views, the domain objects will just magically keep themselves up to date. * If for some reason you need to retrieve an object manually via openmct.objects.get (you should ask why you need to do this) and you want it to magically keep itself in sync, there is a new API function named openmct.objects.getMutable(identifier). Note that if you do this you will be responsible for the object's lifecycle. It relies on listeners which must be destroyed when the object is no longer needed, otherwise memory leaks will occur. You can destroy a MutableDomainObject and its (internal) listeners by calling openmct.objects.destroyMutable(mutableDomainObject). Any listeners created by calls to openmct.objects.observe need to be cleaned up separately. * If the composition of a MutableDomainObject is retrieved using the Composition API, all children will be returned as MutableDomainObjects automatically. Their lifecycle will be managed automatically, and is tied to the lifecycle of the parent. Any MutableDomainObject provided by the Open MCT framework itself (eg. provided to view providers by the View API, or from the composition API) will have its lifecycle managed by Open MCT, you don't need to worry destroying it. --- .../policies/EditPersistableObjectsPolicy.js | 4 +- .../policies/EditPersistableObjectsSpec.js | 3 +- .../src/PersistableCompositionPolicy.js | 4 +- .../test/PersistableCompositionPolicySpec.js | 3 +- src/MCT.js | 4 +- .../services/LegacyObjectAPIInterceptor.js | 1 + src/api/actions/ActionCollectionSpec.js | 4 + src/api/composition/CompositionCollection.js | 44 +- src/api/objects/MutableDomainObject.js | 137 ++++ src/api/objects/MutableObject.js | 102 --- src/api/objects/ObjectAPI.js | 738 ++++++++++-------- src/api/objects/ObjectAPISpec.js | 134 +++- src/plugins/LADTable/LADTableViewProvider.js | 14 +- src/plugins/LADTable/components/LADRow.vue | 21 +- src/plugins/LADTable/components/LADTable.vue | 13 +- .../components/DisplayLayout.vue | 39 +- .../components/SubobjectView.vue | 15 +- .../components/TelemetryView.vue | 16 +- src/plugins/duplicate/pluginSpec.js | 2 + .../notebook/utils/notebook-entriesSpec.js | 7 + .../notebook/utils/notebook-storageSpec.js | 5 +- src/plugins/persistence/couch/pluginSpec.js | 4 +- src/plugins/tabs/components/tabs.vue | 2 +- src/plugins/telemetryTable/pluginSpec.js | 4 + src/selection/Selection.js | 13 +- src/ui/components/ObjectFrame.vue | 2 +- src/ui/components/ObjectLabel.vue | 18 +- src/ui/components/ObjectView.vue | 60 +- src/ui/inspector/Elements.vue | 11 - src/ui/layout/BrowseBar.vue | 8 - src/ui/router/Browse.js | 64 +- 31 files changed, 885 insertions(+), 611 deletions(-) create mode 100644 src/api/objects/MutableDomainObject.js delete mode 100644 src/api/objects/MutableObject.js diff --git a/platform/commonUI/edit/src/policies/EditPersistableObjectsPolicy.js b/platform/commonUI/edit/src/policies/EditPersistableObjectsPolicy.js index cbc5340b6b..5cb7f76df6 100644 --- a/platform/commonUI/edit/src/policies/EditPersistableObjectsPolicy.js +++ b/platform/commonUI/edit/src/policies/EditPersistableObjectsPolicy.js @@ -44,9 +44,9 @@ define( // is also invoked during the create process which should be allowed, // because it may be saved elsewhere if ((key === 'edit' && category === 'view-control') || key === 'properties') { - let newStyleObject = objectUtils.toNewFormat(domainObject, domainObject.getId()); + let identifier = this.openmct.objects.parseKeyString(domainObject.getId()); - return this.openmct.objects.isPersistable(newStyleObject); + return this.openmct.objects.isPersistable(identifier); } return true; diff --git a/platform/commonUI/edit/test/policies/EditPersistableObjectsSpec.js b/platform/commonUI/edit/test/policies/EditPersistableObjectsSpec.js index 92b0da2d36..8213c6253d 100644 --- a/platform/commonUI/edit/test/policies/EditPersistableObjectsSpec.js +++ b/platform/commonUI/edit/test/policies/EditPersistableObjectsSpec.js @@ -43,7 +43,8 @@ define( ); mockObjectAPI = jasmine.createSpyObj('objectAPI', [ - 'isPersistable' + 'isPersistable', + 'parseKeyString' ]); mockAPI = { diff --git a/platform/containment/src/PersistableCompositionPolicy.js b/platform/containment/src/PersistableCompositionPolicy.js index b18fa100bd..389fcb8f9f 100644 --- a/platform/containment/src/PersistableCompositionPolicy.js +++ b/platform/containment/src/PersistableCompositionPolicy.js @@ -48,9 +48,9 @@ define( // prevents editing of objects that cannot be persisted, so we can assume that this // is a new object. if (!(parent.hasCapability('editor') && parent.getCapability('editor').isEditContextRoot())) { - let newStyleObject = objectUtils.toNewFormat(parent, parent.getId()); + let identifier = this.openmct.objects.parseKeyString(parent.getId()); - return this.openmct.objects.isPersistable(newStyleObject); + return this.openmct.objects.isPersistable(identifier); } return true; diff --git a/platform/containment/test/PersistableCompositionPolicySpec.js b/platform/containment/test/PersistableCompositionPolicySpec.js index dcc2a928a5..6f9aa74bd6 100644 --- a/platform/containment/test/PersistableCompositionPolicySpec.js +++ b/platform/containment/test/PersistableCompositionPolicySpec.js @@ -33,7 +33,8 @@ define( beforeEach(function () { objectAPI = jasmine.createSpyObj('objectsAPI', [ - 'isPersistable' + 'isPersistable', + 'parseKeyString' ]); mockOpenMCT = { diff --git a/src/MCT.js b/src/MCT.js index 8e8f8ee215..c8120569ba 100644 --- a/src/MCT.js +++ b/src/MCT.js @@ -219,7 +219,7 @@ define([ * @memberof module:openmct.MCT# * @name objects */ - this.objects = new api.ObjectAPI(); + this.objects = new api.ObjectAPI.default(this.types); /** * An interface for retrieving and interpreting telemetry data associated @@ -371,7 +371,7 @@ define([ * MCT; if undefined, MCT will be run in the body of the document */ MCT.prototype.start = function (domElement = document.body, isHeadlessMode = false) { - if (!this.plugins.DisplayLayout._installed) { + if (this.types.get('layout') === undefined) { this.install(this.plugins.DisplayLayout({ showAsView: ['summary-widget'] })); diff --git a/src/adapter/services/LegacyObjectAPIInterceptor.js b/src/adapter/services/LegacyObjectAPIInterceptor.js index af9545078a..680646a77a 100644 --- a/src/adapter/services/LegacyObjectAPIInterceptor.js +++ b/src/adapter/services/LegacyObjectAPIInterceptor.js @@ -61,6 +61,7 @@ define([ const newStyleObject = utils.toNewFormat(legacyObject.getModel(), legacyObject.getId()); const keystring = utils.makeKeyString(newStyleObject.identifier); + this.eventEmitter.emit(keystring + ':$_synchronize_model', newStyleObject); this.eventEmitter.emit(keystring + ":*", newStyleObject); this.eventEmitter.emit('mutation', newStyleObject); }.bind(this); diff --git a/src/api/actions/ActionCollectionSpec.js b/src/api/actions/ActionCollectionSpec.js index c7a4cb0440..c5b3233844 100644 --- a/src/api/actions/ActionCollectionSpec.js +++ b/src/api/actions/ActionCollectionSpec.js @@ -50,6 +50,10 @@ describe('The ActionCollection', () => { } } ]; + openmct.objects.addProvider('', jasmine.createSpyObj('mockMutableObjectProvider', [ + 'create', + 'update' + ])); mockView = { getViewContext: () => { return { diff --git a/src/api/composition/CompositionCollection.js b/src/api/composition/CompositionCollection.js index fd1ec95834..16071ad69c 100644 --- a/src/api/composition/CompositionCollection.js +++ b/src/api/composition/CompositionCollection.js @@ -60,6 +60,17 @@ define([ }; this.onProviderAdd = this.onProviderAdd.bind(this); this.onProviderRemove = this.onProviderRemove.bind(this); + this.mutables = {}; + + if (this.domainObject.isMutable) { + this.returnMutables = true; + let unobserve = this.domainObject.$on('$_destroy', () => { + Object.values(this.mutables).forEach(mutable => { + this.publicAPI.objects.destroyMutable(mutable); + }); + unobserve(); + }); + } } /** @@ -75,10 +86,6 @@ define([ throw new Error('Event not supported by composition: ' + event); } - if (!this.mutationListener) { - this._synchronize(); - } - if (this.provider.on && this.provider.off) { if (event === 'add') { this.provider.on( @@ -189,6 +196,13 @@ define([ this.provider.add(this.domainObject, child.identifier); } else { + if (this.returnMutables && this.publicAPI.objects.supportsMutation(child)) { + let keyString = this.publicAPI.objects.makeKeyString(child.identifier); + + child = this.publicAPI.objects._toMutable(child); + this.mutables[keyString] = child; + } + this.emit('add', child); } }; @@ -202,6 +216,8 @@ define([ * @name load */ CompositionCollection.prototype.load = function () { + this.cleanUpMutables(); + return this.provider.load(this.domainObject) .then(function (children) { return Promise.all(children.map((c) => this.publicAPI.objects.get(c))); @@ -234,6 +250,14 @@ define([ if (!skipMutate) { this.provider.remove(this.domainObject, child.identifier); } else { + if (this.returnMutables) { + let keyString = this.publicAPI.objects.makeKeyString(child); + if (this.mutables[keyString] !== undefined && this.mutables[keyString].isMutable) { + this.publicAPI.objects.destroyMutable(this.mutables[keyString]); + delete this.mutables[keyString]; + } + } + this.emit('remove', child); } }; @@ -281,12 +305,6 @@ define([ this.remove(child, true); }; - CompositionCollection.prototype._synchronize = function () { - this.mutationListener = this.publicAPI.objects.observe(this.domainObject, '*', (newDomainObject) => { - this.domainObject = JSON.parse(JSON.stringify(newDomainObject)); - }); - }; - CompositionCollection.prototype._destroy = function () { if (this.mutationListener) { this.mutationListener(); @@ -308,5 +326,11 @@ define([ }); }; + CompositionCollection.prototype.cleanUpMutables = function () { + Object.values(this.mutables).forEach(mutable => { + this.publicAPI.objects.destroyMutable(mutable); + }); + }; + return CompositionCollection; }); diff --git a/src/api/objects/MutableDomainObject.js b/src/api/objects/MutableDomainObject.js new file mode 100644 index 0000000000..821f64df8d --- /dev/null +++ b/src/api/objects/MutableDomainObject.js @@ -0,0 +1,137 @@ +/***************************************************************************** + * Open MCT, Copyright (c) 2014-2020, United States Government + * as represented by the Administrator of the National Aeronautics and Space + * Administration. All rights reserved. + * + * Open MCT is licensed under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * http://www.apache.org/licenses/LICENSE-2.0. + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations + * under the License. + * + * Open MCT includes source code licensed under additional open source + * licenses. See the Open Source Licenses file (LICENSES.md) included with + * this source code distribution or the Licensing information page available + * at runtime from the About dialog for additional information. + *****************************************************************************/ +import _ from 'lodash'; +import utils from './object-utils.js'; +import EventEmitter from 'EventEmitter'; + +const ANY_OBJECT_EVENT = 'mutation'; + +/** + * Wraps a domain object to keep its model synchronized with other instances of the same object. + * + * Creating a MutableDomainObject will automatically register listeners to keep its model in sync. As such, developers + * should be careful to destroy MutableDomainObject in order to avoid memory leaks. + * + * All Open MCT API functions that provide objects will provide MutableDomainObjects where possible, except + * `openmct.objects.get()`, and will manage that object's lifecycle for you. Calling `openmct.objects.getMutable()` + * will result in the creation of a new MutableDomainObject and you will be responsible for destroying it + * (via openmct.objects.destroy) when you're done with it. + * + * @typedef MutableDomainObject + * @memberof module:openmct + */ +class MutableDomainObject { + constructor(eventEmitter) { + Object.defineProperties(this, { + _globalEventEmitter: { + value: eventEmitter, + // Property should not be serialized + enumerable: false + }, + _instanceEventEmitter: { + value: new EventEmitter(), + // Property should not be serialized + enumerable: false + }, + _observers: { + value: [], + // Property should not be serialized + enumerable: false + }, + isMutable: { + value: true, + // Property should not be serialized + enumerable: false + } + }); + } + $observe(path, callback) { + let fullPath = qualifiedEventName(this, path); + let eventOff = + this._globalEventEmitter.off.bind(this._globalEventEmitter, fullPath, callback); + + this._globalEventEmitter.on(fullPath, callback); + this._observers.push(eventOff); + + return eventOff; + } + $set(path, value) { + _.set(this, path, value); + _.set(this, 'modified', Date.now()); + + //Emit secret synchronization event first, so that all objects are in sync before subsequent events fired. + this._globalEventEmitter.emit(qualifiedEventName(this, '$_synchronize_model'), this); + + //Emit a general "any object" event + this._globalEventEmitter.emit(ANY_OBJECT_EVENT, this); + //Emit wildcard event, with path so that callback knows what changed + this._globalEventEmitter.emit(qualifiedEventName(this, '*'), this, path, value); + + //Emit events specific to properties affected + let parentPropertiesList = path.split('.'); + for (let index = parentPropertiesList.length; index > 0; index--) { + let parentPropertyPath = parentPropertiesList.slice(0, index).join('.'); + this._globalEventEmitter.emit(qualifiedEventName(this, parentPropertyPath), _.get(this, parentPropertyPath)); + } + + //TODO: Emit events for listeners of child properties when parent changes. + // Do it at observer time - also register observers for parent attribute path. + } + $on(event, callback) { + this._instanceEventEmitter.on(event, callback); + + return () => this._instanceEventEmitter.off(event, callback); + } + $destroy() { + this._observers.forEach(observer => observer()); + delete this._globalEventEmitter; + delete this._observers; + this._instanceEventEmitter.emit('$_destroy'); + } + + static createMutable(object, mutationTopic) { + let mutable = Object.create(new MutableDomainObject(mutationTopic)); + Object.assign(mutable, object); + + mutable.$observe('$_synchronize_model', (updatedObject) => { + let clone = JSON.parse(JSON.stringify(updatedObject)); + let deleted = _.difference(Object.keys(mutable), Object.keys(updatedObject)); + deleted.forEach((propertyName) => delete mutable[propertyName]); + Object.assign(mutable, clone); + }); + + return mutable; + } + + static mutateObject(object, path, value) { + _.set(object, path, value); + _.set(object, 'modified', Date.now()); + } +} + +function qualifiedEventName(object, eventName) { + let keystring = utils.makeKeyString(object.identifier); + + return [keystring, eventName].join(':'); +} + +export default MutableDomainObject; diff --git a/src/api/objects/MutableObject.js b/src/api/objects/MutableObject.js deleted file mode 100644 index a0875e34ae..0000000000 --- a/src/api/objects/MutableObject.js +++ /dev/null @@ -1,102 +0,0 @@ -/***************************************************************************** - * Open MCT, Copyright (c) 2014-2020, United States Government - * as represented by the Administrator of the National Aeronautics and Space - * Administration. All rights reserved. - * - * Open MCT is licensed under the Apache License, Version 2.0 (the - * "License"); you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * http://www.apache.org/licenses/LICENSE-2.0. - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT - * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the - * License for the specific language governing permissions and limitations - * under the License. - * - * Open MCT includes source code licensed under additional open source - * licenses. See the Open Source Licenses file (LICENSES.md) included with - * this source code distribution or the Licensing information page available - * at runtime from the About dialog for additional information. - *****************************************************************************/ - -define([ - 'objectUtils', - 'lodash' -], function ( - utils, - _ -) { - const ANY_OBJECT_EVENT = "mutation"; - - /** - * The MutableObject wraps a DomainObject and provides getters and - * setters for - * @param eventEmitter - * @param object - * @interface MutableObject - */ - function MutableObject(eventEmitter, object) { - this.eventEmitter = eventEmitter; - this.object = object; - this.unlisteners = []; - } - - function qualifiedEventName(object, eventName) { - const keystring = utils.makeKeyString(object.identifier); - - return [keystring, eventName].join(':'); - } - - MutableObject.prototype.stopListening = function () { - this.unlisteners.forEach(function (unlisten) { - unlisten(); - }); - this.unlisteners = []; - }; - - /** - * Observe changes to this domain object. - * @param {string} path the property to observe - * @param {Function} callback a callback to invoke when new values for - * this property are observed - * @method on - * @memberof module:openmct.MutableObject# - */ - MutableObject.prototype.on = function (path, callback) { - const fullPath = qualifiedEventName(this.object, path); - const eventOff = - this.eventEmitter.off.bind(this.eventEmitter, fullPath, callback); - - this.eventEmitter.on(fullPath, callback); - this.unlisteners.push(eventOff); - }; - - /** - * Modify this domain object. - * @param {string} path the property to modify - * @param {*} value the new value for this property - * @method set - * @memberof module:openmct.MutableObject# - */ - MutableObject.prototype.set = function (path, value) { - _.set(this.object, path, value); - _.set(this.object, 'modified', Date.now()); - - const handleRecursiveMutation = function (newObject) { - this.object = newObject; - }.bind(this); - - //Emit wildcard event - this.eventEmitter.emit(qualifiedEventName(this.object, '*'), this.object); - //Emit a general "any object" event - this.eventEmitter.emit(ANY_OBJECT_EVENT, this.object); - - this.eventEmitter.on(qualifiedEventName(this.object, '*'), handleRecursiveMutation); - //Emit event specific to property - this.eventEmitter.emit(qualifiedEventName(this.object, path), value); - this.eventEmitter.off(qualifiedEventName(this.object, '*'), handleRecursiveMutation); - }; - - return MutableObject; -}); diff --git a/src/api/objects/ObjectAPI.js b/src/api/objects/ObjectAPI.js index c2747be611..386adb8f6c 100644 --- a/src/api/objects/ObjectAPI.js +++ b/src/api/objects/ObjectAPI.js @@ -20,365 +20,425 @@ * at runtime from the About dialog for additional information. *****************************************************************************/ -define([ - 'lodash', - 'objectUtils', - './MutableObject', - './RootRegistry', - './RootObjectProvider', - './InterceptorRegistry', - 'EventEmitter' -], function ( - _, - utils, - MutableObject, - RootRegistry, - RootObjectProvider, - InterceptorRegistry, - EventEmitter -) { +import utils from 'objectUtils'; +import MutableDomainObject from './MutableDomainObject'; +import RootRegistry from './RootRegistry'; +import RootObjectProvider from './RootObjectProvider'; +import EventEmitter from 'EventEmitter'; +import InterceptorRegistry from './InterceptorRegistry'; - /** - * Utilities for loading, saving, and manipulating domain objects. - * @interface ObjectAPI - * @memberof module:openmct - */ +/** + * Utilities for loading, saving, and manipulating domain objects. + * @interface ObjectAPI + * @memberof module:openmct + */ - function ObjectAPI() { - this.eventEmitter = new EventEmitter(); - this.providers = {}; - this.rootRegistry = new RootRegistry(); - this.rootProvider = new RootObjectProvider.default(this.rootRegistry); - this.cache = {}; - this.interceptorRegistry = new InterceptorRegistry.default(); +function ObjectAPI(typeRegistry) { + this.typeRegistry = typeRegistry; + this.eventEmitter = new EventEmitter(); + this.providers = {}; + this.rootRegistry = new RootRegistry(); + this.rootProvider = new RootObjectProvider(this.rootRegistry); + this.cache = {}; + this.interceptorRegistry = new InterceptorRegistry(); +} + +/** + * Set fallback provider, this is an internal API for legacy reasons. + * @private + */ +ObjectAPI.prototype.supersecretSetFallbackProvider = function (p) { + this.fallbackProvider = p; +}; + +/** + * Retrieve the provider for a given identifier. + * @private + */ +ObjectAPI.prototype.getProvider = function (identifier) { + if (identifier.key === 'ROOT') { + return this.rootProvider; } - /** - * Set fallback provider, this is an internal API for legacy reasons. - * @private - */ - ObjectAPI.prototype.supersecretSetFallbackProvider = function (p) { - this.fallbackProvider = p; - }; + return this.providers[identifier.namespace] || this.fallbackProvider; +}; - /** - * Retrieve the provider for a given identifier. - * @private - */ - ObjectAPI.prototype.getProvider = function (identifier) { - if (identifier.key === 'ROOT') { - return this.rootProvider; - } +/** + * Get the root-level object. + * @returns {Promise.} a promise for the root object + */ +ObjectAPI.prototype.getRoot = function () { + return this.rootProvider.get(); +}; - return this.providers[identifier.namespace] || this.fallbackProvider; - }; +/** + * Register a new object provider for a particular namespace. + * + * @param {string} namespace the namespace for which to provide objects + * @param {module:openmct.ObjectProvider} provider the provider which + * will handle loading domain objects from this namespace + * @memberof {module:openmct.ObjectAPI#} + * @name addProvider + */ +ObjectAPI.prototype.addProvider = function (namespace, provider) { + this.providers[namespace] = provider; +}; - /** - * Get the root-level object. - * @returns {Promise.} a promise for the root object - */ - ObjectAPI.prototype.getRoot = function () { - return this.rootProvider.get(); - }; +/** + * Provides the ability to read, write, and delete domain objects. + * + * When registering a new object provider, all methods on this interface + * are optional. + * + * @interface ObjectProvider + * @memberof module:openmct + */ - /** - * Register a new object provider for a particular namespace. - * - * @param {string} namespace the namespace for which to provide objects - * @param {module:openmct.ObjectProvider} provider the provider which - * will handle loading domain objects from this namespace - * @memberof {module:openmct.ObjectAPI#} - * @name addProvider - */ - ObjectAPI.prototype.addProvider = function (namespace, provider) { - this.providers[namespace] = provider; - }; +/** + * Create the given domain object in the corresponding persistence store + * + * @method create + * @memberof module:openmct.ObjectProvider# + * @param {module:openmct.DomainObject} domainObject the domain object to + * create + * @returns {Promise} a promise which will resolve when the domain object + * has been created, or be rejected if it cannot be saved + */ - /** - * Provides the ability to read, write, and delete domain objects. - * - * When registering a new object provider, all methods on this interface - * are optional. - * - * @interface ObjectProvider - * @memberof module:openmct - */ +/** + * Update this domain object in its persistence store + * + * @method update + * @memberof module:openmct.ObjectProvider# + * @param {module:openmct.DomainObject} domainObject the domain object to + * update + * @returns {Promise} a promise which will resolve when the domain object + * has been updated, or be rejected if it cannot be saved + */ - /** - * Create the given domain object in the corresponding persistence store - * - * @method create - * @memberof module:openmct.ObjectProvider# - * @param {module:openmct.DomainObject} domainObject the domain object to - * create - * @returns {Promise} a promise which will resolve when the domain object - * has been created, or be rejected if it cannot be saved - */ +/** + * Delete this domain object. + * + * @method delete + * @memberof module:openmct.ObjectProvider# + * @param {module:openmct.DomainObject} domainObject the domain object to + * delete + * @returns {Promise} a promise which will resolve when the domain object + * has been deleted, or be rejected if it cannot be deleted + */ - /** - * Update this domain object in its persistence store - * - * @method update - * @memberof module:openmct.ObjectProvider# - * @param {module:openmct.DomainObject} domainObject the domain object to - * update - * @returns {Promise} a promise which will resolve when the domain object - * has been updated, or be rejected if it cannot be saved - */ +/** + * Get a domain object. + * + * @method get + * @memberof module:openmct.ObjectProvider# + * @param {string} key the key for the domain object to load + * @returns {Promise} a promise which will resolve when the domain object + * has been saved, or be rejected if it cannot be saved + */ - /** - * Delete this domain object. - * - * @method delete - * @memberof module:openmct.ObjectProvider# - * @param {module:openmct.DomainObject} domainObject the domain object to - * delete - * @returns {Promise} a promise which will resolve when the domain object - * has been deleted, or be rejected if it cannot be deleted - */ +ObjectAPI.prototype.get = function (identifier) { + let keystring = this.makeKeyString(identifier); + if (this.cache[keystring] !== undefined) { + return this.cache[keystring]; + } - /** - * Get a domain object. - * - * @method get - * @memberof module:openmct.ObjectProvider# - * @param {string} key the key for the domain object to load - * @returns {Promise} a promise which will resolve when the domain object - * has been saved, or be rejected if it cannot be saved - */ + identifier = utils.parseKeyString(identifier); + const provider = this.getProvider(identifier); - /** - * Get a domain object. - * - * @method get - * @memberof module:openmct.ObjectAPI# - * @param {module:openmct.ObjectAPI~Identifier} identifier - * the identifier for the domain object to load - * @returns {Promise} a promise which will resolve when the domain object - * has been saved, or be rejected if it cannot be saved - */ - ObjectAPI.prototype.get = function (identifier) { - let keystring = this.makeKeyString(identifier); - if (this.cache[keystring] !== undefined) { - return this.cache[keystring]; - } + if (!provider) { + throw new Error('No Provider Matched'); + } - identifier = utils.parseKeyString(identifier); - const provider = this.getProvider(identifier); + if (!provider.get) { + throw new Error('Provider does not support get!'); + } - if (!provider) { - throw new Error('No Provider Matched'); - } + let objectPromise = provider.get(identifier); + this.cache[keystring] = objectPromise; - if (!provider.get) { - throw new Error('Provider does not support get!'); - } - - let objectPromise = provider.get(identifier); - - this.cache[keystring] = objectPromise; - - return objectPromise.then(result => { - delete this.cache[keystring]; - const interceptors = this.listGetInterceptors(identifier, result); - interceptors.forEach(interceptor => { - result = interceptor.invoke(identifier, result); - }); - - return result; + return objectPromise.then(result => { + delete this.cache[keystring]; + const interceptors = this.listGetInterceptors(identifier, result); + interceptors.forEach(interceptor => { + result = interceptor.invoke(identifier, result); }); - }; - - ObjectAPI.prototype.delete = function () { - throw new Error('Delete not implemented'); - }; - - ObjectAPI.prototype.isPersistable = function (domainObject) { - let provider = this.getProvider(domainObject.identifier); - - return provider !== undefined - && provider.create !== undefined - && provider.update !== undefined; - }; - - /** - * Save this domain object in its current state. EXPERIMENTAL - * - * @private - * @memberof module:openmct.ObjectAPI# - * @param {module:openmct.DomainObject} domainObject the domain object to - * save - * @returns {Promise} a promise which will resolve when the domain object - * has been saved, or be rejected if it cannot be saved - */ - ObjectAPI.prototype.save = function (domainObject) { - let provider = this.getProvider(domainObject.identifier); - let savedResolve; - let result; - - if (!this.isPersistable(domainObject)) { - result = Promise.reject('Object provider does not support saving'); - } else if (hasAlreadyBeenPersisted(domainObject)) { - result = Promise.resolve(true); - } else { - const persistedTime = Date.now(); - if (domainObject.persisted === undefined) { - result = new Promise((resolve) => { - savedResolve = resolve; - }); - domainObject.persisted = persistedTime; - provider.create(domainObject).then((response) => { - this.mutate(domainObject, 'persisted', persistedTime); - savedResolve(response); - }); - } else { - domainObject.persisted = persistedTime; - this.mutate(domainObject, 'persisted', persistedTime); - result = provider.update(domainObject); - } - } return result; - }; + }); +}; - /** - * Add a root-level object. - * @param {module:openmct.ObjectAPI~Identifier|function} an array of - * identifiers for root level objects, or a function that returns a - * promise for an identifier or an array of root level objects. - * @method addRoot - * @memberof module:openmct.ObjectAPI# - */ - ObjectAPI.prototype.addRoot = function (key) { - this.rootRegistry.addRoot(key); - }; - - /** - * Modify a domain object. - * @param {module:openmct.DomainObject} object the object to mutate - * @param {string} path the property to modify - * @param {*} value the new value for this property - * @method mutate - * @memberof module:openmct.ObjectAPI# - */ - ObjectAPI.prototype.mutate = function (domainObject, path, value) { - const mutableObject = - new MutableObject(this.eventEmitter, domainObject); - - return mutableObject.set(path, value); - }; - - /** - * Observe changes to a domain object. - * @param {module:openmct.DomainObject} object the object to observe - * @param {string} path the property to observe - * @param {Function} callback a callback to invoke when new values for - * this property are observed - * @method observe - * @memberof module:openmct.ObjectAPI# - */ - ObjectAPI.prototype.observe = function (domainObject, path, callback) { - const mutableObject = - new MutableObject(this.eventEmitter, domainObject); - mutableObject.on(path, callback); - - return mutableObject.stopListening.bind(mutableObject); - }; - - /** - * @param {module:openmct.ObjectAPI~Identifier} identifier - * @returns {string} A string representation of the given identifier, including namespace and key - */ - ObjectAPI.prototype.makeKeyString = function (identifier) { - return utils.makeKeyString(identifier); - }; - - /** - * Given any number of identifiers, will return true if they are all equal, otherwise false. - * @param {module:openmct.ObjectAPI~Identifier[]} identifiers - */ - ObjectAPI.prototype.areIdsEqual = function (...identifiers) { - return identifiers.map(utils.parseKeyString) - .every(identifier => { - return identifier === identifiers[0] - || (identifier.namespace === identifiers[0].namespace - && identifier.key === identifiers[0].key); - }); - }; - - ObjectAPI.prototype.getOriginalPath = function (identifier, path = []) { - return this.get(identifier).then((domainObject) => { - path.push(domainObject); - let location = domainObject.location; - - if (location) { - return this.getOriginalPath(utils.parseKeyString(location), path); - } else { - return path; - } - }); - }; - - /** - * Register an object interceptor that transforms a domain object requested via module:openmct.ObjectAPI.get - * The domain object will be transformed after it is retrieved from the persistence store - * The domain object will be transformed only if the interceptor is applicable to that domain object as defined by the InterceptorDef - * - * @param {module:openmct.InterceptorDef} interceptorDef the interceptor definition to add - * @method addGetInterceptor - * @memberof module:openmct.InterceptorRegistry# - */ - ObjectAPI.prototype.addGetInterceptor = function (interceptorDef) { - this.interceptorRegistry.addInterceptor(interceptorDef); - }; - - /** - * Retrieve the interceptors for a given domain object. - * @private - */ - ObjectAPI.prototype.listGetInterceptors = function (identifier, object) { - return this.interceptorRegistry.getInterceptors(identifier, object); - }; - - /** - * Uniquely identifies a domain object. - * - * @typedef Identifier - * @memberof module:openmct.ObjectAPI~ - * @property {string} namespace the namespace to/from which this domain - * object should be loaded/stored. - * @property {string} key a unique identifier for the domain object - * within that namespace - */ - - /** - * A domain object is an entity of relevance to a user's workflow, that - * should appear as a distinct and meaningful object within the user - * interface. Examples of domain objects are folders, telemetry sensors, - * and so forth. - * - * A few common properties are defined for domain objects. Beyond these, - * individual types of domain objects may add more as they see fit. - * - * @property {module:openmct.ObjectAPI~Identifier} identifier a key/namespace pair which - * uniquely identifies this domain object - * @property {string} type the type of domain object - * @property {string} name the human-readable name for this domain object - * @property {string} [creator] the user name of the creator of this domain - * object - * @property {number} [modified] the time, in milliseconds since the UNIX - * epoch, at which this domain object was last modified - * @property {module:openmct.ObjectAPI~Identifier[]} [composition] if - * present, this will be used by the default composition provider - * to load domain objects - * @typedef DomainObject - * @memberof module:openmct - */ - - function hasAlreadyBeenPersisted(domainObject) { - return domainObject.persisted !== undefined - && domainObject.persisted === domainObject.modified; +/** + * Will fetch object for the given identifier, returning a version of the object that will automatically keep + * itself updated as it is mutated. Before using this function, you should ask yourself whether you really need it. + * The platform will provide mutable objects to views automatically if the underlying object can be mutated. The + * platform will manage the lifecycle of any mutable objects that it provides. If you use `getMutable` you are + * committing to managing that lifecycle yourself. `.destroy` should be called when the object is no longer needed. + * + * @memberof {module:openmct.ObjectAPI#} + * @returns {Promise.} a promise that will resolve with a MutableDomainObject if + * the object can be mutated. + */ +ObjectAPI.prototype.getMutable = function (identifier) { + if (!this.supportsMutation(identifier)) { + throw new Error(`Object "${this.makeKeyString(identifier)}" does not support mutation.`); } - return ObjectAPI; -}); + return this.get(identifier).then((object) => { + return this._toMutable(object); + }); +}; + +/** + * This function is for cleaning up a mutable domain object when you're done with it. + * You only need to use this if you retrieved the object using `getMutable()`. If the object was provided by the + * platform (eg. passed into a `view()` function) then the platform is responsible for its lifecycle. + * @param {MutableDomainObject} domainObject + */ +ObjectAPI.prototype.destroyMutable = function (domainObject) { + if (domainObject.isMutable) { + return domainObject.$destroy(); + } else { + throw new Error("Attempted to destroy non-mutable domain object"); + } +}; + +ObjectAPI.prototype.delete = function () { + throw new Error('Delete not implemented'); +}; + +ObjectAPI.prototype.isPersistable = function (idOrKeyString) { + let identifier = utils.parseKeyString(idOrKeyString); + let provider = this.getProvider(identifier); + + return provider !== undefined + && provider.create !== undefined + && provider.update !== undefined; +}; + +/** + * Save this domain object in its current state. EXPERIMENTAL + * + * @private + * @memberof module:openmct.ObjectAPI# + * @param {module:openmct.DomainObject} domainObject the domain object to + * save + * @returns {Promise} a promise which will resolve when the domain object + * has been saved, or be rejected if it cannot be saved + */ +ObjectAPI.prototype.save = function (domainObject) { + let provider = this.getProvider(domainObject.identifier); + let savedResolve; + let result; + + if (!this.isPersistable(domainObject.identifier)) { + result = Promise.reject('Object provider does not support saving'); + } else if (hasAlreadyBeenPersisted(domainObject)) { + result = Promise.resolve(true); + } else { + const persistedTime = Date.now(); + if (domainObject.persisted === undefined) { + result = new Promise((resolve) => { + savedResolve = resolve; + }); + domainObject.persisted = persistedTime; + provider.create(domainObject).then((response) => { + this.mutate(domainObject, 'persisted', persistedTime); + savedResolve(response); + }); + } else { + domainObject.persisted = persistedTime; + this.mutate(domainObject, 'persisted', persistedTime); + result = provider.update(domainObject); + } + } + + return result; +}; + +/** + * Add a root-level object. + * @param {module:openmct.ObjectAPI~Identifier|function} an array of + * identifiers for root level objects, or a function that returns a + * promise for an identifier or an array of root level objects. + * @method addRoot + * @memberof module:openmct.ObjectAPI# + */ +ObjectAPI.prototype.addRoot = function (key) { + this.rootRegistry.addRoot(key); +}; + +/** + * Register an object interceptor that transforms a domain object requested via module:openmct.ObjectAPI.get + * The domain object will be transformed after it is retrieved from the persistence store + * The domain object will be transformed only if the interceptor is applicable to that domain object as defined by the InterceptorDef + * + * @param {module:openmct.InterceptorDef} interceptorDef the interceptor definition to add + * @method addGetInterceptor + * @memberof module:openmct.InterceptorRegistry# + */ +ObjectAPI.prototype.addGetInterceptor = function (interceptorDef) { + this.interceptorRegistry.addInterceptor(interceptorDef); +}; + +/** + * Retrieve the interceptors for a given domain object. + * @private + */ +ObjectAPI.prototype.listGetInterceptors = function (identifier, object) { + return this.interceptorRegistry.getInterceptors(identifier, object); +}; + +/** + * Modify a domain object. + * @param {module:openmct.DomainObject} object the object to mutate + * @param {string} path the property to modify + * @param {*} value the new value for this property + * @method mutate + * @memberof module:openmct.ObjectAPI# + */ +ObjectAPI.prototype.mutate = function (domainObject, path, value) { + if (!this.supportsMutation(domainObject.identifier)) { + throw `Error: Attempted to mutate immutable object ${domainObject.name}`; + } + + if (domainObject.isMutable) { + domainObject.$set(path, value); + } else { + //Creating a temporary mutable domain object allows other mutable instances of the + //object to be kept in sync. + let mutableDomainObject = this._toMutable(domainObject); + + //Mutate original object + MutableDomainObject.mutateObject(domainObject, path, value); + + //Mutate temporary mutable object, in the process informing any other mutable instances + mutableDomainObject.$set(path, value); + + //Destroy temporary mutable object + this.destroyMutable(mutableDomainObject); + } +}; + +/** + * @private + */ +ObjectAPI.prototype._toMutable = function (object) { + if (object.isMutable) { + return object; + } else { + return MutableDomainObject.createMutable(object, this.eventEmitter); + } +}; + +/** + * @param module:openmct.ObjectAPI~Identifier identifier An object identifier + * @returns {boolean} true if the object can be mutated, otherwise returns false + */ +ObjectAPI.prototype.supportsMutation = function (identifier) { + return this.isPersistable(identifier); +}; + +/** + * Observe changes to a domain object. + * @param {module:openmct.DomainObject} object the object to observe + * @param {string} path the property to observe + * @param {Function} callback a callback to invoke when new values for + * this property are observed + * @method observe + * @memberof module:openmct.ObjectAPI# + */ +ObjectAPI.prototype.observe = function (domainObject, path, callback) { + if (domainObject.isMutable) { + return domainObject.$observe(path, callback); + } else { + let mutable = this._toMutable(domainObject); + mutable.$observe(path, callback); + + return () => mutable.$destroy(); + } +}; + +/** + * @param {module:openmct.ObjectAPI~Identifier} identifier + * @returns {string} A string representation of the given identifier, including namespace and key + */ +ObjectAPI.prototype.makeKeyString = function (identifier) { + return utils.makeKeyString(identifier); +}; + +/** + * @param {string} keyString A string representation of the given identifier, that is, a namespace and key separated by a colon. + * @returns {module:openmct.ObjectAPI~Identifier} An identifier object + */ +ObjectAPI.prototype.parseKeyString = function (keyString) { + return utils.parseKeyString(keyString); +}; + +/** + * Given any number of identifiers, will return true if they are all equal, otherwise false. + * @param {module:openmct.ObjectAPI~Identifier[]} identifiers + */ +ObjectAPI.prototype.areIdsEqual = function (...identifiers) { + return identifiers.map(utils.parseKeyString) + .every(identifier => { + return identifier === identifiers[0] + || (identifier.namespace === identifiers[0].namespace + && identifier.key === identifiers[0].key); + }); +}; + +ObjectAPI.prototype.getOriginalPath = function (identifier, path = []) { + return this.get(identifier).then((domainObject) => { + path.push(domainObject); + let location = domainObject.location; + + if (location) { + return this.getOriginalPath(utils.parseKeyString(location), path); + } else { + return path; + } + }); +}; + +/** + * Uniquely identifies a domain object. + * + * @typedef Identifier + * @memberof module:openmct.ObjectAPI~ + * @property {string} namespace the namespace to/from which this domain + * object should be loaded/stored. + * @property {string} key a unique identifier for the domain object + * within that namespace + */ + +/** + * A domain object is an entity of relevance to a user's workflow, that + * should appear as a distinct and meaningful object within the user + * interface. Examples of domain objects are folders, telemetry sensors, + * and so forth. + * + * A few common properties are defined for domain objects. Beyond these, + * individual types of domain objects may add more as they see fit. + * + * @property {module:openmct.ObjectAPI~Identifier} identifier a key/namespace pair which + * uniquely identifies this domain object + * @property {string} type the type of domain object + * @property {string} name the human-readable name for this domain object + * @property {string} [creator] the user name of the creator of this domain + * object + * @property {number} [modified] the time, in milliseconds since the UNIX + * epoch, at which this domain object was last modified + * @property {module:openmct.ObjectAPI~Identifier[]} [composition] if + * present, this will be used by the default composition provider + * to load domain objects + * @typedef DomainObject + * @memberof module:openmct + */ + +function hasAlreadyBeenPersisted(domainObject) { + return domainObject.persisted !== undefined + && domainObject.persisted === domainObject.modified; +} + +export default ObjectAPI; diff --git a/src/api/objects/ObjectAPISpec.js b/src/api/objects/ObjectAPISpec.js index ad6293b729..fa154717ff 100644 --- a/src/api/objects/ObjectAPISpec.js +++ b/src/api/objects/ObjectAPISpec.js @@ -2,12 +2,16 @@ import ObjectAPI from './ObjectAPI.js'; describe("The Object API", () => { let objectAPI; + let typeRegistry; let mockDomainObject; const TEST_NAMESPACE = "test-namespace"; const FIFTEEN_MINUTES = 15 * 60 * 1000; beforeEach(() => { - objectAPI = new ObjectAPI(); + typeRegistry = jasmine.createSpyObj('typeRegistry', [ + 'get' + ]); + objectAPI = new ObjectAPI(typeRegistry); mockDomainObject = { identifier: { namespace: TEST_NAMESPACE, @@ -33,6 +37,7 @@ describe("The Object API", () => { "update" ]); mockProvider.create.and.returnValue(Promise.resolve(true)); + mockProvider.update.and.returnValue(Promise.resolve(true)); objectAPI.addProvider(TEST_NAMESPACE, mockProvider); }); it("Calls 'create' on provider if object is new", () => { @@ -128,4 +133,131 @@ describe("The Object API", () => { }); }); }); + + describe("the mutation API", () => { + let testObject; + let mutable; + let mockProvider; + + beforeEach(function () { + objectAPI = new ObjectAPI(typeRegistry); + testObject = { + identifier: { + namespace: TEST_NAMESPACE, + key: 'test-key' + }, + name: 'test object', + otherAttribute: 'other-attribute-value', + objectAttribute: { + embeddedObject: { + embeddedKey: 'embedded-value' + } + } + }; + mockProvider = jasmine.createSpyObj("mock provider", [ + "get", + "create", + "update" + ]); + mockProvider.get.and.returnValue(Promise.resolve(testObject)); + objectAPI.addProvider(TEST_NAMESPACE, mockProvider); + + return objectAPI.getMutable(testObject.identifier) + .then(object => { + mutable = object; + + return mutable; + }); + }); + + afterEach(() => { + mutable.$destroy(); + }); + + it('mutates the original object', () => { + const MUTATED_NAME = 'mutated name'; + objectAPI.mutate(testObject, 'name', MUTATED_NAME); + expect(testObject.name).toBe(MUTATED_NAME); + }); + + describe ('uses a MutableDomainObject', () => { + it('and retains properties of original object ', function () { + expect(hasOwnProperty(mutable, 'identifier')).toBe(true); + expect(hasOwnProperty(mutable, 'otherAttribute')).toBe(true); + expect(mutable.identifier).toEqual(testObject.identifier); + expect(mutable.otherAttribute).toEqual(testObject.otherAttribute); + }); + + it('that is identical to original object when serialized', function () { + expect(JSON.stringify(mutable)).toEqual(JSON.stringify(testObject)); + }); + }); + + describe('uses events', function () { + let testObjectDuplicate; + let mutableSecondInstance; + + beforeEach(function () { + // Duplicate object to guarantee we are not sharing object instance, which would invalidate test + testObjectDuplicate = JSON.parse(JSON.stringify(testObject)); + mutableSecondInstance = objectAPI._toMutable(testObjectDuplicate); + }); + + afterEach(() => { + mutableSecondInstance.$destroy(); + }); + + it('to stay synchronized when mutated', function () { + objectAPI.mutate(mutable, 'otherAttribute', 'new-attribute-value'); + expect(mutableSecondInstance.otherAttribute).toBe('new-attribute-value'); + }); + + it('to indicate when a property changes', function () { + let mutationCallback = jasmine.createSpy('mutation-callback'); + let unlisten; + + return new Promise(function (resolve) { + mutationCallback.and.callFake(resolve); + unlisten = objectAPI.observe(mutableSecondInstance, 'otherAttribute', mutationCallback); + objectAPI.mutate(mutable, 'otherAttribute', 'some-new-value'); + }).then(function () { + expect(mutationCallback).toHaveBeenCalledWith('some-new-value'); + unlisten(); + }); + }); + + it('to indicate when a child property has changed', function () { + let embeddedKeyCallback = jasmine.createSpy('embeddedKeyCallback'); + let embeddedObjectCallback = jasmine.createSpy('embeddedObjectCallback'); + let objectAttributeCallback = jasmine.createSpy('objectAttribute'); + let listeners = []; + + return new Promise(function (resolve) { + objectAttributeCallback.and.callFake(resolve); + + listeners.push(objectAPI.observe(mutableSecondInstance, 'objectAttribute.embeddedObject.embeddedKey', embeddedKeyCallback)); + listeners.push(objectAPI.observe(mutableSecondInstance, 'objectAttribute.embeddedObject', embeddedObjectCallback)); + listeners.push(objectAPI.observe(mutableSecondInstance, 'objectAttribute', objectAttributeCallback)); + + objectAPI.mutate(mutable, 'objectAttribute.embeddedObject.embeddedKey', 'updated-embedded-value'); + }).then(function () { + expect(embeddedKeyCallback).toHaveBeenCalledWith('updated-embedded-value'); + expect(embeddedObjectCallback).toHaveBeenCalledWith({ + embeddedKey: 'updated-embedded-value' + }); + expect(objectAttributeCallback).toHaveBeenCalledWith({ + embeddedObject: { + embeddedKey: 'updated-embedded-value' + } + }); + + listeners.forEach(listener => listener()); + }); + }); + }); + }); }); + +function hasOwnProperty(object, property) { + return Object.prototype.hasOwnProperty.call(object, property); +} diff --git a/src/plugins/LADTable/LADTableViewProvider.js b/src/plugins/LADTable/LADTableViewProvider.js index 44c6c2ab01..43845350b4 100644 --- a/src/plugins/LADTable/LADTableViewProvider.js +++ b/src/plugins/LADTable/LADTableViewProvider.js @@ -43,12 +43,16 @@ export default function LADTableViewProvider(openmct) { components: { LadTableComponent: LadTable }, - provide: { - openmct, - domainObject, - objectPath + data: () => { + return { + domainObject, + objectPath + }; }, - template: '' + provide: { + openmct + }, + template: '' }); }, destroy: function (element) { diff --git a/src/plugins/LADTable/components/LADRow.vue b/src/plugins/LADTable/components/LADRow.vue index dbedfbc81a..fba838e81b 100644 --- a/src/plugins/LADTable/components/LADRow.vue +++ b/src/plugins/LADTable/components/LADRow.vue @@ -26,7 +26,7 @@ class="js-lad-table__body__row" @contextmenu.prevent="showContextMenu" > - {{ name }} + {{ domainObject.name }} {{ formattedTimestamp }} this.updateValues(array[array.length - 1])); }, - updateName(name) { - this.name = name; - }, updateBounds(bounds, isTick) { this.bounds = bounds; if (!isTick) { diff --git a/src/plugins/LADTable/components/LADTable.vue b/src/plugins/LADTable/components/LADTable.vue index 9dc48e4768..ebb4edb5ad 100644 --- a/src/plugins/LADTable/components/LADTable.vue +++ b/src/plugins/LADTable/components/LADTable.vue @@ -36,6 +36,7 @@ v-for="item in items" :key="item.key" :domain-object="item.domainObject" + :object-path="objectPath" :has-units="hasUnits" /> @@ -47,10 +48,20 @@ import LadRow from './LADRow.vue'; export default { - inject: ['openmct', 'domainObject', 'objectPath'], + inject: ['openmct'], components: { LadRow }, + props: { + domainObject: { + type: Object, + required: true + }, + objectPath: { + type: Array, + required: true + } + }, data() { return { items: [] diff --git a/src/plugins/displayLayout/components/DisplayLayout.vue b/src/plugins/displayLayout/components/DisplayLayout.vue index cb60316497..14170f8f54 100644 --- a/src/plugins/displayLayout/components/DisplayLayout.vue +++ b/src/plugins/displayLayout/components/DisplayLayout.vue @@ -152,10 +152,7 @@ export default { } }, data() { - let domainObject = JSON.parse(JSON.stringify(this.domainObject)); - return { - internalDomainObject: domainObject, initSelectIndex: undefined, selection: [], showGrid: true @@ -163,10 +160,10 @@ export default { }, computed: { gridSize() { - return this.internalDomainObject.configuration.layoutGrid; + return this.domainObject.configuration.layoutGrid; }, layoutItems() { - return this.internalDomainObject.configuration.items; + return this.domainObject.configuration.items; }, selectedLayoutItems() { return this.layoutItems.filter(item => { @@ -174,7 +171,7 @@ export default { }); }, layoutDimensions() { - return this.internalDomainObject.configuration.layoutDimensions; + return this.domainObject.configuration.layoutDimensions; }, shouldDisplayLayoutDimensions() { return this.layoutDimensions @@ -206,12 +203,9 @@ export default { } }, mounted() { - this.unlisten = this.openmct.objects.observe(this.internalDomainObject, '*', function (obj) { - this.internalDomainObject = JSON.parse(JSON.stringify(obj)); - }.bind(this)); this.openmct.selection.on('change', this.setSelection); this.initializeItems(); - this.composition = this.openmct.composition.get(this.internalDomainObject); + this.composition = this.openmct.composition.get(this.domainObject); this.composition.on('add', this.addChild); this.composition.on('remove', this.removeChild); this.composition.load(); @@ -220,7 +214,6 @@ export default { this.openmct.selection.off('change', this.setSelection); this.composition.off('add', this.addChild); this.composition.off('remove', this.removeChild); - this.unlisten(); }, methods: { addElement(itemType, element) { @@ -347,7 +340,7 @@ export default { this.startingMinY2 = undefined; }, mutate(path, value) { - this.openmct.objects.mutate(this.internalDomainObject, path, value); + this.openmct.objects.mutate(this.domainObject, path, value); }, handleDrop($event) { if (!$event.dataTransfer.types.includes('openmct/domain-object-path')) { @@ -387,11 +380,11 @@ export default { } }, containsObject(identifier) { - return _.get(this.internalDomainObject, 'composition') + return _.get(this.domainObject, 'composition') .some(childId => this.openmct.objects.areIdsEqual(childId, identifier)); }, handleDragOver($event) { - if (this.internalDomainObject.locked) { + if (this.domainObject.locked) { return; } @@ -420,7 +413,7 @@ export default { item.id = uuid(); this.trackItem(item); this.layoutItems.push(item); - this.openmct.objects.mutate(this.internalDomainObject, "configuration.items", this.layoutItems); + this.openmct.objects.mutate(this.domainObject, "configuration.items", this.layoutItems); this.initSelectIndex = this.layoutItems.length - 1; }, trackItem(item) { @@ -477,7 +470,7 @@ export default { } }, removeFromComposition(keyString) { - let composition = _.get(this.internalDomainObject, 'composition'); + let composition = _.get(this.domainObject, 'composition'); composition = composition.filter(identifier => { return this.openmct.objects.makeKeyString(identifier) !== keyString; }); @@ -629,10 +622,10 @@ export default { createNewDomainObject(domainObject, composition, viewType, nameExtension, model) { let identifier = { key: uuid(), - namespace: this.internalDomainObject.identifier.namespace + namespace: this.domainObject.identifier.namespace }; let type = this.openmct.types.get(viewType); - let parentKeyString = this.openmct.objects.makeKeyString(this.internalDomainObject.identifier); + let parentKeyString = this.openmct.objects.makeKeyString(this.domainObject.identifier); let objectName = nameExtension ? `${domainObject.name}-${nameExtension}` : domainObject.name; let object = {}; @@ -689,7 +682,7 @@ export default { }); }, duplicateItem(selectedItems) { - let objectStyles = this.internalDomainObject.configuration.objectStyles || {}; + let objectStyles = this.domainObject.configuration.objectStyles || {}; let selectItemsArray = []; let newDomainObjectsArray = []; @@ -728,8 +721,8 @@ export default { }); this.$nextTick(() => { - this.openmct.objects.mutate(this.internalDomainObject, "configuration.items", this.layoutItems); - this.openmct.objects.mutate(this.internalDomainObject, "configuration.objectStyles", objectStyles); + this.openmct.objects.mutate(this.domainObject, "configuration.items", this.layoutItems); + this.openmct.objects.mutate(this.domainObject, "configuration.objectStyles", objectStyles); this.$el.click(); //clear selection; newDomainObjectsArray.forEach(domainObject => { @@ -768,13 +761,13 @@ export default { }; this.createNewDomainObject(mockDomainObject, overlayPlotIdentifiers, viewType).then((newDomainObject) => { let newDomainObjectKeyString = this.openmct.objects.makeKeyString(newDomainObject.identifier); - let internalDomainObjectKeyString = this.openmct.objects.makeKeyString(this.internalDomainObject.identifier); + let domainObjectKeyString = this.openmct.objects.makeKeyString(this.domainObject.identifier); this.composition.add(newDomainObject); this.addItem('subobject-view', newDomainObject, position); overlayPlots.forEach(overlayPlot => { - if (overlayPlot.location === internalDomainObjectKeyString) { + if (overlayPlot.location === domainObjectKeyString) { this.openmct.objects.mutate(overlayPlot, 'location', newDomainObjectKeyString); } }); diff --git a/src/plugins/displayLayout/components/SubobjectView.vue b/src/plugins/displayLayout/components/SubobjectView.vue index 556061fe6c..7f8366e3b8 100644 --- a/src/plugins/displayLayout/components/SubobjectView.vue +++ b/src/plugins/displayLayout/components/SubobjectView.vue @@ -129,13 +129,22 @@ export default { } }, mounted() { - this.openmct.objects.get(this.item.identifier) - .then(this.setObject); + if (this.openmct.objects.supportsMutation(this.item.identifier)) { + this.openmct.objects.getMutable(this.item.identifier) + .then(this.setObject); + } else { + this.openmct.objects.get(this.item.identifier) + .then(this.setObject); + } }, - destroyed() { + beforeDestroy() { if (this.removeSelectable) { this.removeSelectable(); } + + if (this.domainObject.isMutable) { + this.openmct.objects.destroyMutable(this.domainObject); + } }, methods: { setObject(domainObject) { diff --git a/src/plugins/displayLayout/components/TelemetryView.vue b/src/plugins/displayLayout/components/TelemetryView.vue index 3552e7ded0..b4d69722b3 100644 --- a/src/plugins/displayLayout/components/TelemetryView.vue +++ b/src/plugins/displayLayout/components/TelemetryView.vue @@ -212,14 +212,20 @@ export default { } }, mounted() { - this.openmct.objects.get(this.item.identifier) - .then(this.setObject); + if (this.openmct.objects.supportsMutation(this.item.identifier)) { + this.openmct.objects.getMutable(this.item.identifier) + .then(this.setObject); + } else { + this.openmct.objects.get(this.item.identifier) + .then(this.setObject); + } + this.openmct.time.on("bounds", this.refreshData); this.status = this.openmct.status.get(this.item.identifier); this.removeStatusListener = this.openmct.status.observe(this.item.identifier, this.setStatus); }, - destroyed() { + beforeDestroy() { this.removeSubscription(); this.removeStatusListener(); @@ -228,6 +234,10 @@ export default { } this.openmct.time.off("bounds", this.refreshData); + + if (this.domainObject.isMutable) { + this.openmct.objects.destroyMutable(this.domainObject); + } }, methods: { formattedValueForCopy() { diff --git a/src/plugins/duplicate/pluginSpec.js b/src/plugins/duplicate/pluginSpec.js index 07af1bb78f..730a051206 100644 --- a/src/plugins/duplicate/pluginSpec.js +++ b/src/plugins/duplicate/pluginSpec.js @@ -57,6 +57,7 @@ describe("The Duplicate Action plugin", () => { overwrite: { folder: { name: "Parent Folder", + type: "folder", composition: [childObject.identifier] } } @@ -104,6 +105,7 @@ describe("The Duplicate Action plugin", () => { // already installed by default, but never hurts, just adds to context menu openmct.install(DuplicateActionPlugin()); + openmct.types.addType('folder', {creatable: true}); openmct.on('start', done); openmct.startHeadless(); diff --git a/src/plugins/notebook/utils/notebook-entriesSpec.js b/src/plugins/notebook/utils/notebook-entriesSpec.js index 9a83fad5a8..5c8c1db7b0 100644 --- a/src/plugins/notebook/utils/notebook-entriesSpec.js +++ b/src/plugins/notebook/utils/notebook-entriesSpec.js @@ -113,6 +113,13 @@ let openmct; describe('Notebook Entries:', () => { beforeEach(done => { openmct = createOpenMct(); + openmct.types.addType('notebook', { + creatable: true + }); + openmct.objects.addProvider('', jasmine.createSpyObj('mockNotebookProvider', [ + 'create', + 'update' + ])); window.localStorage.setItem('notebook-storage', null); done(); diff --git a/src/plugins/notebook/utils/notebook-storageSpec.js b/src/plugins/notebook/utils/notebook-storageSpec.js index 39438da286..6ae35aeae1 100644 --- a/src/plugins/notebook/utils/notebook-storageSpec.js +++ b/src/plugins/notebook/utils/notebook-storageSpec.js @@ -62,7 +62,10 @@ describe('Notebook Storage:', () => { beforeEach((done) => { openmct = createOpenMct(); window.localStorage.setItem('notebook-storage', null); - + openmct.objects.addProvider('', jasmine.createSpyObj('mockNotebookProvider', [ + 'create', + 'update' + ])); done(); }); diff --git a/src/plugins/persistence/couch/pluginSpec.js b/src/plugins/persistence/couch/pluginSpec.js index 364da70cef..93c2a1fbfc 100644 --- a/src/plugins/persistence/couch/pluginSpec.js +++ b/src/plugins/persistence/couch/pluginSpec.js @@ -39,10 +39,12 @@ describe('the plugin', () => { identifier: { namespace: 'mct', key: 'some-value' - } + }, + type: 'mock-type' }; openmct = createOpenMct(false); openmct.install(new CouchPlugin(testPath)); + openmct.types.addType('mock-type', {creatable: true}); element = document.createElement('div'); child = document.createElement('div'); diff --git a/src/plugins/tabs/components/tabs.vue b/src/plugins/tabs/components/tabs.vue index b55a643353..5e2e778e70 100644 --- a/src/plugins/tabs/components/tabs.vue +++ b/src/plugins/tabs/components/tabs.vue @@ -55,7 +55,7 @@ diff --git a/src/plugins/telemetryTable/pluginSpec.js b/src/plugins/telemetryTable/pluginSpec.js index bd7408ba92..2e1fe231bf 100644 --- a/src/plugins/telemetryTable/pluginSpec.js +++ b/src/plugins/telemetryTable/pluginSpec.js @@ -68,6 +68,10 @@ describe("the plugin", () => { end: 4 }); + openmct.types.addType('test-object', { + creatable: true + }); + spyOnBuiltins(['requestAnimationFrame']); window.requestAnimationFrame.and.callFake((callBack) => { callBack(); diff --git a/src/selection/Selection.js b/src/selection/Selection.js index 0b9857a1bf..3882b02c08 100644 --- a/src/selection/Selection.js +++ b/src/selection/Selection.js @@ -241,11 +241,8 @@ define( element.addEventListener('click', capture, true); element.addEventListener('click', selectCapture); - let unlisten = undefined; if (context.item) { - unlisten = this.openmct.objects.observe(context.item, "*", function (newItem) { - context.item = newItem; - }); + context.item = this.openmct.objects._toMutable(context.item); } if (select) { @@ -256,14 +253,14 @@ define( } } - return function () { + return (function () { element.removeEventListener('click', capture, true); element.removeEventListener('click', selectCapture); - if (unlisten !== undefined) { - unlisten(); + if (context.item !== undefined && context.item.isMutable) { + this.openmct.objects.destroyMutable(context.item); } - }; + }).bind(this); }; return Selection; diff --git a/src/ui/components/ObjectFrame.vue b/src/ui/components/ObjectFrame.vue index 15c9c64d6f..306716185b 100644 --- a/src/ui/components/ObjectFrame.vue +++ b/src/ui/components/ObjectFrame.vue @@ -88,7 +88,6 @@
- {{ observedObject.name }} + {{ domainObject.name }}
@@ -45,13 +45,12 @@ export default { }, data() { return { - observedObject: this.domainObject, status: '' }; }, computed: { typeClass() { - let type = this.openmct.types.get(this.observedObject.type); + let type = this.openmct.types.get(this.domainObject.type); if (!type) { return 'icon-object-unknown'; } @@ -63,15 +62,8 @@ export default { } }, mounted() { - if (this.observedObject) { - let removeListener = this.openmct.objects.observe(this.observedObject, '*', (newObject) => { - this.observedObject = newObject; - }); - this.$once('hook:destroyed', removeListener); - } - - this.removeStatusListener = this.openmct.status.observe(this.observedObject.identifier, this.setStatus); - this.status = this.openmct.status.get(this.observedObject.identifier); + this.removeStatusListener = this.openmct.status.observe(this.domainObject.identifier, this.setStatus); + this.status = this.openmct.status.get(this.domainObject.identifier); this.previewAction = new PreviewAction(this.openmct); }, destroyed() { @@ -101,7 +93,7 @@ export default { * that point. If dragged object can be composed by navigated object, then indicate with presence of * 'composable-domain-object' in data transfer */ - if (this.openmct.composition.checkPolicy(navigatedObject, this.observedObject)) { + if (this.openmct.composition.checkPolicy(navigatedObject, this.domainObject)) { event.dataTransfer.setData("openmct/composable-domain-object", JSON.stringify(this.domainObject)); } diff --git a/src/ui/components/ObjectView.vue b/src/ui/components/ObjectView.vue index caf06f3c1d..09d9995a6f 100644 --- a/src/ui/components/ObjectView.vue +++ b/src/ui/components/ObjectView.vue @@ -10,11 +10,11 @@ import {STYLE_CONSTANTS} from "@/plugins/condition/utils/constants"; export default { inject: ["openmct"], props: { - object: { + showEditView: Boolean, + defaultObject: { type: Object, default: undefined }, - showEditView: Boolean, objectPath: { type: Array, default: () => { @@ -32,12 +32,12 @@ export default { }, data() { return { - currentObject: this.object + domainObject: this.defaultObject }; }, computed: { objectFontStyle() { - return this.currentObject && this.currentObject.configuration && this.currentObject.configuration.fontStyle; + return this.domainObject && this.domainObject.configuration && this.domainObject.configuration.fontStyle; }, fontSize() { return this.objectFontStyle ? this.objectFontStyle.fontSize : this.layoutFontSize; @@ -46,22 +46,12 @@ export default { return this.objectFontStyle ? this.objectFontStyle.font : this.layoutFont; } }, - watch: { - object(newObject, oldObject) { - this.currentObject = newObject; - this.debounceUpdateView(); - } - }, destroyed() { this.clear(); if (this.releaseEditModeHandler) { this.releaseEditModeHandler(); } - if (this.unlisten) { - this.unlisten(); - } - if (this.stopListeningStyles) { this.stopListeningStyles(); } @@ -92,7 +82,7 @@ export default { capture: true }); this.$el.addEventListener('drop', this.addObjectToParent); - if (this.currentObject) { + if (this.domainObject) { //This is to apply styles to subobjects in a layout this.initObjectStyles(); } @@ -135,7 +125,7 @@ export default { invokeEditModeHandler(editMode) { let edit; - if (this.currentObject.locked) { + if (this.domainObject.locked) { edit = false; } else { edit = editMode; @@ -175,13 +165,13 @@ export default { }, updateView(immediatelySelect) { this.clear(); - if (!this.currentObject) { + if (!this.domainObject) { return; } - this.composition = this.openmct.composition.get(this.currentObject); + this.composition = this.openmct.composition.get(this.domainObject); + if (this.composition) { - this.composition._synchronize(); this.loadComposition(); } @@ -197,15 +187,15 @@ export default { if (provider.edit && this.showEditView) { if (this.openmct.editor.isEditing()) { - this.currentView = provider.edit(this.currentObject, true, objectPath); + this.currentView = provider.edit(this.domainObject, true, objectPath); } else { - this.currentView = provider.view(this.currentObject, objectPath); + this.currentView = provider.view(this.domainObject, objectPath); } this.openmct.editor.on('isEditing', this.toggleEditView); this.releaseEditModeHandler = () => this.openmct.editor.off('isEditing', this.toggleEditView); } else { - this.currentView = provider.view(this.currentObject, objectPath); + this.currentView = provider.view(this.domainObject, objectPath); if (this.currentView.onEditModeChange) { this.openmct.editor.on('isEditing', this.invokeEditModeHandler); @@ -247,16 +237,12 @@ export default { this.composition._destroy(); } - this.currentObject = object; + this.domainObject = object; if (currentObjectPath) { this.currentObjectPath = currentObjectPath; } - this.unlisten = this.openmct.objects.observe(this.currentObject, '*', (mutatedObject) => { - this.currentObject = mutatedObject; - }); - this.viewKey = viewKey; this.updateView(immediatelySelect); @@ -265,16 +251,16 @@ export default { }, initObjectStyles() { if (!this.styleRuleManager) { - this.styleRuleManager = new StyleRuleManager((this.currentObject.configuration && this.currentObject.configuration.objectStyles), this.openmct, this.updateStyle.bind(this), true); + this.styleRuleManager = new StyleRuleManager((this.domainObject.configuration && this.domainObject.configuration.objectStyles), this.openmct, this.updateStyle.bind(this), true); } else { - this.styleRuleManager.updateObjectStyleConfig(this.currentObject.configuration && this.currentObject.configuration.objectStyles); + this.styleRuleManager.updateObjectStyleConfig(this.domainObject.configuration && this.domainObject.configuration.objectStyles); } if (this.stopListeningStyles) { this.stopListeningStyles(); } - this.stopListeningStyles = this.openmct.objects.observe(this.currentObject, 'configuration.objectStyles', (newObjectStyle) => { + this.stopListeningStyles = this.openmct.objects.observe(this.domainObject, 'configuration.objectStyles', (newObjectStyle) => { //Updating styles in the inspector view will trigger this so that the changes are reflected immediately this.styleRuleManager.updateObjectStyleConfig(newObjectStyle); }); @@ -282,7 +268,7 @@ export default { this.setFontSize(this.fontSize); this.setFont(this.font); - this.stopListeningFontStyles = this.openmct.objects.observe(this.currentObject, 'configuration.fontStyle', (newFontStyle) => { + this.stopListeningFontStyles = this.openmct.objects.observe(this.domainObject, 'configuration.fontStyle', (newFontStyle) => { this.setFontSize(newFontStyle.fontSize); this.setFont(newFontStyle.font); }); @@ -294,7 +280,7 @@ export default { if (this.currentView && this.currentView.getSelectionContext) { return this.currentView.getSelectionContext(); } else { - return { item: this.currentObject }; + return { item: this.domainObject }; } }, onDragOver(event) { @@ -321,7 +307,7 @@ export default { let provider = this.openmct.objectViews.getByProviderKey(this.viewKey); if (!provider) { - provider = this.openmct.objectViews.get(this.currentObject)[0]; + provider = this.openmct.objectViews.get(this.domainObject)[0]; if (!provider) { return; } @@ -333,7 +319,7 @@ export default { let provider = this.getViewProvider(); if (provider && provider.canEdit - && provider.canEdit(this.currentObject) + && provider.canEdit(this.domainObject) && this.isEditingAllowed() && !this.openmct.editor.isEditing()) { this.openmct.editor.edit(); @@ -350,7 +336,7 @@ export default { clearData(domainObject) { if (domainObject) { let clearKeyString = this.openmct.objects.makeKeyString(domainObject.identifier); - let currentObjectKeyString = this.openmct.objects.makeKeyString(this.currentObject.identifier); + let currentObjectKeyString = this.openmct.objects.makeKeyString(this.domainObject.identifier); if (clearKeyString === currentObjectKeyString) { if (this.currentView.onClearData) { @@ -364,11 +350,11 @@ export default { } }, isEditingAllowed() { - let browseObject = this.openmct.layout.$refs.browseObject.currentObject; + let browseObject = this.openmct.layout.$refs.browseObject.domainObject; let objectPath = this.currentObjectPath || this.objectPath; let parentObject = objectPath[1]; - return [browseObject, parentObject, this.currentObject].every(object => object && !object.locked); + return [browseObject, parentObject, this.domainObject].every(object => object && !object.locked); }, setFontSize(newSize) { let elemToStyle = this.getStyleReceiver(); diff --git a/src/ui/inspector/Elements.vue b/src/ui/inspector/Elements.vue index 710aac5180..52caa624f0 100644 --- a/src/ui/inspector/Elements.vue +++ b/src/ui/inspector/Elements.vue @@ -82,10 +82,6 @@ export default { this.openmct.editor.off('isEditing', this.setEditState); this.openmct.selection.off('change', this.showSelection); - if (this.mutationUnobserver) { - this.mutationUnobserver(); - } - if (this.compositionUnlistener) { this.compositionUnlistener(); } @@ -106,18 +102,11 @@ export default { this.listeners = []; this.parentObject = selection && selection[0] && selection[0][0].context.item; - if (this.mutationUnobserver) { - this.mutationUnobserver(); - } - if (this.compositionUnlistener) { this.compositionUnlistener(); } if (this.parentObject) { - this.mutationUnobserver = this.openmct.objects.observe(this.parentObject, '*', (updatedModel) => { - this.parentObject = updatedModel; - }); this.composition = this.openmct.composition.get(this.parentObject); if (this.composition) { diff --git a/src/ui/layout/BrowseBar.vue b/src/ui/layout/BrowseBar.vue index aee5aea717..931a1c30f8 100644 --- a/src/ui/layout/BrowseBar.vue +++ b/src/ui/layout/BrowseBar.vue @@ -211,14 +211,6 @@ export default { }, watch: { domainObject() { - if (this.mutationObserver) { - this.mutationObserver(); - } - - this.mutationObserver = this.openmct.objects.observe(this.domainObject, '*', (domainObject) => { - this.domainObject = domainObject; - }); - if (this.removeStatusListener) { this.removeStatusListener(); } diff --git a/src/ui/router/Browse.js b/src/ui/router/Browse.js index 2f19c6f556..43f04278b0 100644 --- a/src/ui/router/Browse.js +++ b/src/ui/router/Browse.js @@ -10,12 +10,14 @@ define([ let unobserve = undefined; let currentObjectPath; let isRoutingInProgress = false; + let mutable; openmct.router.route(/^\/browse\/?$/, navigateToFirstChildOfRoot); openmct.router.route(/^\/browse\/(.*)$/, (path, results, params) => { isRoutingInProgress = true; let navigatePath = results[1]; + clearMutationListeners(); navigateToPath(navigatePath, params.view); onParamsChanged(null, null, params); }); @@ -36,10 +38,25 @@ define([ } function viewObject(object, viewProvider) { + if (mutable) { + openmct.objects.destroyMutable(mutable); + mutable = undefined; + } + + if (openmct.objects.supportsMutation(object)) { + mutable = openmct.objects._toMutable(object); + } + currentObjectPath = openmct.router.path; - openmct.layout.$refs.browseObject.show(object, viewProvider.key, true, currentObjectPath); - openmct.layout.$refs.browseBar.domainObject = object; + if (mutable !== undefined) { + openmct.layout.$refs.browseObject.show(mutable, viewProvider.key, true, currentObjectPath); + openmct.layout.$refs.browseBar.domainObject = mutable; + } else { + openmct.layout.$refs.browseObject.show(object, viewProvider.key, true, currentObjectPath); + openmct.layout.$refs.browseBar.domainObject = object; + } + openmct.layout.$refs.browseBar.viewKey = viewProvider.key; } @@ -64,23 +81,14 @@ define([ return; // Prevent race. } - let navigatedObject = objects[objects.length - 1]; + objects = objects.reverse(); - // FIXME: this is a hack to support create action, intended to - // expose the current routed path. We need to rewrite the - // navigation service and router to expose a clear and minimal - // API for this. - openmct.router.path = objects.reverse(); + openmct.router.path = objects; + browseObject = objects[0]; - unobserve = openmct.objects.observe(openmct.router.path[0], '*', (newObject) => { - openmct.router.path[0] = newObject; - browseObject = newObject; - }); + openmct.layout.$refs.browseBar.domainObject = browseObject; - openmct.layout.$refs.browseBar.domainObject = navigatedObject; - browseObject = navigatedObject; - - if (!navigatedObject) { + if (!browseObject) { openmct.layout.$refs.browseObject.clear(); return; @@ -92,13 +100,13 @@ define([ document.title = browseObject.name; //change document title to current object in main view - if (currentProvider && currentProvider.canView(navigatedObject)) { - viewObject(navigatedObject, currentProvider); + if (currentProvider && currentProvider.canView(browseObject)) { + viewObject(browseObject, currentProvider); return; } - let defaultProvider = openmct.objectViews.get(navigatedObject)[0]; + let defaultProvider = openmct.objectViews.get(browseObject)[0]; if (defaultProvider) { openmct.router.updateParams({ view: defaultProvider.key @@ -114,7 +122,13 @@ define([ function pathToObjects(path) { return Promise.all(path.map((keyString) => { - return openmct.objects.get(keyString); + let identifier = openmct.objects.parseKeyString(keyString); + + if (openmct.objects.supportsMutation(identifier)) { + return openmct.objects.getMutable(identifier); + } else { + return openmct.objects.get(identifier); + } })); } @@ -132,5 +146,15 @@ define([ }); }); } + + function clearMutationListeners() { + if (openmct.router.path !== undefined) { + openmct.router.path.forEach((pathObject) => { + if (pathObject.isMutable) { + openmct.objects.destroyMutable(pathObject); + } + }); + } + } }; });