From 9dee8fb26033681bac632d311136effc03083406 Mon Sep 17 00:00:00 2001 From: Samir Romdhani Date: Mon, 26 Feb 2024 18:40:44 +0100 Subject: [PATCH] feat(): refactor DTT - manage DO and DA in DataTypeTemplate / DOI, SDI and DAI in LN Signed-off-by: Samir Romdhani --- .../compas/sct/commons/BDAService.java | 28 +++ .../compas/sct/commons/DaTypeService.java | 28 +++ .../sct/commons/DataTypeTemplatesService.java | 232 +++++++++++++++++- .../compas/sct/commons/LnService.java | 172 ++++++++++++- .../compas/sct/commons/SDOOrDAService.java | 29 +++ .../commons/api/DataTypeTemplateReader.java | 25 ++ .../compas/sct/commons/api/LNEditor.java | 17 ++ .../commons/DataTypeTemplatesServiceTest.java | 183 +++++++++++++- .../compas/sct/commons/LnServiceTest.java | 119 ++++++++- 9 files changed, 817 insertions(+), 16 deletions(-) create mode 100644 sct-commons/src/main/java/org/lfenergy/compas/sct/commons/BDAService.java create mode 100644 sct-commons/src/main/java/org/lfenergy/compas/sct/commons/DaTypeService.java create mode 100644 sct-commons/src/main/java/org/lfenergy/compas/sct/commons/SDOOrDAService.java create mode 100644 sct-commons/src/main/java/org/lfenergy/compas/sct/commons/api/DataTypeTemplateReader.java create mode 100644 sct-commons/src/main/java/org/lfenergy/compas/sct/commons/api/LNEditor.java diff --git a/sct-commons/src/main/java/org/lfenergy/compas/sct/commons/BDAService.java b/sct-commons/src/main/java/org/lfenergy/compas/sct/commons/BDAService.java new file mode 100644 index 000000000..ebf096e95 --- /dev/null +++ b/sct-commons/src/main/java/org/lfenergy/compas/sct/commons/BDAService.java @@ -0,0 +1,28 @@ +// SPDX-FileCopyrightText: 2023 RTE FRANCE +// +// SPDX-License-Identifier: Apache-2.0 + +package org.lfenergy.compas.sct.commons; + +import org.lfenergy.compas.scl2007b4.model.TBDA; +import org.lfenergy.compas.scl2007b4.model.TDAType; + +import java.util.Optional; +import java.util.function.Predicate; +import java.util.stream.Stream; + +public class BDAService { + + public Stream getBDAs(TDAType tdaType) { + return tdaType.getBDA().stream(); + } + + public Stream getFilteredSDOOrDAs(TDAType tdaType, Predicate tTBDAPredicate) { + return getBDAs(tdaType).filter(tTBDAPredicate); + } + + public Optional findBDA(TDAType tdaType, Predicate tBDAPredicate) { + return getFilteredSDOOrDAs(tdaType, tBDAPredicate).findFirst(); + } + +} diff --git a/sct-commons/src/main/java/org/lfenergy/compas/sct/commons/DaTypeService.java b/sct-commons/src/main/java/org/lfenergy/compas/sct/commons/DaTypeService.java new file mode 100644 index 000000000..b93afb9a7 --- /dev/null +++ b/sct-commons/src/main/java/org/lfenergy/compas/sct/commons/DaTypeService.java @@ -0,0 +1,28 @@ +// SPDX-FileCopyrightText: 2024 RTE FRANCE +// +// SPDX-License-Identifier: Apache-2.0 + +package org.lfenergy.compas.sct.commons; + +import org.lfenergy.compas.scl2007b4.model.TDAType; +import org.lfenergy.compas.scl2007b4.model.TDataTypeTemplates; + +import java.util.Optional; +import java.util.function.Predicate; +import java.util.stream.Stream; + +public class DaTypeService { + + public Stream getDaTypes(TDataTypeTemplates tDataTypeTemplates) { + return tDataTypeTemplates.getDAType().stream(); + } + + public Stream getFilteredDaTypes(TDataTypeTemplates tDataTypeTemplates, Predicate tdaTypePredicate) { + return getDaTypes(tDataTypeTemplates).filter(tdaTypePredicate); + } + + public Optional findDaType(TDataTypeTemplates tDataTypeTemplates, Predicate tdaTypePredicate) { + return getFilteredDaTypes(tDataTypeTemplates, tdaTypePredicate).findFirst(); + } + +} diff --git a/sct-commons/src/main/java/org/lfenergy/compas/sct/commons/DataTypeTemplatesService.java b/sct-commons/src/main/java/org/lfenergy/compas/sct/commons/DataTypeTemplatesService.java index b08a5fc29..bc8b2b77c 100644 --- a/sct-commons/src/main/java/org/lfenergy/compas/sct/commons/DataTypeTemplatesService.java +++ b/sct-commons/src/main/java/org/lfenergy/compas/sct/commons/DataTypeTemplatesService.java @@ -5,15 +5,26 @@ package org.lfenergy.compas.sct.commons; import org.lfenergy.compas.scl2007b4.model.*; +import org.lfenergy.compas.sct.commons.api.DataTypeTemplateReader; +import org.lfenergy.compas.sct.commons.dto.DaTypeName; +import org.lfenergy.compas.sct.commons.dto.DataAttributeRef; +import org.lfenergy.compas.sct.commons.dto.DoTypeName; +import org.lfenergy.compas.sct.commons.dto.SclReportItem; +import org.lfenergy.compas.sct.commons.exception.ScdException; + +import java.util.*; import static org.lfenergy.compas.sct.commons.util.CommonConstants.MOD_DO_NAME; import static org.lfenergy.compas.sct.commons.util.CommonConstants.STVAL_DA_NAME; -public class DataTypeTemplatesService { +public class DataTypeTemplatesService implements DataTypeTemplateReader { final LnodeTypeService lnodeTypeService = new LnodeTypeService(); final DoTypeService doTypeService = new DoTypeService(); + final DaTypeService daTypeService = new DaTypeService(); final DoService doService = new DoService(); + final SDOOrDAService sdoOrDAService = new SDOOrDAService(); + final BDAService bdaService = new BDAService(); /** * verify if DO(name=Mod)/DA(name=stVal) exists in DataTypeTemplate @@ -36,11 +47,218 @@ public boolean isDoModAndDaStValExist(TDataTypeTemplates dtt, String lNodeTypeId .map(lNodeType -> doService.findDo(lNodeType, tdo -> MOD_DO_NAME.equals(tdo.getName())) .map(tdo -> doTypeService.findDoType(dtt, doType -> tdo.getType().equals(doType.getId())) .map(doType -> doType.getSDOOrDA().stream() - .filter(sdoOrDa -> sdoOrDa.getClass().equals(TDA.class)) - .map(TDA.class::cast) - .anyMatch(tda -> STVAL_DA_NAME.equals(tda.getName()))) - .orElse(false)) - .orElse(false)) - .orElse(false); + .filter(sdoOrDa -> sdoOrDa.getClass().equals(TDA.class)) + .map(TDA.class::cast) + .anyMatch(tda -> STVAL_DA_NAME.equals(tda.getName()))) + .orElse(false)) + .orElse(false)) + .orElse(false); + } + + public List isDataObjectsAndDataAttributesExists(TDataTypeTemplates dtt, String lNodeTypeId, String dataRef) { + List sclReportItems = new ArrayList<>(); + LinkedList dataRefList = new LinkedList<>(Arrays.asList(dataRef.split("\\."))); + if (dataRefList.size() < 2) { + sclReportItems.add(SclReportItem.error(null, "Invalid data reference %s. At least DO name and DA name are required".formatted(dataRef))); + } + String doName = dataRefList.remove(); + return lnodeTypeService.findLnodeType(dtt, lNodeType -> lNodeTypeId.equals(lNodeType.getId())) + .map(lNodeType -> doService.findDo(lNodeType, tdo -> tdo.getName().equals(doName)) + .map(tdo -> doTypeService.findDoType(dtt, doType -> doType.getId().equals(tdo.getType())) + .map(tdoType -> { + TDOType lastDoType = findDOTypeBySdoName(dtt, tdoType, dataRefList); + var tdaType = getDATypeByDaNameIfExist(dtt, lastDoType, dataRefList.get(0)); + tdaType.ifPresentOrElse(tdaType1 -> { + if(tdaType1 instanceof TDOType) return; + dataRefList.remove(); + checkDATypeByBdaName(dtt, (TDAType) tdaType1, dataRefList, sclReportItems); + }, ()-> sclReportItems.add(SclReportItem.error(null, + String.format("Unknown Sub Data Object SDO or Data Attribute DA (%s) in DOType.id (%s)", + dataRefList.get(0), lastDoType.getId())))); + return sclReportItems; + }) + .orElseGet(() -> { + sclReportItems.add(SclReportItem.error(null, String.format("DOType.id (%s) for DO.name (%s) not found in DataTypeTemplates", tdo.getType(), tdo.getName()))); + return sclReportItems; + })) + .orElseGet(() -> { + sclReportItems.add(SclReportItem.error(null, String.format("Unknown DO.name (%s) in DOType.id (%s)", doName, lNodeTypeId))); + return sclReportItems; + })) + .orElseGet(() -> { + sclReportItems.add(SclReportItem.error(null, "No Data Attribute found with this reference %s for LNodeType.id (%s)".formatted(dataRef, lNodeTypeId))); + return sclReportItems; + }); + } + + public List verifyDataObjectsAndDataAttributes(TDataTypeTemplates dtt, String lNodeTypeId, DoTypeName doTypeName, DaTypeName daTypeName) { + + List sclReportItems = new ArrayList<>(); + LinkedList structNamesRefList = new LinkedList<>(); + structNamesRefList.addFirst(doTypeName.getName()); + doTypeName.getStructNames().forEach(structNamesRefList::addLast); + structNamesRefList.addLast(daTypeName.getName()); + daTypeName.getStructNames().forEach(structNamesRefList::addLast); + if (structNamesRefList.size() < 2) { + sclReportItems.add(SclReportItem.error(null, "Invalid data reference %s. At least DO name and DA name are required".formatted(sclReportItems))); + } + String doName = structNamesRefList.remove(); + return lnodeTypeService.findLnodeType(dtt, lNodeType -> lNodeTypeId.equals(lNodeType.getId())) + .map(lNodeType -> doService.findDo(lNodeType, tdo -> tdo.getName().equals(doName)) + .map(tdo -> doTypeService.findDoType(dtt, doType -> doType.getId().equals(tdo.getType())) + .map(tdoType -> { + TDOType lastDoType = findDOTypeBySdoName(dtt, tdoType, structNamesRefList); + var tdaType = getDATypeByDaNameIfExist(dtt, lastDoType, structNamesRefList.get(0)); + tdaType.ifPresentOrElse(tdaType1 -> { + if(tdaType1 instanceof TDOType) return; + System.out.println(":: DA Type found :: "+tdaType1.getId()); + structNamesRefList.remove(); + checkDATypeByBdaName(dtt, (TDAType) tdaType1, structNamesRefList, sclReportItems); + }, ()-> sclReportItems.add(SclReportItem.error(null, + String.format("Unknown Sub Data Object SDO or Data Attribute DA (%s) in DOType.id (%s)", + structNamesRefList.get(0), lastDoType.getId())))); + return sclReportItems; + }) + .orElseGet(() -> { + sclReportItems.add(SclReportItem.error(null, String.format("DOType.id (%s) for DO.name (%s) not found in DataTypeTemplates", tdo.getType(), tdo.getName()))); + return sclReportItems; + })) + .orElseGet(() -> { + sclReportItems.add(SclReportItem.error(null, String.format("Unknown DO.name (%s) in DOType.id (%s)", doName, lNodeTypeId))); + return sclReportItems; + })) + .orElseGet(() -> { + sclReportItems.add(SclReportItem.error(null, "No Data Attribute found with this reference %s for LNodeType.id (%s)".formatted(structNamesRefList, lNodeTypeId))); + return sclReportItems; + }); + } + + public DataAttributeRef getDataObjectsAndDataAttributes(TDataTypeTemplates dtt, String lNodeTypeId, String dataRef) { + DataAttributeRef dataAttributeRef = new DataAttributeRef(); + LinkedList dataRefList = new LinkedList<>(Arrays.asList(dataRef.split("\\."))); + if (dataRefList.size() < 2) { + throw new ScdException("Invalid data reference %s. At least DO name and DA name are required".formatted(dataRef)); + } + String doName = dataRefList.remove(); + return lnodeTypeService.findLnodeType(dtt, lNodeType -> lNodeTypeId.equals(lNodeType.getId())) + .map(lNodeType -> doService.findDo(lNodeType, tdo -> tdo.getName().equals(doName)) + .map(tdo -> doTypeService.findDoType(dtt, doType -> doType.getId().equals(tdo.getType())) + .map(tdoType -> { + //DO: Setter + DoTypeName doTypeName = new DoTypeName(doName); + //last DoType finder + TDOType lastDoType = findDOTypeBySdoName(dtt, tdoType, dataRefList, doTypeName.getStructNames()); + doTypeName.setCdc(tdoType.getCdc()); + dataAttributeRef.setDoName(doTypeName); + //DA::Setter + DaTypeName daTypeName = new DaTypeName(dataRefList.get(0)); + TDA tda = sdoOrDAService.findSDOOrDA(lastDoType, TDA.class, tda1 -> tda1.getName().equals(daTypeName.getName())) + .orElseThrow(); + // FC only exist within DA + daTypeName.setFc(tda.getFc()); + if(tda.getBType() != TPredefinedBasicTypeEnum.STRUCT) { + daTypeName.setBType(tda.getBType()); + daTypeName.setType(tda.getType()); + daTypeName.setValImport(tda.isValImport()); + dataAttributeRef.setDaiValues(tda.getVal()); + } + //DAType finder + var tdaType = getDATypeByDaNameIfExist(dtt, lastDoType, daTypeName.getName()); + tdaType.ifPresentOrElse(tdaType1 -> { + if(tdaType1 instanceof TDOType) return; + //last DAType finder + dataRefList.remove(); + TDAType lastDAType = findDATypeByBdaName(dtt, (TDAType) tdaType1, dataRefList, daTypeName.getStructNames()); + //DA/BDA::Setter + TBDA tbda = bdaService.findBDA(lastDAType, bda -> bda.getName().equals(daTypeName.getStructNames().get( + daTypeName.getStructNames().size() - 1 + ))).orElseThrow(); + if(tbda.getBType() != TPredefinedBasicTypeEnum.STRUCT) { + daTypeName.setBType(tbda.getBType()); + daTypeName.setType(tbda.getType()); + daTypeName.setValImport(tbda.isValImport()); + dataAttributeRef.setDaiValues(tbda.getVal()); + } + dataAttributeRef.setDaName(daTypeName); + }, ()-> { + throw new ScdException(String.format("Unknown Sub Data Object SDO or Data Attribute DA (%s) in DOType.id (%s)", dataRefList.get(0), lastDoType.getId())); + }); + return dataAttributeRef; + }) + .orElseThrow(() -> new ScdException( String.format("DOType.id (%s) for DO.name (%s) not found in DataTypeTemplates", tdo.getType(), tdo.getName())))) + .orElseThrow(() -> new ScdException(String.format("Unknown DO.name (%s) in DOType.id (%s)", doName, lNodeTypeId)))) + .orElseThrow(() -> new ScdException("No Data Attribute found with this reference %s for LNodeType.id (%s)".formatted(dataRef, lNodeTypeId))); + } + + private Optional getDATypeByDaNameIfExist(TDataTypeTemplates dtt, TDOType tdoType, String daName) { + Optional dai = sdoOrDAService.findSDOOrDA(tdoType, TDA.class, tda -> tda.getName().equals(daName)); + if(dai.isPresent()){ + if(dai.get().getType() == null){ + return (Optional) Optional.of(tdoType); + } else { + return (Optional) daTypeService.findDaType(dtt, tdaType -> tdaType.getId().equals(dai.get().getType())); + } + } + return Optional.empty(); + } + + private Optional getDATypeByBdaName(TDataTypeTemplates dtt, TDAType tdaType, String bdaName) { + if(tdaType == null) return Optional.empty(); + return bdaService.findBDA(tdaType, tbda -> tbda.getName().equals(bdaName)) + .map(tbda -> { + if(tbda.getBType() == TPredefinedBasicTypeEnum.STRUCT) { + return daTypeService.findDaType(dtt, tdaType2 -> tdaType2.getId().equals(tbda.getType())) + .orElseThrow(() -> new ScdException("bdaName = "+tbda + " not exist in datype id = "+tdaType.getId())); + } + return tdaType; + }) + .stream().findFirst(); + } + + private TDOType findDOTypeBySdoName(TDataTypeTemplates dtt, TDOType tdoType, List sdoNames) { + if(sdoNames.isEmpty()) return tdoType; + return sdoOrDAService.findSDOOrDA(tdoType, TSDO.class, tsdo -> tsdo.getName().equals(sdoNames.get(0))) + .flatMap(sdo1 -> doTypeService.findDoType(dtt, tdoType1 -> tdoType1.getId().equals(sdo1.getType())) + .stream().findFirst()) + .map(tdoType1 -> { + sdoNames.remove(0); + return findDOTypeBySdoName(dtt, tdoType1, sdoNames); + }) + .orElse(tdoType); + } + + private TDOType findDOTypeBySdoName(TDataTypeTemplates dtt, TDOType tdoType, List sdoNames, List concreteList) { + if(sdoNames.isEmpty()) return tdoType; + return sdoOrDAService.findSDOOrDA(tdoType, TSDO.class, tsdo -> tsdo.getName().equals(sdoNames.get(0))) + .flatMap(sdo1 -> doTypeService.findDoType(dtt, tdoType1 -> tdoType1.getId().equals(sdo1.getType())) + .stream().findFirst()) + .map(tdoType1 -> { + concreteList.add(sdoNames.get(0)); + sdoNames.remove(0); + return findDOTypeBySdoName(dtt, tdoType1, sdoNames, concreteList); + }) + .orElse(tdoType); + } + + private void checkDATypeByBdaName(TDataTypeTemplates dtt, TDAType tdaType, List bdaNames, List sclReportItems) { + if(bdaNames.isEmpty()) return ; + getDATypeByBdaName(dtt, tdaType, bdaNames.get(0)) + .ifPresentOrElse(tdaType1 -> { + bdaNames.remove(0); + checkDATypeByBdaName(dtt, tdaType1, bdaNames, sclReportItems); + }, () -> sclReportItems.add(SclReportItem.error(null,String.format("Unknown BDA.name (%s) in DAType.id (%s)", + bdaNames.get(0), tdaType.getId())))); } + + private TDAType findDATypeByBdaName(TDataTypeTemplates dtt, TDAType tdaType, List bdaNames, List concreteList) { + if(bdaNames.isEmpty()) return tdaType; + return getDATypeByBdaName(dtt, tdaType, bdaNames.get(0)) + .map(tdaType1 -> { + concreteList.add(bdaNames.get(0)); + bdaNames.remove(0); + return findDATypeByBdaName(dtt, tdaType1, bdaNames, concreteList); + }) + .orElse(tdaType); + } + } diff --git a/sct-commons/src/main/java/org/lfenergy/compas/sct/commons/LnService.java b/sct-commons/src/main/java/org/lfenergy/compas/sct/commons/LnService.java index bf4b616b8..5de0aec67 100644 --- a/sct-commons/src/main/java/org/lfenergy/compas/sct/commons/LnService.java +++ b/sct-commons/src/main/java/org/lfenergy/compas/sct/commons/LnService.java @@ -5,16 +5,20 @@ package org.lfenergy.compas.sct.commons; import org.lfenergy.compas.scl2007b4.model.*; +import org.lfenergy.compas.sct.commons.api.LNEditor; +import org.lfenergy.compas.sct.commons.dto.DaTypeName; +import org.lfenergy.compas.sct.commons.dto.DataAttributeRef; +import org.lfenergy.compas.sct.commons.dto.DoTypeName; import org.lfenergy.compas.sct.commons.util.ActiveStatus; -import java.util.Collection; -import java.util.Optional; +import java.util.*; import java.util.stream.Stream; import static org.lfenergy.compas.sct.commons.util.CommonConstants.MOD_DO_NAME; import static org.lfenergy.compas.sct.commons.util.CommonConstants.STVAL_DA_NAME; +import static org.lfenergy.compas.sct.commons.util.SclConstructorHelper.newVal; -public class LnService { +public class LnService implements LNEditor { public Stream getAnylns(TLDevice tlDevice) { return Stream.concat(Stream.of(tlDevice.getLN0()), tlDevice.getLN().stream()); @@ -61,4 +65,166 @@ public Stream getActiveLns(TLDevice tlDevice) { Stream ln0Stream = Stream.of(ln0).filter(ln02 -> getDaiModStval(ln02).map(ActiveStatus.ON::equals).orElse(false)); return Stream.concat(ln0Stream, tlnStream); } + + public boolean isDoObjectsInstanceAndDataAttributesInstanceExists(TAnyLN tAnyLN, DoTypeName doTypeName, DaTypeName daTypeName) { + return tAnyLN.getDOI().stream().filter(doi -> doTypeName.getName().equals(doi.getName())) + .findFirst() + .map(doi -> { + LinkedList structNamesList = new LinkedList<>(doTypeName.getStructNames()); + structNamesList.addLast(daTypeName.getName()); + daTypeName.getStructNames().forEach(structNamesList::addLast); + if(structNamesList.size() > 1) { + String firstSDIName = structNamesList.remove(); + return doi.getSDIOrDAI().stream() + .filter(sdi -> sdi.getClass().equals(TSDI.class)) + .map(TSDI.class::cast) + .filter(tsdi -> tsdi.getName().equals(firstSDIName)) + .findFirst() + .map(intermediateSdi -> findSDIByStructName(intermediateSdi, structNamesList)) + .stream() + .findFirst() + .flatMap(lastDsi -> { + if (structNamesList.size() == 1) { + return lastDsi.getSDIOrDAI().stream() + .filter(dai -> dai.getClass().equals(TDAI.class)) + .map(TDAI.class::cast) + .filter(dai -> dai.getName().equals(structNamesList.get(0))) + .findFirst(); + } + return Optional.empty(); + }) + .isPresent(); + } else if(structNamesList.size() == 1){ + return doi.getSDIOrDAI().stream() + .filter(unNaming -> unNaming.getClass().equals(TDAI.class)) + .map(TDAI.class::cast) + .anyMatch(dai -> dai.getName().equals(structNamesList.get(0))); + } + return false; + }) + .orElse(false); + } + + public void updateOrCreateDoObjectsAndDataAttributesInstances(TAnyLN tAnyLN, DataAttributeRef dataAttributeRef) { + createDoiSdiDaiChainIfNotExists(tAnyLN, dataAttributeRef.getDoName(), dataAttributeRef.getDaName()) + .ifPresent(tdai -> { + for (Map.Entry mapVal : dataAttributeRef.getDaName().getDaiValues().entrySet()) { + if (mapVal.getKey() != null && mapVal.getKey() != 0L) { + tdai.getVal().stream() + .filter(tValElem -> tValElem.isSetSGroup() && mapVal.getKey().equals(tValElem.getSGroup())) + .findFirst() + .ifPresentOrElse( + tVal -> tVal.setValue(mapVal.getValue()), + () -> tdai.getVal().add(newVal(mapVal.getValue(), mapVal.getKey()))); + } else { + tdai.getVal().stream().findFirst() + .ifPresentOrElse( + tVal -> tVal.setValue(mapVal.getValue()), + () -> tdai.getVal().add(newVal(mapVal.getValue()))); + } + } + }); + } + + private TSDI findSDIByStructName(TSDI tsdi, List structNames) { + if(structNames.isEmpty()) return tsdi; + return tsdi.getSDIOrDAI().stream() + .filter(sdi -> sdi.getClass().equals(TSDI.class)) + .map(TSDI.class::cast) + .filter(sdi -> sdi.getName().equals(structNames.get(0))) + .findFirst() + .map(sdi1 -> { + structNames.remove(0); + return findSDIByStructName(sdi1, structNames); + }) + .orElse(tsdi); + } + + private TSDI findOrCreateSDIByStructName(TSDI tsdi, List structNames) { + structNames.remove(0); + if(structNames.isEmpty() || structNames.size() == 1) return tsdi; + return findOrCreateSDIByStructName(findOrCreateSDIFromSDI(tsdi, structNames.get(0)), structNames); + } + + private Optional createDoiSdiDaiChainIfNotExists(TAnyLN tAnyLN, DoTypeName doTypeName, DaTypeName daTypeName) { + LinkedList structNamesList = new LinkedList<>(); + structNamesList.addLast(doTypeName.getName()); + doTypeName.getStructNames().forEach(structNamesList::addLast); + structNamesList.addLast(daTypeName.getName()); + daTypeName.getStructNames().forEach(structNamesList::addLast); + + String doiName = structNamesList.remove(); + TDOI doi = tAnyLN.getDOI().stream().filter(tdoi -> tdoi.getName().equals(doiName)) + .findFirst() + .orElseGet(() -> { + TDOI tdoi = new TDOI(); + tdoi.setName(doiName); + tAnyLN.getDOI().add(tdoi); + return tdoi; + }); + if(structNamesList.size() > 1) { + TSDI lastDsi = findOrCreateSDIByStructName(findOrCreateSDIFromDOI(doi, structNamesList.get(0)), structNamesList); + if (structNamesList.size() == 1) { + return Optional.of(findOrCreateDAIFromSDI(lastDsi, structNamesList.get(0))); + } + } + else if(structNamesList.size() == 1){ + return Optional.of(doi.getSDIOrDAI().stream() + .filter(dai -> dai.getClass().equals(TDAI.class)) + .map(TDAI.class::cast) + .filter(tdai -> tdai.getName().equals(structNamesList.get(0))) + .findFirst() + .orElseGet(() -> { + TDAI tdai = new TDAI(); + tdai.setName(structNamesList.get(0)); + doi.getSDIOrDAI().add(tdai); + return tdai; + })); + } + return Optional.empty(); + } + + private TDAI findOrCreateDAIFromSDI(TSDI sdi, String daiName) { + return sdi.getSDIOrDAI().stream() + .filter(unNaming -> unNaming.getClass().equals(TDAI.class)) + .map(TDAI.class::cast) + .filter(tdai -> tdai.getName().equals(daiName)) + .findFirst() + .orElseGet(() -> { + TDAI tdai = new TDAI(); + tdai.setName(daiName); + sdi.getSDIOrDAI().add(tdai); + return tdai; + }); + } + + + private TSDI findOrCreateSDIFromDOI(TDOI doi, String sdiName) { + return doi.getSDIOrDAI().stream() + .filter(sdi -> sdi.getClass().equals(TSDI.class)) + .map(TSDI.class::cast) + .filter(tsdi -> tsdi.getName().equals(sdiName)) + .findFirst() + .orElseGet(() -> { + TSDI tsdi = new TSDI(); + tsdi.setName(sdiName); + doi.getSDIOrDAI().add(tsdi); + return tsdi; + }); + } + + private TSDI findOrCreateSDIFromSDI(TSDI sdi, String sdiName) { + return sdi.getSDIOrDAI().stream() + .filter(unNaming -> unNaming.getClass().equals(TSDI.class)) + .map(TSDI.class::cast) + .filter(tsdi -> tsdi.getName().equals(sdiName)) + .findFirst() + .orElseGet(() -> { + TSDI tsdi = new TSDI(); + tsdi.setName(sdiName); + sdi.getSDIOrDAI().add(tsdi); + return tsdi; + }); + } + } diff --git a/sct-commons/src/main/java/org/lfenergy/compas/sct/commons/SDOOrDAService.java b/sct-commons/src/main/java/org/lfenergy/compas/sct/commons/SDOOrDAService.java new file mode 100644 index 000000000..a6aa5e50b --- /dev/null +++ b/sct-commons/src/main/java/org/lfenergy/compas/sct/commons/SDOOrDAService.java @@ -0,0 +1,29 @@ +// SPDX-FileCopyrightText: 2024 RTE FRANCE +// +// SPDX-License-Identifier: Apache-2.0 + +package org.lfenergy.compas.sct.commons; + +import org.lfenergy.compas.scl2007b4.model.*; + +import java.util.Optional; +import java.util.function.Predicate; +import java.util.stream.Stream; + +public class SDOOrDAService { + + public Stream getSDOOrDAs(TDOType tdoType, Class clazz) { + return tdoType.getSDOOrDA().stream() + .filter(unNaming -> unNaming.getClass().equals(clazz)) + .map(clazz::cast); + } + + public Stream getFilteredSDOOrDAs(TDOType tdoType, Class clazz, Predicate tSDOOrDAPredicate) { + return getSDOOrDAs(tdoType, clazz).filter(tSDOOrDAPredicate); + } + + public Optional findSDOOrDA(TDOType tdoType, Class clazz, Predicate tSDOOrDAPredicate) { + return getFilteredSDOOrDAs(tdoType, clazz, tSDOOrDAPredicate).findFirst(); + } + +} diff --git a/sct-commons/src/main/java/org/lfenergy/compas/sct/commons/api/DataTypeTemplateReader.java b/sct-commons/src/main/java/org/lfenergy/compas/sct/commons/api/DataTypeTemplateReader.java new file mode 100644 index 000000000..bc4692223 --- /dev/null +++ b/sct-commons/src/main/java/org/lfenergy/compas/sct/commons/api/DataTypeTemplateReader.java @@ -0,0 +1,25 @@ +// SPDX-FileCopyrightText: 2024 RTE FRANCE +// +// SPDX-License-Identifier: Apache-2.0 + +package org.lfenergy.compas.sct.commons.api; + +import org.lfenergy.compas.scl2007b4.model.TDataTypeTemplates; +import org.lfenergy.compas.sct.commons.dto.DaTypeName; +import org.lfenergy.compas.sct.commons.dto.DataAttributeRef; +import org.lfenergy.compas.sct.commons.dto.DoTypeName; +import org.lfenergy.compas.sct.commons.dto.SclReportItem; + +import java.util.List; + +public interface DataTypeTemplateReader { + + boolean isDoModAndDaStValExist(TDataTypeTemplates dtt, String lNodeTypeId); + + List isDataObjectsAndDataAttributesExists(TDataTypeTemplates dtt, String lNodeTypeId, String dataRef); + + List verifyDataObjectsAndDataAttributes(TDataTypeTemplates dtt, String lNodeTypeId, DoTypeName doTypeName, DaTypeName daTypeName); + + DataAttributeRef getDataObjectsAndDataAttributes(TDataTypeTemplates dtt, String lNodeTypeId, String dataRef); + +} diff --git a/sct-commons/src/main/java/org/lfenergy/compas/sct/commons/api/LNEditor.java b/sct-commons/src/main/java/org/lfenergy/compas/sct/commons/api/LNEditor.java new file mode 100644 index 000000000..7c7dcc93d --- /dev/null +++ b/sct-commons/src/main/java/org/lfenergy/compas/sct/commons/api/LNEditor.java @@ -0,0 +1,17 @@ +// SPDX-FileCopyrightText: 2024 RTE FRANCE +// +// SPDX-License-Identifier: Apache-2.0 + +package org.lfenergy.compas.sct.commons.api; + +import org.lfenergy.compas.scl2007b4.model.TAnyLN; +import org.lfenergy.compas.sct.commons.dto.DaTypeName; +import org.lfenergy.compas.sct.commons.dto.DataAttributeRef; +import org.lfenergy.compas.sct.commons.dto.DoTypeName; + +public interface LNEditor { + + boolean isDoObjectsInstanceAndDataAttributesInstanceExists(TAnyLN tAnyLN, DoTypeName doTypeName, DaTypeName daTypeName); + + void updateOrCreateDoObjectsAndDataAttributesInstances(TAnyLN tAnyLN, DataAttributeRef dataAttributeRef); +} diff --git a/sct-commons/src/test/java/org/lfenergy/compas/sct/commons/DataTypeTemplatesServiceTest.java b/sct-commons/src/test/java/org/lfenergy/compas/sct/commons/DataTypeTemplatesServiceTest.java index ee24a4d86..9c5be5c10 100644 --- a/sct-commons/src/test/java/org/lfenergy/compas/sct/commons/DataTypeTemplatesServiceTest.java +++ b/sct-commons/src/test/java/org/lfenergy/compas/sct/commons/DataTypeTemplatesServiceTest.java @@ -6,8 +6,18 @@ import org.junit.jupiter.api.Test; import org.lfenergy.compas.scl2007b4.model.*; +import org.lfenergy.compas.sct.commons.dto.DaTypeName; +import org.lfenergy.compas.sct.commons.dto.DataAttributeRef; +import org.lfenergy.compas.sct.commons.dto.DoTypeName; +import org.lfenergy.compas.sct.commons.dto.SclReportItem; +import org.lfenergy.compas.sct.commons.scl.dtt.DataTypeTemplateAdapter; -import static org.assertj.core.api.AssertionsForClassTypes.assertThat; +import java.util.List; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.AssertionsForClassTypes.assertThatCode; +import static org.lfenergy.compas.sct.commons.scl.dtt.DataTypeTemplateTestUtils.SCD_DTT_DO_SDO_DA_BDA; +import static org.lfenergy.compas.sct.commons.scl.dtt.DataTypeTemplateTestUtils.initDttAdapterFromFile; class DataTypeTemplatesServiceTest { @@ -44,7 +54,6 @@ void isDoModAndDaStValExist_when_Do_not_exist_should_return_false() { @Test void isDoModAndDaStValExist_when_DoType_not_exist_should_return_false() { //Given - SCL scl = new SCL(); TDataTypeTemplates dtt = new TDataTypeTemplates(); TLNodeType tlNodeType = new TLNodeType(); tlNodeType.setId("lnodeTypeId"); @@ -137,4 +146,172 @@ void isDoModAndDaStValExist_when_DO_Mod_And_DA_stVal_exist_return_true() { //Then assertThat(result).isTrue(); } -} \ No newline at end of file + + + @Test + void isDataAttributeExist2_should_find_DO_SDO_DA_and_BDA() { + // Given + DataTypeTemplateAdapter dttAdapter = initDttAdapterFromFile(SCD_DTT_DO_SDO_DA_BDA); + // When + DataTypeTemplatesService dataTypeTemplatesService = new DataTypeTemplatesService(); + + DataAttributeRef dataAttributeRefs = dataTypeTemplatesService.getDataObjectsAndDataAttributes( + dttAdapter.getCurrentElem(), "LN1", "Do1.sdo1.sdo2.da2.bda1.bda2"); + // Then + assertThatCode(() -> dataTypeTemplatesService.isDataObjectsAndDataAttributesExists( + dttAdapter.getCurrentElem(), "LN1", "Do1.sdo1.sdo2.da2.bda1.bda2")) + .doesNotThrowAnyException(); + + assertThat(dataAttributeRefs.getDoRef()).isEqualTo("Do1.sdo1.sdo2"); + assertThat(dataAttributeRefs.getDaRef()).isEqualTo("da2.bda1.bda2"); + assertThat(dataAttributeRefs).extracting(DataAttributeRef::getDoRef, DataAttributeRef::getDaRef) + .containsExactly("Do1.sdo1.sdo2", "da2.bda1.bda2"); + assertThat(dataAttributeRefs.getDoName().getCdc()).isEqualTo(TPredefinedCDCEnum.WYE); + assertThat(dataAttributeRefs.getDaName()).extracting(DaTypeName::getBType, DaTypeName::getFc) + .containsExactly(TPredefinedBasicTypeEnum.ENUM, TFCEnum.ST); + } + + @Test + void isDoObjectsAndDataAttributesExists_when_LNodeType_not_exist_should_return_error_report_item() { + // Given + TDataTypeTemplates dtt = new TDataTypeTemplates(); + TLNodeType tlNodeType = new TLNodeType(); + tlNodeType.setId("lnodeTypeId"); + dtt.getLNodeType().add(tlNodeType); + // When + DataTypeTemplatesService dataTypeTemplatesService = new DataTypeTemplatesService(); + List sclReportItems = dataTypeTemplatesService.isDataObjectsAndDataAttributesExists(dtt, + "lnodeTypeId2", "Do1.sdo1.sdo2.da2.bda1.bda2"); + // Then + assertThat(sclReportItems) + .hasSize(1) + .extracting(SclReportItem::message) + .containsExactly("No Data Attribute found with this reference Do1.sdo1.sdo2.da2.bda1.bda2 for LNodeType.id (lnodeTypeId2)"); + } + + @Test + void isDoObjectsAndDataAttributesExists_when_DO_not_exist_should_return_error_report_item() { + // Given + TDataTypeTemplates dtt = new TDataTypeTemplates(); + TLNodeType tlNodeType = new TLNodeType(); + tlNodeType.setId("lnodeTypeId"); + TDO tdo = new TDO(); + tdo.setType("doTypeId"); + tdo.setName("Mods"); + tlNodeType.getDO().add(tdo); + dtt.getLNodeType().add(tlNodeType); + // When + DataTypeTemplatesService dataTypeTemplatesService = new DataTypeTemplatesService(); + List sclReportItems = dataTypeTemplatesService.isDataObjectsAndDataAttributesExists(dtt, + "lnodeTypeId", "Mod.stVal"); + // Then + assertThat(sclReportItems) + .hasSize(1) + .extracting(SclReportItem::message) + .containsExactly("Unknown DO.name (Mod) in DOType.id (lnodeTypeId)"); + } + + + @Test + void isDoObjectsAndDataAttributesExists_when_DOType_not_exist_should_return_error_report_item() { + // Given + TDataTypeTemplates dtt = new TDataTypeTemplates(); + TLNodeType tlNodeType = new TLNodeType(); + tlNodeType.setId("lnodeTypeId"); + TDO tdo = new TDO(); + tdo.setType("doTypeId"); + tdo.setName("Mod"); + tlNodeType.getDO().add(tdo); + dtt.getLNodeType().add(tlNodeType); + // When + DataTypeTemplatesService dataTypeTemplatesService = new DataTypeTemplatesService(); + List sclReportItems = dataTypeTemplatesService.isDataObjectsAndDataAttributesExists(dtt, + "lnodeTypeId", "Mod.stVal"); + // Then + assertThat(sclReportItems) + .hasSize(1) + .extracting(SclReportItem::message) + .containsExactly("DOType.id (doTypeId) for DO.name (Mod) not found in DataTypeTemplates"); + } + + @Test + void isDoObjectsAndDataAttributesExists_when_DA_not_exist_should_return_error_report_item() { + // Given + TDataTypeTemplates dtt = new TDataTypeTemplates(); + TLNodeType tlNodeType = new TLNodeType(); + tlNodeType.setId("lnodeTypeId"); + TDO tdo = new TDO(); + tdo.setType("doTypeId"); + tdo.setName("Mod"); + tlNodeType.getDO().add(tdo); + dtt.getLNodeType().add(tlNodeType); + TDOType tdoType = new TDOType(); + tdoType.setId("doTypeId"); + TDA tda = new TDA(); + tda.setName("daName"); + tdoType.getSDOOrDA().add(tda); + dtt.getDOType().add(tdoType); + // When + DataTypeTemplatesService dataTypeTemplatesService = new DataTypeTemplatesService(); + List sclReportItems = dataTypeTemplatesService.isDataObjectsAndDataAttributesExists(dtt, + "lnodeTypeId", "Mod.stVal"); + // Then + assertThat(sclReportItems) + .hasSize(1) + .extracting(SclReportItem::message) + .containsExactly("Unknown Sub Data Object SDO or Data Attribute DA (stVal) in DOType.id (doTypeId)"); + } + + + @Test + void isDoObjectsAndDataAttributesExists_when_DO_DA_exist_should_return_empty_report() { + // Given + TDataTypeTemplates dtt = new TDataTypeTemplates(); + TLNodeType tlNodeType = new TLNodeType(); + tlNodeType.setId("lnodeTypeId"); + TDO tdo = new TDO(); + tdo.setType("doTypeId"); + tdo.setName("Mod"); + tlNodeType.getDO().add(tdo); + dtt.getLNodeType().add(tlNodeType); + TDOType tdoType = new TDOType(); + tdoType.setId("doTypeId"); + TDA tda = new TDA(); + tda.setName("stVal"); + tdoType.getSDOOrDA().add(tda); + dtt.getDOType().add(tdoType); + // When + DataTypeTemplatesService dataTypeTemplatesService = new DataTypeTemplatesService(); + List sclReportItems = dataTypeTemplatesService.isDataObjectsAndDataAttributesExists(dtt, + "lnodeTypeId", "Mod.stVal"); + // Then + assertThat(sclReportItems).isEmpty(); + } + + @Test + void isDoObjectsAndDataAttributesExists_should_return_empty_report() { + // Given + DataTypeTemplateAdapter dttAdapter = initDttAdapterFromFile(SCD_DTT_DO_SDO_DA_BDA); + // When + DataTypeTemplatesService dataTypeTemplatesService = new DataTypeTemplatesService(); + List sclReportItems = dataTypeTemplatesService.isDataObjectsAndDataAttributesExists( + dttAdapter.getCurrentElem(), "LN1", "Do1.sdo1.sdo2.da2.bda1.bda2"); + // Then + assertThat(sclReportItems).isEmpty(); + } + + @Test + void verifyDataObjectsAndDataAttributes_should_return_empty_report() { + // Given + DataTypeTemplateAdapter dttAdapter = initDttAdapterFromFile(SCD_DTT_DO_SDO_DA_BDA); + DoTypeName doTypeName = new DoTypeName("Do1.sdo1.sdo2"); + DaTypeName daTypeName = new DaTypeName("da2.bda1.bda2"); + // When + DataTypeTemplatesService dataTypeTemplatesService = new DataTypeTemplatesService(); + List sclReportItems = dataTypeTemplatesService.verifyDataObjectsAndDataAttributes( + dttAdapter.getCurrentElem(), "LN1", doTypeName, daTypeName); + // Then + assertThat(sclReportItems).isEmpty(); + } + +} diff --git a/sct-commons/src/test/java/org/lfenergy/compas/sct/commons/LnServiceTest.java b/sct-commons/src/test/java/org/lfenergy/compas/sct/commons/LnServiceTest.java index 447e69f03..97c07d7eb 100644 --- a/sct-commons/src/test/java/org/lfenergy/compas/sct/commons/LnServiceTest.java +++ b/sct-commons/src/test/java/org/lfenergy/compas/sct/commons/LnServiceTest.java @@ -6,9 +6,10 @@ import org.assertj.core.groups.Tuple; import org.junit.jupiter.api.Test; -import org.lfenergy.compas.scl2007b4.model.SCL; -import org.lfenergy.compas.scl2007b4.model.TAnyLN; -import org.lfenergy.compas.scl2007b4.model.TLDevice; +import org.lfenergy.compas.scl2007b4.model.*; +import org.lfenergy.compas.sct.commons.dto.DaTypeName; +import org.lfenergy.compas.sct.commons.dto.DataAttributeRef; +import org.lfenergy.compas.sct.commons.dto.DoTypeName; import org.lfenergy.compas.sct.commons.testhelpers.SclTestMarshaller; import org.lfenergy.compas.sct.commons.util.ActiveStatus; @@ -16,6 +17,7 @@ import java.util.Optional; import static org.assertj.core.api.Assertions.assertThat; +import static org.lfenergy.compas.sct.commons.testhelpers.DataTypeUtils.*; class LnServiceTest { @@ -81,4 +83,115 @@ void getActiveLns_should_return_lns() { .containsExactly(Tuple.tuple("RTE_080BBB4D93E4E704CF69E8616CAF1A74_LLN0_V1.0.0", ""), Tuple.tuple("RTE_8884DBCF760D916CCE3EE9D1846CE46F_LPAI_V1.0.0", "")); } + + @Test + void isDoObjectsInstanceAndDataAttributesInstanceExists_should_return_true_when_DO_and_DA_instances_exists() { + //Given + SCL scd = SclTestMarshaller.getSCLFromFile("/ied-test-schema-conf/ied_unit_test.xml"); + TAnyLN tAnyLN = scd.getIED().stream() + .filter(tied -> tied.getName().equals("IED_NAME")).findFirst().get() + .getAccessPoint() + .get(0) + .getServer() + .getLDevice().stream() + .filter(tlDevice -> tlDevice.getInst().equals("LD_INS1")).findFirst() + .get() + .getLN0(); + DoTypeName doTypeName = new DoTypeName("Do.sdo1.d"); + DaTypeName daTypeName = new DaTypeName("antRef.bda1.bda2.bda3"); + //When + LnService lnService = new LnService(); + boolean exist = lnService.isDoObjectsInstanceAndDataAttributesInstanceExists(tAnyLN, doTypeName, daTypeName); + //Then + assertThat(exist).isTrue(); + } + + + @Test + void isDoObjectsInstanceAndDataAttributesInstanceExists_should_return_false_when_DO_and_DA_instances_not_exists() { + //Given + SCL scd = SclTestMarshaller.getSCLFromFile("/ied-test-schema-conf/ied_unit_test.xml"); + TAnyLN tAnyLN = scd.getIED().stream() + .filter(tied -> tied.getName().equals("IED_NAME")).findFirst().get() + .getAccessPoint() + .get(0) + .getServer() + .getLDevice().stream() + .filter(tlDevice -> tlDevice.getInst().equals("LD_INS1")).findFirst() + .get() + .getLN0(); + DoTypeName doTypeName = new DoTypeName("Do.sdo1.d"); + DaTypeName daTypeName = new DaTypeName("antRef.unknown.bda2.bda3"); + //When + LnService lnService = new LnService(); + boolean exist = lnService.isDoObjectsInstanceAndDataAttributesInstanceExists(tAnyLN, doTypeName, daTypeName); + //Then + assertThat(exist).isFalse(); + } + + @Test + void updateOrCreateDoObjectsAndDataAttributesInstances_should_create_given_DO_and_DA_instances_when_no_struct_and_with_settingGroup() { + //Given + TAnyLN tAnyLN = new LN0(); + + DoTypeName doTypeName = new DoTypeName("Mod"); + DaTypeName daTypeName = new DaTypeName("stVal"); + daTypeName.getDaiValues().put(1L, "new value"); + daTypeName.getDaiValues().put(2L, "new value 2"); + DataAttributeRef dataAttributeRef = createDataAttributeRef(doTypeName, daTypeName); + + //When + LnService lnService = new LnService(); + lnService.updateOrCreateDoObjectsAndDataAttributesInstances(tAnyLN, dataAttributeRef); + //Then + assertThat(tAnyLN.getDOI()).hasSize(1); + assertThat(tAnyLN.getDOI().get(0).getName()).isEqualTo("Mod"); + assertThat(tAnyLN.getDOI().get(0).getSDIOrDAI()).hasSize(1); + assertThat(((TDAI)tAnyLN.getDOI().get(0).getSDIOrDAI().get(0)).getName()).isEqualTo("stVal"); + assertThat(((TDAI)tAnyLN.getDOI().get(0).getSDIOrDAI().get(0)).getVal()).hasSize(2); + assertThat(((TDAI)tAnyLN.getDOI().get(0).getSDIOrDAI().get(0)).getVal().get(0).getSGroup()).isEqualTo(1L); + assertThat(((TDAI)tAnyLN.getDOI().get(0).getSDIOrDAI().get(0)).getVal().get(0).getValue()).isEqualTo("new value"); + assertThat(((TDAI)tAnyLN.getDOI().get(0).getSDIOrDAI().get(0)).getVal().get(1).getSGroup()).isEqualTo(2L); + assertThat(((TDAI)tAnyLN.getDOI().get(0).getSDIOrDAI().get(0)).getVal().get(1).getValue()).isEqualTo("new value 2"); + } + + + @Test + void updateOrCreateDoObjectsAndDataAttributesInstances_should_create_given_DO_and_DA_instances_when_struct_and_without_settingGroup() { + //Given + TAnyLN tAnyLN = new LN0(); + DoTypeName doTypeName = new DoTypeName("Do.sdo1.d"); + DaTypeName daTypeName = new DaTypeName("antRef.bda1"); + daTypeName.getDaiValues().put(0L, "new value"); + DataAttributeRef dataAttributeRef = createDataAttributeRef(doTypeName, daTypeName); + + //When + LnService lnService = new LnService(); + lnService.updateOrCreateDoObjectsAndDataAttributesInstances(tAnyLN, dataAttributeRef); + + //Then + assertThat(tAnyLN.getDOI()).hasSize(1); + assertThat(tAnyLN.getDOI().get(0).getName()).isEqualTo("Do"); + assertThat(tAnyLN.getDOI().get(0).getSDIOrDAI()).hasSize(1); + assertThat((( TSDI )tAnyLN.getDOI().get(0).getSDIOrDAI().get(0)).getName()).isEqualTo("sdo1"); + assertThat((( TSDI )tAnyLN.getDOI().get(0).getSDIOrDAI().get(0)).getSDIOrDAI()).hasSize(1); + assertThat((( TSDI )(( TSDI )tAnyLN.getDOI().get(0).getSDIOrDAI().get(0)).getSDIOrDAI().get(0)).getName()).isEqualTo("d"); + assertThat((( TSDI )(( TSDI )tAnyLN.getDOI().get(0).getSDIOrDAI().get(0)).getSDIOrDAI().get(0)).getSDIOrDAI()).hasSize(1); + + assertThat((( TSDI )(( TSDI )(( TSDI )tAnyLN.getDOI().get(0).getSDIOrDAI().get(0)).getSDIOrDAI().get(0)) + .getSDIOrDAI().get(0)).getName()).isEqualTo("antRef"); + assertThat((( TSDI )(( TSDI )(( TSDI )tAnyLN.getDOI().get(0).getSDIOrDAI().get(0)).getSDIOrDAI().get(0)) + .getSDIOrDAI().get(0)).getSDIOrDAI()).hasSize(1); + + assertThat((( TDAI )(( TSDI )(( TSDI )(( TSDI )tAnyLN.getDOI().get(0).getSDIOrDAI().get(0)).getSDIOrDAI().get(0)) + .getSDIOrDAI().get(0)).getSDIOrDAI().get(0)).getName()).isEqualTo("bda1"); + assertThat((( TDAI )(( TSDI )(( TSDI )(( TSDI )tAnyLN.getDOI().get(0).getSDIOrDAI().get(0)).getSDIOrDAI().get(0)) + .getSDIOrDAI().get(0)).getSDIOrDAI().get(0)).getVal()).hasSize(1); + assertThat((( TDAI )(( TSDI )(( TSDI )(( TSDI )tAnyLN.getDOI().get(0).getSDIOrDAI().get(0)).getSDIOrDAI().get(0)) + .getSDIOrDAI().get(0)).getSDIOrDAI().get(0)).getVal().get(0).isSetSGroup()).isFalse(); + assertThat((( TDAI )(( TSDI )(( TSDI )(( TSDI )tAnyLN.getDOI().get(0).getSDIOrDAI().get(0)).getSDIOrDAI().get(0)) + .getSDIOrDAI().get(0)).getSDIOrDAI().get(0)).getVal().get(0).getValue()).isEqualTo("new value"); + } + + } \ No newline at end of file