[#67] : update LNode iedName (#124)

* [#67] : update /Substation/VoltageLevel/Bay/Function/LNode.iedName 

Signed-off-by: massifben <[email protected]>

* [#67] : take comments into account

Signed-off-by: massifben <[email protected]>

* [#67] : add XPath in error message

Signed-off-by: massifben <[email protected]>

Signed-off-by: massifben <[email protected]>

Author: massifben

sct-app/src/main/java/org/lfenergy/compas/sct/app/SclAutomationService.java

@@ -13,6 +13,7 @@
 import org.lfenergy.compas.sct.commons.exception.ScdException;
 import org.lfenergy.compas.sct.commons.scl.SclRootAdapter;
 import org.lfenergy.compas.sct.commons.scl.SclService;
+import org.lfenergy.compas.sct.commons.scl.SubstationService;
 
 import java.util.*;
 
@@ -32,7 +33,7 @@ public static SclRootAdapter createSCD(@NonNull SCL ssd, @NonNull HeaderDTO head
             HeaderDTO.HistoryItem hItem = headerDTO.getHistoryItems().get(0);
             SclService.addHistoryItem(scdAdapter.getCurrentElem(), hItem.getWho(), hItem.getWhat(), hItem.getWhy());
         }
-        SclService.addSubstation(scdAdapter.getCurrentElem(), ssd);
+        SubstationService.addSubstation(scdAdapter.getCurrentElem(), ssd);
         SclService.importSTDElementsInSCD(scdAdapter, stds, comMap);
         return scdAdapter;
     }

sct-commons/src/main/java/org/lfenergy/compas/sct/commons/CommonConstants.java

@@ -72,7 +72,7 @@ public void validateDestination(SclRootAdapter sclRootAdapter) throws ScdExcepti
                                     )
                             )
                     );
-            if (iedName.isSetLnClass() && !iedName.getLnClass().isEmpty()) {
+            if (iedName.isSetLnClass()) {
                 try {
                     lDeviceAdapter.getLNAdapter(iedName.getLnClass().get(0), iedName.getLnInst(), iedName.getPrefix());
                 } catch (ScdException e) {

sct-commons/src/main/java/org/lfenergy/compas/sct/commons/dto/ControlBlock.java

@@ -6,12 +6,10 @@
 
 import lombok.Getter;
 import lombok.NoArgsConstructor;
-
 import lombok.extern.slf4j.Slf4j;
-import org.lfenergy.compas.sct.commons.Utils;
 import org.lfenergy.compas.sct.commons.scl.ied.LDeviceAdapter;
 import org.lfenergy.compas.sct.commons.scl.ied.LNAdapter;
-
+import org.lfenergy.compas.sct.commons.util.Utils;
 
 import java.util.HashSet;
 import java.util.List;

sct-commons/src/main/java/org/lfenergy/compas/sct/commons/dto/LDeviceDTO.java

@@ -9,12 +9,12 @@
 import lombok.extern.slf4j.Slf4j;
 import org.lfenergy.compas.scl2007b4.model.TAnyLN;
 import org.lfenergy.compas.scl2007b4.model.TExtRef;
-import org.lfenergy.compas.sct.commons.Utils;
 import org.lfenergy.compas.sct.commons.scl.dtt.DataTypeTemplateAdapter;
 import org.lfenergy.compas.sct.commons.scl.dtt.LNodeTypeAdapter;
 import org.lfenergy.compas.sct.commons.scl.ied.AbstractLNAdapter;
 import org.lfenergy.compas.sct.commons.scl.ied.LDeviceAdapter;
 import org.lfenergy.compas.sct.commons.scl.ied.LNAdapter;
+import org.lfenergy.compas.sct.commons.util.Utils;
 
 import java.util.HashSet;
 import java.util.List;

sct-commons/src/main/java/org/lfenergy/compas/sct/commons/dto/LNodeDTO.java

@@ -4,7 +4,10 @@
 
 package org.lfenergy.compas.sct.commons.exception;
 
-public class ScdException extends Exception {
+/**
+ * Thrown when SCD is inconsistent
+ */
+public class ScdException extends RuntimeException {
     public ScdException(String message) {
         super(message);
     }

sct-commons/src/main/java/org/lfenergy/compas/sct/commons/exception/ScdException.java

@@ -0,0 +1,133 @@
+// SPDX-FileCopyrightText: 2022 RTE FRANCE
+//
+// SPDX-License-Identifier: Apache-2.0
+
+package org.lfenergy.compas.sct.commons.scl;
+
+import lombok.NonNull;
+import lombok.extern.slf4j.Slf4j;
+import org.lfenergy.compas.scl2007b4.model.*;
+import org.lfenergy.compas.sct.commons.exception.ScdException;
+import org.lfenergy.compas.sct.commons.util.PrivateEnum;
+
+import javax.xml.bind.JAXBElement;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Optional;
+import java.util.function.Predicate;
+import java.util.stream.Collectors;
+
+@Slf4j
+public final class PrivateService {
+
+    private PrivateService() {
+        throw new UnsupportedOperationException("This is a utility class and cannot be instantiated");
+    }
+
+    private static final ObjectFactory objectFactory = new ObjectFactory();
+
+    public static <T> List<T> getCompasPrivates(List<TPrivate> tPrivates, Class<T> compasClass) throws ScdException {
+        PrivateEnum privateEnum = PrivateEnum.fromClass(compasClass);
+        List<Object> compasElements = tPrivates.stream().filter(tPrivate -> privateEnum.getPrivateType().equals(tPrivate.getType()))
+            .map(TAnyContentFromOtherNamespace::getContent).flatMap(List::stream)
+            .filter(JAXBElement.class::isInstance).map(JAXBElement.class::cast)
+            .filter(Predicate.not(JAXBElement::isNil))
+            .map(JAXBElement::getValue).collect(Collectors.toList());
+
+        List<T> result = new ArrayList<>();
+        for (Object compasElement : compasElements) {
+            if (compasClass.isInstance(compasElement)) {
+                result.add(compasClass.cast(compasElement));
+            } else {
+                throw new ScdException(String.format("Private is inconsistent. It has type=%s which expect JAXBElement<%s> content, " +
+                        "but got JAXBElement<%s>",
+                    privateEnum.getPrivateType(), privateEnum.getCompasClass().getName(), compasElement.getClass().getName()));
+            }
+        }
+        return result;
+    }
+
+    public static <T> List<T> getCompasPrivates(TBaseElement baseElement, Class<T> compasClass) throws ScdException {
+        if (!baseElement.isSetPrivate()) {
+            return Collections.emptyList();
+        }
+        return getCompasPrivates(baseElement.getPrivate(), compasClass);
+    }
+
+    public static <T> Optional<T> getCompasPrivate(TPrivate tPrivate, Class<T> compasClass) throws ScdException {
+        List<T> compasPrivates = getCompasPrivates(Collections.singletonList(tPrivate), compasClass);
+        if (compasPrivates.size() > 1) {
+            throw new ScdException(String.format("Expecting maximum 1 element of type %s in private %s, but got %d",
+                compasClass.getName(), tPrivate.getType(), compasPrivates.size()));
+        }
+        if (compasPrivates.isEmpty()) {
+            return Optional.empty();
+        }
+        return Optional.of(compasPrivates.get(0));
+    }
+
+    public static Optional<TCompasICDHeader> getCompasICDHeader(TPrivate tPrivate) throws ScdException {
+        return getCompasPrivate(tPrivate, TCompasICDHeader.class);
+    }
+
+    public static void removePrivates(TBaseElement baseElement, @NonNull PrivateEnum privateEnum) {
+        if (baseElement.isSetPrivate()) {
+            baseElement.getPrivate().removeIf(tPrivate -> privateEnum.getPrivateType().equals(tPrivate.getType()));
+            if (baseElement.getPrivate().isEmpty()) {
+                baseElement.unsetPrivate();
+            }
+        }
+    }
+
+    public static TPrivate createPrivate(TCompasBay compasBay) {
+        return createPrivate(objectFactory.createBay(compasBay));
+    }
+
+    public static TPrivate createPrivate(TCompasCriteria compasCriteria) {
+        return createPrivate(objectFactory.createCriteria(compasCriteria));
+    }
+
+    public static TPrivate createPrivate(TCompasFlow compasFlow) {
+        return createPrivate(objectFactory.createFlow(compasFlow));
+    }
+
+    public static TPrivate createPrivate(TCompasFunction compasFunction) {
+        return createPrivate(objectFactory.createFunction(compasFunction));
+    }
+
+    public static TPrivate createPrivate(TCompasICDHeader compasICDHeader) {
+        return createPrivate(objectFactory.createICDHeader(compasICDHeader));
+    }
+
+    public static TPrivate createPrivate(TCompasLDevice compasLDevice) {
+        return createPrivate(objectFactory.createLDevice(compasLDevice));
+    }
+
+    public static TPrivate createPrivate(TCompasSclFileType compasSclFileType) {
+        return createPrivate(objectFactory.createSclFileType(compasSclFileType));
+    }
+
+    public static TPrivate createPrivate(TCompasSystemVersion compasSystemVersion) {
+        return createPrivate(objectFactory.createSystemVersion(compasSystemVersion));
+    }
+
+    private static TPrivate createPrivate(JAXBElement<?> jaxbElement) {
+        PrivateEnum privateEnum = PrivateEnum.fromClass(jaxbElement.getDeclaredType());
+        TPrivate tPrivate = new TPrivate();
+        tPrivate.setType(privateEnum.getPrivateType());
+        tPrivate.getContent().add(jaxbElement);
+        return tPrivate;
+    }
+
+
+
+
+
+
+
+
+
+
+
+    }

sct-commons/src/main/java/org/lfenergy/compas/sct/commons/scl/PrivateService.java

@@ -5,6 +5,7 @@
 package org.lfenergy.compas.sct.commons.scl;
 
 import lombok.Getter;
+import org.lfenergy.compas.scl2007b4.model.TBaseElement;
 import org.lfenergy.compas.scl2007b4.model.TPrivate;
 
 
@@ -43,7 +44,21 @@ public final void setCurrentElem(T currentElem){
 
     protected abstract boolean amChildElementRef();
 
-    protected abstract void addPrivate(TPrivate tPrivate);
+    public void addPrivate(TPrivate tPrivate){
+        if (currentElem instanceof TBaseElement){
+            ((TBaseElement) currentElem).getPrivate().add(tPrivate);
+        } else {
+            throw new UnsupportedOperationException("Not implemented for class " + this.getClass().getName());
+        }
+    }
 
-}
+    public String getXPath(){
+        String parentXpath = (parentAdapter != null) ? parentAdapter.getXPath() : "";
+        return parentXpath + "/" + elementXPath();
+    }
 
+    protected String elementXPath(){
+        return String.format("undefined(%s)", currentElem.getClass().getSimpleName());
+    }
+
+}

sct-commons/src/main/java/org/lfenergy/compas/sct/commons/scl/SclElementAdapter.java

@@ -54,8 +54,8 @@ protected boolean amChildElementRef() {
     }
 
     @Override
-    protected void addPrivate(TPrivate tPrivate) {
-        currentElem.getPrivate().add(tPrivate);
+    protected String elementXPath() {
+        return "SCL";
     }
 
     public Short getSclRelease(){