Locamation Plugin to update private fields, working screens.

Signed-off-by: Dennis Labordus <[email protected]>

Author: Dennis Labordus

src/foundation.ts

@@ -133,7 +133,7 @@ export function newActionEvent<T extends EditorAction>(
 }
 
 export const wizardInputSelector =
-  'wizard-textfield, mwc-textfield, ace-editor, mwc-select,wizard-select';
+  'wizard-textfield, mwc-textfield, ace-editor, mwc-select, wizard-select';
 export type WizardInput =
   | WizardTextField
   | TextField

src/locamation/LocamationIEDList.ts

@@ -1,10 +1,12 @@
 import {css, customElement, html, LitElement, property, TemplateResult} from 'lit-element';
 import {get, translate} from "lit-translate";
 
+import '@material/mwc-list';
+import '@material/mwc-list/mwc-list-item';
+
 import {newSubWizardEvent, newWizardEvent, Wizard, WizardInput} from '../foundation.js';
 import {isSCLNamespace} from "../schemas.js";
 import {Nsdoc} from "../foundation/nsdoc.js";
-import {dispatchEventOnOpenScd} from "../compas/foundation.js";
 
 import {iedHeader, lDeviceHeader} from "./foundation.js";
 import {locamationLNListWizard} from "./LocamationLNList.js";
@@ -17,15 +19,14 @@ export class LocamationIEDListElement extends LitElement {
   nsdoc!: Nsdoc;
 
   private get logicaDevices(): Element[] {
-    return Array.from(this.doc!.querySelectorAll(
-        'IED[manufacturer="Locamation B.V."] LDevice'))
+    return Array.from(this.doc!.querySelectorAll('IED[manufacturer="Locamation B.V."] LDevice'))
       .filter(isSCLNamespace)
       .filter(element => element.querySelector('LN > Private[type="LCMTN_VMU_SENSOR"]') !== null);
   }
 
   close(): void {
     // Close the Save Dialog.
-    dispatchEventOnOpenScd(newWizardEvent());
+    this.dispatchEvent(newWizardEvent());
   }
 
   render(): TemplateResult {

src/locamation/LocamationLNEdit.ts

@@ -1,19 +1,23 @@
 import {css, customElement, html, LitElement, property, TemplateResult} from 'lit-element';
 import {get, translate} from "lit-translate";
 
-import {Wizard, WizardAction, WizardInput} from '../foundation.js';
+import {patterns} from "../wizards/foundation/limits.js";
+import {checkValidity, ComplexAction, Wizard, WizardAction, WizardInput, wizardInputSelector} from '../foundation.js';
 import {Nsdoc} from "../foundation/nsdoc.js";
 
+import '../wizard-textfield.js';
+
 import {
+  createEditorAction,
+  getInputFieldValue,
+  getPrivate,
   getPrivateTextValue,
   hasPrivateElement,
   iedHeader,
+  inputFieldChanged,
   lDeviceHeader,
   lnHeader,
-  LOCAMATION_PRIVATE
 } from "./foundation.js";
-import Protocol from "devtools-protocol";
-import integer = Protocol.integer;
 
 @customElement('locamation-ln-edit')
 export class LocamationVMUEditElement extends LitElement {
@@ -22,102 +26,121 @@ export class LocamationVMUEditElement extends LitElement {
   @property()
   nsdoc!: Nsdoc;
 
-  save(inputs: WizardInput[]): WizardAction[] {
-    // if (!this.fieldsChanged(inputs)) {
+  save(): WizardAction[] {
+    const inputs: WizardInput[] = Array.from(this.shadowRoot!.querySelectorAll(wizardInputSelector));
+    const locamationPrivate = getPrivate(this.logicalNode);
+
+    if (!this.fieldsChanged(locamationPrivate, inputs) || !this.checkValidityInputs(inputs)) {
       return [];
-    // }
-    //
-    // cloneElement(element, { name, desc });
-    //
-    // const oldPrivateElement = getPrivate(oldElement, 'compas_substation');
-    // const newPrivateElement = getOrCreatePrivate(oldElement, newElement, 'compas_substation');
-    //
-    // const compasName = getInputFieldValue(inputs, 'compasName');
-    // processPrivateTextElement(newPrivateElement, EXTENSION_NAMESPACE, 'compas', 'CompasName', compasName);
-    //
-    // if (oldPrivateElement) {
-    //   return [{old: {element: oldPrivateElement}, new: {element: newPrivateElement}}];
-    // }
-    // return [{new: {parent: newElement, element: newPrivateElement}}];
-  }
-  //
-  // private fieldsChanged(inputs: WizardInput[]): boolean {
-  //   const oldIdentifier= getPrivateTextValue(this.logicalNode, LOCAMATION_PRIVATE, 'IDENTIFIER');
-  //   const oldChannel = getPrivateTextValue(this.logicalNode, LOCAMATION_PRIVATE, 'CHANNEL');
-  //   const oldTransformPrimary = getPrivateTextValue(this.logicalNode, LOCAMATION_PRIVATE, 'TRANSFORM-PRIMARY');
-  //   const oldTransformSecondary = getPrivateTextValue(this.logicalNode, LOCAMATION_PRIVATE, 'TRANSFORM-SECONDARY');
-  //   return inputFieldChanged(inputs, 'Identifier', oldIdentifier)
-  //     || inputFieldChanged(inputs, 'Channel', oldChannel)
-  //     || inputFieldChanged(inputs, 'TransformPrimary', oldTransformPrimary)
-  //     || inputFieldChanged(inputs, 'TransformSecondary', oldTransformSecondary);
-  // }
-
-  private getIdentifierPart(partNr: integer): string {
-    const identifier = getPrivateTextValue(this.logicalNode, LOCAMATION_PRIVATE, 'IDENTIFIER')?? '';
-    const parts = identifier.trim().split('.');
-    if (parts.length < partNr) {
-      return '';
     }
-    return parts[partNr];
+
+    const complexAction: ComplexAction = {
+      actions: [],
+      title: get('locamation.vmu.updateAction', {lnName: lnHeader(this.logicalNode, this.nsdoc)}),
+    };
+
+    complexAction.actions.push(...createEditorAction(locamationPrivate, 'IDENTIFIER', getInputFieldValue(inputs, 'Identifier')));
+    if (hasPrivateElement(this.logicalNode, 'SUM')) {
+      complexAction.actions.push(...createEditorAction(locamationPrivate, 'SUM', getInputFieldValue(inputs, 'Sum')));
+    } else {
+      complexAction.actions.push(...createEditorAction(locamationPrivate, 'CHANNEL', getInputFieldValue(inputs, 'Channel')));
+    }
+    complexAction.actions.push(...createEditorAction(locamationPrivate, 'TRANSFORM-PRIMARY', getInputFieldValue(inputs, 'TransformPrimary')));
+    complexAction.actions.push(...createEditorAction(locamationPrivate, 'TRANSFORM-SECONDARY', getInputFieldValue(inputs, 'TransformSecondary')));
+
+    return complexAction.actions.length ? [complexAction] : [];
+  }
+
+  private fieldsChanged(locamationPrivate: Element, inputs: WizardInput[]): boolean {
+    const oldIdentifier= getPrivateTextValue(locamationPrivate, 'IDENTIFIER');
+    const oldChannel = getPrivateTextValue(locamationPrivate, 'CHANNEL');
+    const oldSum = getPrivateTextValue(locamationPrivate, 'SUM');
+    const oldTransformPrimary = getPrivateTextValue(locamationPrivate, 'TRANSFORM-PRIMARY');
+    const oldTransformSecondary = getPrivateTextValue(locamationPrivate, 'TRANSFORM-SECONDARY');
+
+    return inputFieldChanged(inputs, 'Identifier', oldIdentifier)
+      || (hasPrivateElement(locamationPrivate, 'SUM') ? inputFieldChanged(inputs, 'Sum', oldSum) : false)
+      || (hasPrivateElement(locamationPrivate, 'CHANNEL') ? inputFieldChanged(inputs, 'Channel', oldChannel) : false)
+      || inputFieldChanged(inputs, 'TransformPrimary', oldTransformPrimary)
+      || inputFieldChanged(inputs, 'TransformSecondary', oldTransformSecondary);
+  }
+
+  private checkValidityInputs(inputs: WizardInput[]): boolean {
+    return Array.from(inputs).every(checkValidity);
   }
 
   render(): TemplateResult {
     const lDevice = this.logicalNode.closest('LDevice')!;
     const ied = lDevice.closest('IED')!;
+    const locamationPrivate = getPrivate(this.logicalNode);
+
+    // Depending on the value of the class the pattern for the CIM or VIM for SUM/CHANNEL will change.
+    let channelPattern = '[0-5]';
+    let sumPattern = '[0-5],[0-5],[0-5]';
+    if (this.logicalNode.getAttribute('lnClass') === 'TVTR') {
+      channelPattern = '[0-2]';
+      sumPattern = '[0-2],[0-2],[0-2]';
+    }
+
     return html `
-      <wizard-textfield label="IED"
+      <wizard-textfield label="${translate('locamation.vmu.ied.name')}"
                         .maybeValue=${iedHeader(ied)}
-                        helper="${translate('locamation.vmu.ied.name')}"
                         disabled>
       </wizard-textfield>
-      <wizard-textfield label="Logical Device"
+      <wizard-textfield label="${translate('locamation.vmu.ldevice.name')}"
                         .maybeValue=${lDeviceHeader(lDevice)}
-                        helper="${translate('locamation.vmu.ldevice.name')}"
                         disabled>
       </wizard-textfield>
-      <wizard-textfield label="Logical Node"
+      <wizard-textfield label="${translate('locamation.vmu.ln.name')}"
                         .maybeValue=${lnHeader(this.logicalNode, this.nsdoc)}
-                        helper="${translate('locamation.vmu.ln.name')}"
                         disabled>
       </wizard-textfield>
 
-      <div id="Identifier">
-        <wizard-textfield label="IdentifierPart0"
-                          .maybeValue=${this.getIdentifierPart(0)}
-                          helper="Identifier"
-                          required>
-        </wizard-textfield>
-        <wizard-textfield label="IdentifierPart1"
-                          .maybeValue=${this.getIdentifierPart(1)}
-                          helper="Identifier"
-                          required>
-        </wizard-textfield>
-        <wizard-textfield label="IdentifierPart2"
-                          .maybeValue=${this.getIdentifierPart(2)}
-                          helper="Identifier"
-                          required>
-        </wizard-textfield>
-      </div>
-      ${hasPrivateElement(this.logicalNode, LOCAMATION_PRIVATE, 'SUM') ?
-        html `<wizard-textfield label="Sum"
-                                  .maybeValue=${getPrivateTextValue(this.logicalNode, LOCAMATION_PRIVATE, 'SUM')}
-                                  helper="Sum"
-                                  required>
-              </wizard-textfield>` :
-        html `<wizard-textfield label="Channel"
-                                  .maybeValue=${getPrivateTextValue(this.logicalNode, LOCAMATION_PRIVATE, 'CHANNEL')}
-                                  helper="Channel"
-                                  required>
-               </wizard-textfield>`
+      <wizard-textfield label="${translate('locamation.vmu.version')}"
+                        .maybeValue=${getPrivateTextValue(locamationPrivate, 'VERSION')}
+                        disabled>
+      </wizard-textfield>
+
+      <wizard-textfield id="Identifier"
+                        label="Identifier"
+                        .maybeValue=${getPrivateTextValue(locamationPrivate, 'IDENTIFIER')}
+                        helper="${translate('locamation.vmu.identifierHelper')}"
+                        pattern="^(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(\\.(?!$)|$)){3}$"
+                        required
+                        dialogInitialFocus>
+      </wizard-textfield>
+
+      ${hasPrivateElement(locamationPrivate, 'SUM') ?
+        html `<wizard-textfield id="Sum"
+                                label="Sum"
+                                .maybeValue=${getPrivateTextValue(locamationPrivate, 'SUM')}
+                                helper="The collection of three channel numbers for which the sum of currents or voltages will be calculated. The numbers are separated by commas. Values for the current sensor range from 0 - 5, for the voltage sensor 0-2."
+                                pattern="${sumPattern}"
+                                required>
+              </wizard-textfield>` : html ``
       }
-      <wizard-textfield label="TransformPrimary"
-                        .maybeValue=${getPrivateTextValue(this.logicalNode, LOCAMATION_PRIVATE, 'TRANSFORM-PRIMARY')}
-                        helper="TransformPrimary"
+      ${hasPrivateElement(locamationPrivate, 'CHANNEL') ?
+        html `<wizard-textfield id="Channel"
+                                label="Channel"
+                                .maybeValue=${getPrivateTextValue(locamationPrivate, 'CHANNEL')}
+                                helper="The channel number on the sensor. Values for the current sensor range from 0 - 5, for the voltage sensor 0-2."
+                                pattern="${channelPattern}"
+                                required>
+        </wizard-textfield>` : html ``
+      }
+
+      <wizard-textfield id="TransformPrimary"
+                        label="Transform Primary"
+                        .maybeValue=${getPrivateTextValue(locamationPrivate, 'TRANSFORM-PRIMARY')}
+                        helper="The nominator of the ratio of the measement transformer."
+                        pattern="${patterns.unsigned}"
                         required>
       </wizard-textfield>
-      <wizard-textfield label="TransformSecondary"
-                        .maybeValue=${getPrivateTextValue(this.logicalNode, LOCAMATION_PRIVATE, 'TRANSFORM-SECONDARY')}
-                        helper="TransformSecondary"
+      <wizard-textfield id="TransformSecondary"
+                        label="Transform Secondary"
+                        .maybeValue=${getPrivateTextValue(locamationPrivate, 'TRANSFORM-SECONDARY')}
+                        helper="The denominator of the ratio of the measement transformer."
+                        pattern="${patterns.unsigned}"
                         required>
       </wizard-textfield>
     `;
@@ -139,7 +162,7 @@ export function locamationLNEditWizard(logicalNode: Element, nsdoc: Nsdoc): Wiza
   function save() {
     return function (inputs: WizardInput[], wizard: Element): WizardAction[] {
       const locamationVMUEditElement = <LocamationVMUEditElement>wizard.shadowRoot!.querySelector('locamation-ln-edit')
-      return locamationVMUEditElement.save(inputs);
+      return locamationVMUEditElement.save();
     };
   }
 

src/locamation/LocamationLNList.ts

@@ -1,11 +1,15 @@
 import {css, customElement, html, LitElement, property, TemplateResult} from 'lit-element';
 import {get, translate} from "lit-translate";
 
+import '@material/mwc-list';
+import '@material/mwc-list/mwc-list-item';
+
 import {newSubWizardEvent, newWizardEvent, Wizard, WizardInput} from '../foundation.js';
 import {isSCLNamespace} from "../schemas.js";
 import {Nsdoc} from "../foundation/nsdoc.js";
 
-import {dispatchEventOnOpenScd} from "../compas/foundation.js";
+import '../wizard-textfield.js';
+
 import {locamationLNEditWizard} from "./LocamationLNEdit.js";
 import {iedHeader, lDeviceHeader, lnHeader} from "./foundation.js";
 
@@ -24,7 +28,7 @@ export class LocamationLNodeListElement extends LitElement {
 
   close(): void {
     // Close the Save Dialog.
-    dispatchEventOnOpenScd(newWizardEvent());
+    this.dispatchEvent(newWizardEvent());
   }
 
   render(): TemplateResult {

src/locamation/foundation.ts

@@ -1,8 +1,19 @@
 import {Nsdoc} from "../foundation/nsdoc.js";
 
-import {getDescriptionAttribute, getInstanceAttribute, getNameAttribute, getValue, WizardInput} from "../foundation.js";
+import {
+  cloneElement,
+  getDescriptionAttribute,
+  getInstanceAttribute,
+  getNameAttribute,
+  getValue,
+  SimpleAction,
+  WizardInput
+} from "../foundation.js";
 
 export const LOCAMATION_PRIVATE = "LCMTN_VMU_SENSOR";
+export const LOCAMATION_NS = "https://www.locamation.com/61850/VMU/SCL";
+export const LOCAMATION_PREFIX = "lcmtn_ext";
+
 
 export function lnHeader(ln: Element, nsDoc: Nsdoc): string {
   const prefix = ln.getAttribute('prefix');
@@ -27,28 +38,65 @@ export function iedHeader(ied: Element): string {
   return `${name}${description !== undefined ? ' (' + description + ')' : ''}`;
 }
 
-export function getInputFieldValue(inputs: WizardInput[], labelName: string): string | null {
-  return getValue(inputs.find(i => i.label === labelName)!);
+
+export function getInputFieldValue(inputs: WizardInput[], id: string): string | null {
+  return getValue(inputs.find(i => i.id === id)!);
 }
 
-export function inputFieldChanged(inputs: WizardInput[], labelName: string, oldValue: string | null): boolean {
-  const value = getInputFieldValue(inputs, labelName);
+export function inputFieldChanged(inputs: WizardInput[], id: string, oldValue: string | null): boolean {
+  const value = getInputFieldValue(inputs, id);
   if (oldValue) {
     return value !== oldValue;
   }
   return value !== null;
 }
 
-export function hasPrivateElement(element: Element | null, privateType: string, type: string): boolean {
-  if (element) {
-    return element.querySelector(`Private[type="${privateType}"] > P[type="${type}"]`) != null;
+
+export function addPrefixAndNamespaceToDocument(element: Element): void {
+  const rootElement = element.ownerDocument.firstElementChild!;
+  if (!rootElement.hasAttribute('xmlns:' + LOCAMATION_PREFIX)) {
+    rootElement.setAttributeNS('http://www.w3.org/2000/xmlns/', 'xmlns:' + LOCAMATION_PREFIX, LOCAMATION_NS);
+  }
+}
+
+export function getPrivate(element: Element): Element {
+  return element.querySelector(`Private[type="${LOCAMATION_PRIVATE}"]`)!;
+}
+
+export function createEditorAction(locamationPrivate: Element, fieldType: string, value: string | null): SimpleAction[] {
+  let privateField = Array.from(locamationPrivate.querySelectorAll(`P[type="${fieldType}"]`))
+    .filter(element => element.namespaceURI === LOCAMATION_NS)
+    .pop();
+  if (!privateField) {
+    // Make sure the namespace is configured on the root element with the known prefix.
+    addPrefixAndNamespaceToDocument(locamationPrivate);
+
+    privateField = locamationPrivate.ownerDocument.createElementNS(LOCAMATION_NS, "P");
+    privateField.setAttribute("type", fieldType);
+    privateField.textContent = value;
+    return [{new: {parent: locamationPrivate, element: privateField}}];
+  }
+
+  const newPrivateField = cloneElement(privateField, {});
+  newPrivateField.textContent = value;
+  return [{old: {element: privateField}, new: {element: newPrivateField}}];
+}
+
+export function hasPrivateElement(locamationPrivate: Element, type: string): boolean {
+  if (locamationPrivate) {
+    return Array.from(locamationPrivate.querySelectorAll(`P[type="${type}"]`))
+      .filter(element => element.namespaceURI === LOCAMATION_NS)
+      .pop() !== undefined;
   }
   return false;
 }
 
-export function getPrivateTextValue(element: Element | null, privateType: string, type: string): string | null {
-  if (element) {
-    const privateElement = element.querySelector(`Private[type="${privateType}"] > P[type="${type}"]`);
+export function getPrivateTextValue(locamationPrivate: Element, type: string): string | null {
+  if (locamationPrivate) {
+    const privateElement =
+      Array.from(locamationPrivate.querySelectorAll(`P[type="${type}"]`))
+        .filter(element => element.namespaceURI === LOCAMATION_NS)
+        .pop();
     if (privateElement) {
       return privateElement.textContent;
     }