tapi/src/main/java/org/opendaylight/transportpce/tapi/topology/ConvertORToTapiTopology.java

   1 /*
   2  * Copyright © 2023 Orange, Inc. and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8 package org.opendaylight.transportpce.tapi.topology;
   9
  10 import java.math.RoundingMode;
  11 import java.nio.charset.Charset;
  12 import java.util.ArrayList;
  13 import java.util.Arrays;
  14 import java.util.Collection;
  15 import java.util.HashMap;
  16 import java.util.HashSet;
  17 import java.util.List;
  18 import java.util.Map;
  19 import java.util.Set;
  20 import java.util.UUID;
  21 import java.util.stream.Collectors;
  22 import org.opendaylight.transportpce.common.fixedflex.GridConstant;
  23 import org.opendaylight.transportpce.common.fixedflex.GridUtils;
  24 import org.opendaylight.transportpce.tapi.TapiStringConstants;
  25 import org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev230526.TerminationPoint1;
  26 import org.opendaylight.yang.gen.v1.http.org.openroadm.common.state.types.rev191129.State;
  27 import org.opendaylight.yang.gen.v1.http.org.openroadm.degree.rev230526.degree.used.wavelengths.UsedWavelengths;
  28 import org.opendaylight.yang.gen.v1.http.org.openroadm.degree.rev230526.degree.used.wavelengths.UsedWavelengthsKey;
  29 import org.opendaylight.yang.gen.v1.http.org.openroadm.equipment.states.types.rev191129.AdminStates;
  30 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev230526.networks.network.node.termination.point.PpAttributes;
  31 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev230526.networks.network.node.termination.point.TxTtpAttributes;
  32 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev230526.networks.network.node.termination.point.XpdrNetworkAttributes;
  33 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.types.rev230526.xpdr.odu.switching.pools.OduSwitchingPools;
  34 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.types.rev230526.xpdr.odu.switching.pools.OduSwitchingPoolsBuilder;
  35 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.types.rev230526.xpdr.odu.switching.pools.odu.switching.pools.NonBlockingList;
  36 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.types.rev230526.xpdr.odu.switching.pools.odu.switching.pools.NonBlockingListBuilder;
  37 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.types.rev230526.xpdr.odu.switching.pools.odu.switching.pools.NonBlockingListKey;
  38 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.types.rev230526.OpenroadmNodeType;
  39 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.types.rev230526.OpenroadmTpType;
  40 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.types.rev230526.xpdr.tp.supported.interfaces.SupportedInterfaceCapability;
  41 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.network.topology.rev230526.Node1;
  42 import org.opendaylight.yang.gen.v1.http.org.openroadm.xponder.rev230526.xpdr.mode.attributes.supported.operational.modes.OperationalModeKey;
  43 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.networks.network.Node;
  44 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.TpId;
  45 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.networks.network.node.TerminationPoint;
  46 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev221121.AdministrativeState;
  47 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev221121.CAPACITYUNITGBPS;
  48 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev221121.Direction;
  49 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev221121.LayerProtocolName;
  50 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev221121.LifecycleState;
  51 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev221121.OperationalState;
  52 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev221121.PortRole;
  53 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev221121.Uuid;
  54 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev221121.capacity.pac.AvailableCapacityBuilder;
  55 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev221121.capacity.pac.TotalPotentialCapacityBuilder;
  56 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev221121.global._class.Name;
  57 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev221121.global._class.NameBuilder;
  58 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev221121.global._class.NameKey;
  59 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev221121.payload.structure.CapacityBuilder;
  60 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev221121.tapi.context.ServiceInterfacePoint;
  61 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev221121.tapi.context.ServiceInterfacePointBuilder;
  62 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev221121.tapi.context.ServiceInterfacePointKey;
  63 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.digital.otn.rev221121.ODUTYPEODU0;
  64 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.digital.otn.rev221121.ODUTYPEODU2;
  65 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.digital.otn.rev221121.ODUTYPEODU2E;
  66 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.digital.otn.rev221121.ODUTYPEODU4;
  67 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.digital.otn.rev221121.ODUTYPEODUCN;
  68 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.digital.otn.rev221121.OTUTYPEOTUCN;
  69 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.dsr.rev221121.DIGITALSIGNALTYPE100GigE;
  70 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.dsr.rev221121.DIGITALSIGNALTYPE10GigELAN;
  71 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.dsr.rev221121.DIGITALSIGNALTYPEGigE;
  72 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.photonic.media.rev221121.PHOTONICLAYERQUALIFIEROTS;
  73 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.photonic.media.rev221121.PHOTONICLAYERQUALIFIEROTSi;
  74 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.photonic.media.rev221121.PHOTONICLAYERQUALIFIEROTSiMC;
  75 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.photonic.media.rev221121.context.topology.context.topology.node.owned.node.edge.point.PhotonicMediaNodeEdgePointSpec;
  76 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.photonic.media.rev221121.context.topology.context.topology.node.owned.node.edge.point.PhotonicMediaNodeEdgePointSpecBuilder;
  77 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.photonic.media.rev221121.photonic.media.node.edge.point.spec.SpectrumCapabilityPacBuilder;
  78 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.photonic.media.rev221121.spectrum.capability.pac.AvailableSpectrum;
  79 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.photonic.media.rev221121.spectrum.capability.pac.AvailableSpectrumBuilder;
  80 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.photonic.media.rev221121.spectrum.capability.pac.AvailableSpectrumKey;
  81 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.photonic.media.rev221121.spectrum.capability.pac.OccupiedSpectrum;
  82 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.photonic.media.rev221121.spectrum.capability.pac.OccupiedSpectrumBuilder;
  83 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.photonic.media.rev221121.spectrum.capability.pac.OccupiedSpectrumKey;
  84 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.photonic.media.rev221121.spectrum.capability.pac.SupportableSpectrum;
  85 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.photonic.media.rev221121.spectrum.capability.pac.SupportableSpectrumBuilder;
  86 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.photonic.media.rev221121.spectrum.capability.pac.SupportableSpectrumKey;
  87 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.FORWARDINGRULE;
  88 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.FORWARDINGRULECANNOTFORWARDACROSSGROUP;
  89 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.FORWARDINGRULEMAYFORWARDACROSSGROUP;
  90 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.RuleType;
  91 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.inter.rule.group.AssociatedNodeRuleGroup;
  92 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.inter.rule.group.AssociatedNodeRuleGroupBuilder;
  93 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.inter.rule.group.AssociatedNodeRuleGroupKey;
  94 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.node.InterRuleGroup;
  95 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.node.InterRuleGroupBuilder;
  96 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.node.InterRuleGroupKey;
  97 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.node.NodeRuleGroup;
  98 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.node.NodeRuleGroupBuilder;
  99 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.node.NodeRuleGroupKey;
 100 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.node.OwnedNodeEdgePoint;
 101 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.node.OwnedNodeEdgePointBuilder;
 102 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.node.OwnedNodeEdgePointKey;
 103 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.node.RiskParameterPacBuilder;
 104 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.node.edge.point.AvailablePayloadStructure;
 105 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.node.edge.point.AvailablePayloadStructureBuilder;
 106 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.node.edge.point.MappedServiceInterfacePoint;
 107 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.node.edge.point.MappedServiceInterfacePointBuilder;
 108 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.node.edge.point.MappedServiceInterfacePointKey;
 109 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.node.edge.point.SupportedCepLayerProtocolQualifierInstances;
 110 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.node.edge.point.SupportedCepLayerProtocolQualifierInstancesBuilder;
 111 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.node.edge.point.SupportedPayloadStructure;
 112 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.node.edge.point.SupportedPayloadStructureBuilder;
 113 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.node.rule.group.Rule;
 114 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.node.rule.group.RuleBuilder;
 115 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.node.rule.group.RuleKey;
 116 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.risk.parameter.pac.RiskCharacteristic;
 117 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.risk.parameter.pac.RiskCharacteristicBuilder;
 118 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.topology.Link;
 119 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.topology.LinkKey;
 120 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.topology.NodeBuilder;
 121 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.topology.NodeKey;
 122 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.transfer.cost.pac.CostCharacteristic;
 123 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.transfer.cost.pac.CostCharacteristicBuilder;
 124 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.transfer.timing.pac.LatencyCharacteristic;
 125 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.transfer.timing.pac.LatencyCharacteristicBuilder;
 126 import org.opendaylight.yangtools.yang.common.Decimal64;
 127 import org.opendaylight.yangtools.yang.common.Uint16;
 128 import org.opendaylight.yangtools.yang.common.Uint64;
 129 import org.slf4j.Logger;
 130 import org.slf4j.LoggerFactory;
 131
 132
 133 public class ConvertORToTapiTopology {
 134
 135     private static final Logger LOG = LoggerFactory.getLogger(ConvertORToTapiTopology.class);
 136     private String ietfNodeId;
 137     private OpenroadmNodeType ietfNodeType;
 138     private AdminStates ietfNodeAdminState;
 139     private State ietfNodeOperState;
 140     private List<TerminationPoint> oorClientPortList;
 141     private List<TerminationPoint> oorNetworkPortList;
 142     private OduSwitchingPools oorOduSwitchingPool;
 143     private Uuid tapiTopoUuid;
 144     private Map<NodeKey, org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.topology.Node>
 145         tapiNodes;
 146     private Map<LinkKey, Link> tapiLinks;
 147     private Map<ServiceInterfacePointKey, ServiceInterfacePoint> tapiSips;
 148     private Map<String, Uuid> uuidMap;
 149
 150
 151     public ConvertORToTapiTopology(Uuid tapiTopoUuid) {
 152         this.tapiTopoUuid = tapiTopoUuid;
 153         this.tapiNodes = new HashMap<>();
 154         this.tapiLinks = new HashMap<>();
 155         this.uuidMap = new HashMap<>();
 156         this.tapiSips = new HashMap<>();
 157     }
 158
 159     public void convertNode(Node ietfNode, List<String> networkPorts) {
 160         this.ietfNodeId = ietfNode.getNodeId().getValue();
 161         var ietfAug =
 162             ietfNode.augmentation(org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev230526.Node1.class);
 163         if (ietfAug == null) {
 164             return;
 165         }
 166         this.ietfNodeType = ietfAug.getNodeType();
 167         this.ietfNodeAdminState = ietfAug.getAdministrativeState();
 168         this.ietfNodeOperState = ietfAug.getOperationalState();
 169         var ietfAugTopo =
 170             ietfNode.augmentation(
 171                 org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.Node1.class);
 172         this.oorNetworkPortList = ietfAugTopo.getTerminationPoint().values().stream()
 173             .filter(tp -> tp.augmentation(TerminationPoint1.class).getTpType().getIntValue()
 174                     == OpenroadmTpType.XPONDERNETWORK.getIntValue()
 175                 && networkPorts.contains(tp.getTpId().getValue()))
 176             .sorted((tp1, tp2) -> tp1.getTpId().getValue().compareTo(tp2.getTpId().getValue()))
 177             .collect(Collectors.toList());
 178         if (OpenroadmNodeType.TPDR.equals(this.ietfNodeType)) {
 179             this.oorOduSwitchingPool = createOduSwitchingPoolForTp100G();
 180             List<TpId> tpList = this.oorOduSwitchingPool.getNonBlockingList().values().stream()
 181                 .flatMap(nbl -> nbl.getTpList().stream())
 182                 .collect(Collectors.toList());
 183             this.oorClientPortList = ietfAugTopo.getTerminationPoint().values().stream()
 184                 .filter(tp -> tp.augmentation(TerminationPoint1.class).getTpType().getIntValue()
 185                         == OpenroadmTpType.XPONDERCLIENT.getIntValue()
 186                     && tpList.contains(tp.getTpId()))
 187                 .sorted((tp1, tp2) -> tp1.getTpId().getValue().compareTo(tp2.getTpId().getValue()))
 188                 .collect(Collectors.toList());
 189             this.oorClientPortList.forEach(tp -> LOG.info("tp = {}", tp.getTpId()));
 190         } else {
 191             this.oorOduSwitchingPool = ietfNode.augmentation(Node1.class).getSwitchingPools().getOduSwitchingPools()
 192                 .values().stream().findFirst().orElseThrow();
 193             this.oorClientPortList = ietfAugTopo.getTerminationPoint().values().stream()
 194                 .filter(tp -> tp.augmentation(TerminationPoint1.class).getTpType().getIntValue()
 195                     == OpenroadmTpType.XPONDERCLIENT.getIntValue())
 196                 .sorted((tp1, tp2) -> tp1.getTpId().getValue().compareTo(tp2.getTpId().getValue()))
 197                 .collect(Collectors.toList());
 198         }
 199
 200         // node creation [DSR/ODU] ([DSR/ODU] and OTSI merged in R 2.4.X)
 201         LOG.info("creation of a DSR/ODU node for {}", this.ietfNodeId);
 202         String nodeIdXpdr = String.join("+", this.ietfNodeId, TapiStringConstants.XPDR);
 203         this.uuidMap.put(nodeIdXpdr,
 204                 //nodeUuid
 205                 new Uuid(UUID.nameUUIDFromBytes(nodeIdXpdr.getBytes(Charset.forName("UTF-8"))).toString()));
 206         Name nameDsr = new NameBuilder().setValueName("dsr/odu node name").setValue(nodeIdXpdr).build();
 207         Name namePhot = new NameBuilder().setValueName("otsi node name").setValue(nodeIdXpdr).build();
 208         Name nameNodeType = new NameBuilder().setValueName("Node Type").setValue(this.ietfNodeType.getName()).build();
 209         org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121
 210                 .topology.Node dsrNode =
 211             createTapiNode(
 212                 Map.of(nameDsr.key(), nameDsr, namePhot.key(), namePhot,nameNodeType.key(), nameNodeType),
 213                 //dsrLayerProtocols
 214                 Set.of(LayerProtocolName.DSR, LayerProtocolName.ODU,
 215                        LayerProtocolName.DIGITALOTN, LayerProtocolName.PHOTONICMEDIA));
 216         LOG.debug("XPDR Node {} should have {} NEPs and SIPs",
 217             this.ietfNodeId, this.oorClientPortList.size() + this.oorNetworkPortList.size());
 218         LOG.info("XPDR Node {} has {} NEPs and {} SIPs",
 219             this.ietfNodeId,
 220             dsrNode.getOwnedNodeEdgePoint().values().size(),
 221             dsrNode.getOwnedNodeEdgePoint().values().stream()
 222                 .filter(nep -> nep.getMappedServiceInterfacePoint() != null).count());
 223         tapiNodes.put(dsrNode.key(), dsrNode);
 224     }
 225
 226     public Map<NodeRuleGroupKey, NodeRuleGroup> createNodeRuleGroupForRdmNode(String topoType, Uuid nodeUuid,
 227             String subNodeName, List<OwnedNodeEdgePointKey> onepl, FORWARDINGRULE forwardingRule, int index) {
 228         Map<org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.node.rule.group.NodeEdgePointKey,
 229             org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.node.rule.group.NodeEdgePoint>
 230             nepMap = new HashMap<>();
 231         for (OwnedNodeEdgePointKey onepKey : onepl) {
 232             org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.node.rule.group.NodeEdgePoint
 233                 nep = new org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.node.rule.group
 234                     .NodeEdgePointBuilder()
 235                 .setTopologyUuid(tapiTopoUuid)
 236                 .setNodeUuid(nodeUuid)
 237                 .setNodeEdgePointUuid(onepKey.getUuid())
 238                 .build();
 239             nepMap.put(nep.key(), nep);
 240         }
 241         String nrgNameValue = String.join("-", subNodeName, "node-rule-group-" + index);
 242         //Map<NodeRuleGroupKey, NodeRuleGroup> nodeRuleGroupMap = new HashMap<>();
 243         Set<RuleType> ruleTypes = new HashSet<>(Set.of(RuleType.FORWARDING));
 244         Map<RuleKey, Rule> ruleList = new HashMap<>();
 245         Rule rule = new RuleBuilder()
 246             .setLocalId("forward")
 247             .setForwardingRule(forwardingRule)
 248             .setRuleType(ruleTypes)
 249             .build();
 250         ruleList.put(rule.key(), rule);
 251         Name nrgName = new NameBuilder()
 252             .setValueName("nrg name")
 253             .setValue(nrgNameValue)
 254             .build();
 255         NodeRuleGroup nodeRuleGroup = new NodeRuleGroupBuilder()
 256             .setName(Map.of(nrgName.key(), nrgName))
 257             .setUuid(new Uuid(UUID.nameUUIDFromBytes((nrgNameValue)
 258                 .getBytes(Charset.forName("UTF-8"))).toString()))
 259             .setRule(ruleList)
 260             .setNodeEdgePoint(nepMap)
 261             .build();
 262         return new HashMap<>(Map.of(nodeRuleGroup.key(), nodeRuleGroup));
 263     }
 264
 265     public Map<NodeRuleGroupKey, NodeRuleGroup> createAllNodeRuleGroupForRdmNode(String topoType, Uuid nodeUuid,
 266             String orNodeId, Collection<OwnedNodeEdgePoint> onepl) {
 267         List<OwnedNodeEdgePoint> otsNepList = new ArrayList<>();
 268         LOG.info("Creating NRG for {} {}", topoType, otsNepList.toString());
 269         if (topoType.equals("T0ML")) {
 270             otsNepList = onepl.stream().collect(Collectors.toList());
 271         } else {
 272             otsNepList = onepl.stream()
 273                 .filter(onep -> onep.getName().keySet().contains(new NameKey("PHOTONIC_MEDIA_OTSNodeEdgePoint")))
 274                 .collect(Collectors.toList());
 275         }
 276         List<OwnedNodeEdgePointKey> degOnepKeyList = new ArrayList<>();
 277         List<String> srgNames = new ArrayList<>();
 278         Map<OwnedNodeEdgePointKey,String> srgMap = new HashMap<>();
 279         for (OwnedNodeEdgePoint onep : otsNepList) {
 280             String onepName = onep.getName().get(new NameKey(
 281                 topoType.equals("T0ML") ? "NodeEdgePoint name"
 282                     : "PHOTONIC_MEDIA_OTSNodeEdgePoint")).getValue();
 283             String subNodeName = topoType.equals("T0ML") ? "ROADMINFRA-SRG-PP"
 284                 : String.join("-", onepName.split("\\+")[0], onepName.split("\\+")[2]);
 285             if (subNodeName.contains("DEG")) {
 286                 subNodeName = subNodeName.split("\\-TTP")[0];
 287                 degOnepKeyList.add(onep.key());
 288             } else if (subNodeName.contains("SRG")) {
 289                 subNodeName = subNodeName.split("\\-PP")[0];
 290                 srgMap.put(onep.key(), subNodeName);
 291                 if (!srgNames.contains(subNodeName)) {
 292                     srgNames.add(subNodeName);
 293                 }
 294             }
 295         }
 296         int index = 0;
 297         Map<NodeRuleGroupKey, NodeRuleGroup> globalNrgMap = new  HashMap<>();
 298         if (topoType.equals("Full")) {
 299             globalNrgMap.putAll(
 300                 createNodeRuleGroupForRdmNode(topoType, nodeUuid, String.join("-", orNodeId, "DEG"), degOnepKeyList,
 301                     FORWARDINGRULEMAYFORWARDACROSSGROUP.VALUE, index));
 302             index++;
 303         }
 304         for (String srgName : srgNames) {
 305             globalNrgMap.putAll(createNodeRuleGroupForRdmNode(topoType, nodeUuid, srgName,
 306                 srgMap.entrySet().stream()
 307                     .filter(item -> item.getValue().equals(srgName))
 308                     .map(item -> item.getKey())
 309                     .collect(Collectors.toList()),
 310                     // For T0ML we consider any port of ROADM INFRA can connect to potentially any other port
 311                     //topoType.equals("T0ML") ? FORWARDINGRULEMAYFORWARDACROSSGROUP.VALUE
 312                     topoType.equals("T0ML") ? FORWARDINGRULEMAYFORWARDACROSSGROUP.VALUE
 313                     // Whereas for Abstracted or Full Topology we consider any port of the same SRG can not forward to
 314                    // another port of the same SRG. Connectivity between SRGS will be defined through inter-rule-group
 315                     : FORWARDINGRULECANNOTFORWARDACROSSGROUP.VALUE, index));
 316             index++;
 317             LOG.debug("AllNodeRuleGroup : creating a NRG for {}", srgName);
 318         }
 319         return globalNrgMap;
 320     }
 321
 322     public Map<InterRuleGroupKey, InterRuleGroup> createInterRuleGroupForRdmNode(
 323                 String topoType, Uuid nodeUuid,String orNodeId, List<NodeRuleGroupKey> nrgList) {
 324         Map<AssociatedNodeRuleGroupKey, AssociatedNodeRuleGroup> associatedNrgMap = new HashMap<>();
 325         for (NodeRuleGroupKey nrgKey : nrgList) {
 326             AssociatedNodeRuleGroup associatedNrg = new AssociatedNodeRuleGroupBuilder()
 327                 .setTopologyUuid(tapiTopoUuid)
 328                 .setNodeUuid(nodeUuid)
 329                 .setNodeRuleGroupUuid(nrgKey.getUuid())
 330                 .build();
 331             associatedNrgMap.put(associatedNrg.key(), associatedNrg);
 332         }
 333         String irgNameValue =
 334             topoType.equals("Full")
 335                 ? orNodeId + " inter rule group-"
 336                 : "rdm infra inter rule group-";
 337         Set<RuleType> ruleTypes = new HashSet<>(Set.of(RuleType.FORWARDING));
 338         Map<org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.inter.rule.group.RuleKey,
 339             org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.inter.rule.group.Rule> ruleMap
 340             = new HashMap<>();
 341         org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.inter.rule.group.Rule rule
 342             = new org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.inter.rule.group.RuleBuilder()
 343                 .setLocalId("forward")
 344                 .setForwardingRule(FORWARDINGRULEMAYFORWARDACROSSGROUP.VALUE)
 345                 .setRuleType(ruleTypes)
 346                 .build();
 347         ruleMap.put(rule.key(), rule);
 348
 349         Map<InterRuleGroupKey, InterRuleGroup> interRuleGroupMap = new HashMap<>();
 350
 351         Name irgName = new NameBuilder()
 352             .setValueName("irg name")
 353             .setValue(irgNameValue)
 354             .build();
 355         InterRuleGroup interRuleGroup = new InterRuleGroupBuilder()
 356             .setUuid(new Uuid(UUID.nameUUIDFromBytes((irgNameValue)
 357                 .getBytes(Charset.forName("UTF-8"))).toString()))
 358             .setName(Map.of(irgName.key(), irgName))
 359             .setRule(ruleMap)
 360             .setAssociatedNodeRuleGroup(associatedNrgMap)
 361             .build();
 362         interRuleGroupMap.put(new InterRuleGroupKey(interRuleGroup.getUuid()), interRuleGroup);
 363         return interRuleGroupMap;
 364     }
 365
 366     public Map<MappedServiceInterfacePointKey, MappedServiceInterfacePoint> createMSIP(int nb,
 367             LayerProtocolName layerProtocol, String tpId, String nodeid,
 368             Collection<SupportedInterfaceCapability> supportedInterfaceCapability,
 369             OperationalState operState, AdministrativeState adminState) {
 370         // add them to SIP context
 371         Map<MappedServiceInterfacePointKey, MappedServiceInterfacePoint> msipl = new HashMap<>();
 372         for (int i = 0; i < nb; i++) {
 373             String sipName =
 374                 nb == 1
 375                     ? String.join("+", "SIP", nodeid, tpId)
 376                     : String.join("+", "SIP", nodeid, tpId, "Nber", String.valueOf(i));
 377             LOG.info("SIP = {}", sipName);
 378             Uuid sipUuid = new Uuid(UUID.nameUUIDFromBytes(sipName.getBytes(Charset.forName("UTF-8"))).toString());
 379             MappedServiceInterfacePoint msip = new MappedServiceInterfacePointBuilder()
 380                 .setServiceInterfacePointUuid(sipUuid)
 381                 .build();
 382             ServiceInterfacePoint sip =
 383                 createSIP(sipUuid, layerProtocol, tpId, nodeid, supportedInterfaceCapability, operState, adminState);
 384             this.tapiSips.put(sip.key(), sip);
 385             msipl.put(msip.key(), msip);
 386             LOG.debug("SIP created {}", sip.getUuid());
 387             LOG.debug("This SIP corresponds to SIP+nodeId {} + TpId {}", nodeid, tpId);
 388         }
 389         return msipl;
 390     }
 391
 392     public List<AvailablePayloadStructure> createAvailablePayloadStructureForPhtncMedia(
 393             Boolean otsiProvisioned,
 394             Collection<SupportedInterfaceCapability> sicList,
 395             List<OperationalModeKey> supportedOpModes) {
 396         if (supportedOpModes == null || supportedOpModes.isEmpty()) {
 397             return null;
 398         }
 399         Integer nepRate = 0;
 400         Integer loopRate = 0;
 401         for (OperationalModeKey operationalMode : supportedOpModes) {
 402             if (operationalMode.toString().contains("800G")) {
 403                 loopRate = 8;
 404             } else if (operationalMode.toString().contains("600G")) {
 405                 loopRate = 6;
 406             } else if (operationalMode.toString().contains("400G")) {
 407                 loopRate = 4;
 408             } else if (operationalMode.toString().contains("300G")) {
 409                 loopRate = 3;
 410             } else if (operationalMode.toString().contains("200G")) {
 411                 loopRate = 2;
 412             } else if (operationalMode.toString().contains("100G")) {
 413                 loopRate = 1;
 414             }
 415             if (loopRate >= nepRate) {
 416                 nepRate = loopRate;
 417             }
 418         }
 419         List<AvailablePayloadStructure> aps = new ArrayList<>();
 420         Integer cepInstanceNber = otsiProvisioned ? 0 : 1;
 421         for (SupportedInterfaceCapability sic : sicList) {
 422             switch (sic.getIfCapType().toString().split("\\{")[0]) {
 423                 case "IfOCHOTU4ODU4":
 424                 case "IfOCHOTU4ODU4Regen":
 425                 case "IfOCHOTU4ODU4Uniregen":
 426                     aps.add(new AvailablePayloadStructureBuilder()
 427                         .setMultiplexingSequence(Set.of(PHOTONICLAYERQUALIFIEROTSi.VALUE, ODUTYPEODU4.VALUE))
 428                         .setNumberOfCepInstances(Uint64.valueOf(cepInstanceNber))
 429                         .setCapacity(
 430                             new CapacityBuilder()
 431                                 .setUnit(CAPACITYUNITGBPS.VALUE)
 432                                 .setValue(Decimal64.valueOf(100.0 * cepInstanceNber, RoundingMode.DOWN))
 433                                 .build())
 434                         .build());
 435                     break;
 436                 case "IfOCHOTUCnODUCn":
 437                 case "IfOtsiOtucnOducn":
 438                 case "IfOCHOTUCnODUCnRegen":
 439                 case "IfOCHOTUCnODUCnUniregen":
 440                     aps.add(new AvailablePayloadStructureBuilder()
 441                         .setMultiplexingSequence(Set.of(PHOTONICLAYERQUALIFIEROTSi.VALUE, OTUTYPEOTUCN.VALUE,
 442                             ODUTYPEODUCN.VALUE, ODUTYPEODU4.VALUE))
 443                         .setNumberOfCepInstances(Uint64.valueOf(nepRate * cepInstanceNber))
 444                         .setCapacity(
 445                             new CapacityBuilder()
 446                                 .setUnit(CAPACITYUNITGBPS.VALUE)
 447                                 .setValue(Decimal64.valueOf(nepRate * 100.0 * cepInstanceNber, RoundingMode.DOWN))
 448                                 .build())
 449                         .build());
 450                     break;
 451                 default:
 452                     break;
 453             }
 454         }
 455         return aps.stream().distinct().toList();
 456     }
 457
 458     public List<SupportedPayloadStructure> createSupportedPayloadStructureForPhtncMedia(
 459             Collection<SupportedInterfaceCapability> sicList, List<OperationalModeKey> supportedOpModes) {
 460         if (supportedOpModes == null || supportedOpModes.isEmpty()) {
 461             return null;
 462         }
 463         Integer nepRate = 0;
 464         Integer loopRate = 0;
 465         for (OperationalModeKey operationalMode : supportedOpModes) {
 466             if (operationalMode.toString().contains("800G")) {
 467                 loopRate = 8;
 468             } else if (operationalMode.toString().contains("600G")) {
 469                 loopRate = 6;
 470             } else if (operationalMode.toString().contains("400G")) {
 471                 loopRate = 4;
 472             } else if (operationalMode.toString().contains("300G")) {
 473                 loopRate = 3;
 474             } else if (operationalMode.toString().contains("200G")) {
 475                 loopRate = 2;
 476             } else if (operationalMode.toString().contains("100G")) {
 477                 loopRate = 1;
 478             }
 479             if (loopRate >= nepRate) {
 480                 nepRate = loopRate;
 481             }
 482         }
 483         List<SupportedPayloadStructure> sps = new ArrayList<>();
 484         for (SupportedInterfaceCapability sic : sicList) {
 485             String ifCapType = sic.getIfCapType().toString().split("\\{")[0];
 486             switch (ifCapType) {
 487                 case "IfOCHOTU4ODU4":
 488                 case "IfOCHOTU4ODU4Regen":
 489                 case "IfOCHOTU4ODU4Uniregen":
 490                     sps.add(new SupportedPayloadStructureBuilder()
 491                         .setMultiplexingSequence(Set.of(PHOTONICLAYERQUALIFIEROTSi.VALUE, ODUTYPEODU4.VALUE))
 492                         .setNumberOfCepInstances(Uint64.valueOf(1))
 493                         .setCapacity(
 494                             new CapacityBuilder()
 495                                 .setUnit(CAPACITYUNITGBPS.VALUE)
 496                                 .setValue(Decimal64.valueOf(100.0, RoundingMode.DOWN))
 497                                 .build())
 498                         .build());
 499                     break;
 500                 case "IfOCHOTUCnODUCn":
 501                 case "IfOtsiOtucnOducn":
 502                 case "IfOCHOTUCnODUCnRegen":
 503                 case "IfOCHOTUCnODUCnUniregen":
 504                     sps.add(new SupportedPayloadStructureBuilder()
 505                         .setMultiplexingSequence(Set.of(
 506                             PHOTONICLAYERQUALIFIEROTSi.VALUE, OTUTYPEOTUCN.VALUE,
 507                             ODUTYPEODUCN.VALUE, ODUTYPEODU4.VALUE))
 508                         .setNumberOfCepInstances(Uint64.valueOf(nepRate))
 509                         .setCapacity(
 510                             new CapacityBuilder()
 511                                 .setUnit(CAPACITYUNITGBPS.VALUE)
 512                                 .setValue(Decimal64.valueOf(nepRate * 100.0, RoundingMode.DOWN))
 513                                 .build())
 514                         .build());
 515                     break;
 516                 default:
 517                     break;
 518             }
 519         }
 520         return sps.stream().distinct().toList();
 521     }
 522
 523     @edu.umd.cs.findbugs.annotations.SuppressFBWarnings(value = "SF_SWITCH_FALLTHROUGH",
 524         justification = "Voluntarily No break in switchcase where comment is inserted in following method")
 525     public List<SupportedCepLayerProtocolQualifierInstances> createSupportedCepLayerProtocolQualifier(
 526             Collection<SupportedInterfaceCapability> sicList, LayerProtocolName lpn) {
 527         if (sicList == null) {
 528             return new ArrayList<>(List.of(
 529                 new SupportedCepLayerProtocolQualifierInstancesBuilder()
 530                     .setLayerProtocolQualifier(PHOTONICLAYERQUALIFIEROTS.VALUE)
 531                     .setNumberOfCepInstances(Uint64.valueOf(1))
 532                     .build()));
 533         }
 534         LOG.debug("SIC list = {}", sicList);
 535         List<SupportedCepLayerProtocolQualifierInstances> sclpqiList = new ArrayList<>();
 536         for (SupportedInterfaceCapability sic : sicList) {
 537             String ifCapType = sic.getIfCapType().toString().split("\\{")[0];
 538             switch (lpn.getName()) {
 539                 case "ETH":
 540                 case "DSR":
 541                     switch (ifCapType) {
 542                         case "If1GEODU0":
 543                             sclpqiList.add(new SupportedCepLayerProtocolQualifierInstancesBuilder()
 544                                 .setLayerProtocolQualifier(ODUTYPEODU0.VALUE)
 545                                 .setNumberOfCepInstances(Uint64.valueOf(1))
 546                                 .build());
 547                             sclpqiList.add(new SupportedCepLayerProtocolQualifierInstancesBuilder()
 548                                 .setLayerProtocolQualifier(DIGITALSIGNALTYPEGigE.VALUE)
 549                                 .setNumberOfCepInstances(Uint64.valueOf(1))
 550                                 .build());
 551                             break;
 552                         case "If10GEODU2e":
 553                             sclpqiList.add(new SupportedCepLayerProtocolQualifierInstancesBuilder()
 554                                 .setLayerProtocolQualifier(ODUTYPEODU2E.VALUE)
 555                                 .setNumberOfCepInstances(Uint64.valueOf(1))
 556                                 .build());
 557                             sclpqiList.add(new SupportedCepLayerProtocolQualifierInstancesBuilder()
 558                                 .setLayerProtocolQualifier(DIGITALSIGNALTYPE10GigELAN.VALUE)
 559                                 .setNumberOfCepInstances(Uint64.valueOf(1))
 560                                 .build());
 561                             break;
 562                         case "If10GEODU2":
 563                             sclpqiList.add(new SupportedCepLayerProtocolQualifierInstancesBuilder()
 564                                 .setLayerProtocolQualifier(ODUTYPEODU2.VALUE)
 565                                 .setNumberOfCepInstances(Uint64.valueOf(1))
 566                                 .build());
 567                             sclpqiList.add(new SupportedCepLayerProtocolQualifierInstancesBuilder()
 568                                 .setLayerProtocolQualifier(DIGITALSIGNALTYPE10GigELAN.VALUE)
 569                                 .setNumberOfCepInstances(Uint64.valueOf(1))
 570                                 .build());
 571                             break;
 572                         case "If10GE":
 573                             sclpqiList.add(new SupportedCepLayerProtocolQualifierInstancesBuilder()
 574                                 .setLayerProtocolQualifier(DIGITALSIGNALTYPE10GigELAN.VALUE)
 575                                 .setNumberOfCepInstances(Uint64.valueOf(1))
 576                                 .build());
 577                             break;
 578                         case "If100GEODU4":
 579                             sclpqiList.add(new SupportedCepLayerProtocolQualifierInstancesBuilder()
 580                                 .setLayerProtocolQualifier(DIGITALSIGNALTYPE100GigE.VALUE)
 581                                 .setNumberOfCepInstances(Uint64.valueOf(1))
 582                                 .build());
 583                             sclpqiList.add(new SupportedCepLayerProtocolQualifierInstancesBuilder()
 584                                 .setLayerProtocolQualifier(ODUTYPEODU4.VALUE)
 585                                 .setNumberOfCepInstances(Uint64.valueOf(1))
 586                                 .build());
 587                             break;
 588                         case "If100GE":
 589                             sclpqiList.add(new SupportedCepLayerProtocolQualifierInstancesBuilder()
 590                                 .setLayerProtocolQualifier(DIGITALSIGNALTYPE100GigE.VALUE)
 591                                 .setNumberOfCepInstances(Uint64.valueOf(1))
 592                                 .build());
 593                             break;
 594                         case "IfOCHOTU4ODU4":
 595                         case "IfOCH":
 596                             sclpqiList.add(new SupportedCepLayerProtocolQualifierInstancesBuilder()
 597                                 .setLayerProtocolQualifier(ODUTYPEODU4.VALUE)
 598                                 .setNumberOfCepInstances(Uint64.valueOf(1))
 599                                 .build());
 600                             break;
 601                         default:
 602                             LOG.error("IfCapability type not managed");
 603                             break;
 604                     }
 605                     break;
 606                 case "ODU":
 607                     switch (ifCapType) {
 608                         case "If1GEODU0":
 609                             sclpqiList.add(new SupportedCepLayerProtocolQualifierInstancesBuilder()
 610                                 .setLayerProtocolQualifier(ODUTYPEODU0.VALUE)
 611                                 .setNumberOfCepInstances(Uint64.valueOf(1))
 612                                 .build());
 613                             break;
 614                         case "If10GEODU2e":
 615                             sclpqiList.add(new SupportedCepLayerProtocolQualifierInstancesBuilder()
 616                                 .setLayerProtocolQualifier(ODUTYPEODU2E.VALUE)
 617                                 .setNumberOfCepInstances(Uint64.valueOf(1))
 618                                 .build());
 619                             break;
 620                         case "If10GEODU2":
 621                         case "If10GE":
 622                             sclpqiList.add(new SupportedCepLayerProtocolQualifierInstancesBuilder()
 623                                 .setLayerProtocolQualifier(ODUTYPEODU2.VALUE)
 624                                 .setNumberOfCepInstances(Uint64.valueOf(1))
 625                                 .build());
 626                             break;
 627                         case "If100GEODU4":
 628                         case "If100GE":
 629                         case "IfOCHOTU4ODU4":
 630                         case "IfOCH":
 631                             sclpqiList.add(new SupportedCepLayerProtocolQualifierInstancesBuilder()
 632                                 .setLayerProtocolQualifier(ODUTYPEODU4.VALUE)
 633                                 .setNumberOfCepInstances(Uint64.valueOf(1))
 634                                 .build());
 635                             break;
 636                         default:
 637                             LOG.error("IfCapability type not managed");
 638                             break;
 639                     }
 640                     break;
 641                 case "PHOTONIC_MEDIA":
 642                     switch (ifCapType) {
 643                         case "IfOCHOTUCnODUCn":
 644                         case "IfOtsiOtucnOducn":
 645                         case "IfOCHOTUCnODUCnRegen":
 646                         case "IfOCHOTUCnODUCnUniregen":
 647                             sclpqiList.add(new SupportedCepLayerProtocolQualifierInstancesBuilder()
 648                                 .setLayerProtocolQualifier(ODUTYPEODUCN.VALUE)
 649                                 .setNumberOfCepInstances(Uint64.valueOf(1))
 650                                 .build());
 651                             sclpqiList.add(new SupportedCepLayerProtocolQualifierInstancesBuilder()
 652                                 .setLayerProtocolQualifier(OTUTYPEOTUCN.VALUE)
 653                                 .setNumberOfCepInstances(Uint64.valueOf(1))
 654                                 .build());
 655                         //fallthrough
 656                         case "IfOCH":
 657                         case "IfOCHOTU4ODU4":
 658                         case "IfOCHOTU4ODU4Regen":
 659                         case "IfOCHOTU4ODU4Uniregen":
 660                             sclpqiList.add(new SupportedCepLayerProtocolQualifierInstancesBuilder()
 661                                 .setLayerProtocolQualifier(PHOTONICLAYERQUALIFIEROTSiMC.VALUE)
 662                                 .setNumberOfCepInstances(Uint64.valueOf(1))
 663                                 .build());
 664                             sclpqiList.add(new SupportedCepLayerProtocolQualifierInstancesBuilder()
 665                                 .setLayerProtocolQualifier(PHOTONICLAYERQUALIFIEROTS.VALUE)
 666                                 .setNumberOfCepInstances(Uint64.valueOf(1))
 667                                 .build());
 668                             break;
 669                         default:
 670                             break;
 671                     }
 672                     break;
 673                 default:
 674                     LOG.error("Layer Protocol Name is unknown {}", lpn.getName());
 675                     break;
 676             }
 677         }
 678         return sclpqiList.stream().distinct().toList();
 679     }
 680
 681     public Map<Double, Double> getXpdrUsedWavelength(TerminationPoint tp) {
 682         var tpAug = tp.augmentation(
 683             org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev230526.TerminationPoint1.class);
 684         if (tpAug == null || tpAug.getXpdrNetworkAttributes() == null) {
 685             return null;
 686         }
 687         XpdrNetworkAttributes xnatt = tpAug.getXpdrNetworkAttributes();
 688         //Map<Double,Double> freqWidthMap = new HashMap<>();
 689         var xnattWvlgth = tpAug.getXpdrNetworkAttributes().getWavelength();
 690         return xnattWvlgth == null || xnattWvlgth.getFrequency() == null || xnattWvlgth.getWidth() == null
 691             ? null
 692             : new HashMap<>(Map.of(
 693                 (xnatt.getWavelength().getFrequency().getValue().doubleValue()
 694                     - xnatt.getWavelength().getWidth().getValue().doubleValue() * 0.001 / 2),
 695                 (xnatt.getWavelength().getFrequency().getValue().doubleValue()
 696                     - xnatt.getWavelength().getWidth().getValue().doubleValue() * 0.001 / 2)));
 697     }
 698
 699     public Map<Double, Double> getPPUsedWavelength(TerminationPoint tp) {
 700         var tpAug = tp.augmentation(
 701             org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev230526.TerminationPoint1.class);
 702         if (tpAug == null) {
 703             return null;
 704         }
 705         PpAttributes ppAtt = tpAug.getPpAttributes();
 706         if (ppAtt == null) {
 707             return null;
 708         }
 709         if (ppAtt != null && ppAtt.getUsedWavelength() != null
 710                 && ppAtt.getUsedWavelength().entrySet().iterator().next() != null) {
 711             Double centFreq = ppAtt.getUsedWavelength().entrySet().iterator().next().getValue().getFrequency()
 712                 .getValue().doubleValue();
 713             Double width = ppAtt.getUsedWavelength().entrySet().iterator().next().getValue().getWidth()
 714                 .getValue().doubleValue();
 715             return  new HashMap<>(Map.of(centFreq - width * 0.001 / 2, centFreq + width * 0.001 / 2));
 716         }
 717         return null;
 718     }
 719
 720     public Map<Double, Double> getTTPUsedFreqMap(TerminationPoint tp) {
 721         byte[] byteArray = new byte[GridConstant.NB_OCTECTS];
 722         Arrays.fill(byteArray, (byte) GridConstant.AVAILABLE_SLOT_VALUE);
 723         var termPoint1 = tp.augmentation(org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev230526
 724             .TerminationPoint1.class);
 725         if (termPoint1 == null || termPoint1.getTxTtpAttributes() == null) {
 726             return null;
 727         }
 728         TxTtpAttributes txttpAtt = termPoint1.getTxTtpAttributes();
 729         Map<Double,Double> freqMap = new HashMap<>();
 730         if (txttpAtt.getUsedWavelengths() != null
 731                 && txttpAtt.getUsedWavelengths().entrySet().iterator().next() != null) {
 732             for (Map.Entry<UsedWavelengthsKey, UsedWavelengths> usedLambdas :
 733                     txttpAtt.getUsedWavelengths().entrySet()) {
 734                 Double centFreq = usedLambdas.getValue().getFrequency().getValue().doubleValue();
 735                 Double width = usedLambdas.getValue().getWidth()
 736                     .getValue().doubleValue();
 737                 freqMap.put(centFreq - width * 0.001 / 2, centFreq + width * 0.001 / 2);
 738             }
 739             return freqMap;
 740         } else if (txttpAtt.getAvailFreqMaps() != null
 741                 && txttpAtt.getAvailFreqMaps().keySet().toString().contains(GridConstant.C_BAND)) {
 742             byte[] freqBitSet = new byte[GridConstant.NB_OCTECTS];
 743             LOG.debug("Creation of Bitset {}", freqBitSet);
 744             freqBitSet = txttpAtt.getAvailFreqMaps().entrySet().stream()
 745                 .filter(afm -> afm.getKey().toString().equals(GridConstant.C_BAND))
 746                 .findFirst().orElseThrow().getValue().getFreqMap();
 747             for (int i = 0; i < GridConstant.EFFECTIVE_BITS; i++) {
 748                 if (freqBitSet[i] == 0) {
 749                     freqBitSet[i] = 1;
 750                 } else {
 751                     freqBitSet[i] = 0;
 752                 }
 753             }
 754             return getFreqMapFromBitSet(freqBitSet);
 755         } else {
 756             return null;
 757         }
 758     }
 759
 760     public Map<Double, Double> getTTPAvailableFreqMap(TerminationPoint tp) {
 761         var termPoint1 = tp.augmentation(org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev230526
 762             .TerminationPoint1.class);
 763         if (termPoint1 == null || termPoint1.getTxTtpAttributes() == null
 764                 || termPoint1.getTxTtpAttributes().getAvailFreqMaps() == null
 765                 || !(termPoint1.getTxTtpAttributes().getAvailFreqMaps().keySet().toString()
 766                     .contains(GridConstant.C_BAND))) {
 767             return null;
 768         }
 769         byte[] byteArray = new byte[GridConstant.NB_OCTECTS];
 770         LOG.debug("Creation of Bitset {}", byteArray);
 771         return getFreqMapFromBitSet(
 772             termPoint1.getTxTtpAttributes().getAvailFreqMaps().entrySet().stream()
 773                 .filter(afm -> afm.getKey().toString().equals(GridConstant.C_BAND))
 774                 .findFirst().orElseThrow().getValue().getFreqMap());
 775     }
 776
 777     public Map<Double, Double> getTTP11AvailableFreqMap(
 778             org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev230526.TerminationPoint1 tp) {
 779         if (tp == null || tp.getTxTtpAttributes() == null
 780                 || tp.getTxTtpAttributes().getAvailFreqMaps() == null
 781                 || !(tp.getTxTtpAttributes().getAvailFreqMaps().keySet().toString()
 782                     .contains(GridConstant.C_BAND))) {
 783             return null;
 784         }
 785         byte[] byteArray = new byte[GridConstant.NB_OCTECTS];
 786         LOG.debug("Creation of Bitset {}", byteArray);
 787         return getFreqMapFromBitSet(
 788             tp.getTxTtpAttributes().getAvailFreqMaps().entrySet().stream()
 789                 .filter(afm -> afm.getKey().toString().equals(GridConstant.C_BAND))
 790                 .findFirst().orElseThrow().getValue().getFreqMap());
 791     }
 792
 793     public Map<Double, Double> getPP11UsedWavelength(
 794             org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev230526.TerminationPoint1 tp) {
 795         if (tp == null || tp.getPpAttributes() == null
 796                 || tp.getPpAttributes().getUsedWavelength() == null
 797                 || tp.getPpAttributes().getUsedWavelength().entrySet().iterator().next() == null) {
 798             return null;
 799         }
 800         PpAttributes ppAtt = tp.getPpAttributes();
 801         Map<Double,Double> freqMap = new HashMap<>();
 802         Double centFreq = ppAtt.getUsedWavelength().entrySet().iterator().next().getValue().getFrequency()
 803             .getValue().doubleValue();
 804         Double width = ppAtt.getUsedWavelength().entrySet().iterator().next().getValue().getWidth()
 805             .getValue().doubleValue();
 806         freqMap.put(centFreq - width * 0.001 / 2, centFreq + width * 0.001 / 2);
 807         return freqMap;
 808     }
 809
 810     public Map<Double, Double> getTTP11UsedFreqMap(
 811             org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev230526.TerminationPoint1 tp) {
 812         byte[] byteArray = new byte[GridConstant.NB_OCTECTS];
 813         Arrays.fill(byteArray, (byte) GridConstant.AVAILABLE_SLOT_VALUE);
 814         if (tp == null || tp.getTxTtpAttributes() == null) {
 815             return null;
 816         }
 817         TxTtpAttributes txttpAtt = tp.getTxTtpAttributes();
 818         Map<Double,Double> freqMap = new HashMap<>();
 819         if (txttpAtt.getUsedWavelengths() != null
 820                 && txttpAtt.getUsedWavelengths().entrySet().iterator().next() != null) {
 821             for (Map.Entry<UsedWavelengthsKey, UsedWavelengths> usedLambdas :
 822                     txttpAtt.getUsedWavelengths().entrySet()) {
 823                 Double centFreq = usedLambdas.getValue().getFrequency().getValue().doubleValue();
 824                 Double width = usedLambdas.getValue().getWidth()
 825                     .getValue().doubleValue();
 826                 freqMap.put(centFreq - width * 0.001 / 2, centFreq + width * 0.001 / 2);
 827             }
 828             return freqMap;
 829         } else if (txttpAtt.getAvailFreqMaps() != null
 830                 && txttpAtt.getAvailFreqMaps().keySet().toString().contains(GridConstant.C_BAND)) {
 831             byte[] freqBitSet = new byte[GridConstant.NB_OCTECTS];
 832             LOG.debug("Creation of Bitset {}", freqBitSet);
 833             freqBitSet = txttpAtt.getAvailFreqMaps().entrySet().stream()
 834                 .filter(afm -> afm.getKey().toString().equals(GridConstant.C_BAND))
 835                 .findFirst().orElseThrow().getValue().getFreqMap();
 836             for (int i = 0; i < GridConstant.EFFECTIVE_BITS; i++) {
 837                 if (freqBitSet[i] == 0) {
 838                     freqBitSet[i] = 1;
 839                 } else {
 840                     freqBitSet[i] = 0;
 841                 }
 842             }
 843             return getFreqMapFromBitSet(freqBitSet);
 844         } else {
 845             return null;
 846         }
 847     }
 848
 849     public Map<Double, Double> getFreqMapFromBitSet(byte[] byteArray) {
 850         // Provides a Map <LowerFreq, HigherFreq> describing start and stop frequencies of all slots that are available
 851         // in the ByteArray describing the spectrum : bit sets initially sets to 1/true
 852         // In case the byte array has been inverted before calling this method, it provides respectively a map
 853         // describing all occupied slots!
 854         Map<Double,Double> freqMap = new HashMap<>();
 855         Double startFreq = GridConstant.START_EDGE_FREQUENCY;
 856         Double stopFreq = 0.0;
 857         boolean occupied = false;
 858         if (byteArray[0] == 0) {
 859             occupied = true;
 860         }
 861         for (int index = 0 ; index < GridConstant.EFFECTIVE_BITS ; index++) {
 862             if (byteArray[index] == 1 && occupied) {
 863                 startFreq = GridUtils.getStartFrequencyFromIndex(index).doubleValue();
 864                 stopFreq = GridUtils.getStartFrequencyFromIndex(index).doubleValue();
 865                 occupied = false;
 866             } else if (byteArray[index] == 0 && !occupied) {
 867                 stopFreq = GridUtils.getStartFrequencyFromIndex(index).doubleValue();
 868                 occupied = true;
 869             }
 870             if (stopFreq.doubleValue() > startFreq.doubleValue() && occupied) {
 871                 freqMap.put(startFreq, stopFreq);
 872                 startFreq = stopFreq;
 873             }
 874             if ((index == GridConstant.EFFECTIVE_BITS - 1) && (startFreq.doubleValue() == stopFreq.doubleValue())
 875                     && !occupied) {
 876                 stopFreq = GridUtils.getStopFrequencyFromIndex(index).doubleValue();
 877                 freqMap.put(startFreq, stopFreq);
 878             }
 879         }
 880         return freqMap;
 881     }
 882
 883     public OwnedNodeEdgePointBuilder addPayloadStructureAndPhotSpecToOnep(String nodeId,
 884             Map<Double, Double> freqMap, List<OperationalModeKey> operModeList,
 885             Collection<SupportedInterfaceCapability> sicColl, OwnedNodeEdgePointBuilder onepBldr, String keyword) {
 886         if (String.join("+", nodeId, TapiStringConstants.OTSI_MC).equals(keyword)
 887                 || String.join("+", nodeId, TapiStringConstants.PHTNC_MEDIA_OTS).equals(keyword)) {
 888             LOG.debug("Entering LOOP Step1");
 889             // Creating OTS & OTSI_MC NEP specific attributes
 890             onepBldr.setSupportedPayloadStructure(createSupportedPayloadStructureForPhtncMedia(
 891                 sicColl,operModeList));
 892             SpectrumCapabilityPacBuilder spectrumPac = new SpectrumCapabilityPacBuilder();
 893             OccupiedSpectrumBuilder ospecBd = new OccupiedSpectrumBuilder();
 894             if (freqMap == null || freqMap.isEmpty()) {
 895 //                TODO: verify if we need to fill OcupiedSpectrum as follows when no lambda provisioned
 896 //                ospecBd
 897 //                    .setUpperFrequency(Uint64.valueOf(0))
 898 //                    .setLowerFrequency(Uint64.valueOf(0));
 899                 onepBldr.setAvailablePayloadStructure(createAvailablePayloadStructureForPhtncMedia(
 900                     false, sicColl,operModeList));
 901                 double naz = 0.01;
 902                 AvailableSpectrum  aspec = new AvailableSpectrumBuilder()
 903                     .setLowerFrequency(Uint64.valueOf(Math.round(GridConstant.START_EDGE_FREQUENCY * 1E09 + naz)))
 904                     .setUpperFrequency(Uint64.valueOf(Math.round(GridConstant.START_EDGE_FREQUENCY * 1E09
 905                         + GridConstant.GRANULARITY * GridConstant.EFFECTIVE_BITS * 1E06 + naz)))
 906                     .build();
 907                 Map<AvailableSpectrumKey, AvailableSpectrum> aspecMap = new HashMap<>();
 908                 aspecMap.put(new AvailableSpectrumKey(aspec.getLowerFrequency(),
 909                     aspec.getUpperFrequency()), aspec);
 910                 spectrumPac.setAvailableSpectrum(aspecMap);
 911             } else {
 912                 LOG.debug("Entering LOOP Step2");
 913                 onepBldr.setAvailablePayloadStructure(createAvailablePayloadStructureForPhtncMedia(
 914                     true, sicColl,operModeList));
 915                 Map<OccupiedSpectrumKey, OccupiedSpectrum> ospecMap = new HashMap<>();
 916                 for (Map.Entry<Double, Double> frequency : freqMap.entrySet()) {
 917                     ospecBd
 918                         .setLowerFrequency(Uint64.valueOf(Math.round(frequency.getKey().doubleValue() * 1E09)))
 919                         .setUpperFrequency(Uint64.valueOf(Math.round(frequency.getValue().doubleValue() * 1E09)));
 920                 }
 921                 OccupiedSpectrum ospec = ospecBd.build();
 922                 ospecMap.put(new OccupiedSpectrumKey(ospec.getLowerFrequency(), ospec.getUpperFrequency()), ospec);
 923                 spectrumPac.setOccupiedSpectrum(ospecMap);
 924             }
 925             LOG.debug("Entering LOOP Step3");
 926             double nazz = 0.01;
 927             SupportableSpectrum  sspec = new SupportableSpectrumBuilder()
 928                 .setUpperFrequency(Uint64.valueOf(Math.round(GridConstant.START_EDGE_FREQUENCY * 1E09 + nazz)))
 929                 .setLowerFrequency(Uint64.valueOf(Math.round(GridConstant.START_EDGE_FREQUENCY * 1E09
 930                     + GridConstant.GRANULARITY * GridConstant.EFFECTIVE_BITS * 1E06 + nazz)))
 931                 .build();
 932             Map<SupportableSpectrumKey, SupportableSpectrum> sspecMap = new HashMap<>();
 933             sspecMap.put(new SupportableSpectrumKey(sspec.getLowerFrequency(),
 934                 sspec.getUpperFrequency()), sspec);
 935             spectrumPac.setSupportableSpectrum(sspecMap);
 936             LOG.debug("Entering LOOP Step4");
 937             PhotonicMediaNodeEdgePointSpec pnepSpec = new PhotonicMediaNodeEdgePointSpecBuilder()
 938                 .setSpectrumCapabilityPac(spectrumPac.build())
 939                 .build();
 940             org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.photonic.media.rev221121.OwnedNodeEdgePoint1 onep1 =
 941                 new org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.photonic.media.rev221121
 942                     .OwnedNodeEdgePoint1Builder()
 943                 .setPhotonicMediaNodeEdgePointSpec(pnepSpec)
 944                 .build();
 945             LOG.debug("creating Photonic NEP SPEC for node {} and nep {}", nodeId, onep1);
 946             onepBldr.addAugmentation(onep1);
 947             LOG.debug("Entering LOOP Step5");
 948         }
 949         return onepBldr;
 950     }
 951
 952
 953     public OwnedNodeEdgePointBuilder addPhotSpecToRoadmOnep(String nodeId,
 954             Map<Double, Double> usedFreqMap, Map<Double, Double> availableFreqMap,
 955             OwnedNodeEdgePointBuilder onepBldr, String keyword) {
 956         if (String.join("+", nodeId, TapiStringConstants.PHTNC_MEDIA_OTS).equals(keyword)
 957                 || String.join("+", nodeId, TapiStringConstants.PHTNC_MEDIA_OMS).equals(keyword)) {
 958             // Creating OTS/OMS NEP specific attributes
 959             SpectrumCapabilityPacBuilder spectrumPac = new SpectrumCapabilityPacBuilder();
 960             if ((usedFreqMap == null || usedFreqMap.isEmpty())
 961                     && (availableFreqMap == null || availableFreqMap.isEmpty())) {
 962                 double naz = 0.01;
 963                 AvailableSpectrum  aspec = new AvailableSpectrumBuilder()
 964                     .setLowerFrequency(Uint64.valueOf(Math.round(GridConstant.START_EDGE_FREQUENCY * 1E09 + naz)))
 965                     .setUpperFrequency(Uint64.valueOf(Math.round(GridConstant.START_EDGE_FREQUENCY * 1E09
 966                         + GridConstant.GRANULARITY * GridConstant.EFFECTIVE_BITS * 1E06 + naz)))
 967                     .build();
 968                 Map<AvailableSpectrumKey, AvailableSpectrum> aspecMap = new HashMap<>();
 969                 aspecMap.put(new AvailableSpectrumKey(aspec.getLowerFrequency(),
 970                     aspec.getUpperFrequency()), aspec);
 971                 spectrumPac.setAvailableSpectrum(aspecMap);
 972             } else {
 973                 if (availableFreqMap != null && !availableFreqMap.isEmpty()) {
 974                     Map<AvailableSpectrumKey, AvailableSpectrum> aspecMap = new HashMap<>();
 975                     AvailableSpectrumBuilder  aspecBd = new AvailableSpectrumBuilder();
 976                     for (Map.Entry<Double, Double> frequency : availableFreqMap.entrySet()) {
 977                         aspecBd
 978                             .setLowerFrequency(Uint64.valueOf(Math.round(frequency.getKey().doubleValue() * 1E09)))
 979                             .setUpperFrequency(Uint64.valueOf(Math.round(frequency.getValue().doubleValue() * 1E09)));
 980                         AvailableSpectrum aspec = aspecBd.build();
 981                         aspecMap.put(new AvailableSpectrumKey(aspec.getLowerFrequency(),
 982                             aspec.getUpperFrequency()), aspec);
 983                     }
 984                     spectrumPac.setAvailableSpectrum(aspecMap);
 985                 }
 986                 if (usedFreqMap != null && !usedFreqMap.isEmpty()) {
 987                     Map<OccupiedSpectrumKey, OccupiedSpectrum> ospecMap = new HashMap<>();
 988                     OccupiedSpectrumBuilder ospecBd = new OccupiedSpectrumBuilder();
 989                     for (Map.Entry<Double, Double> frequency : usedFreqMap.entrySet()) {
 990                         ospecBd
 991                             .setLowerFrequency(Uint64.valueOf(Math.round(frequency.getKey().doubleValue() * 1E09)))
 992                             .setUpperFrequency(Uint64.valueOf(Math.round(frequency.getValue().doubleValue() * 1E09)));
 993                         OccupiedSpectrum ospec = ospecBd.build();
 994                         ospecMap.put(new OccupiedSpectrumKey(ospec.getLowerFrequency(),
 995                             ospec.getUpperFrequency()), ospec);
 996                     }
 997                     spectrumPac.setOccupiedSpectrum(ospecMap);
 998                 }
 999             }
1000             double nazz = 0.01;
1001             SupportableSpectrum  sspec = new SupportableSpectrumBuilder()
1002                 .setUpperFrequency(Uint64.valueOf(Math.round(GridConstant.START_EDGE_FREQUENCY * 1E09 + nazz)))
1003                 .setLowerFrequency(Uint64.valueOf(Math.round(GridConstant.START_EDGE_FREQUENCY * 1E09
1004                     + GridConstant.GRANULARITY * GridConstant.EFFECTIVE_BITS * 1E06 + nazz)))
1005                 .build();
1006             Map<SupportableSpectrumKey, SupportableSpectrum> sspecMap = new HashMap<>();
1007             sspecMap.put(new SupportableSpectrumKey(sspec.getLowerFrequency(),
1008                 sspec.getUpperFrequency()), sspec);
1009             spectrumPac.setSupportableSpectrum(sspecMap);
1010
1011             PhotonicMediaNodeEdgePointSpec pnepSpec = new PhotonicMediaNodeEdgePointSpecBuilder()
1012                 .setSpectrumCapabilityPac(spectrumPac.build())
1013                 .build();
1014             org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.photonic.media.rev221121.OwnedNodeEdgePoint1 onep1 =
1015                 new org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.photonic.media.rev221121
1016                         .OwnedNodeEdgePoint1Builder()
1017                     .setPhotonicMediaNodeEdgePointSpec(pnepSpec)
1018                     .build();
1019             onepBldr.addAugmentation(onep1);
1020             LOG.debug("Add Photonic Node Edge point Spec to {} including available Spectrum {} = ",
1021                 onepBldr.getName(),
1022                 onep1.getPhotonicMediaNodeEdgePointSpec().getSpectrumCapabilityPac().getAvailableSpectrum());
1023         }
1024         return onepBldr;
1025     }
1026
1027     private OduSwitchingPools createOduSwitchingPoolForTp100G() {
1028         Map<NonBlockingListKey, NonBlockingList> nblMap = new HashMap<>();
1029         int count = 1;
1030         for (TerminationPoint tp : this.oorNetworkPortList) {
1031             NonBlockingList nbl = new NonBlockingListBuilder()
1032                 .setNblNumber(Uint16.valueOf(count))
1033                 .setTpList(new HashSet<>(Set.of(
1034                     tp.getTpId(),
1035                     tp.augmentation(org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev230526
1036                             .TerminationPoint1.class)
1037                         .getAssociatedConnectionMapTp().iterator().next())))
1038                 .build();
1039             nblMap.put(nbl.key(), nbl);
1040             count++;
1041         }
1042         return new OduSwitchingPoolsBuilder()
1043             .setNonBlockingList(nblMap)
1044             .setSwitchingPoolNumber(Uint16.valueOf(1))
1045             .build();
1046     }
1047
1048     private org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.topology.Node createTapiNode(
1049             Map<NameKey, Name> nodeNames, Set<LayerProtocolName> layerProtocols) {
1050         Uuid nodeUuid = null;
1051         Map<OwnedNodeEdgePointKey, OwnedNodeEdgePoint> onepl = new HashMap<>();
1052         Map<NodeRuleGroupKey, NodeRuleGroup> nodeRuleGroupList = new HashMap<>();
1053         if (layerProtocols.contains(LayerProtocolName.DSR)
1054                 || layerProtocols.contains(LayerProtocolName.PHOTONICMEDIA)) {
1055             Rule rule = new RuleBuilder()
1056                 .setLocalId("forward")
1057                 .setForwardingRule(FORWARDINGRULEMAYFORWARDACROSSGROUP.VALUE)
1058                 .setRuleType(new HashSet<>(Set.of(RuleType.FORWARDING)))
1059                 .build();
1060             nodeUuid = getNodeUuid4Dsr(onepl, nodeRuleGroupList, new HashMap<>(Map.of(rule.key(), rule)));
1061         } else {
1062             LOG.error("Undefined LayerProtocolName for {} node {}",
1063                 nodeNames.get(nodeNames.keySet().iterator().next()).getValueName(),
1064                 nodeNames.get(nodeNames.keySet().iterator().next()).getValue());
1065         }
1066      // Empty random creation of mandatory fields for avoiding errors....
1067         CostCharacteristic costCharacteristic = new CostCharacteristicBuilder()
1068             .setCostAlgorithm("Restricted Shortest Path - RSP")
1069             .setCostName("HOP_COUNT")
1070             .setCostValue(TapiStringConstants.COST_HOP_VALUE)
1071             .build();
1072         LatencyCharacteristic latencyCharacteristic = new LatencyCharacteristicBuilder()
1073             .setFixedLatencyCharacteristic(TapiStringConstants.FIXED_LATENCY_VALUE)
1074             .setQueuingLatencyCharacteristic(TapiStringConstants.QUEING_LATENCY_VALUE)
1075             .setJitterCharacteristic(TapiStringConstants.JITTER_VALUE)
1076             .setWanderCharacteristic(TapiStringConstants.WANDER_VALUE)
1077             .setTrafficPropertyName("FIXED_LATENCY")
1078             .build();
1079         RiskCharacteristic riskCharacteristic = new RiskCharacteristicBuilder()
1080             .setRiskCharacteristicName("risk characteristic")
1081             .setRiskIdentifierList(Set.of("risk identifier1", "risk identifier2"))
1082             .build();
1083         return new NodeBuilder()
1084             .setUuid(nodeUuid)
1085             .setName(nodeNames)
1086             .setLayerProtocolName(layerProtocols)
1087             .setAdministrativeState(transformAsToTapiAdminState(this.ietfNodeAdminState.getName()))
1088             .setOperationalState(transformOsToTapiOperationalState(this.ietfNodeOperState.getName()))
1089             .setLifecycleState(LifecycleState.INSTALLED)
1090             .setOwnedNodeEdgePoint(onepl)
1091             .setNodeRuleGroup(nodeRuleGroupList)
1092             .setCostCharacteristic(Map.of(costCharacteristic.key(), costCharacteristic))
1093             .setLatencyCharacteristic(Map.of(latencyCharacteristic.key(), latencyCharacteristic))
1094             .setRiskParameterPac(
1095                 new RiskParameterPacBuilder()
1096                     .setRiskCharacteristic(Map.of(riskCharacteristic.key(), riskCharacteristic))
1097                     .build())
1098             .setErrorCharacteristic("error")
1099             .setLossCharacteristic("loss")
1100             .setRepeatDeliveryCharacteristic("repeat delivery")
1101             .setDeliveryOrderCharacteristic("delivery order")
1102             .setUnavailableTimeCharacteristic("unavailable time")
1103             .setServerIntegrityProcessCharacteristic("server integrity process")
1104             .build();
1105     }
1106
1107     private Uuid getNodeUuid4Dsr(
1108             Map<OwnedNodeEdgePointKey, OwnedNodeEdgePoint> onepl,
1109             Map<NodeRuleGroupKey, NodeRuleGroup> nodeRuleGroupList,
1110             Map<RuleKey, Rule> ruleList) {
1111         // client NEP DSR creation on DSR/ODU node
1112         for (int i = 0; i < oorClientPortList.size(); i++) {
1113             String nodeIdDsr = String.join("+",
1114                 this.ietfNodeId, TapiStringConstants.DSR, oorClientPortList.get(i).getTpId().getValue());
1115             Uuid nepUuid = new Uuid(UUID.nameUUIDFromBytes(nodeIdDsr.getBytes(Charset.forName("UTF-8"))).toString());
1116             LOG.info("NEP = {} has Uuid {} ", nodeIdDsr, nepUuid);
1117             this.uuidMap.put(nodeIdDsr, nepUuid);
1118             Name name = new NameBuilder()
1119                 .setValue(nodeIdDsr)
1120                 .setValueName(OpenroadmNodeType.TPDR.equals(this.ietfNodeType) ? "100G-tpdr" : "NodeEdgePoint_C")
1121                 .build();
1122             OwnedNodeEdgePoint onep = createNep(
1123                 oorClientPortList.get(i),
1124                 Map.of(name.key(), name),
1125                 LayerProtocolName.DSR, LayerProtocolName.DSR, true,
1126                 String.join("+", this.ietfNodeId, TapiStringConstants.DSR));
1127             onepl.put(onep.key(), onep);
1128         }
1129         // CLIENT NEP E_ODU creation on DSR/ODU node
1130         for (int i = 0; i < oorClientPortList.size(); i++) {
1131             String nodeIdEodu = String.join("+",
1132                 this.ietfNodeId, TapiStringConstants.E_ODU, oorClientPortList.get(i).getTpId().getValue());
1133             Uuid nepUuid1 = new Uuid(UUID.nameUUIDFromBytes(nodeIdEodu.getBytes(Charset.forName("UTF-8"))).toString());
1134             LOG.info("NEP = {} has Uuid {} ", nodeIdEodu, nepUuid1);
1135             this.uuidMap.put(nodeIdEodu, nepUuid1);
1136             Name onedName = new NameBuilder()
1137                 .setValueName("eNodeEdgePoint_N")
1138                 .setValue(nodeIdEodu)
1139                 .build();
1140             OwnedNodeEdgePoint onep = createNep(
1141                 oorClientPortList.get(i),
1142                 Map.of(onedName.key(), onedName),
1143                 LayerProtocolName.ODU, LayerProtocolName.DSR, false,
1144                 String.join("+", this.ietfNodeId, TapiStringConstants.E_ODU));
1145             onepl.put(onep.key(), onep);
1146         }
1147         // NETWORK NEPs I_ODU creation on DSR/ODU node
1148         for (int i = 0; i < oorNetworkPortList.size(); i++) {
1149             String nodeIdIodu = String.join("+",
1150                 this.ietfNodeId, TapiStringConstants.I_ODU, oorNetworkPortList.get(i).getTpId().getValue());
1151             Uuid nepUuid1 = new Uuid(UUID.nameUUIDFromBytes(nodeIdIodu.getBytes(Charset.forName("UTF-8"))).toString());
1152             LOG.info("NEP = {} has Uuid {} ", nodeIdIodu, nepUuid1);
1153             this.uuidMap.put(nodeIdIodu, nepUuid1);
1154             Name onedName = new NameBuilder()
1155                 .setValueName("iNodeEdgePoint_N")
1156                 .setValue(nodeIdIodu)
1157                 .build();
1158             OwnedNodeEdgePoint onep = createNep(
1159                 oorNetworkPortList.get(i),
1160                 Map.of(onedName.key(), onedName),
1161                 LayerProtocolName.ODU, LayerProtocolName.DSR, true,
1162                 String.join("+", this.ietfNodeId, TapiStringConstants.I_ODU));
1163             onepl.put(onep.key(), onep);
1164         }
1165         // NETWORK NEP OTS network on DSR/ODU node
1166         for (int i = 0; i < oorNetworkPortList.size(); i++) {
1167             String nodeIdPmOts = String.join("+",
1168                 this.ietfNodeId, TapiStringConstants.PHTNC_MEDIA_OTS, oorNetworkPortList.get(i).getTpId().getValue());
1169             Uuid nepUuid2 = new Uuid(UUID.nameUUIDFromBytes(nodeIdPmOts.getBytes(Charset.forName("UTF-8"))).toString());
1170             LOG.info("NEP = {} has Uuid {} ", nodeIdPmOts, nepUuid2);
1171             this.uuidMap.put(nodeIdPmOts, nepUuid2);
1172             Name onedName = new NameBuilder()
1173                 .setValueName("eNodeEdgePoint")
1174                 .setValue(nodeIdPmOts)
1175                 .build();
1176             OwnedNodeEdgePoint onep = createNep(
1177                 oorNetworkPortList.get(i),
1178                 Map.of(onedName.key(), onedName),
1179                 LayerProtocolName.PHOTONICMEDIA, LayerProtocolName.PHOTONICMEDIA, true,
1180                 String.join("+", this.ietfNodeId, TapiStringConstants.PHTNC_MEDIA_OTS));
1181             onepl.put(onep.key(), onep);
1182         }
1183         for (int i = 0; i < oorNetworkPortList.size(); i++) {
1184             String nodeIdOtMc = String.join("+",
1185                 this.ietfNodeId, TapiStringConstants.OTSI_MC, oorNetworkPortList.get(i).getTpId().getValue());
1186             Uuid nepUuid3 = new Uuid(UUID.nameUUIDFromBytes(nodeIdOtMc.getBytes(Charset.forName("UTF-8"))).toString());
1187             LOG.info("NEP = {} has Uuid {} ", nodeIdOtMc, nepUuid3);
1188             this.uuidMap.put(nodeIdOtMc, nepUuid3);
1189             Name onedName = new NameBuilder()
1190                 .setValueName("PhotMedNodeEdgePoint")
1191                 .setValue(nodeIdOtMc)
1192                 .build();
1193             OwnedNodeEdgePoint onep = createNep(
1194                 oorNetworkPortList.get(i),
1195                 Map.of(onedName.key(), onedName),
1196                 LayerProtocolName.PHOTONICMEDIA, LayerProtocolName.PHOTONICMEDIA, true,
1197                 String.join("+", this.ietfNodeId, TapiStringConstants.OTSI_MC));
1198             onepl.put(onep.key(), onep);
1199         }
1200         // create NodeRuleGroup
1201         int count = 1;
1202         LOG.debug("ODU switching pool = {}", this.oorOduSwitchingPool.nonnullNonBlockingList().values());
1203         String ietfXpdr = String.join("+", this.ietfNodeId, TapiStringConstants.XPDR);
1204         for (NonBlockingList nbl : this.oorOduSwitchingPool.nonnullNonBlockingList().values()) {
1205             Map<org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.node.rule.group.NodeEdgePointKey,
1206                 org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.node.rule.group.NodeEdgePoint>
1207                     nepList = new HashMap<>();
1208             Map<org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.node.rule.group.NodeEdgePointKey,
1209                 org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.node.rule.group.NodeEdgePoint>
1210                     oduNepList = new HashMap<>();
1211             LOG.debug("UUidMap={}", this.uuidMap.keySet());
1212             LOG.debug("TP list = {}", nbl.getTpList());
1213             for (TpId tp : nbl.getTpList()) {
1214                 LOG.debug("TP={}", tp.getValue());
1215                 String ietfEoduTp = String.join("+", this.ietfNodeId, TapiStringConstants.E_ODU, tp.getValue());
1216                 LOG.debug("UuidKey={}", ietfEoduTp);
1217                 String ietfIoduTp = String.join("+", this.ietfNodeId, TapiStringConstants.I_ODU, tp.getValue());
1218                 if (this.uuidMap.containsKey(String.join("+", this.ietfNodeId, TapiStringConstants.DSR, tp.getValue()))
1219                         || this.uuidMap.containsKey(ietfIoduTp)) {
1220                     String qual = tp.getValue().contains("CLIENT")
1221                         ? TapiStringConstants.DSR : TapiStringConstants.I_ODU;
1222                     var nep = new org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121
1223                                 .node.rule.group.NodeEdgePointBuilder()
1224                             .setTopologyUuid(tapiTopoUuid)
1225                             .setNodeUuid(this.uuidMap.get(ietfXpdr))
1226                             .setNodeEdgePointUuid(this.uuidMap.get(
1227                                 String.join("+", this.ietfNodeId, qual, tp.getValue())))
1228                             .build();
1229                     nepList.put(nep.key(), nep);
1230                 }
1231                 if (this.uuidMap.containsKey(ietfEoduTp)) {
1232                     var nep1 = new org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121
1233                                 .node.rule.group.NodeEdgePointBuilder()
1234                             .setTopologyUuid(tapiTopoUuid)
1235                             .setNodeUuid(this.uuidMap.get(ietfXpdr))
1236                             .setNodeEdgePointUuid(this.uuidMap.get(ietfEoduTp))
1237                             .build();
1238                     oduNepList.put(nep1.key(), nep1);
1239                 }
1240                 if (this.uuidMap.containsKey(ietfIoduTp)) {
1241                 // TODO already checked with DSR above -> potential factorization ?
1242                     var nep2 = new org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121
1243                                 .node.rule.group.NodeEdgePointBuilder()
1244                             .setTopologyUuid(tapiTopoUuid)
1245                             .setNodeUuid(this.uuidMap.get(ietfXpdr))
1246                             .setNodeEdgePointUuid(this.uuidMap.get(ietfIoduTp))
1247                             .build();
1248                     oduNepList.put(nep2.key(), nep2);
1249                 }
1250             }
1251             LOG.debug("NEPLIST (DSR/I_ODU) of [dsr node rule group] is {}", nepList);
1252             LOG.debug("NEPLIST (E_ODU/I_ODU) of [odu node rule group] is {}", nepList);
1253             // Empty random creation of mandatory fields for avoiding errors....
1254             CostCharacteristic costCharacteristic = new CostCharacteristicBuilder()
1255                 .setCostAlgorithm("Restricted Shortest Path - RSP")
1256                 .setCostName("HOP_COUNT")
1257                 .setCostValue(TapiStringConstants.COST_HOP_VALUE)
1258                 .build();
1259             LatencyCharacteristic latencyCharacteristic = new LatencyCharacteristicBuilder()
1260                 .setFixedLatencyCharacteristic(TapiStringConstants.FIXED_LATENCY_VALUE)
1261                 .setQueuingLatencyCharacteristic(TapiStringConstants.QUEING_LATENCY_VALUE)
1262                 .setJitterCharacteristic(TapiStringConstants.JITTER_VALUE)
1263                 .setWanderCharacteristic(TapiStringConstants.WANDER_VALUE)
1264                 .setTrafficPropertyName("FIXED_LATENCY")
1265                 .build();
1266             RiskCharacteristic riskCharacteristic = new RiskCharacteristicBuilder()
1267                 .setRiskCharacteristicName("risk characteristic")
1268                 .setRiskIdentifierList(Set.of("risk identifier1", "risk identifier2"))
1269                 .build();
1270             Name nrgName = new NameBuilder()
1271                 .setValueName("nrg name")
1272                 .setValue("odu node rule group " + count)
1273                 .build();
1274             NodeRuleGroup nodeRuleGroup1 = new NodeRuleGroupBuilder()
1275                 .setName(Map.of(nrgName.key(), nrgName))
1276                 .setUuid(new Uuid(UUID.nameUUIDFromBytes(("dsr node rule group " + count)
1277                     .getBytes(Charset.forName("UTF-8"))).toString()))
1278                 .setRule(ruleList)
1279                 .setNodeEdgePoint(nepList)
1280                 .setRiskCharacteristic(Map.of(riskCharacteristic.key(), riskCharacteristic))
1281                 .setCostCharacteristic(Map.of(costCharacteristic.key(), costCharacteristic))
1282                 .setLatencyCharacteristic(Map.of(latencyCharacteristic.key(), latencyCharacteristic))
1283                 .build();
1284             nodeRuleGroupList.put(nodeRuleGroup1.key(), nodeRuleGroup1);
1285             NodeRuleGroup nodeRuleGroup2 = new NodeRuleGroupBuilder()
1286                 .setUuid(new Uuid(UUID.nameUUIDFromBytes(("odu node rule group " + count)
1287                     .getBytes(Charset.forName("UTF-8"))).toString()))
1288                 .setRule(ruleList)
1289                 .setNodeEdgePoint(oduNepList)
1290                 .setRiskCharacteristic(Map.of(riskCharacteristic.key(), riskCharacteristic))
1291                 .setCostCharacteristic(Map.of(costCharacteristic.key(), costCharacteristic))
1292                 .setLatencyCharacteristic(Map.of(latencyCharacteristic.key(), latencyCharacteristic))
1293                 .build();
1294             nodeRuleGroupList.put(nodeRuleGroup2.key(), nodeRuleGroup2);
1295             count++;
1296         }
1297         return this.uuidMap.get(ietfXpdr);
1298     }
1299
1300     private OwnedNodeEdgePoint createNep(TerminationPoint oorTp, Map<NameKey, Name> nepNames,
1301             LayerProtocolName nepProtocol, LayerProtocolName nodeProtocol, boolean withSip, String keyword) {
1302         var tp1 = oorTp.augmentation(
1303             org.opendaylight.yang.gen.v1.http.org.openroadm.otn.network.topology.rev230526.TerminationPoint1.class);
1304         if (tp1.getTpSupportedInterfaces() == null) {
1305             LOG.warn("Tp supported interface doesnt exist on TP {}", oorTp.getTpId().getValue());
1306             return null;
1307         }
1308         AdministrativeState adminState =
1309             oorTp.augmentation(TerminationPoint1.class).getAdministrativeState() == null
1310                 ? null
1311                 : transformAsToTapiAdminState(
1312                     oorTp.augmentation(TerminationPoint1.class).getAdministrativeState().getName());
1313         OperationalState operState =
1314             oorTp.augmentation(TerminationPoint1.class).getOperationalState() == null
1315                 ? null
1316                 : transformOsToTapiOperationalState(
1317                     oorTp.augmentation(TerminationPoint1.class).getOperationalState().getName());
1318         Collection<SupportedInterfaceCapability> sicColl =
1319             tp1.getTpSupportedInterfaces().getSupportedInterfaceCapability().values();
1320         OwnedNodeEdgePointBuilder onepBldr = new OwnedNodeEdgePointBuilder()
1321             .setUuid(this.uuidMap.get(String.join("+", keyword, oorTp.getTpId().getValue())))
1322             .setLayerProtocolName(nepProtocol)
1323             .setName(nepNames)
1324             .setSupportedCepLayerProtocolQualifierInstances(
1325                 createSupportedCepLayerProtocolQualifier(sicColl, nepProtocol))
1326             .setDirection(Direction.BIDIRECTIONAL)
1327             .setLinkPortRole(PortRole.SYMMETRIC)
1328             .setAdministrativeState(adminState)
1329             .setOperationalState(operState)
1330             .setLifecycleState(LifecycleState.INSTALLED);
1331         if (withSip) {
1332             onepBldr.setMappedServiceInterfacePoint(
1333                 createMSIP(1, nepProtocol, oorTp.getTpId().getValue(), keyword, sicColl, operState, adminState));
1334         }
1335         if (oorTp.augmentation(TerminationPoint1.class).getTpType().equals(OpenroadmTpType.XPONDERNETWORK)) {
1336             List<OperationalModeKey> opModeList = new ArrayList<>();
1337             var tp11 = oorTp.augmentation(
1338                 org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev230526.TerminationPoint1.class);
1339             if (tp11 == null || tp11.getXpdrNetworkAttributes() == null) {
1340                 for (SupportedInterfaceCapability sic : sicColl) {
1341                     String ifCapType = sic.getIfCapType().toString().split("\\{")[0];
1342                     if (("IfOCHOTUCnODUCn").equals(ifCapType) || ("IfOCHOTUCnODUCnUniregen").equals(ifCapType)
1343                             || ("IfOCHOTUCnODUCnRegen").equals(ifCapType)) {
1344                         opModeList.add(new OperationalModeKey("400G"));
1345                         LOG.warn(TopologyUtils.NOOPMODEDECLARED + "400G rate available", oorTp.getTpId());
1346                         break;
1347                     }
1348                 }
1349                 opModeList.add(new OperationalModeKey("100G"));
1350                 LOG.warn(TopologyUtils.NOOPMODEDECLARED + "100G rate available", oorTp.getTpId());
1351             } else {
1352                 opModeList = tp11.getXpdrNetworkAttributes().getSupportedOperationalModes().getOperationalMode()
1353                     .keySet().stream().toList();
1354             }
1355             onepBldr = addPayloadStructureAndPhotSpecToOnep(
1356                 this.ietfNodeId, getXpdrUsedWavelength(oorTp), opModeList, sicColl, onepBldr, keyword);
1357         }
1358         LOG.debug("ConvertORToTapiTopology 1360, onep = {}", onepBldr.build());
1359         return onepBldr.build();
1360     }
1361
1362     private ServiceInterfacePoint createSIP(Uuid sipUuid, LayerProtocolName layerProtocol, String tpId,
1363         String nodeid, Collection<SupportedInterfaceCapability> supportedInterfaceCapability,
1364         OperationalState operState, AdministrativeState adminState) {
1365     // TODO: what value should be set in total capacity and available capacity??
1366         LOG.debug("SIP name = {}", String.join("+", nodeid, tpId));
1367         Name sipName = new NameBuilder()
1368             .setValueName("SIP name")
1369             .setValue(String.join("+", nodeid, tpId))
1370             .build();
1371         return new ServiceInterfacePointBuilder()
1372             .setUuid(sipUuid)
1373             .setName(Map.of(sipName.key(), sipName))
1374             .setLayerProtocolName(layerProtocol)
1375             .setAdministrativeState(adminState)
1376             .setOperationalState(operState)
1377             .setLifecycleState(LifecycleState.INSTALLED)
1378             .setAvailableCapacity(new AvailableCapacityBuilder().build())
1379             .setTotalPotentialCapacity(new TotalPotentialCapacityBuilder().build())
1380             .setSupportedCepLayerProtocolQualifierInstances(createSipSupportedLayerProtocolQualifier(
1381                 supportedInterfaceCapability, layerProtocol))
1382             .build();
1383     }
1384
1385     @edu.umd.cs.findbugs.annotations.SuppressFBWarnings(value = "SF_SWITCH_FALLTHROUGH",
1386         justification = "Voluntarily No break in switchcase where comment is inserted in following method")
1387     private List<org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev221121
1388                 .service._interface.point.SupportedCepLayerProtocolQualifierInstances>
1389              createSipSupportedLayerProtocolQualifier(
1390                 Collection<SupportedInterfaceCapability> supportedInterfaceCapability, LayerProtocolName lpn) {
1391         if (supportedInterfaceCapability == null) {
1392             return new ArrayList<>(List.of(new org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev221121
1393                     .service._interface.point.SupportedCepLayerProtocolQualifierInstancesBuilder()
1394                 .setLayerProtocolQualifier(PHOTONICLAYERQUALIFIEROTS.VALUE)
1395                 .setNumberOfCepInstances(Uint64.valueOf(1))
1396                 .build()));
1397         }
1398         List<org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev221121
1399             .service._interface.point.SupportedCepLayerProtocolQualifierInstances> sclpqiList = new ArrayList<>();
1400         for (SupportedInterfaceCapability sic : supportedInterfaceCapability) {
1401             String ifCapType = sic.getIfCapType().toString().split("\\{")[0];
1402             switch (lpn.getName()) {
1403                 case "ETH":
1404                 case "DSR":
1405                     switch (ifCapType) {
1406                         case "If1GEODU0":
1407                             sclpqiList.add(new org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev221121
1408                                     .service._interface.point.SupportedCepLayerProtocolQualifierInstancesBuilder()
1409                                 .setLayerProtocolQualifier(ODUTYPEODU0.VALUE)
1410                                 .setNumberOfCepInstances(Uint64.valueOf(0))
1411                                 .build());
1412                             sclpqiList.add(new org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev221121
1413                                     .service._interface.point.SupportedCepLayerProtocolQualifierInstancesBuilder()
1414                                 .setLayerProtocolQualifier(DIGITALSIGNALTYPEGigE.VALUE)
1415                                 .setNumberOfCepInstances(Uint64.valueOf(0))
1416                                 .build());
1417                             break;
1418                         case "If10GEODU2e":
1419                             sclpqiList.add(new org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev221121
1420                                     .service._interface.point.SupportedCepLayerProtocolQualifierInstancesBuilder()
1421                                 .setLayerProtocolQualifier(ODUTYPEODU2E.VALUE)
1422                                 .setNumberOfCepInstances(Uint64.valueOf(0))
1423                                 .build());
1424                             sclpqiList.add(new org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev221121
1425                                     .service._interface.point.SupportedCepLayerProtocolQualifierInstancesBuilder()
1426                                 .setLayerProtocolQualifier(DIGITALSIGNALTYPE10GigELAN.VALUE)
1427                                 .setNumberOfCepInstances(Uint64.valueOf(0))
1428                                 .build());
1429                             break;
1430                         case "If10GEODU2":
1431                             sclpqiList.add(new org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev221121
1432                                     .service._interface.point.SupportedCepLayerProtocolQualifierInstancesBuilder()
1433                                 .setLayerProtocolQualifier(ODUTYPEODU2.VALUE)
1434                                 .setNumberOfCepInstances(Uint64.valueOf(0))
1435                                 .build());
1436                             sclpqiList.add(new org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev221121
1437                                     .service._interface.point.SupportedCepLayerProtocolQualifierInstancesBuilder()
1438                                 .setLayerProtocolQualifier(DIGITALSIGNALTYPE10GigELAN.VALUE)
1439                                 .setNumberOfCepInstances(Uint64.valueOf(0))
1440                                 .build());
1441                             break;
1442                         case "If10GE":
1443                             sclpqiList.add(new org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev221121
1444                                     .service._interface.point.SupportedCepLayerProtocolQualifierInstancesBuilder()
1445                                 .setLayerProtocolQualifier(DIGITALSIGNALTYPE10GigELAN.VALUE)
1446                                 .setNumberOfCepInstances(Uint64.valueOf(0))
1447                                 .build());
1448                             break;
1449                         case "If100GEODU4":
1450                             sclpqiList.add(new org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev221121
1451                                     .service._interface.point.SupportedCepLayerProtocolQualifierInstancesBuilder()
1452                                 .setLayerProtocolQualifier(DIGITALSIGNALTYPE100GigE.VALUE)
1453                                 .setNumberOfCepInstances(Uint64.valueOf(0))
1454                                 .build());
1455                             sclpqiList.add(new org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev221121
1456                                     .service._interface.point.SupportedCepLayerProtocolQualifierInstancesBuilder()
1457                                 .setLayerProtocolQualifier(ODUTYPEODU4.VALUE)
1458                                 .setNumberOfCepInstances(Uint64.valueOf(0))
1459                                 .build());
1460                             break;
1461                         case "If100GE":
1462                             sclpqiList.add(new org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev221121
1463                                     .service._interface.point.SupportedCepLayerProtocolQualifierInstancesBuilder()
1464                                 .setLayerProtocolQualifier(DIGITALSIGNALTYPE100GigE.VALUE)
1465                                 .setNumberOfCepInstances(Uint64.valueOf(0))
1466                                 .build());
1467                             break;
1468                         case "IfOCHOTU4ODU4":
1469                         case "IfOCH":
1470                             sclpqiList.add(new org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev221121
1471                                     .service._interface.point.SupportedCepLayerProtocolQualifierInstancesBuilder()
1472                                 .setLayerProtocolQualifier(ODUTYPEODU4.VALUE)
1473                                 .setNumberOfCepInstances(Uint64.valueOf(0))
1474                                 .build());
1475                             break;
1476                         default:
1477                             LOG.error("IfCapability type not managed");
1478                             break;
1479                     }
1480                     break;
1481                 case "ODU":
1482                     switch (ifCapType) {
1483                         case "If1GEODU0":
1484                             sclpqiList.add(new org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev221121
1485                                     .service._interface.point.SupportedCepLayerProtocolQualifierInstancesBuilder()
1486                                 .setLayerProtocolQualifier(ODUTYPEODU0.VALUE)
1487                                 .setNumberOfCepInstances(Uint64.valueOf(0))
1488                                 .build());
1489                             break;
1490                         case "If10GEODU2e":
1491                             sclpqiList.add(new org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev221121
1492                                     .service._interface.point.SupportedCepLayerProtocolQualifierInstancesBuilder()
1493                                 .setLayerProtocolQualifier(ODUTYPEODU2E.VALUE)
1494                                 .setNumberOfCepInstances(Uint64.valueOf(0))
1495                                 .build());
1496                             break;
1497                         case "If10GEODU2":
1498                         case "If10GE":
1499                             sclpqiList.add(new org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev221121
1500                                     .service._interface.point.SupportedCepLayerProtocolQualifierInstancesBuilder()
1501                                 .setLayerProtocolQualifier(ODUTYPEODU2.VALUE)
1502                                 .setNumberOfCepInstances(Uint64.valueOf(0))
1503                                 .build());
1504                             break;
1505                         case "If100GEODU4":
1506                         case "If100GE":
1507                         case "IfOCHOTU4ODU4":
1508                         case "IfOCH":
1509                             sclpqiList.add(new org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev221121
1510                                     .service._interface.point.SupportedCepLayerProtocolQualifierInstancesBuilder()
1511                                 .setLayerProtocolQualifier(ODUTYPEODU4.VALUE)
1512                                 .setNumberOfCepInstances(Uint64.valueOf(0))
1513                                 .build());
1514                             break;
1515                         default:
1516                             LOG.error("IfCapability type not managed");
1517                             break;
1518                     }
1519                     break;
1520                 case "PHOTONIC_MEDIA":
1521                     switch (ifCapType) {
1522                         case "IfOCHOTUCnODUCn":
1523                         case "IfOtsiOtucnOducn":
1524                         case "IfOCHOTUCnODUCnRegen":
1525                         case "IfOCHOTUCnODUCnUniregen":
1526                             sclpqiList.add(new org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev221121
1527                                     .service._interface.point.SupportedCepLayerProtocolQualifierInstancesBuilder()
1528                                 .setLayerProtocolQualifier(ODUTYPEODUCN.VALUE)
1529                                 .setNumberOfCepInstances(Uint64.valueOf(1))
1530                                 .build());
1531                             sclpqiList.add(new org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev221121
1532                                     .service._interface.point.SupportedCepLayerProtocolQualifierInstancesBuilder()
1533                                 .setLayerProtocolQualifier(OTUTYPEOTUCN.VALUE)
1534                                 .setNumberOfCepInstances(Uint64.valueOf(1))
1535                                 .build());
1536                          //fallthrough
1537                         case "IfOCH":
1538                         case "IfOCHOTU4ODU4":
1539                         case "IfOCHOTU4ODU4Regen":
1540                         case "IfOCHOTU4ODU4Uniregen":
1541                             sclpqiList.add(new org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev221121
1542                                     .service._interface.point.SupportedCepLayerProtocolQualifierInstancesBuilder()
1543                                 .setLayerProtocolQualifier(PHOTONICLAYERQUALIFIEROTSiMC.VALUE)
1544                                 .setNumberOfCepInstances(Uint64.valueOf(1))
1545                                 .build());
1546                             sclpqiList.add(new org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev221121
1547                                     .service._interface.point.SupportedCepLayerProtocolQualifierInstancesBuilder()
1548                                 .setLayerProtocolQualifier(PHOTONICLAYERQUALIFIEROTS.VALUE)
1549                                 .setNumberOfCepInstances(Uint64.valueOf(1))
1550                                 .build());
1551                             break;
1552                         default:
1553                             break;
1554                     }
1555                     break;
1556                 default:
1557                     LOG.error("Layer Protocol Name is unknown");
1558                     break;
1559             }
1560         }
1561         return sclpqiList.stream().distinct().toList();
1562     }
1563
1564     public Map<NodeKey, org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.topology.Node>
1565             getTapiNodes() {
1566         return tapiNodes;
1567     }
1568
1569     public Map<LinkKey, Link> getTapiLinks() {
1570         return tapiLinks;
1571     }
1572
1573     public AdministrativeState transformAsToTapiAdminState(String adminState) {
1574         return adminState == null
1575             ? null
1576             : adminState.equals(AdminStates.InService.getName())
1577                     || adminState.equals(AdministrativeState.UNLOCKED.getName())
1578                 ? AdministrativeState.UNLOCKED : AdministrativeState.LOCKED;
1579     }
1580
1581     public OperationalState transformOsToTapiOperationalState(String operState) {
1582         return operState == null
1583             ? null
1584             : operState.equals("inService") || operState.equals(OperationalState.ENABLED.getName())
1585                 ? OperationalState.ENABLED : OperationalState.DISABLED;
1586     }
1587
1588     public Map<ServiceInterfacePointKey, ServiceInterfacePoint> getTapiSips() {
1589         return tapiSips;
1590     }
1591
1592     public void setTapiSips(Map<ServiceInterfacePointKey, ServiceInterfacePoint> tapiSip) {
1593         this.tapiSips.putAll(tapiSip);
1594     }
1595
1596 }