node-red-contrib-avid-interplay 1.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 ZZZCROSSS
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,162 @@
+# node-red-contrib-avid-interplay
+
+A [Node-RED](https://nodered.org) package for calling the **Avid Interplay PAM SOAP Web Services**.
+
+Supports all standard Avid Interplay services: **Assets**, **Archive**, **Infrastructure**, **Jobs**, **Transfer**, **UserManagement**.
+
+---
+
+## Features
+
+- Service and operation selected via dropdown menus in the node editor
+- **Live WSDL introspection** — operations are fetched directly from the server at design time
+- **Payload template generator** — reads the XSD schema and produces an annotated `msg.payload` template with `[R]` / `[O]` markers
+- WS-Security `UsernameToken` authentication
+- Configurable HTTP timeout
+- Accepts self-signed / internal CA certificates
+- Runtime override via `msg.service` and `msg.operation`
+
+---
+
+## Installation
+
+```bash
+# inside your Node-RED user directory (usually ~/.node-red)
+npm install node-red-contrib-avid-interplay
+```
+
+Or use the **Manage Palette** panel in the Node-RED editor.
+
+---
+
+## Nodes
+
+### `interplay-config` (config node)
+
+Holds the connection settings shared by all request nodes.
+
+| Field | Description |
+|---|---|
+| **Base URL** | Root CXF endpoint, e.g. `https://host:1881/services` |
+| **Username** | Interplay username (optional) |
+| **Password** | Interplay password (optional) |
+| **Timeout** | HTTP request timeout in ms (default: 30 000) |
+| **Allow self-signed SSL** | Bypass certificate verification for internal servers |
+
+### `interplay-request` (function node)
+
+Executes a single SOAP operation and outputs the response.
+
+| Field | Description |
+|---|---|
+| **Server** | Reference to an `interplay-config` node |
+| **Service** | One of `Assets`, `Archive`, `Infrastructure`, `Jobs`, `Transfer`, `UserManagement` |
+| **Operation** | Loaded from the live WSDL after clicking **Load operations from WSDL** |
+
+#### Buttons
+
+| Button | Action |
+|---|---|
+| **Load operations from WSDL** | Fetches the operation list from `{baseUrl}/{service}?wsdl` |
+| **Generate payload template** | Parses the XSD schema and renders an annotated `msg.payload` template |
+
+---
+
+## Usage
+
+1. Add an **`interplay-config`** node and fill in the server URL and credentials.
+2. Drop an **`interplay-request`** node onto the canvas and open it.
+3. Select the **Service** (e.g. `Assets`).
+4. Click **Load operations from WSDL** — the Operation dropdown will populate.
+5. Select an **Operation** (e.g. `GetChildren`).
+6. Click **Generate payload template** — an annotated JSON template appears.
+7. Copy the template and paste it into an upstream **Change** or **Function** node,
+   replacing placeholder values with real data.
+8. Wire the output of that node to the `interplay-request` node.
+
+### Payload template legend
+
+```
+[R]  Required — must be provided
+[O]  Optional — may be omitted
+```
+
+A value wrapped in `[…]` is a repeatable array element.  
+The `_legend` key is metadata only — **do not include it** in `msg.payload`.
+
+### Example
+
+```javascript
+// Function node upstream of interplay-request
+msg.payload = {
+    InterplayURI: "interplay://MyWorkgroup/MyDatabase/Projects/MyFolder"
+};
+return msg;
+```
+
+---
+
+## Message properties
+
+### Input
+
+| Property | Type | Description |
+|---|---|---|
+| `msg.payload` | object | Operation parameters (property names must match the XSD element names) |
+| `msg.service` | string | *(optional)* Runtime override for the service name |
+| `msg.operation` | string | *(optional)* Runtime override for the operation name |
+
+### Output
+
+| Property | Type | Description |
+|---|---|---|
+| `msg.payload` | object | Deserialised SOAP response. A top-level `<return>` element is unwrapped automatically |
+| `msg.statusCode` | number | HTTP status code of the SOAP response |
+| `msg.service` | string | Name of the service that was called |
+| `msg.operation` | string | Name of the operation that was called |
+
+---
+
+## Supported services
+
+| Service | Endpoint path |
+|---|---|
+| Assets | `/services/Assets` |
+| Archive | `/services/Archive` |
+| Infrastructure | `/services/Infrastructure` |
+| Jobs | `/services/Jobs` |
+| Transfer | `/services/Transfer` |
+| UserManagement | `/services/UserManagement` |
+
+---
+
+## Cache management
+
+WSDL and XSD documents are cached in memory after the first load. To force a reload
+(e.g. after an Interplay server upgrade), send a `POST` request from Node-RED to the
+internal admin endpoint:
+
+```
+POST /interplay/clear-cache
+```
+
+---
+
+## Error handling
+
+On SOAP fault or network error the node raises a Node-RED error catchable with a
+**Catch** node. The error message is in `error.message`.
+
+---
+
+## Requirements
+
+- Node-RED ≥ 3.0.0
+- Node.js ≥ 14.0.0
+- Network access to the Avid Interplay server at design time (for WSDL/XSD introspection)
+
+---
+
+## License
+
+[MIT](LICENSE)

package/interplay.html

@@ -0,0 +1,501 @@
+<!-- ══════════════════════════════════════════════════════════════════════════
+     interplay-config  –  Config node
+     ══════════════════════════════════════════════════════════════════════════ -->
+<script type="text/html" data-template-name="interplay-config">
+
+  <div class="form-row">
+    <label for="node-config-input-name">
+      <i class="fa fa-tag"></i> Name
+    </label>
+    <input type="text" id="node-config-input-name" placeholder="Interplay Server">
+  </div>
+
+  <div class="form-row">
+    <label for="node-config-input-baseUrl">
+      <i class="fa fa-globe"></i> Base URL
+    </label>
+    <input type="text" id="node-config-input-baseUrl"
+           placeholder="https://host:1881/services"
+           style="width:72%">
+  </div>
+
+  <div class="form-row">
+    <label for="node-config-input-username">
+      <i class="fa fa-user"></i> Username
+    </label>
+    <input type="text" id="node-config-input-username" placeholder="(optional)">
+  </div>
+
+  <div class="form-row">
+    <label for="node-config-input-password">
+      <i class="fa fa-lock"></i> Password
+    </label>
+    <input type="password" id="node-config-input-password" placeholder="(optional)">
+  </div>
+
+  <div class="form-row">
+    <label for="node-config-input-timeout">
+      <i class="fa fa-clock-o"></i> Timeout
+    </label>
+    <input type="number" id="node-config-input-timeout"
+           placeholder="30000" style="width:100px"> ms
+  </div>
+
+  <div class="form-row">
+    <label style="width:auto">
+      <i class="fa fa-shield"></i>&nbsp;
+    </label>
+    <input type="checkbox" id="node-config-input-allowSelfSigned"
+           style="display:inline-block;width:auto;margin-right:6px">
+    <label for="node-config-input-allowSelfSigned" style="width:auto">
+      Allow self-signed / internal SSL certificates
+    </label>
+  </div>
+
+  <div class="form-tips">
+    Credentials are injected as a WS-Security <code>UsernameToken</code> SOAP header on every request.<br>
+    Enable <em>Allow self-signed SSL</em> when the server uses an internal CA certificate.
+  </div>
+
+</script>
+
+<script type="text/javascript">
+RED.nodes.registerType("interplay-config", {
+  category: "config",
+  defaults: {
+    name:            { value: "" },
+    baseUrl:         { value: "https://yourwebservice.yourdomain:1881/services", required: true },
+    timeout:         { value: 30000 },
+    allowSelfSigned: { value: true },
+  },
+  credentials: {
+    username: { type: "text"     },
+    password: { type: "password" },
+  },
+  label: function () {
+    return this.name || this.baseUrl || "Interplay Server";
+  },
+});
+</script>
+
+
+<!-- ══════════════════════════════════════════════════════════════════════════
+     interplay-request  –  Request node
+     ══════════════════════════════════════════════════════════════════════════ -->
+<script type="text/html" data-template-name="interplay-request">
+
+  <!-- Name -->
+  <div class="form-row">
+    <label for="node-input-name">
+      <i class="fa fa-tag"></i> Name
+    </label>
+    <input type="text" id="node-input-name" placeholder="Interplay Request">
+  </div>
+
+  <!-- Server -->
+  <div class="form-row">
+    <label for="node-input-server">
+      <i class="fa fa-server"></i> Server
+    </label>
+    <input type="text" id="node-input-server">
+  </div>
+
+  <!-- Service selector -->
+  <div class="form-row">
+    <label for="node-input-service">
+      <i class="fa fa-cogs"></i> Service
+    </label>
+    <select id="node-input-service" style="width:72%">
+      <option value="Assets">Assets</option>
+      <option value="Archive">Archive</option>
+      <option value="Infrastructure">Infrastructure</option>
+      <option value="Jobs">Jobs</option>
+      <option value="Transfer">Transfer</option>
+      <option value="UserManagement">UserManagement</option>
+    </select>
+  </div>
+
+  <!-- Load operations button -->
+  <div class="form-row">
+    <label></label>
+    <button id="interplay-load-ops-btn" type="button"
+            class="red-ui-button" style="font-size:12px">
+      <i class="fa fa-refresh"></i>&nbsp;Load operations from WSDL
+    </button>
+    <span id="interplay-ops-spinner"
+          style="display:none;margin-left:8px;font-size:12px;color:#888">
+      <i class="fa fa-spinner fa-spin"></i> Loading…
+    </span>
+  </div>
+
+  <!-- Operation selector -->
+  <div class="form-row">
+    <label for="node-input-operation">
+      <i class="fa fa-bolt"></i> Operation
+    </label>
+    <select id="node-input-operation" style="width:72%">
+      <option value="">— select operation —</option>
+    </select>
+  </div>
+
+  <!-- Namespace info (shown after WSDL load) -->
+  <div id="interplay-ns-row" style="display:none;margin-left:112px;margin-bottom:8px">
+    <span style="font-size:11px;color:#888">
+      Namespace: <code id="interplay-ns-lbl" style="color:#4a90d9"></code>
+    </span>
+  </div>
+
+  <!-- Load parameters button -->
+  <div class="form-row" id="interplay-load-params-row" style="display:none">
+    <label></label>
+    <button id="interplay-load-params-btn" type="button"
+            class="red-ui-button" style="font-size:12px">
+      <i class="fa fa-magic"></i>&nbsp;Generate payload template
+    </button>
+    <span id="interplay-params-spinner"
+          style="display:none;margin-left:8px;font-size:12px;color:#888">
+      <i class="fa fa-spinner fa-spin"></i> Loading…
+    </span>
+  </div>
+
+  <!-- Schema / template box -->
+  <div id="interplay-schema-wrap" style="display:none;margin-top:4px">
+
+    <div style="font-size:11px;padding:4px 8px;margin-bottom:4px;
+                background:#f5f5f5;border:1px solid #ddd;border-radius:3px;
+                display:flex;justify-content:space-between;align-items:center">
+      <span>
+        <strong>msg.payload template</strong>&nbsp;&nbsp;
+        <code style="color:#2a7">&#91;R&#93;</code> = required&nbsp;&nbsp;
+        <code style="color:#a70">&#91;O&#93;</code> = optional
+      </span>
+      <span>
+        <button id="interplay-copy-btn" type="button"
+                class="red-ui-button" style="font-size:11px;padding:2px 8px">
+          <i class="fa fa-copy"></i>&nbsp;Copy
+        </button>
+        <span id="interplay-copy-ok"
+              style="display:none;font-size:11px;color:green;margin-left:6px">
+          Copied!
+        </span>
+      </span>
+    </div>
+
+    <pre id="interplay-schema-json"
+         style="background:#1e1e1e;color:#d4d4d4;padding:12px;border-radius:4px;
+                font-size:12px;overflow:auto;max-height:340px;margin:0;
+                white-space:pre;line-height:1.5"></pre>
+
+    <div style="margin-top:4px;font-size:11px;color:#888">
+      <i class="fa fa-info-circle"></i>
+      Populate a <b>Change</b> or <b>Function</b> node upstream with this JSON
+      (replace the placeholder values), then wire its output to this node.
+    </div>
+  </div>
+
+  <!-- Error box -->
+  <div id="interplay-error"
+       style="display:none;margin-top:6px;padding:6px 10px;
+              background:#fff0f0;border:1px solid #f5a0a0;
+              border-radius:3px;font-size:12px;color:#c00">
+  </div>
+
+  <hr style="margin:12px 0">
+
+  <div class="form-tips">
+    <b>Input →</b> <code>msg.payload</code> = operation parameters as a JS object.<br>
+    Runtime override: <code>msg.service</code>, <code>msg.operation</code>.<br>
+    <b>Output →</b> <code>msg.payload</code> = deserialised SOAP response.
+  </div>
+
+</script>
+
+<script type="text/javascript">
+(function () {
+  "use strict";
+
+  // ── helpers ──────────────────────────────────────────────────────────────────
+  function showError(msg) {
+    $("#interplay-error").text(msg).show();
+  }
+  function hideError() {
+    $("#interplay-error").hide();
+  }
+
+  // Colour-code [R] and [O] markers in the JSON string
+  function colorizeTemplate(raw) {
+    return raw
+      .replace(/"\[R\]/g,  '"<span style="color:#4ec9b0;font-weight:bold">[R]</span>')
+      .replace(/"\[O\]/g,  '"<span style="color:#ce9178">[O]</span>');
+  }
+
+  // ── node registration ────────────────────────────────────────────────────────
+  RED.nodes.registerType("interplay-request", {
+    category:     "Avid Interplay",
+    color:        "#3a7bd5",
+    defaults: {
+      name:      { value: "" },
+      server:    { value: "", type: "interplay-config", required: true },
+      service:   { value: "Assets" },
+      operation: { value: "" },
+    },
+    inputs:  1,
+    outputs: 1,
+    icon:    "font-awesome/fa-film",
+    paletteLabel: "interplay request",
+
+    label: function () {
+      if (this.name)      return this.name;
+      if (this.service && this.operation)
+                          return `${this.service} · ${this.operation}`;
+      return "interplay request";
+    },
+
+    labelStyle: function () {
+      return this.name ? "node_label_italic" : "";
+    },
+
+    oneditprepare: function () {
+      var node      = this;
+      var $svcSel   = $("#node-input-service");
+      var $opSel    = $("#node-input-operation");
+      var currentOp = node.operation || "";
+
+      // ── restore saved state ─────────────────────────────────────────────────
+      $svcSel.val(node.service || "Assets");
+
+      if (currentOp) {
+        $opSel.empty();
+        $opSel.append(
+          $("<option>").val(currentOp).text(currentOp).prop("selected", true)
+        );
+        $("#interplay-load-params-row").show();
+      }
+
+      // ── reset when service changes ──────────────────────────────────────────
+      $svcSel.on("change", function () {
+        $opSel.empty().append('<option value="">— select operation —</option>');
+        $("#interplay-load-params-row").hide();
+        $("#interplay-schema-wrap").hide();
+        $("#interplay-ns-row").hide();
+        hideError();
+      });
+
+      // ── show/hide "Generate payload" when operation changes ─────────────────
+      $opSel.on("change", function () {
+        var val = $(this).val();
+        $("#interplay-load-params-row").toggle(!!val);
+        $("#interplay-schema-wrap").hide();
+        hideError();
+      });
+
+      // ── Load operations from WSDL ───────────────────────────────────────────
+      $("#interplay-load-ops-btn").on("click", function () {
+        var serverId = $("#node-input-server").val();
+        var service  = $svcSel.val();
+
+        if (!serverId) { showError("Please select a server first."); return; }
+        if (!service)  { showError("Please select a service."); return; }
+
+        $("#interplay-load-ops-btn").prop("disabled", true);
+        $("#interplay-ops-spinner").show();
+        hideError();
+
+        $.get("interplay/operations", { configId: serverId, service: service })
+          .done(function (data) {
+            if (!data || !data.ok) {
+              showError((data && data.error) || "Unknown error.");
+              return;
+            }
+
+            var saved = currentOp || $opSel.val();
+            $opSel.empty().append('<option value="">— select operation —</option>');
+            (data.operations || []).forEach(function (op) {
+              $opSel.append($("<option>").val(op).text(op));
+            });
+            if (saved) $opSel.val(saved);
+
+            if (data.targetNamespace) {
+              $("#interplay-ns-lbl").text(data.targetNamespace);
+              $("#interplay-ns-row").show();
+            }
+
+            var sel = $opSel.val();
+            $("#interplay-load-params-row").toggle(!!sel);
+          })
+          .fail(function (xhr) {
+            var msg = "Communication error with Node-RED.";
+            try { var j = JSON.parse(xhr.responseText); if (j && j.error) msg = j.error; } catch (_) {}
+            showError(msg);
+          })
+          .always(function () {
+            $("#interplay-load-ops-btn").prop("disabled", false);
+            $("#interplay-ops-spinner").hide();
+          });
+      });
+
+      // ── Generate payload template ───────────────────────────────────────────
+      $("#interplay-load-params-btn").on("click", function () {
+        var serverId  = $("#node-input-server").val();
+        var service   = $svcSel.val();
+        var operation = $opSel.val();
+
+        if (!serverId)  { showError("Please select a server first."); return; }
+        if (!service)   { showError("Please select a service."); return; }
+        if (!operation) { showError("Please select an operation."); return; }
+
+        $("#interplay-load-params-btn").prop("disabled", true);
+        $("#interplay-params-spinner").show();
+        $("#interplay-schema-wrap").hide();
+        hideError();
+
+        $.get("interplay/schema", { configId: serverId, service: service, operation: operation })
+          .done(function (data) {
+            if (data && data.ok) {
+              $("#interplay-schema-json").html(colorizeTemplate(data.annotated));
+              $("#interplay-schema-wrap").show();
+              hideError();
+            } else {
+              showError((data && data.error) || "Unknown error.");
+            }
+          })
+          .fail(function (xhr) {
+            var msg = "Communication error with Node-RED.";
+            try { var j = JSON.parse(xhr.responseText); if (j && j.error) msg = j.error; } catch (_) {}
+            showError(msg);
+          })
+          .always(function () {
+            $("#interplay-load-params-btn").prop("disabled", false);
+            $("#interplay-params-spinner").hide();
+          });
+      });
+
+      // ── Copy to clipboard ───────────────────────────────────────────────────
+      $("#interplay-copy-btn").on("click", function () {
+        // Get raw text (strip HTML colour spans)
+        var text = $("#interplay-schema-json").text();
+        if (!text) return;
+
+        function flash() {
+          var $ok = $("#interplay-copy-ok");
+          $ok.show();
+          setTimeout(function () { $ok.hide(); }, 2000);
+        }
+
+        if (navigator.clipboard && navigator.clipboard.writeText) {
+          navigator.clipboard.writeText(text).then(flash);
+        } else {
+          var ta = document.createElement("textarea");
+          ta.value = text;
+          ta.style.cssText = "position:fixed;opacity:0";
+          document.body.appendChild(ta);
+          ta.select();
+          document.execCommand("copy");
+          document.body.removeChild(ta);
+          flash();
+        }
+      });
+    },
+
+    oneditsave: function () {
+      this.service   = $("#node-input-service").val()   || "Assets";
+      this.operation = $("#node-input-operation").val() || "";
+    },
+  });
+
+}());
+</script>
+
+
+<!-- ══════════════════════════════════════════════════════════════════════════
+     Help panels
+     ══════════════════════════════════════════════════════════════════════════ -->
+<script type="text/html" data-help-name="interplay-request">
+  <p>
+    Executes SOAP operations on the <b>Avid Interplay PAM Web Services</b>.
+  </p>
+
+  <h3>Setup</h3>
+  <ol>
+    <li>Configure a server with the <b>interplay-config</b> node (URL, credentials, timeout).</li>
+    <li>Select the <b>Service</b> (Assets, Archive, Infrastructure, Jobs, Transfer, UserManagement).</li>
+    <li>Click <b>Load operations from WSDL</b> to fetch the available operations from the live server.</li>
+    <li>Select an <b>Operation</b> and click <b>Generate payload template</b>
+        to view the required and optional parameters.</li>
+    <li>Copy the template and use it as the basis for <code>msg.payload</code>
+        in an upstream Change or Function node.</li>
+  </ol>
+
+  <h3>Input</h3>
+  <dl class="message-properties">
+    <dt>payload <span class="property-type">object</span></dt>
+    <dd>Operation parameters as a JS object — property names must match the XSD element names.</dd>
+    <dt class="optional">service <span class="property-type">string</span></dt>
+    <dd>Runtime override for the service (e.g. <code>"Assets"</code>).</dd>
+    <dt class="optional">operation <span class="property-type">string</span></dt>
+    <dd>Runtime override for the operation (e.g. <code>"GetChildren"</code>).</dd>
+  </dl>
+
+  <h3>Output</h3>
+  <dl class="message-properties">
+    <dt>payload <span class="property-type">object</span></dt>
+    <dd>Deserialised SOAP response. A top-level <code>&lt;return&gt;</code> element is unwrapped automatically.</dd>
+    <dt>statusCode <span class="property-type">number</span></dt>
+    <dd>HTTP status code of the SOAP response.</dd>
+    <dt>service <span class="property-type">string</span></dt>
+    <dd>Name of the service that was called.</dd>
+    <dt>operation <span class="property-type">string</span></dt>
+    <dd>Name of the operation that was called.</dd>
+  </dl>
+
+  <h3>Authentication</h3>
+  <p>
+    Username and password are sent as a WS-Security <code>UsernameToken</code>
+    in the SOAP header of every request.
+  </p>
+
+  <h3>Error handling</h3>
+  <p>
+    On SOAP fault or network error the node raises a Node-RED error catchable
+    with a <b>Catch</b> node. The error message is available in <code>error.message</code>.
+  </p>
+
+  <h3>Payload template legend</h3>
+  <ul>
+    <li><code style="color:#4ec9b0">[R]</code> = <b>Required</b> — must be provided</li>
+    <li><code style="color:#ce9178">[O]</code> = <b>Optional</b> — may be omitted</li>
+    <li>Values wrapped in <code>[]</code> denote a repeatable array element.</li>
+    <li>The <code>_legend</code> key is documentation only — <b>do not include it</b> in <code>msg.payload</code>.</li>
+  </ul>
+
+  <h3>Example</h3>
+  <pre>// Get children of a folder
+msg.payload = {
+  InterplayURI: "interplay://MyWorkgroup/MyDB/Projects/MyFolder"
+};
+return msg;</pre>
+</script>
+
+<script type="text/html" data-help-name="interplay-config">
+  <p>Connection settings for the <b>Avid Interplay PAM SOAP Web Services</b>.</p>
+
+  <dl class="message-properties">
+    <dt>Base URL</dt>
+    <dd>
+      Root CXF endpoint, e.g. <code>https://host:1881/services</code>.<br>
+      The service name (Assets, Archive, Jobs…) is appended automatically.
+    </dd>
+    <dt>Username / Password</dt>
+    <dd>
+      Interplay credentials sent as a WS-Security UsernameToken header.
+      Leave empty if the service does not require authentication.
+    </dd>
+    <dt>Timeout</dt>
+    <dd>HTTP request timeout in milliseconds (default: 30000 ms).</dd>
+    <dt>Allow self-signed SSL</dt>
+    <dd>
+      Bypasses SSL certificate verification — required for servers using
+      an internal CA or self-signed certificates.
+    </dd>
+  </dl>
+</script>

package/interplay.js

@@ -0,0 +1,443 @@
+"use strict";
+
+const http  = require("http");
+const https = require("https");
+const { XMLParser } = require("fast-xml-parser");
+
+// ─── Parsers ──────────────────────────────────────────────────────────────────
+const soapParser = new XMLParser({
+  removeNSPrefix:     true,
+  ignoreAttributes:   false,
+  attributeNamePrefix: "@_"
+});
+
+// isArray ensures repeated elements are always arrays even when there is only one
+const xsdParser = new XMLParser({
+  removeNSPrefix:     true,
+  ignoreAttributes:   false,
+  attributeNamePrefix: "@_",
+  isArray: tag => [
+    "operation","message","portType","part",
+    "element","attribute","complexType","simpleType",
+    "import","include","sequence","choice","all",
+    "enumeration"
+  ].includes(tag)
+});
+
+// ─── In-memory caches ─────────────────────────────────────────────────────────
+const wsdlCache   = {};   // `${baseUrl}/${service}` -> wsdl info
+const schemaCache = {};   // `${baseUrl}/${service}` -> schema registry
+
+// ─── HTTP helpers ─────────────────────────────────────────────────────────────
+function httpGet(url, allowSelfSigned, timeoutMs) {
+  return new Promise((resolve, reject) => {
+    const u    = new URL(url);
+    const opts = {
+      hostname:           u.hostname,
+      port:               u.port || (u.protocol === "https:" ? 443 : 80),
+      path:               u.pathname + u.search,
+      method:             "GET",
+      headers:            {},
+      rejectUnauthorized: !allowSelfSigned,
+    };
+    const lib = u.protocol === "https:" ? https : http;
+    const req = lib.request(opts, res => {
+      const chunks = [];
+      res.on("data", d => chunks.push(d));
+      res.on("end",  () => resolve(Buffer.concat(chunks).toString()));
+    });
+    req.setTimeout(timeoutMs || 20000, () => {
+      req.destroy();
+      reject(new Error(`Timeout fetching ${url}`));
+    });
+    req.on("error", reject);
+    req.end();
+  });
+}
+
+function httpPost(url, body, headers, allowSelfSigned, timeoutMs) {
+  return new Promise((resolve, reject) => {
+    const u    = new URL(url);
+    const opts = {
+      hostname:           u.hostname,
+      port:               u.port || (u.protocol === "https:" ? 443 : 80),
+      path:               u.pathname + u.search,
+      method:             "POST",
+      headers,
+      rejectUnauthorized: !allowSelfSigned,
+    };
+    const lib = u.protocol === "https:" ? https : http;
+    const req = lib.request(opts, res => {
+      const chunks = [];
+      res.on("data", d => chunks.push(d));
+      res.on("end",  () => resolve({ status: res.statusCode, body: Buffer.concat(chunks).toString() }));
+    });
+    req.setTimeout(timeoutMs || 30000, () => {
+      req.destroy();
+      reject(new Error("Request timed out"));
+    });
+    req.on("error", reject);
+    req.write(body);
+    req.end();
+  });
+}
+
+// ─── XML escape ───────────────────────────────────────────────────────────────
+function escXml(v) {
+  return String(v)
+    .replace(/&/g,  "&")
+    .replace(/</g,  "&lt;")
+    .replace(/>/g,  "&gt;")
+    .replace(/"/g,  "&quot;")
+    .replace(/'/g,  "&apos;");
+}
+
+// ─── SOAP XML builder ─────────────────────────────────────────────────────────
+function toXml(obj, tag, ns) {
+  const q = tag ? `${ns}:${tag}` : null;
+  if (obj === null || obj === undefined) {
+    return q
+      ? `<${q} xsi:nil="true" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"/>`
+      : "";
+  }
+  if (Array.isArray(obj)) return obj.map(i => toXml(i, tag, ns)).join("");
+  if (typeof obj === "object") {
+    const inner = Object.entries(obj).map(([k, v]) => toXml(v, k, ns)).join("");
+    return q ? `<${q}>${inner}</${q}>` : inner;
+  }
+  return q ? `<${q}>${escXml(obj)}</${q}>` : escXml(obj);
+}
+
+function buildEnvelope(operation, payload, ns, credentials) {
+  const bodyContent = payload ? toXml(payload, null, "ns") : "";
+
+  // WS-Security UsernameToken header (standard for Avid Interplay WS)
+  let wssHeader = "";
+  if (credentials && credentials.username) {
+    wssHeader = `
+    <wsse:Security xmlns:wsse="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd">
+      <wsse:UsernameToken>
+        <wsse:Username>${escXml(credentials.username)}</wsse:Username>
+        <wsse:Password>${escXml(credentials.password || "")}</wsse:Password>
+      </wsse:UsernameToken>
+    </wsse:Security>`;
+  }
+
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/"
+               xmlns:ns="${ns}">
+  <soap:Header>${wssHeader}
+  </soap:Header>
+  <soap:Body>
+    <ns:${operation}>${bodyContent}</ns:${operation}>
+  </soap:Body>
+</soap:Envelope>`;
+}
+
+function parseSOAPResponse(xml) {
+  const json = soapParser.parse(xml);
+  const body = json?.Envelope?.Body;
+  if (!body) throw new Error("Invalid SOAP response — no Body element");
+  if (body.Fault) {
+    const f   = body.Fault;
+    const msg = f.faultstring || f.Reason?.Text || JSON.stringify(f);
+    throw new Error(`SOAP Fault: ${msg}`);
+  }
+  const key = Object.keys(body)[0];
+  return body[key]?.return ?? body[key];
+}
+
+// ─── WSDL loading ─────────────────────────────────────────────────────────────
+async function loadWsdl(baseUrl, service, allowSelfSigned) {
+  const cacheKey = `${baseUrl}/${service}`;
+  if (wsdlCache[cacheKey]) return wsdlCache[cacheKey];
+
+  const text = await httpGet(`${cacheKey}?wsdl`, allowSelfSigned, 20000);
+  const doc  = xsdParser.parse(text);
+  const defs = doc.definitions;
+  if (!defs) throw new Error("Not a valid WSDL document");
+
+  const targetNamespace = defs["@_targetNamespace"] || "";
+
+  // messages: name -> input element name
+  const msgToElement = {};
+  (defs.message || []).forEach(m => {
+    const part = (m.part || [])[0];
+    if (!part) return;
+    const el = (part["@_element"] || "").replace(/^[^:]+:/, "");
+    if (el) msgToElement[m["@_name"]] = el;
+  });
+
+  // operations
+  const operations     = [];
+  const opInputElements = {};
+  (defs.portType || []).forEach(pt => {
+    (pt.operation || []).forEach(o => {
+      const name = o["@_name"];
+      if (!name) return;
+      operations.push(name);
+      if (o.input) {
+        const msgName = (o.input["@_message"] || "").replace(/^[^:]+:/, "");
+        opInputElements[name] = msgToElement[msgName] || name;
+      }
+    });
+  });
+
+  // XSD import locations
+  const xsdUrls = [];
+  const types   = defs.types;
+  if (types) {
+    const schemas = Array.isArray(types.schema)
+      ? types.schema
+      : (types.schema ? [types.schema] : []);
+    schemas.forEach(schema => {
+      (schema.import || []).forEach(imp => {
+        const loc = imp["@_schemaLocation"];
+        if (!loc) return;
+        xsdUrls.push(
+          loc.startsWith("http") ? loc
+          : `${cacheKey}${loc.startsWith("?") ? "" : "/"}${loc}`
+        );
+      });
+    });
+  }
+
+  const result = { operations, opInputElements, targetNamespace, xsdUrls };
+  wsdlCache[cacheKey] = result;
+  return result;
+}
+
+// ─── XSD schema registry ──────────────────────────────────────────────────────
+async function loadSchemaRegistry(baseUrl, service, wsdlInfo, allowSelfSigned) {
+  const cacheKey = `${baseUrl}/${service}`;
+  if (schemaCache[cacheKey]) return schemaCache[cacheKey];
+
+  const elements    = {};
+  const complexTypes = {};
+
+  function ingest(schema) {
+    (schema.element     || []).forEach(e => { if (e["@_name"]) elements[e["@_name"]] = e; });
+    (schema.complexType || []).forEach(t => { if (t["@_name"]) complexTypes[t["@_name"]] = t; });
+  }
+
+  for (const url of wsdlInfo.xsdUrls) {
+    try {
+      const text   = await httpGet(url, allowSelfSigned, 20000);
+      const doc    = xsdParser.parse(text);
+      const schema = doc.schema || doc["xs:schema"] || doc["xsd:schema"];
+      if (schema) ingest(schema);
+    } catch (_) { /* skip XSD load errors silently */ }
+  }
+
+  const result = { elements, complexTypes };
+  schemaCache[cacheKey] = result;
+  return result;
+}
+
+// ─── Payload template generator ───────────────────────────────────────────────
+function stripNs(s) { return (s || "").replace(/^[^:]+:/, ""); }
+
+function elementTemplate(el, registry, depth) {
+  if (depth > 10) return "...";
+
+  const typeRef = stripNs(el["@_type"]);
+  const minOcc  = el["@_minOccurs"] !== undefined ? String(el["@_minOccurs"]) : "1";
+  const maxOcc  = el["@_maxOccurs"] !== undefined ? String(el["@_maxOccurs"]) : "1";
+  const req     = minOcc !== "0";
+  const isArr   = maxOcc === "unbounded" || (maxOcc !== "1" && Number(maxOcc) > 1);
+  const tag     = req ? "[R]" : "[O]";
+
+  // inline complexType
+  if (el.complexType) {
+    const inner = ctTemplate(el.complexType, registry, depth + 1);
+    return isArr ? [inner] : inner;
+  }
+
+  // named complex type
+  if (typeRef && registry.complexTypes[typeRef]) {
+    const inner = ctTemplate(registry.complexTypes[typeRef], registry, depth + 1);
+    return isArr ? [inner] : inner;
+  }
+
+  // ref to another element
+  if (el["@_ref"]) {
+    const refName = stripNs(el["@_ref"]);
+    if (registry.elements[refName]) {
+      return elementTemplate(registry.elements[refName], registry, depth + 1);
+    }
+    return isArr ? [`${tag} ref:${refName}`] : `${tag} ref:${refName}`;
+  }
+
+  // primitive / unknown scalar
+  const prim = typeRef || "string";
+  return isArr ? [`${tag} ${prim}`] : `${tag} ${prim}`;
+}
+
+function ctTemplate(ct, registry, depth) {
+  if (depth > 10) return {};
+  const result = {};
+
+  let container = ct.sequence || ct.all || ct.choice;
+  if (!container && ct.complexContent) {
+    const ext = ct.complexContent.extension || ct.complexContent.restriction;
+    if (ext) container = ext.sequence || ext.all || ext.choice;
+  }
+  if (!container) return result;
+
+  (container.element || []).forEach(el => {
+    const elName = el["@_name"] || stripNs(el["@_ref"]) || "?";
+    result[elName] = elementTemplate(el, registry, depth + 1);
+  });
+
+  return result;
+}
+
+function generatePayloadTemplate(opElementName, registry) {
+  const rootEl = registry.elements[opElementName];
+  if (!rootEl) return null;
+
+  if (rootEl.complexType) return ctTemplate(rootEl.complexType, registry, 0);
+
+  const typeRef = stripNs(rootEl["@_type"]);
+  if (typeRef && registry.complexTypes[typeRef]) {
+    return ctTemplate(registry.complexTypes[typeRef], registry, 0);
+  }
+
+  return {};
+}
+
+// ─── Module export ────────────────────────────────────────────────────────────
+module.exports = function (RED) {
+
+  // ── Config node ─────────────────────────────────────────────────────────────
+  function InterplayConfig(n) {
+    RED.nodes.createNode(this, n);
+    this.name            = n.name;
+    this.baseUrl         = (n.baseUrl || "").replace(/\/$/, "");
+    this.timeout         = parseInt(n.timeout) || 30000;
+    this.allowSelfSigned = n.allowSelfSigned !== false;
+  }
+
+  RED.nodes.registerType("interplay-config", InterplayConfig, {
+    credentials: {
+      username: { type: "text"     },
+      password: { type: "password" },
+    }
+  });
+
+  // ── Admin: load operations from WSDL ────────────────────────────────────────
+  // GET /interplay/operations?configId=<id>&service=<Assets|Infrastructure|...>
+  RED.httpAdmin.get("/interplay/operations", RED.auth.needsPermission("flows.read"), async (req, res) => {
+    try {
+      const cfg = RED.nodes.getNode(req.query.configId);
+      if (!cfg)              { return res.json({ ok: false, error: "Config node not found" }); }
+      const service = req.query.service;
+      if (!service)          { return res.json({ ok: false, error: "'service' parameter required" }); }
+
+      const info = await loadWsdl(cfg.baseUrl, service, cfg.allowSelfSigned);
+      res.json({ ok: true, operations: info.operations, targetNamespace: info.targetNamespace });
+    } catch (e) {
+      res.json({ ok: false, error: e.message });
+    }
+  });
+
+  // ── Admin: generate payload template from XSD ────────────────────────────────
+  // GET /interplay/schema?configId=<id>&service=<...>&operation=<...>
+  RED.httpAdmin.get("/interplay/schema", RED.auth.needsPermission("flows.read"), async (req, res) => {
+    try {
+      const cfg = RED.nodes.getNode(req.query.configId);
+      if (!cfg) { return res.json({ ok: false, error: "Config node not found" }); }
+
+      const { service, operation } = req.query;
+      if (!service || !operation) {
+        return res.json({ ok: false, error: "'service' and 'operation' parameters required" });
+      }
+
+      const wsdlInfo = await loadWsdl(cfg.baseUrl, service, cfg.allowSelfSigned);
+      const registry = await loadSchemaRegistry(cfg.baseUrl, service, wsdlInfo, cfg.allowSelfSigned);
+
+      const inputElName = wsdlInfo.opInputElements[operation] || operation;
+      let template = generatePayloadTemplate(inputElName, registry);
+
+      if (!template) {
+        template = { "_note": `[O] Schema not found for '${operation}'. Inspect the WSDL manually.` };
+      }
+
+      const annotated = JSON.stringify(
+        { "_legend": "[R] = required  |  [O] = optional", ...template },
+        null, 2
+      );
+
+      res.json({ ok: true, annotated, inputElementName: inputElName });
+    } catch (e) {
+      res.json({ ok: false, error: e.message });
+    }
+  });
+
+  // ── Admin: clear caches (useful after config change) ────────────────────────
+  // POST /interplay/clear-cache
+  RED.httpAdmin.post("/interplay/clear-cache", RED.auth.needsPermission("flows.write"), (req, res) => {
+    Object.keys(wsdlCache).forEach(k   => delete wsdlCache[k]);
+    Object.keys(schemaCache).forEach(k => delete schemaCache[k]);
+    res.json({ ok: true });
+  });
+
+  // ── Request node ─────────────────────────────────────────────────────────────
+  function InterplayRequest(config) {
+    RED.nodes.createNode(this, config);
+    const node       = this;
+    node.cfg         = RED.nodes.getNode(config.server);
+    node.service     = config.service  || "Assets";
+    node.operation   = config.operation || "";
+
+    node.on("input", async (msg, send, done) => {
+      send = send || ((...a) => node.send(...a));
+      done = done || ((e) => { if (e) node.error(e, msg); });
+
+      const cfg = node.cfg;
+      if (!cfg) {
+        node.status({ fill: "red", shape: "ring", text: "no server config" });
+        return done(new Error("No server configuration"));
+      }
+
+      const service   = msg.service   || node.service;
+      const operation = msg.operation || node.operation;
+
+      if (!service || !operation) {
+        node.status({ fill: "red", shape: "dot", text: "service/operation missing" });
+        return done(new Error("msg.service and msg.operation (or node config) must be set"));
+      }
+
+      try {
+        node.status({ fill: "blue", shape: "dot", text: `${service}.${operation}…` });
+
+        const wsdlInfo = await loadWsdl(cfg.baseUrl, service, cfg.allowSelfSigned);
+        const ns       = wsdlInfo.targetNamespace;
+        const url      = `${cfg.baseUrl}/${service}`;
+        const xml      = buildEnvelope(operation, msg.payload || null, ns, cfg.credentials);
+
+        const result = await httpPost(url, xml, {
+          "Content-Type":   "text/xml; charset=utf-8",
+          "SOAPAction":     `"${ns}/${operation}"`,
+          "Content-Length": Buffer.byteLength(xml),
+        }, cfg.allowSelfSigned, cfg.timeout);
+
+        msg.payload   = parseSOAPResponse(result.body);
+        msg.statusCode = result.status;
+        msg.service   = service;
+        msg.operation = operation;
+
+        node.status({ fill: "green", shape: "dot", text: `${service}.${operation} ✓` });
+        send(msg);
+        done();
+      } catch (err) {
+        node.status({ fill: "red", shape: "dot", text: String(err.message).substring(0, 60) });
+        done(err);
+      }
+    });
+
+    node.on("close", () => node.status({}));
+  }
+
+  RED.nodes.registerType("interplay-request", InterplayRequest);
+};

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "node-red-contrib-avid-interplay",
+  "version": "1.1.0",
+  "description": "Node-RED nodes for Avid Interplay PAM SOAP Web Services",
+  "keywords": [
+    "node-red",
+    "avid",
+    "interplay",
+    "soap",
+    "media",
+    "asset-management",
+    "pam"
+  ],
+  "author": {
+    "name": "ZZZCROSSS",
+    "email": "YOUR_EMAIL@example.com",
+    "url": "https://github.com/zzzcrosss"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/zzzcrosss/node-red-contrib-avid-interplay.git"
+  },
+  "homepage": "https://github.com/zzzcrosss/node-red-contrib-avid-interplay#readme",
+  "bugs": {
+    "url": "https://github.com/zzzcrosss/node-red-contrib-avid-interplay/issues"
+  },
+  "files": [
+    "interplay.js",
+    "interplay.html",
+    "README.md",
+    "LICENSE"
+  ],
+  "dependencies": {
+    "fast-xml-parser": "^5.8.0"
+  },
+  "node-red": {
+    "version": ">=3.0.0",
+    "nodes": {
+      "avid-interplay": "interplay.js"
+    }
+  },
+  "engines": {
+    "node": ">=14.0.0"
+  }
+}