Merge pull request #1 from openscd/feat/copy-control-blocks

feat: Copy control blocks

Author: clepski

editors/base-element-editor.ts

@@ -14,6 +14,25 @@ import {
   identity,
 } from '@openenergytools/scl-lib';
 import '@openenergytools/filterable-lists/dist/action-list.js';
+import {
+  isFCDACompatibleWithIED,
+  queryLDevice,
+  queryLN,
+} from '../foundation/utils/xml.js';
+
+// eslint-disable-next-line no-shadow
+export enum ControlBlockCopyStatus {
+  CanCopy = 'CanCopy',
+  IEDStructureIncompatible = 'IEDStructureIncompatible',
+  ControlBlockOrDataSetAlreadyExists = 'ControlBlockOrDataSetAlreadyExists',
+}
+
+export interface ControlBlockCopyOption {
+  ied: Element;
+  control: Element;
+  status: ControlBlockCopyStatus;
+  selected: boolean;
+}
 
 export class BaseElementEditor extends ScopedElementsMixin(LitElement) {
   /** The document being edited as provided to plugins by [[`OpenSCD`]]. */
@@ -30,12 +49,21 @@ export class BaseElementEditor extends ScopedElementsMixin(LitElement) {
   @state()
   selectedDataSet?: Element | null;
 
+  @state()
+  controlBlockCopyOptions: ControlBlockCopyOption[] = [];
+
   @query('.dialog.select') selectDataSetDialog!: MdDialog;
 
+  @query('.dialog.copy') copyControlBlockDialog!: MdDialog;
+
   @query('.new.dataset') newDataSet!: MdIconButton;
 
   @query('.change.dataset') changeDataSet!: MdIconButton;
 
+  get hasCopyControlSelected(): boolean {
+    return this.controlBlockCopyOptions.some(o => o.selected);
+  }
+
   protected selectDataSet(dataSet: Element): void {
     const name = dataSet.getAttribute('name');
     if (!name || !this.selectCtrlBlock) return;
@@ -54,6 +82,130 @@ export class BaseElementEditor extends ScopedElementsMixin(LitElement) {
     this.selectDataSetDialog.close();
   }
 
+  protected queryIEDs(): Element[] {
+    return Array.from(this.doc.querySelectorAll(':root > IED'));
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  protected queryLnForControl(ied: Element, control: Element): Element | null {
+    const lDevice = control.closest('LDevice');
+    const lnOrLn0 = control.closest('LN0, LN');
+
+    if (!lnOrLn0 || !lDevice) {
+      throw new Error('ControlBlock must be a child of LN or LN0 and LDevice');
+    }
+
+    const ldInst = lDevice.getAttribute('inst') ?? '';
+    const lDeviceInIed = queryLDevice(ied, ldInst);
+
+    if (!lDeviceInIed) {
+      return null;
+    }
+
+    const lnClass = lnOrLn0.getAttribute('lnClass') ?? '';
+    const inst = lnOrLn0.getAttribute('inst') ?? '';
+    const prefix = lnOrLn0.getAttribute('prefix');
+
+    return queryLN(lDeviceInIed, lnClass, inst, prefix);
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  protected getDataSet(control: Element): Element | null {
+    return (
+      control.parentElement?.querySelector(
+        `DataSet[name="${control.getAttribute('datSet')}"]`
+      ) ?? null
+    );
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  protected getCopyControlBlockCopyStatus(
+    controlBlock: Element,
+    otherIED: Element
+  ): ControlBlockCopyStatus {
+    const ln = this.queryLnForControl(otherIED, controlBlock);
+
+    if (!ln) {
+      return ControlBlockCopyStatus.IEDStructureIncompatible;
+    }
+
+    const controlInOtherIED = ln.querySelector(
+      `${controlBlock.tagName}[name="${controlBlock.getAttribute('name')}"]`
+    );
+    const hasControl = Boolean(controlInOtherIED);
+
+    const dataSet = this.getDataSet(controlBlock);
+
+    if (!dataSet) {
+      throw new Error('ControlBlock has no DataSet');
+    }
+
+    const hasDataSet =
+      dataSet !== null &&
+      Boolean(
+        ln.querySelector(`DataSet[name="${dataSet?.getAttribute('name')}"]`)
+      );
+
+    if (hasDataSet || hasControl) {
+      return ControlBlockCopyStatus.ControlBlockOrDataSetAlreadyExists;
+    }
+
+    const fcdas = Array.from(dataSet.querySelectorAll('FCDA'));
+    for (const fcda of fcdas) {
+      const isCompatible = isFCDACompatibleWithIED(fcda, otherIED);
+
+      if (!isCompatible) {
+        return ControlBlockCopyStatus.IEDStructureIncompatible;
+      }
+    }
+
+    return ControlBlockCopyStatus.CanCopy;
+  }
+
+  protected copyControlBlock(): void {
+    const selectedOptions = this.controlBlockCopyOptions.filter(
+      o => o.selected
+    );
+
+    if (selectedOptions.length === 0) {
+      this.copyControlBlockDialog.close();
+      return;
+    }
+
+    const inserts = selectedOptions.flatMap(o => {
+      const ln = this.queryLnForControl(o.ied, o.control);
+      const dataSet = this.getDataSet(o.control);
+
+      if (!ln || !dataSet) {
+        throw new Error('ControlBlock or DataSet not found');
+      }
+
+      const controlCopy = o.control.cloneNode(true) as Element;
+      const controlInsert = {
+        parent: ln,
+        node: controlCopy,
+        reference: null,
+      };
+
+      const dataSetCcopy = dataSet.cloneNode(true) as Element;
+      const dataSetInsert = {
+        parent: ln,
+        node: dataSetCcopy,
+        reference: null,
+      };
+
+      return [controlInsert, dataSetInsert];
+    });
+
+    this.dispatchEvent(
+      newEditEvent(inserts, {
+        title: `Copy control block to ${selectedOptions.length} IEDs`,
+      })
+    );
+
+    this.copyControlBlockDialog.close();
+  }
+
   private addNewDataSet(control: Element): void {
     const parent = control.parentElement;
     if (!parent) return;
@@ -79,6 +231,20 @@ export class BaseElementEditor extends ScopedElementsMixin(LitElement) {
     this.selectDataSetDialog.show();
   }
 
+  // eslint-disable-next-line class-methods-use-this
+  private getCopyStatusText(status: ControlBlockCopyStatus): string {
+    switch (status) {
+      case ControlBlockCopyStatus.CanCopy:
+        return 'Copy possible';
+      case ControlBlockCopyStatus.IEDStructureIncompatible:
+        return 'IED structure incompatible';
+      case ControlBlockCopyStatus.ControlBlockOrDataSetAlreadyExists:
+        return 'Control block or data set already exists';
+      default:
+        return '';
+    }
+  }
+
   protected renderSelectDataSetDialog(): TemplateResult {
     const items = Array.from(
       this.selectCtrlBlock?.parentElement?.querySelectorAll(
@@ -97,6 +263,52 @@ export class BaseElementEditor extends ScopedElementsMixin(LitElement) {
     </md-dialog>`;
   }
 
+  protected renderCopyControlBlockDialog(): TemplateResult {
+    return html`<md-dialog
+      class="dialog copy"
+      @close=${() => {
+        this.controlBlockCopyOptions = [];
+      }}
+    >
+      <div slot="content" class="copy-option-list">
+        ${this.controlBlockCopyOptions.map(
+          option =>
+            html` <label class="copy-optin-row">
+              <div class="copy-option-description">
+                <div class="copy-option-description-ied">
+                  ${option.ied.getAttribute('name')}
+                </div>
+                <div class="copy-option-description-status">
+                  ${this.getCopyStatusText(option.status)}
+                </div>
+              </div>
+              <md-checkbox
+                ?checked=${option.selected}
+                @change=${() => {
+                  // eslint-disable-next-line no-param-reassign
+                  option.selected = !option.selected;
+                  this.requestUpdate();
+                }}
+                ?disabled=${option.status !== ControlBlockCopyStatus.CanCopy}
+              >
+              </md-checkbox>
+            </label>`
+        )}
+        <div class="copy-button">
+          <md-outlined-button
+            @click=${() => this.copyControlBlockDialog.close()}
+            >Close</md-outlined-button
+          >
+          <md-outlined-button
+            @click=${this.copyControlBlock}
+            ?disabled=${!this.hasCopyControlSelected}
+            >Copy</md-outlined-button
+          >
+        </div>
+      </div>
+    </md-dialog>`;
+  }
+
   protected renderDataSetElementContainer(): TemplateResult {
     return html`
       <div class="content dataSet">

editors/gsecontrol/gse-control-editor.spec.ts

@@ -42,7 +42,7 @@ describe('GSEControl editor component', () => {
   });
 
   it('allows to insert new GSEControl element', async () => {
-    await sendMouse({ type: 'click', position: [760, 100] });
+    await sendMouse({ type: 'click', position: [688, 100] });
 
     expect(editEvent).to.have.been.calledOnce;
     expect(editEvent.args[0][0].detail.edit[0]).to.satisfy(isInsert);