Static root plugin not loading after namespace/key changes in OpenMCT #4684

Static root plugin not loading after namespace/key changes in OpenMCT

src/plugins/plugins.js

@@ -151,7 +151,7 @@ define([
 
     plugins.MyItems = MyItems.default;
 
-    plugins.StaticRootPlugin = StaticRootPlugin;
+    plugins.StaticRootPlugin = StaticRootPlugin.default;
 
     /**
      * A tabular view showing the latest values of multiple telemetry points at

src/plugins/staticRootPlugin/StaticModelProvider.js

@@ -1,45 +1,139 @@
-define([
-    'objectUtils'
-], function (
-    objectUtils
-) {
-    /**
+/*****************************************************************************
+ * Open MCT, Copyright (c) 2014-2022, 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.
+ *****************************************************************************/
+
+/**
  * Transforms an import json blob into a object map that can be used to
  * provide objects.  Rewrites root identifier in import data with provided
  * rootIdentifier, and rewrites all child object identifiers so that they
  * exist in the same namespace as the rootIdentifier.
  */
-    function rewriteObjectIdentifiers(importData, rootIdentifier) {
-        const rootId = importData.rootId;
-        let objectString = JSON.stringify(importData.openmct);
+import objectUtils from 'objectUtils';
 
-        Object.keys(importData.openmct).forEach(function (originalId, i) {
-            let newId;
-            if (originalId === rootId) {
-                newId = objectUtils.makeKeyString(rootIdentifier);
+class StaticModelProvider {
+    constructor(importData, rootIdentifier) {
+        this.objectMap = {};
+        this.rewriteModel(importData, rootIdentifier);
+    }
+
+    /**
+     * Standard "Get".
+     */
+    get(identifier) {
+        const keyString = objectUtils.makeKeyString(identifier);
+        if (this.objectMap[keyString]) {
+            return this.objectMap[keyString];
+        }
+
+        throw new Error(keyString + ' not found in import models.');
+    }
+
+    parseObjectLeaf(objectLeaf, idMap, namespace) {
+        Object.keys(objectLeaf).forEach((nodeKey) => {
+            if (idMap.get(nodeKey)) {
+                const newIdentifier = objectUtils.makeKeyString({
+                    namespace,
+                    key: idMap.get(nodeKey)
+                });
+                objectLeaf[newIdentifier] = { ...objectLeaf[nodeKey] };
+                delete objectLeaf[nodeKey];
+                objectLeaf[newIdentifier] = this.parseTreeLeaf(newIdentifier, objectLeaf[newIdentifier], idMap, namespace);
             } else {
-                newId = objectUtils.makeKeyString({
-                    namespace: rootIdentifier.namespace,
-                    key: i
-                });
-            }
-
-            while (objectString.indexOf(originalId) !== -1) {
-                objectString = objectString.replace(
-                    '"' + originalId + '"',
-                    '"' + newId + '"'
-                );
+                objectLeaf[nodeKey] = this.parseTreeLeaf(nodeKey, objectLeaf[nodeKey], idMap, namespace);
             }
         });
 
-        return JSON.parse(objectString);
+        return objectLeaf;
+    }
+
+    parseArrayLeaf(arrayLeaf, idMap, namespace) {
+        return arrayLeaf.map((leafValue, index) => this.parseTreeLeaf(
+            null, leafValue, idMap, namespace));
+    }
+
+    parseBranchedLeaf(branchedLeafValue, idMap, namespace) {
+        if (Array.isArray(branchedLeafValue)) {
+            return this.parseArrayLeaf(branchedLeafValue, idMap, namespace);
+        } else {
+            return this.parseObjectLeaf(branchedLeafValue, idMap, namespace);
+        }
+    }
+
+    parseTreeLeaf(leafKey, leafValue, idMap, namespace) {
+        const hasChild = typeof leafValue === 'object';
+        if (hasChild) {
+            return this.parseBranchedLeaf(leafValue, idMap, namespace);
+        }
+
+        if (leafKey === 'key') {
+            return idMap.get(leafValue);
+        } else if (leafKey === 'namespace') {
+            return namespace;
+        } else if (leafKey === 'location') {
+            if (idMap.get(leafValue)) {
+                const newLocationIdentifier = objectUtils.makeKeyString({
+                    namespace,
+                    key: idMap.get(leafValue)
+                });
+
+                return newLocationIdentifier;
+            }
+
+            return null;
+        } else if (idMap.get(leafValue)) {
+            const newIdentifier = objectUtils.makeKeyString({
+                namespace,
+                key: idMap.get(leafValue)
+            });
+
+            return newIdentifier;
+        } else {
+            return leafValue;
+        }
+    }
+
+    rewriteObjectIdentifiers(importData, rootIdentifier) {
+        const namespace = rootIdentifier.namespace;
+        const idMap = new Map();
+        const objectTree = importData.openmct;
+
+        Object.keys(objectTree).forEach((originalId, index) => {
+            let newId = index.toString();
+            if (originalId === importData.rootId) {
+                newId = rootIdentifier.key;
+            }
+
+            idMap.set(originalId, newId);
+        });
+
+        const newTree = this.parseTreeLeaf(null, objectTree, idMap, namespace);
+
+        return newTree;
     }
 
     /**
      * Converts all objects in an object make from old format objects to new
      * format objects.
      */
-    function convertToNewObjects(oldObjectMap) {
+    convertToNewObjects(oldObjectMap) {
         return Object.keys(oldObjectMap)
             .reduce(function (newObjectMap, key) {
                 newObjectMap[key] = objectUtils.toNewFormat(oldObjectMap[key], key);
@@ -49,7 +143,7 @@ define([
     }
 
     /* Set the root location correctly for a top-level object */
-    function setRootLocation(objectMap, rootIdentifier) {
+    setRootLocation(objectMap, rootIdentifier) {
         objectMap[objectUtils.makeKeyString(rootIdentifier)].location = 'ROOT';
 
         return objectMap;
@@ -59,24 +153,11 @@ define([
      * Takes importData (as provided by the ImportExport plugin) and exposes
      * an object provider to fetch those objects.
      */
-    function StaticModelProvider(importData, rootIdentifier) {
-        const oldFormatObjectMap = rewriteObjectIdentifiers(importData, rootIdentifier);
-        const newFormatObjectMap = convertToNewObjects(oldFormatObjectMap);
-        this.objectMap = setRootLocation(newFormatObjectMap, rootIdentifier);
+    rewriteModel(importData, rootIdentifier) {
+        const oldFormatObjectMap = this.rewriteObjectIdentifiers(importData, rootIdentifier);
+        const newFormatObjectMap = this.convertToNewObjects(oldFormatObjectMap);
+        this.objectMap = this.setRootLocation(newFormatObjectMap, rootIdentifier);
     }
+}
 
-    /**
-     * Standard "Get".
-     */
-    StaticModelProvider.prototype.get = function (identifier) {
-        const keyString = objectUtils.makeKeyString(identifier);
-        if (this.objectMap[keyString]) {
-            return this.objectMap[keyString];
-        }
-
-        throw new Error(keyString + ' not found in import models.');
-    };
-
-    return StaticModelProvider;
-
-});
+export default StaticModelProvider;

src/plugins/staticRootPlugin/StaticModelProviderSpec.js

@@ -1,12 +1,29 @@
-define([
-    './StaticModelProvider',
-    './static-provider-test.json'
-], function (
-    StaticModelProvider,
-    testStaticData
-) {
+/*****************************************************************************
+ * Open MCT, Copyright (c) 2014-2022, 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.
+ *****************************************************************************/
 
-    describe('StaticModelProvider', function () {
+import testStaticData from './static-provider-test.json';
+import StaticModelProvider from './StaticModelProvider';
+
+describe('StaticModelProvider', function () {
 
     let staticProvider;
 
@@ -129,5 +146,4 @@ define([
         });
 
     });
-    });
 });

src/plugins/staticRootPlugin/plugin.js

@@ -1,23 +1,37 @@
-define([
-    './StaticModelProvider'
-], function (
-    StaticModelProvider
-) {
-    /**
-     * Static Root Plugin: takes an export file and exposes it as a new root
-     * object.
-     */
-    function StaticRootPlugin(namespace, exportUrl) {
+/*****************************************************************************
+ * Open MCT, Copyright (c) 2014-2022, 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 StaticModelProvider from './StaticModelProvider';
+
+export default function StaticRootPlugin(options) {
     const rootIdentifier = {
-            namespace: namespace,
+        namespace: options.namespace,
         key: 'root'
     };
 
     let cachedProvider;
 
     function loadProvider() {
-            return fetch(exportUrl)
+        return fetch(options.exportUrl)
             .then(function (response) {
                 return response.json();
             })
@@ -38,7 +52,7 @@ define([
 
     return function install(openmct) {
         openmct.objects.addRoot(rootIdentifier);
-            openmct.objects.addProvider(namespace, {
+        openmct.objects.addProvider(options.namespace, {
             get: function (identifier) {
                 return getProvider().then(function (provider) {
                     return provider.get(identifier);
@@ -46,7 +60,4 @@ define([
             }
         });
     };
-    }
-
-    return StaticRootPlugin;
-});
+}