feature: update expression browser and add plugin expression extensions

2025-01-16 12:36:01 +11:00
parent 963970feeb
commit a3e1e1d030
23 changed files with 652 additions and 555 deletions
@@ -0,0 +1,160 @@
+@model Disco.Web.Areas.Config.Models.Expressions.BrowserModel
+@{
+    Authorization.Require(Claims.Config.Show);
+
+    ViewBag.Title = Html.ToBreadcrumb("Configuration", MVC.Config.Config.Index(), "Expression Browser");
+    Html.BundleDeferred("~/Style/jQueryUI/dynatree");
+    Html.BundleDeferred("~/ClientScripts/Modules/jQueryUI-DynaTree");
+}
+<div id="Config_Expressions_Browser">
+    Expressions within Disco ICT are based on the <a href="http://www.springframework.net/" target="_blank">Spring.NET Framework</a>. Please refer to the <a href="http://www.springframework.net/doc-latest/reference/html/expressions.html" target="_blank">Expression Evaluation</a> documentation.
+    <h2 id="DeviceScope">
+        Device Scope
+    </h2>
+    <div id="deviceScopeTree" class="expressionTree">
+    </div>
+    <h2 id="JobScope">
+        Job Scope
+    </h2>
+    <div id="jobScopeTree" class="expressionTree">
+    </div>
+    <h2 id="UserScope">
+        User Scope
+    </h2>
+    <div id="userScopeTree" class="expressionTree">
+    </div>
+    <h2 id="Variables">
+        Variables
+    </h2>
+    <div id="variableScopeTree" class="expressionTree">
+    </div>
+    <h2 id="ExtensionLibraries">
+        Extension Libraries
+    </h2>
+    <div id="extScopeTree" class="expressionTree">
+    </div>
+    @if (Model.PluginExtensionLibraries.Any())
+    {
+        <h2 id="PluginExtensionLibraries">
+            Plugin Extension Libraries
+        </h2>
+        <div id="pluginExtScopeTree" class="expressionTree">
+        </div>
+    }
+</div>
+<script id="expressionBrowserModel" type="application/json">
+@Html.Raw(Json.Encode(Model))
+</script>
+@using (Html.BeginForm(MVC.API.Expressions.TypeDescriptor(), FormMethod.Post, new { id = "expressionBrowserForm" }))
+{
+    @Html.AntiForgeryToken()
+}
+<script type="text/javascript">
+    $(function () {
+        if (!document.DiscoFunctions) {
+            document.DiscoFunctions = {};
+        }
+
+        const typeLib = {};
+        const model = JSON.parse($('#expressionBrowserModel').html());
+
+        function lazyLoadNode(node) {
+            if (node.data.expressionType) {
+                node.setLazyNodeStatus(DTNodeStatus_Loading);
+                loadType(node, node.data.expressionType, node.data.staticMembersOnly);
+            } else {
+                if (node.data.memberDescriptor) {
+                    loadMember(node);
+                } else {
+                    node.setLazyNodeStatus(DTNodeStatus_Ok);
+                }
+            }
+        }
+        function loadMember(memberNode) {
+            const previousUpdateMode = memberNode.tree.enableUpdate(false);
+            const memberDescriptor = memberNode.data.memberDescriptor;
+            // Return Type
+            memberNode.addChild({ title: 'Returns: ' + memberDescriptor.ReturnType, tooltip: memberDescriptor.ReturnExpressionType, isFolder: true, expressionType: memberDescriptor.ReturnExpressionType, isLazy: true, addClass: 'object' });
+            // Parameters
+            const parametersNode = memberNode.addChild({ title: 'Parameters', isFolder: true, addClass: 'parameter' });
+            for (let i = 0; i < memberDescriptor.Parameters.length; i++) {
+                const p = memberDescriptor.Parameters[i];
+                parametersNode.addChild({ title: p.Name + ' [' + p.ReturnType + ']', tooltip: p.ReturnExpressionType, addClass: 'object' });
+            }
+            memberNode.setLazyNodeStatus(DTNodeStatus_Ok);
+            memberNode.tree.enableUpdate(previousUpdateMode);
+        }
+        function typeLoaded(parentNode, typeDescriptor) {
+            const previousUpdateMode = parentNode.tree.enableUpdate(false);
+            for (let i = 0; i < typeDescriptor.Members.length; i++) {
+                const memberDescriptor = typeDescriptor.Members[i];
+                parentNode.addChild({ title: memberDescriptor.Name, tooltip: memberDescriptor.ReturnType, isFolder: true, addClass: memberDescriptor.Kind, memberDescriptor: memberDescriptor, isLazy: true });
+            }
+            parentNode.setLazyNodeStatus(DTNodeStatus_Ok);
+            parentNode.tree.enableUpdate(previousUpdateMode);
+        }
+
+        async function loadType(parentNode, type, staticMembersOnly) {
+            let typeDef = typeLib[type];
+            if (!typeDef) {
+                $form = $('#expressionBrowserForm');
+                const url = $form.attr('action');
+                const body = new FormData($form[0]);
+                body.append('type', type);
+                if (staticMembersOnly) {
+                    body.append('staticMembersOnly', staticMembersOnly);
+                }
+
+                const response = await fetch(url, {
+                    method: 'POST',
+                    body: body
+                });
+
+                if (!response.ok) {
+                    console.error('Failed to load type', response);
+                    return;
+                }
+
+                typeDef = await response.json();
+
+                typeLib[type] = typeDef;
+            }
+            typeLoaded(parentNode, typeDef);
+        }
+
+        const deviceScopeTree = $('#deviceScopeTree');
+        deviceScopeTree.dynatree({ onLazyRead: lazyLoadNode });
+        loadType(deviceScopeTree.dynatree('getRoot'), model.DeviceType);
+
+        const jobScopeTree = $('#jobScopeTree');
+        jobScopeTree.dynatree({ onLazyRead: lazyLoadNode });
+        loadType(jobScopeTree.dynatree('getRoot'), model.JobType);
+
+        const userScopeTree = $('#userScopeTree');
+        userScopeTree.dynatree({ onLazyRead: lazyLoadNode });
+        loadType(userScopeTree.dynatree('getRoot'), model.UserType);
+
+        const variableScopeTree = $('#variableScopeTree');
+        variableScopeTree.dynatree({ onLazyRead: lazyLoadNode });
+        Object.keys(model.Variables).forEach(name => {
+            const type = model.Variables[name];
+            variableScopeTree.dynatree('getRoot').addChild({ title: name, tooltip: type, isFolder: true, addClass: 'object', expressionType: type, isLazy: true });
+        })
+
+        const extScopeTree = $('#extScopeTree');
+        extScopeTree.dynatree({ onLazyRead: lazyLoadNode });
+        Object.keys(model.ExtensionLibraries).forEach(name => {
+            const type = model.ExtensionLibraries[name];
+            extScopeTree.dynatree('getRoot').addChild({ title: name, tooltip: type, isFolder: true, addClass: 'object', expressionType: type, staticMembersOnly: true, isLazy: true });
+        })
+
+        const pluginExtScopeTree = $('#pluginExtScopeTree');
+        if (pluginExtScopeTree.length) {
+            pluginExtScopeTree.dynatree({ onLazyRead: lazyLoadNode });
+            Object.keys(model.PluginExtensionLibraries).forEach(name => {
+                const type = model.PluginExtensionLibraries[name];
+                pluginExtScopeTree.dynatree('getRoot').addChild({ title: name, tooltip: type, isFolder: true, addClass: 'object', expressionType: type, staticMembersOnly: true, isLazy: true });
+            })
+        }
+    });
+</script>