Folders hierarchy

[serbuh]

I am struggling with Object Provider and Composition Provider in order to create folders tree.
My use case is to create a folder hierarchy from the name of the field that is delimited with "."
For example Spacecraft.FuelSystem.Pressure and Spacecraft.FuelSystem.Fuel shall create the tree:

Spacecraft
└─ FuelSystem
   ├─ Pressure
   └─ Fuel

I would be very thankful for some more examples of use of the Object and Composition Providers

Related topics:
Help With Object Provider and Composition Provider #2281
Templated object views #5334

[jtrack3d]

Not sure I can share an example, but I think I can point out a few things.

1. In my mind, composition provider provides a list of 'identifiers' { key , namespace} that are a children of a folder. This is how I have observed the "My Items" folder works. It puts them under the "composition" sub-element.
2. Then, the Object Provider indicates if it is a "folder" node or a child node.
3. All nodes have a "location" which references either "ROOT" (toplevel) or it's parent.

Take a look at ObjectAPISpec.js (around line 490) where they mock up a grand parent, parent, and child nodes for a hint at what the nodes should look like.

[ozyx]

Hi @serbuh !

I found an example that might help here. We do something similar when loading the telemetry dictionary from YAMCS in our openmct-yamcs plugin. For each "SpaceSystem" (grouping of parameters) we create a folder and add it to the Root object's composition array. Then, for each Parameter, we create the appropriate object for it and eventually add it to its parent object's composition.

This is of course a much more complex example, but I hope it can serve as a blueprint that you can adapt to suit your own needs. Please let us know if it helps or if any issues arise.

Cheers,
Jesse

[serbuh]

Hey @ozyx ,

Thank you for the detailed answer! That's makes some order.
I think I have a fundamental misunderstanding of how the composition of object retrieval works. When does the load() of custom composition provider invoked?
As I understand, each domain object that has type "folder" should also have a "composition" list of identifiers. If I would build my domain objects with composition field with the list of the child domain objects - will they would be retrieved by default composition provider, right? I see that in your example you have not implemented the custom composition provider.

Thank you,
Sergey

[ozyx]

I think I have a fundamental misunderstanding of how the composition of object retrieval works. When does the load() of custom composition provider invoked?

composition.load() is called whenever it's needed to access the deserialized DomainObjects themselves. For example, when the object tree mounts, it will load the ROOT object's composition and use the properties of the DomainObjects to create TreeItems which are then rendered by Vue.

As I understand, each domain object that has type "folder" should also have a "composition" list of identifiers. If I would build my domain objects with composition field with the list of the child domain objects - will they would be retrieved by default composition provider, right? I see that in your example you have not implemented the custom composition provider.

Yes, the default composition provider will be used if no others are registered to your custom namespace, so you may not need a custom one. I see you've already added a new Root for your main folder, which is great. You'll also need to register an Object Provider to your namespace to define how Open MCT can serve those objects. You could, for example, create an ObjectProvider that first parses your JSON, prepares domain objects in the format Open MCT expects, and stores them in a map. Then, simply define its get() function to serve the objects from the map:

const dictionary = require('dictionary.json');

class MyCustomObjectProvider {
  constructor() {
    this.dictionary = new Map();
    // Parse the dictionary JSON file, create domain objects,
    // and add them to the dictionary map.
    loadDictionary(dictionary);
  }

  // Tells the Open MCT ObjectAPI how to load domain objects
  // from this namespace when requested.
  async get(identifier) {
    const { key } = identifier;
    return this.dictionary.get(key);
  }
};

openmct.objects.addProvider('TelemetryMainspace', new MyCustomObjectProvider());

Hope this helps. Give it a shot and let me know if you have any questions! 🚀

[serbuh]

Thank you for the help.
Finally managed to get the desired results!

In the JSON I added nested_under field that points to the ObjectProvider and CompositionProvider where to nest the specific folder/telemetry entry.

JSON:

{
    "version": "2024_02_11",
    "measurements": [
        {
            "name": "Folder_0",
            "key": "Folder_0",
            "nested_under": "RootFolder"
        },
        {
            "name": "Folder_0_1",
            "key": "Folder_0_1",
            "nested_under": "Folder_0"
        },
        {
            "name": "A",
            "key": "A",
            "nested_under": "Folder_0_1",
            "values": [
                {
                    "key": "value",
                    "name": "Value",
                    "units": "unit",
                    "format": "number",
                    "hints": {
                        "range": 1
                    }
                },
                {
                    "key": "utc",
                    "source": "timestamp",
                    "name": "Timestamp",
                    "format": "utc",
                    "hints": {
                        "domain": 1
                    }
                }
            ]
        },
        {
            "name": "B",
            "key": "Folder_0.B",
            "nested_under": "Folder_0",
            "values": [
                {
                    "key": "value",
                    "name": "Value",
                    "units": "unit",
                    "format": "string",
                    "hints": {
                        "range": 1
                    }
                },
                {
                    "key": "utc",
                    "source": "timestamp",
                    "name": "Timestamp",
                    "format": "utc",
                    "hints": {
                        "domain": 1
                    }
                }
            ]
        },
        {
            "name": "C",
            "key": "C",
            "nested_under": "RootFolder",
            "values": [
                {
                    "key": "value",
                    "name": "Value",
                    "units": "unit",
                    "format": "number",
                    "hints": {
                        "range": 1
                    }
                },
                {
                    "key": "utc",
                    "source": "timestamp",
                    "name": "Timestamp",
                    "format": "utc",
                    "hints": {
                        "domain": 1
                    }
                }
            ]
        }
    ]
}

Dictionary plugin (with Object and Composition Providers)

import dictionary_src from './openmct_interface.json' assert { type: 'json' };

export default function TelemetryDictionaryPlugin() {
    function get_openmct_interface() {
        return Promise.resolve(dictionary_src)
    }

    return function install(openmct) {
        // The addRoot function takes an "object identifier" as an argument
        openmct.objects.addRoot({
            namespace: 'TelemetryMainspace',
            key: 'RootFolder'
        });

        // An object provider builds Domain Objects
        openmct.objects.addProvider('TelemetryMainspace', {
            get: function(identifier) {
                return get_openmct_interface().then(function (dictionary) {
                    if (identifier.key === 'RootFolder') {
                        // Create root folder
                        return {
                            identifier: identifier,
                            name: "PredefinedTelemetry",
                            type: 'folder',
                            location: 'ROOT'
                        };
                    } else {
                        var measurement = dictionary.measurements.filter(function (m) {
                            return m.key === identifier.key;
                        })[0];
                        // Asuming that telemetry entries has 'value' fields. Otherwise treating as a folder
                        if (measurement.hasOwnProperty('values')) {
                            // Telemetry entry
                            return {
                                identifier: identifier,
                                name: measurement.name,
                                type: 'TelemetryDomainObject',
                                telemetry: {
                                    values: measurement.values
                                },
                                location: 'TelemetryMainspace:' + measurement.nested_under
                            };
                        } else {
                            // Folder
                            return {
                                identifier: identifier,
                                name: measurement.name,
                                type: 'folder',
                                location: 'TelemetryMainspace:' + measurement.nested_under
                            };    
                        }
                    }
                });
            }
        });

        // Composition provider
        openmct.composition.addProvider({
            appliesTo: function (domainObject) {
                return domainObject.identifier.namespace === 'TelemetryMainspace'
                && domainObject.type === 'folder';
            },
            load: function (domainObject) {
                // console.log("Load for " + domainObject.identifier.key)
                return get_openmct_interface()
                    .then(function (dictionary) {
                        return dictionary.measurements
                            .filter(m => domainObject.identifier.key === m.nested_under)
                            .map(function (m) {
                            // console.log("   load " + domainObject.identifier.key + " -> " + m.key + " under " + m.nested_under)
                            return {
                                namespace: 'TelemetryMainspace',
                                key: m.key
                            };
                        });
                    });
            }
        });

        openmct.types.addType('TelemetryDomainObject', {
            name: 'Telemetry Point',
            description: 'Telemetry',
            cssClass: 'icon-telemetry',
        });
    };
}

[serbuh]

Hey @ozyx,
I think it would be nice if the development team could include such example that could be easily found be the new users that are starting to write there own plugins (It can be added in plugin examples / README.md / API.md / ...)
Readme explanations worked less for me. And your "complex" example of openmct-yamcs object-provider.js gave me the real push of understanding the mechanisms.
So basic examples could dramatically shorten the time to dive in into the OpenMCT.

Cheers,
Sergey

[ozyx]

@serbuh Totally agree. Our tutorials and examples are in desperate need of an update. We will be prioritizing this more in the coming months. In the meantime, thank you for linking this thread to other folks with similar issues. It is very much appreciated.