@innovatorstack/harness 0.0.0-stage → 0.1.1

package/dist/methods/csharp/managed/DomChanges.cs

@@ -0,0 +1,39 @@
+using System.Runtime.CompilerServices;
+using System.Xml;
+
+namespace InnovatorHarness.Managed;
+
+/// <summary>
+/// Observe live DOM mutations without retaining documents after their world closes.
+/// </summary>
+internal sealed class DomChanges
+{
+    private static readonly ConditionalWeakTable<XmlDocument, DomChanges> documents = new();
+    private long revision;
+
+    private DomChanges(XmlDocument document)
+    {
+        document.NodeChanged += Changed;
+        document.NodeInserted += Changed;
+        document.NodeRemoved += Changed;
+    }
+
+    internal static long Version(XmlElement element)
+    {
+        return Version(XmlTraversal.Owner(element));
+    }
+
+    internal static long Version(XmlDocument document)
+    {
+        var changes = documents.GetValue(document, owner => new DomChanges(owner));
+
+        return Volatile.Read(ref changes.revision);
+    }
+
+    private void Changed(object? sender, XmlNodeChangedEventArgs arguments)
+    {
+        _ = sender;
+        _ = arguments;
+        Interlocked.Increment(ref revision);
+    }
+}

package/dist/methods/csharp/managed/ErrorLookup.cs

@@ -0,0 +1,28 @@
+using System.Globalization;
+
+namespace InnovatorHarness.Managed;
+
+public sealed class ErrorLookup(Remote remote)
+{
+    public string Lookup(string key, params object?[] arguments)
+    {
+        var query = new Innovator(remote).newItem("UserMessage", "get");
+        query.setAttribute("select", "name,text");
+        query.setProperty("name", key);
+        var result = query.apply();
+
+        if (result.isError() || result.getItemCount() != 1)
+        {
+            remote.Unsupported($"Import one UserMessage for error key '{key}'.");
+        }
+
+        string template = result.getProperty("text");
+
+        if (template.Length == 0)
+        {
+            remote.Unsupported($"UserMessage '{key}' has no imported message text.");
+        }
+
+        return string.Format(CultureInfo.InvariantCulture, template, arguments);
+    }
+}

package/dist/methods/csharp/managed/EventMetadata.cs

@@ -0,0 +1,45 @@
+using System.Collections.ObjectModel;
+
+namespace InnovatorHarness.Managed;
+
+public sealed class EventMetadata
+{
+    public string Kind { get; init; } = "";
+    public string? Id { get; init; }
+    public string? TypeId { get; init; }
+    public string? NewItemId { get; init; }
+    public string[]? IdList { get; init; }
+    public Dictionary<string, string>? OldIdsNewIdsMap { get; init; }
+
+    public static EventMetadata Require(Remote remote, string kind)
+    {
+        var data = remote.EventData;
+
+        if (data is null || data.Kind != kind)
+        {
+            throw new InvalidOperationException($"This Method requires '{kind}' event data.");
+        }
+
+        return data;
+    }
+
+    public static string Required(string? value, string name)
+    {
+        return value ?? throw new InvalidOperationException($"Missing event data '{name}'.");
+    }
+
+    public IReadOnlyList<string> Ids()
+    {
+        var ids = IdList ?? throw new InvalidOperationException("Missing event ID list.");
+
+        return Array.AsReadOnly(ids.ToArray());
+    }
+
+    public IReadOnlyDictionary<string, string> Mapping()
+    {
+        var mapping = OldIdsNewIdsMap
+            ?? throw new InvalidOperationException("Missing event generation mapping.");
+
+        return new ReadOnlyDictionary<string, string>(new Dictionary<string, string>(mapping));
+    }
+}

package/dist/methods/csharp/managed/GlobalUsings.cs.template

@@ -0,0 +1,9 @@
+global using System;
+global using System.Collections.Generic;
+global using System.IO;
+global using System.Linq;
+global using System.Net.Http;
+global using System.Threading;
+global using System.Threading.Tasks;
+
+[assembly: System.Reflection.AssemblyVersion("1.0.0.0")]

package/dist/methods/csharp/managed/Identity.cs

@@ -0,0 +1,30 @@
+using InnovatorHarness.Managed;
+
+namespace Aras.Server.Security;
+
+public sealed class Identity
+{
+    public string Id { get; }
+    public string Name { get; }
+
+    private Identity(string id, string name)
+    {
+        Id = id;
+        Name = name;
+    }
+
+    public static Identity? GetByName(string name)
+    {
+        var remote = RemoteContext.Current;
+        var payload = remote.Call("securityIdentity", new { name });
+
+        if (payload.Items.Count == 0)
+        {
+            return null;
+        }
+
+        var item = new Item(payload, remote);
+
+        return new Identity(item.getID(), item.getProperty("name"));
+    }
+}

package/dist/methods/csharp/managed/InOut.cs.template

@@ -0,0 +1,42 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Xml;
+using Aras.IOM;
+using InnovatorHarness.Managed;
+
+namespace InnovatorHarness.Generated;
+
+public sealed class __TYPE_NAME__ : IArasMethod
+{
+    private readonly InOutInvocation invocation;
+
+    public __TYPE_NAME__(ItemPayload context, Remote remote)
+    {
+        invocation = new InOutInvocation(context, remote);
+    }
+
+    ItemPayload IArasMethod.ContextPayload => invocation.ContextPayload;
+    XmlDocument IArasMethod.ContextDocument => invocation.Input;
+
+    public Item Execute()
+    {
+        var eventData = new __EVENT_ARGS_TYPE__(invocation.Remote, invocation.Input);
+        Run(invocation.Connection, invocation.Input, eventData, invocation.Output);
+
+        return invocation.Result();
+    }
+
+    private void Run(
+        IServerConnection InnovatorServerASP,
+        XmlDocument inDom,
+        __EVENT_ARGS_TYPE__ eventData,
+        XmlDocument outDom)
+    {
+        var CCO = invocation.Connection.CCO;
+
+#line __SOURCE_LINE__ "__SOURCE_PATH__"
+__METHOD_CODE__
+#line default
+    }
+}

package/dist/methods/csharp/managed/InOutInvocation.cs

@@ -0,0 +1,41 @@
+using System.Xml;
+using Aras.Server.Core;
+
+namespace InnovatorHarness.Managed;
+
+public sealed class InOutInvocation
+{
+    private readonly Item context;
+    public Remote Remote { get; }
+    public IOMConnection Connection { get; }
+    public XmlDocument Input { get; }
+    public XmlDocument Output { get; }
+    public ItemPayload ContextPayload => context.DocumentPayload;
+
+    public InOutInvocation(ItemPayload payload, Remote remote)
+    {
+        Remote = remote;
+        Connection = new IOMConnection(remote);
+        context = new Item(payload, remote);
+
+        Input = context.dom
+            ?? throw new InvalidOperationException("Missing Method input document.");
+
+        Output = XmlTraversal.Document();
+        PayloadXml.CreateResult(Output, new ItemPayload(), wrapEnvelope: true);
+    }
+
+    public Item Result()
+    {
+        try
+        {
+            return new Item(ResponseXml.Read(Output), Remote);
+        }
+        catch (NotSupportedException exception)
+        {
+            Remote.Unsupported(exception.Message);
+
+            throw;
+        }
+    }
+}

package/dist/methods/csharp/managed/Innovator.cs

@@ -0,0 +1,106 @@
+namespace InnovatorHarness.Managed;
+
+public sealed class Innovator(Remote remote)
+{
+    public Innovator(Aras.IOM.IServerConnection connection)
+        : this(ConnectionRemote(connection))
+    {
+    }
+
+    private static Remote ConnectionRemote(Aras.IOM.IServerConnection connection)
+    {
+        if (connection is Aras.Server.Core.IOMConnection native)
+        {
+            return native.Remote;
+        }
+
+        throw new NotSupportedException("Only the active local connection is supported.");
+    }
+
+    public Item newItem(string type = "", string action = "")
+    {
+        var item = new ItemData { Type = type };
+        item.Attributes["isNew"] = "1";
+        item.Attributes["isTemp"] = "1";
+
+        if (action.Length > 0)
+        {
+            item.Attributes["action"] = action;
+        }
+
+        if (action == "add")
+        {
+            item.Attributes["id"] = getNewID();
+        }
+
+        return new Item(new ItemPayload { Items = new() { item } }, remote);
+    }
+
+    public Item newError(string message)
+    {
+        return new Item(new ItemPayload { Error = new("ApplicationError", message) }, remote);
+    }
+
+    public string getNewID()
+    {
+        return remote.Call("newId", new { }).Result
+            ?? throw new InvalidOperationException("The Item ID port returned no ID.");
+    }
+
+    public Item newResult(string value)
+    {
+        return new Item(new ItemPayload { Result = value }, remote);
+    }
+
+    public string getUserID()
+    {
+        ItemPayload session = remote.Call("session", new
+        {
+        });
+
+        return session.Result
+            ?? throw new InvalidOperationException("The current session has no user.");
+    }
+
+    public Item applyAML(string xml)
+    {
+        return new Item(remote.Call("aml", new
+        {
+            xml
+        }), remote);
+    }
+
+    public Item applyMethod(string name, string body)
+    {
+        return new Item(remote.Call("method", new
+        {
+            name,
+            body
+        }), remote);
+    }
+
+    public Item applySQL(string sql)
+    {
+        return new Item(remote.Call("sql", new
+        {
+            sql
+        }), remote);
+    }
+
+    public Item applySQLWithParameters(string sql, string parameters)
+    {
+        return new Item(remote.Call("sql", new
+        {
+            sql,
+            parameters
+        }), remote);
+    }
+
+    public Item getItemById(string type, string id)
+    {
+        Item request = newItem(type, "get");
+        request.setID(id);
+
+        return request.apply();
+    }
+}