bpmn/MSOCommonBPMN/src/main/groovy/org/openecomp/mso/bpmn/common/scripts/NetworkUtils.groovy

   1 /*-\r
   2  * ============LICENSE_START=======================================================\r
   3  * ONAP - SO\r
   4  * ================================================================================\r
   5  * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.\r
   6  * ================================================================================\r
   7  * Licensed under the Apache License, Version 2.0 (the "License");\r
   8  * you may not use this file except in compliance with the License.\r
   9  * You may obtain a copy of the License at\r
  10  * \r
  11  *      http://www.apache.org/licenses/LICENSE-2.0\r
  12  * \r
  13  * Unless required by applicable law or agreed to in writing, software\r
  14  * distributed under the License is distributed on an "AS IS" BASIS,\r
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
  16  * See the License for the specific language governing permissions and\r
  17  * limitations under the License.\r
  18  * ============LICENSE_END=========================================================\r
  19  */\r
  20 \r
  21 package org.openecomp.mso.bpmn.common.scripts;\r
  22 \r
  23 import org.apache.commons.lang3.*\r
  24 \r
  25 import groovy.xml.XmlUtil\r
  26 \r
  27 import javax.xml.parsers.DocumentBuilder\r
  28 import javax.xml.parsers.DocumentBuilderFactory\r
  29 import javax.xml.transform.Transformer\r
  30 import javax.xml.transform.TransformerFactory\r
  31 import javax.xml.transform.TransformerException\r
  32 import javax.xml.transform.dom.DOMSource\r
  33 import javax.xml.transform.stream.StreamResult\r
  34 \r
  35 import org.camunda.bpm.engine.delegate.BpmnError\r
  36 import org.camunda.bpm.engine.delegate.DelegateExecution\r
  37 import org.w3c.dom.Document\r
  38 import org.w3c.dom.Element\r
  39 \r
  40 import org.w3c.dom.NamedNodeMap\r
  41 import org.w3c.dom.Node\r
  42 import org.w3c.dom.NodeList;\r
  43 import org.xml.sax.InputSource\r
  44 \r
  45 import org.camunda.bpm.engine.delegate.BpmnError\r
  46 import org.camunda.bpm.engine.delegate.DelegateExecution\r
  47 import org.openecomp.mso.bpmn.common.scripts.AbstractServiceTaskProcessor;\r
  48 import org.w3c.dom.Document\r
  49 import org.w3c.dom.Element\r
  50 import org.w3c.dom.NamedNodeMap\r
  51 import org.w3c.dom.Node\r
  52 import org.w3c.dom.NodeList;\r
  53 import org.xml.sax.InputSource\r
  54 \r
  55 \r
  56 /**\r
  57  * This groovy class supports the any Network processes that need the methods defined here.\r
  58  */\r
  59 class NetworkUtils {\r
  60 \r
  61         public MsoUtils utils = new MsoUtils()\r
  62         private AbstractServiceTaskProcessor taskProcessor\r
  63 \r
  64         public NetworkUtils(AbstractServiceTaskProcessor taskProcessor) {\r
  65                 this.taskProcessor = taskProcessor\r
  66         }\r
  67 \r
  68         /**\r
  69          * This method returns the string for Network request\r
  70          * V2 for Contrail 3.x will populate cloud-region data in same cloudSiteId filed\r
  71          * Network adapter will handle it properly\r
  72          * @param requestId either 'request-id' or 'mso-request-id'\r
  73          * @param requestInput the request in the process\r
  74          * @param queryIdResponse the response of REST AAI query by Id\r
  75          * @param routeCollection the collection\r
  76          * @param policyFqdns the policy\r
  77          * @param tableCollection the collection\r
  78          * @param cloudRegionId the cloud-region-region\r
  79          * @return String request\r
  80          */\r
  81         def CreateNetworkRequestV2(execution, requestId, messageId, requestInput, queryIdResponse, routeCollection, policyFqdns, tableCollection, cloudRegionId, backoutOnFailure, source) {\r
  82                 String createNetworkRequest = null\r
  83                 if(requestInput!=null && queryIdResponse!=null) {\r
  84                                 String serviceInstanceId = ""\r
  85                                 String sharedValue = ""\r
  86                                 String externalValue = ""\r
  87 \r
  88                                 if (source == "VID") {\r
  89                                         sharedValue = utils.getNodeText1(queryIdResponse, "is-shared-network") != null ? utils.getNodeText1(queryIdResponse, "is-shared-network") : "false"\r
  90                                         externalValue = utils.getNodeText1(queryIdResponse, "is-external-network") != null ? utils.getNodeText1(queryIdResponse, "is-external-network") : "false"\r
  91                                         serviceInstanceId = utils.getNodeText1(requestInput, "service-instance-id")\r
  92 \r
  93                                 } else { // source = 'PORTAL'\r
  94                                         sharedValue = getParameterValue(requestInput, "shared")\r
  95                                         externalValue = getParameterValue(requestInput, "external")\r
  96                                         serviceInstanceId = utils.getNodeText1(requestInput, "service-instance-id") != null ? utils.getNodeText1(requestInput, "service-instance-id") : ""\r
  97                                 }\r
  98 \r
  99                                 String networkParams = ""\r
 100                                 if (utils.nodeExists(requestInput, "network-params")) {\r
 101                                         String netParams = utils.getNodeXml(requestInput, "network-params", false).replace("tag0:","").replace(":tag0","")\r
 102                                         networkParams = buildParams(netParams)\r
 103                                 }\r
 104 \r
 105                                 String failIfExists = "false"\r
 106                                 // requestInput\r
 107                                 String cloudRegion = cloudRegionId\r
 108                                 String tenantId = utils.getNodeText1(requestInput, "tenant-id")\r
 109 \r
 110                                 String networkType = ""\r
 111                                 String modelCustomizationUuid = ""\r
 112                                 if (utils.nodeExists(requestInput, "networkModelInfo")) {\r
 113                                         String networkModelInfo = utils.getNodeXml(requestInput, "networkModelInfo", false).replace("tag0:","").replace(":tag0","")\r
 114                                         networkType = utils.getNodeText1(networkModelInfo, "modelName")\r
 115                                         modelCustomizationUuid = utils.getNodeText1(networkModelInfo, "modelCustomizationUuid")\r
 116                                 } else {\r
 117                                         networkType = utils.getNodeText1(queryIdResponse, "network-type")\r
 118                                         modelCustomizationUuid = utils.getNodeText1(requestInput, "modelCustomizationId")\r
 119                                 }\r
 120 \r
 121                                 // queryIdResponse\r
 122                                 String networkName = utils.getNodeText1(queryIdResponse, "network-name")\r
 123                                 String networkId = utils.getNodeText1(queryIdResponse, "network-id")\r
 124                                 String networkTechnology = utils.getNodeText1(queryIdResponse, "network-technology")\r
 125 \r
 126                                 // contrailNetwork - networkTechnology = 'Contrail' vs. 'AIC_SR_IOV')\r
 127                                 String contrailNetwork = ""\r
 128                                 if (networkTechnology.contains('Contrail') || networkTechnology.contains('contrail') || networkTechnology.contains('CONTRAIL')) {\r
 129                                         contrailNetwork = """<contrailNetwork>\r
 130                                                                <shared>${sharedValue}</shared>\r
 131                                                                <external>${externalValue}</external>\r
 132                                                                ${routeCollection}\r
 133                                                                ${policyFqdns}\r
 134                                                                ${tableCollection}\r
 135                                                          </contrailNetwork>"""\r
 136                                         networkTechnology = "CONTRAIL"    // replace\r
 137                             }\r
 138 \r
 139                                 // rebuild subnets\r
 140                                 String subnets = ""\r
 141                                 if (utils.nodeExists(queryIdResponse, "subnets")) {\r
 142                                         def subnetsGroup = utils.getNodeXml(queryIdResponse, "subnets", false)\r
 143                                         subnets = buildSubnets(subnetsGroup)\r
 144                                 }\r
 145 \r
 146                                 String physicalNetworkName = ""\r
 147                                 physicalNetworkName = utils.getNodeText1(queryIdResponse, "physical-network-name")\r
 148 \r
 149                                 String vlansCollection = buildVlans(queryIdResponse)\r
 150 \r
 151                                 String notificationUrl = ""                                   //TODO - is this coming from URN? What variable/value to use?\r
 152                                 //String notificationUrl = execution.getVariable("URN_?????") //TODO - is this coming from URN? What variable/value to use?\r
 153 \r
 154                                 createNetworkRequest = """\r
 155                                                                 <createNetworkRequest>\r
 156                                                                         <cloudSiteId>${cloudRegion}</cloudSiteId>\r
 157                                                                         <tenantId>${tenantId}</tenantId>\r
 158                                                                         <networkId>${networkId}</networkId>\r
 159                                                                         <networkName>${networkName}</networkName>\r
 160                                                                         <networkType>${networkType}</networkType>\r
 161                                                                         <modelCustomizationUuid>${modelCustomizationUuid}</modelCustomizationUuid>\r
 162                                                                         <networkTechnology>${networkTechnology}</networkTechnology>\r
 163                                                                         <providerVlanNetwork>\r
 164                                                                                 <physicalNetworkName>${physicalNetworkName}</physicalNetworkName >\r
 165                                                                                 ${vlansCollection}\r
 166                                                                         </providerVlanNetwork>\r
 167                                     ${contrailNetwork}\r
 168                                                                         ${subnets}\r
 169                                                                         <skipAAI>true</skipAAI>\r
 170                                                                         <backout>${backoutOnFailure}</backout>\r
 171                                                                         <failIfExists>${failIfExists}</failIfExists>\r
 172                                                                         ${networkParams}\r
 173                                                                         <msoRequest>\r
 174                                                                                 <requestId>${requestId}</requestId>\r
 175                                                                                 <serviceInstanceId>${serviceInstanceId}</serviceInstanceId>\r
 176                                                                 </msoRequest>\r
 177                                                                         <messageId>${messageId}</messageId>\r
 178                                                                         <notificationUrl>${notificationUrl}</notificationUrl>\r
 179                                                                 </createNetworkRequest>\r
 180                                                                 """.trim()\r
 181                 }\r
 182                 return createNetworkRequest\r
 183 \r
 184         }\r
 185 \r
 186         /**\r
 187          * This method returns the string for Network request\r
 188          * V2 for Contrail 3.x will populate cloud-region data in same cloudSiteId filed\r
 189          * Network adapter will handle it properly\r
 190          * @param requestId either 'request-id' or 'mso-request-id'\r
 191          * @param requestInput the request in the process\r
 192          * @param queryIdResponse the response of REST AAI query by Id\r
 193          * @param routeCollection the collection\r
 194          * @param policyFqdns the policy\r
 195          * @param cloudRegionId the cloud-region-region\r
 196          * @return String request\r
 197          */\r
 198         def UpdateNetworkRequestV2(execution, requestId, messageId, requestInput, queryIdResponse, routeCollection, policyFqdns, tableCollection, cloudRegionId, backoutOnFailure, source) {\r
 199                 String updateNetworkRequest = null\r
 200                 if(requestInput!=null && queryIdResponse!=null) {\r
 201                                 String serviceInstanceId = ""\r
 202                                 String sharedValue = ""\r
 203                                 String externalValue = ""\r
 204 \r
 205                                 if (source == "VID") {\r
 206                                         sharedValue = utils.getNodeText1(queryIdResponse, "is-shared-network") != null ? utils.getNodeText1(queryIdResponse, "is-shared-network") : "false"\r
 207                                         externalValue = utils.getNodeText1(queryIdResponse, "is-external-network") != null ? utils.getNodeText1(queryIdResponse, "is-external-network") : "false"\r
 208                                         serviceInstanceId = utils.getNodeText1(requestInput, "service-instance-id")\r
 209 \r
 210                                 } else { // source = 'PORTAL'\r
 211                                         sharedValue = getParameterValue(requestInput, "shared")\r
 212                                         externalValue = getParameterValue(requestInput, "external")\r
 213                                         serviceInstanceId = utils.getNodeText1(requestInput, "service-instance-id") != null ? utils.getNodeText1(requestInput, "service-instance-id") : ""\r
 214                                 }\r
 215 \r
 216                                 String failIfExists = "false"\r
 217                                 // requestInput\r
 218                                 String cloudRegion = cloudRegionId\r
 219                                 String tenantId = utils.getNodeText1(requestInput, "tenant-id")\r
 220 \r
 221                                 // queryIdResponse\r
 222                                 String networkName = utils.getNodeText1(queryIdResponse, "network-name")\r
 223                                 String networkId = utils.getNodeText1(queryIdResponse, "network-id")\r
 224                                 \r
 225                                 String networkType = ""\r
 226                                 String modelCustomizationUuid = ""\r
 227                                 if (utils.nodeExists(requestInput, "networkModelInfo")) {\r
 228                                         String networkModelInfo = utils.getNodeXml(requestInput, "networkModelInfo", false).replace("tag0:","").replace(":tag0","")\r
 229                                         networkType = utils.getNodeText1(networkModelInfo, "modelName")\r
 230                                         modelCustomizationUuid = utils.getNodeText1(networkModelInfo, "modelCustomizationUuid")\r
 231                                 } else {\r
 232                                         networkType = utils.getNodeText1(queryIdResponse, "network-type")\r
 233                                         modelCustomizationUuid = utils.getNodeText1(requestInput, "modelCustomizationId")\r
 234                                 }\r
 235 \r
 236                                 // rebuild subnets\r
 237                                 String subnets = ""\r
 238                                 if (utils.nodeExists(queryIdResponse, "subnets")) {\r
 239                                         def subnetsGroup = utils.getNodeXml(queryIdResponse, "subnets", false)\r
 240                                         subnets = buildSubnets(subnetsGroup)\r
 241                                 }\r
 242 \r
 243                                 String networkParams = ""\r
 244                                 if (utils.nodeExists(requestInput, "network-params")) {\r
 245                                         String netParams = utils.getNodeXml(requestInput, "network-params", false).replace("tag0:","").replace(":tag0","")\r
 246                                         networkParams = buildParams(netParams)\r
 247                                 }\r
 248 \r
 249                                 String networkStackId = utils.getNodeText1(queryIdResponse, "heat-stack-id")\r
 250                                 if (networkStackId == 'null' || networkStackId == "" || networkStackId == null) {\r
 251                                         networkStackId = "force_update"\r
 252                                 }\r
 253 \r
 254                                 String physicalNetworkName = utils.getNodeText1(queryIdResponse, "physical-network-name")\r
 255                                 String vlansCollection = buildVlans(queryIdResponse)\r
 256 \r
 257                                 updateNetworkRequest =\r
 258                          """<updateNetworkRequest>\r
 259                                                                 <cloudSiteId>${cloudRegion}</cloudSiteId>\r
 260                                                                 <tenantId>${tenantId}</tenantId>\r
 261                                                                 <networkId>${networkId}</networkId>\r
 262                                                         <networkStackId>${networkStackId}</networkStackId>\r
 263                                                                 <networkName>${networkName}</networkName>\r
 264                                                                 <networkType>${networkType}</networkType>\r
 265                                                                 <modelCustomizationUuid>${modelCustomizationUuid}</modelCustomizationUuid>\r
 266                                                                 <networkTypeVersion/>\r
 267                                                                 <networkTechnology>CONTRAIL</networkTechnology>\r
 268                                                                 <providerVlanNetwork>\r
 269                                                                         <physicalNetworkName>${physicalNetworkName}</physicalNetworkName>\r
 270                                                                         ${vlansCollection}\r
 271                                                                 </providerVlanNetwork>\r
 272                                                                 <contrailNetwork>\r
 273                                                                         <shared>${sharedValue}</shared>\r
 274                                                                         <external>${externalValue}</external>\r
 275                                                                         ${routeCollection}\r
 276                                                                         ${policyFqdns}\r
 277                                                                         ${tableCollection}\r
 278                                                                 </contrailNetwork>\r
 279                                                                 ${subnets}\r
 280                                                                 <skipAAI>true</skipAAI>\r
 281                                                                 <backout>${backoutOnFailure}</backout>\r
 282                                                                 <failIfExists>${failIfExists}</failIfExists>\r
 283                                                                         ${networkParams}\r
 284 \r
 285                                                                 <msoRequest>\r
 286                                                                   <requestId>${requestId}</requestId>\r
 287                                                                   <serviceInstanceId>${serviceInstanceId}</serviceInstanceId>\r
 288                                                                 </msoRequest>\r
 289                                                                 <messageId>${messageId}</messageId>\r
 290                                                                 <notificationUrl></notificationUrl>\r
 291                                                         </updateNetworkRequest>""".trim()\r
 292 \r
 293                 }\r
 294                 return updateNetworkRequest\r
 295 \r
 296         }\r
 297 \r
 298         /**\r
 299          * This method returns the string for Create Volume Request payload\r
 300          * @param groupId the volume-group-id\r
 301          * @param volumeName the volume-group-name\r
 302          * @param vnfType the vnf-type\r
 303          * @param tenantId the value of relationship-key 'tenant.tenant-id'\r
 304          * @return String request payload\r
 305          */\r
 306         def String CreateNetworkVolumeRequest(groupId, volumeName, vnfType, tenantId) {\r
 307 \r
 308                 String requestPayload =\r
 309                 """<volume-group xmlns="http://org.openecomp.mso/v6">\r
 310                                 <volume-group-id>${groupId}</volume-group-id>\r
 311                                 <volume-group-name>${volumeName}</volume-group-name>\r
 312                                 <heat-stack-id></heat-stack-id>\r
 313                                 <vnf-type>${vnfType}</vnf-type>\r
 314                                 <orchestration-status>Pending</orchestration-status>\r
 315                                 <relationship-list>\r
 316                                    <relationship>\r
 317                                            <related-to>tenant</related-to>\r
 318                                            <relationship-data>\r
 319                                                    <relationship-key>tenant.tenant-id</relationship-key>\r
 320                                                    <relationship-value>${tenantId}</relationship-value>\r
 321                                            </relationship-data>\r
 322                                    </relationship>\r
 323                            </relationship-list>\r
 324                    </volume-group>"""\r
 325 \r
 326                 return requestPayload\r
 327         }\r
 328 \r
 329         def String createCloudRegionVolumeRequest(groupId, volumeName, vnfType, tenantId, cloudRegion, namespace, modelCustomizationId) {\r
 330 \r
 331                                 String requestPayload =\r
 332                                 """<volume-group xmlns="${namespace}">\r
 333                                 <volume-group-id>${groupId}</volume-group-id>\r
 334                                 <volume-group-name>${volumeName}</volume-group-name>\r
 335                                 <heat-stack-id></heat-stack-id>\r
 336                                 <vnf-type>${vnfType}</vnf-type>\r
 337                                 <orchestration-status>Pending</orchestration-status>\r
 338                                 <vf-module-model-customization-id>${modelCustomizationId}</vf-module-model-customization-id>\r
 339                                 <relationship-list>\r
 340                                    <relationship>\r
 341                                            <related-to>tenant</related-to>\r
 342                                            <relationship-data>\r
 343                                                    <relationship-key>tenant.tenant-id</relationship-key>\r
 344                                                    <relationship-value>${tenantId}</relationship-value>\r
 345                                            </relationship-data>\r
 346                                            <relationship-data>\r
 347                                                    <relationship-key>cloud-region.cloud-owner</relationship-key>\r
 348                                                    <relationship-value>att-aic</relationship-value>\r
 349                                            </relationship-data>\r
 350                                            <relationship-data>\r
 351                                                    <relationship-key>cloud-region.cloud-region-id</relationship-key>\r
 352                                                    <relationship-value>${cloudRegion}</relationship-value>\r
 353                                            </relationship-data>\r
 354                                    </relationship>\r
 355                            </relationship-list>\r
 356                    </volume-group>"""\r
 357 \r
 358                                 return requestPayload\r
 359                         }\r
 360 \r
 361         def String createCloudRegionVolumeRequest(groupId, volumeName, vnfType, vnfId, tenantId, cloudRegion, namespace, modelCustomizationId) {\r
 362 \r
 363                 String requestPayload =\r
 364                 """<volume-group xmlns="${namespace}">\r
 365                         <volume-group-id>${groupId}</volume-group-id>\r
 366                         <volume-group-name>${volumeName}</volume-group-name>\r
 367                         <heat-stack-id></heat-stack-id>\r
 368                         <vnf-type>${vnfType}</vnf-type>\r
 369                         <orchestration-status>Pending</orchestration-status>\r
 370                         <vf-module-model-customization-id>${modelCustomizationId}</vf-module-model-customization-id>\r
 371                         <relationship-list>\r
 372                                 <relationship>\r
 373                                    <related-to>generic-vnf</related-to>\r
 374                                    <relationship-data>\r
 375                                            <relationship-key>generic-vnf.vnf-id</relationship-key>\r
 376                                            <relationship-value>${vnfId}</relationship-value>\r
 377                                    </relationship-data>\r
 378                            </relationship>\r
 379                            <relationship>\r
 380                                    <related-to>tenant</related-to>\r
 381                                    <relationship-data>\r
 382                                            <relationship-key>tenant.tenant-id</relationship-key>\r
 383                                            <relationship-value>${tenantId}</relationship-value>\r
 384                                    </relationship-data>\r
 385                                    <relationship-data>\r
 386                                            <relationship-key>cloud-region.cloud-owner</relationship-key>\r
 387                                            <relationship-value>att-aic</relationship-value>\r
 388                                    </relationship-data>\r
 389                                    <relationship-data>\r
 390                                            <relationship-key>cloud-region.cloud-region-id</relationship-key>\r
 391                                            <relationship-value>${cloudRegion}</relationship-value>\r
 392                                    </relationship-data>\r
 393                            </relationship>\r
 394                    </relationship-list>\r
 395                 </volume-group>"""\r
 396 \r
 397                 return requestPayload\r
 398         }\r
 399 \r
 400 \r
 401         /**\r
 402          * This method returns the string for Update Volume Request payload\r
 403          * @param requeryAAIVolGrpNameResponse the response of query volume group name (in AAI)\r
 404           * @param heatStackId the value of heat stack id\r
 405          * @return String request payload\r
 406          */\r
 407         def String updateCloudRegionVolumeRequest(requeryAAIVolGrpNameResponse, heatStackId, namespace, modelCustomizationId) {\r
 408                 String requestPayload = ""\r
 409                 if (requeryAAIVolGrpNameResponse != null) {\r
 410                         def groupId = utils.getNodeText(requeryAAIVolGrpNameResponse, "volume-group-id")\r
 411                         def volumeName = utils.getNodeText(requeryAAIVolGrpNameResponse, "volume-group-name")\r
 412                         def vnfType = utils.getNodeText(requeryAAIVolGrpNameResponse, "vnf-type")\r
 413                         def resourceVersion = utils.getNodeText(requeryAAIVolGrpNameResponse, "resource-version")\r
 414                         def relationshipList = ""\r
 415                         if (utils.nodeExists(requeryAAIVolGrpNameResponse, "relationship")) {\r
 416                                 relationshipList = rebuildRelationship(requeryAAIVolGrpNameResponse)\r
 417                         }\r
 418 \r
 419                         requestPayload =\r
 420                                 """<volume-group xmlns="${namespace}">\r
 421                                         <volume-group-id>${groupId}</volume-group-id>\r
 422                                         <volume-group-name>${volumeName}</volume-group-name>\r
 423                                         <heat-stack-id>${heatStackId}</heat-stack-id>\r
 424                                         <vnf-type>${vnfType}</vnf-type>\r
 425                                         <orchestration-status>Active</orchestration-status>\r
 426                                         <resource-version>${resourceVersion}</resource-version>\r
 427                                         <vf-module-model-customization-id>${modelCustomizationId}</vf-module-model-customization-id>\r
 428                                         ${relationshipList}\r
 429                                  </volume-group>"""\r
 430                 }\r
 431 \r
 432                 return requestPayload\r
 433         }\r
 434 \r
 435 \r
 436         /**\r
 437          * This method returns the string for Update Volume Request payload\r
 438          * @param requeryAAIVolGrpNameResponse the response of query volume group name (in AAI)\r
 439          * @param heatStackId the value of heat stack id\r
 440          * @return String request payload\r
 441          */\r
 442         def String UpdateNetworkVolumeRequest(requeryAAIVolGrpNameResponse, heatStackId) {\r
 443                 String requestPayload = ""\r
 444                 if (requeryAAIVolGrpNameResponse != null) {\r
 445                         def groupId = utils.getNodeText(requeryAAIVolGrpNameResponse, "volume-group-id")\r
 446                         def volumeName = utils.getNodeText(requeryAAIVolGrpNameResponse, "volume-group-name")\r
 447                         def vnfType = utils.getNodeText(requeryAAIVolGrpNameResponse, "vnf-type")\r
 448                         def resourceVersion = utils.getNodeText(requeryAAIVolGrpNameResponse, "resource-version")\r
 449                         def relationshipList = ""\r
 450                         if (utils.nodeExists(requeryAAIVolGrpNameResponse, "relationship")) {\r
 451                                 relationshipList = rebuildRelationship(requeryAAIVolGrpNameResponse)\r
 452                         }\r
 453 \r
 454                         requestPayload =\r
 455                                 """<volume-group xmlns="http://org.openecomp.mso/v6">\r
 456                                         <volume-group-id>${groupId}</volume-group-id>\r
 457                                         <volume-group-name>${volumeName}</volume-group-name>\r
 458                                         <heat-stack-id>${heatStackId}</heat-stack-id>\r
 459                                         <vnf-type>${vnfType}</vnf-type>\r
 460                                         <orchestration-status>Active</orchestration-status>\r
 461                                         <resource-version>${resourceVersion}</resource-version>\r
 462                                         ${relationshipList}\r
 463                                  </volume-group>"""\r
 464                 }\r
 465 \r
 466                 return requestPayload\r
 467         }\r
 468 \r
 469         /**\r
 470          * This method returns the string for Create Contrail Network payload\r
 471          * @param requeryIdAAIResponse the response from AAI query by id\r
 472          * @param createNetworkResponse the response of create network\r
 473          * @return String contrailNetworkCreatedUpdate\r
 474          */\r
 475         def ContrailNetworkCreatedUpdate(requeryIdAAIResponse, createNetworkResponse, schemaVersion) {\r
 476 \r
 477                 String contrailNetworkCreatedUpdate = ""\r
 478                 if(requeryIdAAIResponse!=null && createNetworkResponse!=null) {\r
 479 \r
 480                         def l3Network = utils.getNodeXml(requeryIdAAIResponse, "l3-network", false).replace("tag0:","").replace(":tag0","")\r
 481                         def createNetworkContrailResponse = ""\r
 482                         if (utils.nodeExists(createNetworkResponse, 'createNetworkResponse')) {\r
 483                            createNetworkContrailResponse = utils.getNodeXml(createNetworkResponse, "createNetworkResponse", false).replace("tag0:","").replace(":tag0","")\r
 484                         } else {\r
 485                            createNetworkContrailResponse = utils.getNodeXml(createNetworkResponse, "updateNetworkContrailResponse", false).replace("tag0:","").replace(":tag0","")\r
 486                         }\r
 487 \r
 488                         // rebuild network\r
 489                         def networkList = ["network-id", "network-name", "network-type", "network-role", "network-technology", "neutron-network-id", "is-bound-to-vpn", "service-id", "network-role-instance", "resource-version", "resource-model-uuid", "orchestration-status", "heat-stack-id", "mso-catalog-key", "contrail-network-fqdn",\r
 490                                                              "physical-network-name", "is-provider-network", "is-shared-network", "is-external-network"]\r
 491                         String rebuildNetworkElements = buildNetworkElements(l3Network, createNetworkContrailResponse, networkList)\r
 492 \r
 493                         // rebuild 'subnets'\r
 494                         def rebuildSubnetList = ""\r
 495                         if (utils.nodeExists(requeryIdAAIResponse, 'subnet')) {\r
 496                              rebuildSubnetList = buildSubnets(requeryIdAAIResponse, createNetworkResponse)\r
 497                         }\r
 498 \r
 499                         // rebuild 'segmentation-assignments'\r
 500                         def rebuildSegmentationAssignments = ""\r
 501                         if (utils.nodeExists(requeryIdAAIResponse, 'segmentation-assignments')) {\r
 502                                 List elementList = ["segmentation-id", "resource-version"]\r
 503                                 if (utils.nodeExists(requeryIdAAIResponse, 'segmentation-assignment')) {  // new tag\r
 504                                     rebuildSegmentationAssignments =  buildXMLElements(requeryIdAAIResponse, "segmentation-assignments", "segmentation-assignment", elementList)\r
 505                                 } else {\r
 506                                    rebuildSegmentationAssignments =  buildXMLElements(requeryIdAAIResponse, "", "segmentation-assignments", elementList)\r
 507                                 }   \r
 508                         }\r
 509 \r
 510                         // rebuild 'ctag-assignments' / rebuildCtagAssignments\r
 511                         def rebuildCtagAssignmentsList = ""\r
 512                         if (utils.nodeExists(requeryIdAAIResponse, 'ctag-assignment')) {\r
 513                                 rebuildCtagAssignmentsList = rebuildCtagAssignments(requeryIdAAIResponse)\r
 514                         }\r
 515 \r
 516                         // rebuild 'relationship'\r
 517                         def relationshipList = ""\r
 518                         if (utils.nodeExists(requeryIdAAIResponse, 'relationship-list')) {\r
 519                                 String rootRelationshipData = getFirstNodeXml(requeryIdAAIResponse, "relationship-list").drop(38).trim().replace("tag0:","").replace(":tag0","")\r
 520                                 if (utils.nodeExists(rootRelationshipData, 'relationship')) {\r
 521                                         relationshipList = rebuildRelationship(rootRelationshipData)\r
 522                                 }\r
 523                         }\r
 524 \r
 525                         //Check for optional contrail network fqdn within CreateNetworkResponse\r
 526                         String contrailNetworkFQDN\r
 527                         if(utils.nodeExists(createNetworkResponse, "contrail-network-fqdn")){\r
 528                                 contrailNetworkFQDN = utils.getNodeXml(createNetworkResponse, "contrail-network-fqdn")\r
 529                                 contrailNetworkFQDN = utils.removeXmlNamespaces(contrailNetworkFQDN)\r
 530                                 contrailNetworkFQDN = utils.removeXmlPreamble(contrailNetworkFQDN)\r
 531                         }else{\r
 532                                 contrailNetworkFQDN = ""\r
 533                         }\r
 534 \r
 535                         contrailNetworkCreatedUpdate =\r
 536                                  """<l3-network xmlns="${schemaVersion}">\r
 537                                                 ${rebuildNetworkElements}\r
 538                                                 ${rebuildSubnetList}\r
 539                                                 ${rebuildSegmentationAssignments}\r
 540                                                 ${rebuildCtagAssignmentsList}\r
 541                                                 ${relationshipList}\r
 542                                                 ${contrailNetworkFQDN}\r
 543                                       </l3-network>""".trim()\r
 544 \r
 545                 }\r
 546                         return contrailNetworkCreatedUpdate\r
 547         }\r
 548 \r
 549 \r
 550 \r
 551         /**\r
 552          * This method returns the value for the name paramName.\r
 553          *   Ex:   <network-params>\r
 554          *            <param name="shared">1</param>\r
 555          *            <param name="external">0</external>\r
 556          *         </network-params>\r
 557          *\r
 558          * @param xmlInput the XML document\r
 559          * @param paramName the param name (ex: 'shared')\r
 560          * @return a param value for 'shared' (ex: '1')\r
 561          */\r
 562         def getParameterValue(xmlInput, paramName) {\r
 563                 def rtn=""\r
 564                 if(xmlInput!=null){\r
 565                         def xml= new XmlSlurper().parseText(xmlInput)\r
 566                         rtn= xml.'**'.find {param->param.'@name'.text() == paramName}\r
 567                 }\r
 568                 if (rtn==null) {\r
 569                         return ""\r
 570                 } else {\r
 571                    return rtn\r
 572                 }\r
 573         }\r
 574 \r
 575         /**\r
 576          * This method returns the name of param if found/match with paramName.\r
 577          *   Ex:   <network-params>\r
 578          *            <param name="shared">1</param>\r
 579          *            <param name="external">0</external>\r
 580          *         </network-params>\r
 581          *\r
 582          * @param xmlInput the XML document\r
 583          * @param paramName the param name (ex: 'shared', )\r
 584          * @return a param name for 'shared' (ex: 'shared' if found)\r
 585          */\r
 586         def getParameterName(xmlInput, paramName) {\r
 587                 def rtn=""\r
 588                 if(xmlInput!=null){\r
 589                         def xml= new XmlSlurper().parseText(xmlInput)\r
 590                         try {\r
 591                                 rtn= xml.'**'.find {param->param.'@name' == paramName}.'@name'\r
 592                         } catch (Exception ex) {\r
 593                             rtn=""\r
 594                         }\r
 595                 }\r
 596                 if (rtn==null || rtn=="") {\r
 597                         return ""\r
 598                 } else {\r
 599                    return rtn\r
 600                 }\r
 601         }\r
 602 \r
 603         /**\r
 604          * This method returns the networkParams xml string.\r
 605          *   Ex: input:\r
 606          *         <network-params>\r
 607          *            <param name="shared">1</param>\r
 608          *            <param name="external">0</external>\r
 609          *         </network-params>\r
 610          *\r
 611          *   Sample result:\r
 612          *         <networkParams>\r
 613      *            <shared>1</shared>\r
 614      *            <external>0</external>\r
 615      *         </networkParams>\r
 616      *\r
 617          */\r
 618 \r
 619         def buildParams(networkParams) {\r
 620                 def build = ""\r
 621                         def netParams = new XmlParser().parseText(networkParams)\r
 622                         try {\r
 623                                 def paramsList = netParams.'**'.findAll {param->param.'@name'}.'@name'\r
 624                                 if (paramsList.size() > 0) {\r
 625                                         build += "<networkParams>"\r
 626                                         for (i in 0..paramsList.size()-1) {\r
 627                         def name = netParams.'**'.find {param->param.'@name' == paramsList[i]}.'@name'\r
 628                                                 def value= netParams.'**'.find {param->param.'@name' == paramsList[i]}.text()\r
 629                                                 build += "<${name}>${value}</${name}>"\r
 630                                         }\r
 631                                         build += "</networkParams>"\r
 632                                 }\r
 633 \r
 634                         } catch (Exception ex) {\r
 635                                 println ' buildParams error - ' + ex.getMessage()\r
 636                                 build = ""\r
 637                         }\r
 638                 return build\r
 639         }\r
 640 \r
 641         def getVlans(xmlInput) {\r
 642                 def rtn = ""\r
 643                 if (xmlInput!=null) {\r
 644                         def vlansList = getListWithElements(xmlInput, 'vlans')\r
 645                         def vlansListSize = vlansList.size()\r
 646                         if (vlansListSize > 0) {\r
 647                                 for (i in 0..vlansListSize-1) {\r
 648                                    rtn += '<vlans>'+vlansList[i]+'</vlans>'\r
 649                                 }\r
 650                         }\r
 651                 }\r
 652                 return rtn\r
 653 \r
 654 \r
 655         }\r
 656 \r
 657         /**\r
 658          * This method returns the uri value for the vpn bindings.\r
 659          * Return the a list of value of vpn binding in the <related-link> string.\r
 660          * Ex.\r
 661          *   <relationship-list>\r
 662          *      <relationship>\r
 663          *          <related-to>vpn-binding</related-to>\r
 664          *          <related-link>https://aai-app-e2e.test.openecomp.com:8443/aai/v6/network/vpn-bindings/vpn-binding/85f015d0-2e32-4c30-96d2-87a1a27f8017/</related-link>\r
 665          *          <relationship-data>\r
 666          *             <relationship-key>vpn-binding.vpn-id</relationship-key>\r
 667          *             <relationship-value>85f015d0-2e32-4c30-96d2-87a1a27f8017</relationship-value>\r
 668          *          </relationship-data>\r
 669          *       </relationship>\r
 670          *              <relationship>\r
 671          *              <related-to>vpn-binding</related-to>\r
 672          *                      <related-link>https://aai-ext1.test.openecomp.com:8443/aai/v6/network/vpn-bindings/vpn-binding/24a4b507-853a-4a38-99aa-05fcc54be24d/</related-link>\r
 673          *                      <relationship-data>\r
 674          *                         <relationship-key>vpn-binding.vpn-id</relationship-key>\r
 675          *                         <relationship-value>24a4b507-853a-4a38-99aa-05fcc54be24d</relationship-value>\r
 676          *                  </relationship-data>\r
 677          *                      <related-to-property>\r
 678          *                        <property-key>vpn-binding.vpn-name</property-key>\r
 679          *                        <property-value>oam_protected_net_6_MTN5_msotest1</property-value>\r
 680          *                      </related-to-property>\r
 681          *              </relationship>\r
 682          * @param xmlInput the XML document\r
 683          * @return a list of vpn binding values\r
 684          *            ex: ['aai/v6/network/vpn-bindings/vpn-binding/85f015d0-2e32-4c30-96d2-87a1a27f8017/', 'aai/v6/network/vpn-bindings/vpn-binding/c980a6ef-3b88-49f0-9751-dbad8608d0a6/']\r
 685          *\r
 686          **/\r
 687         def getVnfBindingObject(xmlInput) {\r
 688                 //def rtn = null\r
 689                 List rtn = []\r
 690                 if (xmlInput!=null) {\r
 691                         def relationshipList = getListWithElements(xmlInput, 'relationship')\r
 692                         def relationshipListSize = relationshipList.size()\r
 693                         if (relationshipListSize > 0) {\r
 694                                 for (i in 0..relationshipListSize-1) {\r
 695                                    def relationshipXml = XmlUtil.serialize(relationshipList[i])\r
 696                                    if (utils.getNodeText(relationshipXml, 'related-to') == "vpn-binding") {\r
 697                                           def relatedLink = utils.getNodeText(relationshipXml, 'related-link')\r
 698                                           if (relatedLink != null || relatedLink != "") {\r
 699                                                  rtn.add(relatedLink.substring(relatedLink.indexOf("/aai/"), relatedLink.length()))\r
 700                                           }\r
 701                                    }\r
 702                                 }\r
 703                         }\r
 704                 }\r
 705                 return rtn\r
 706         }\r
 707         /**\r
 708          * similar to VNF bindings method\r
 709         * @param xmlInput the XML document\r
 710         * @return a list of network policy values\r
 711         *            ex: ['aai/v$/network/network-policies/network-policy/cee6d136-e378-4678-a024-2cd15f0ee0cg', 'aai/v$/network/network-policies/network-policy/cee6d136-e378-4678-a024-2cd15f0ee0cg']\r
 712         *\r
 713         **/\r
 714         def getNetworkPolicyObject(xmlInput) {\r
 715                 //def rtn = null\r
 716                 List rtn = []\r
 717                 if (xmlInput!=null) {\r
 718                         def relationshipList = getListWithElements(xmlInput, 'relationship')\r
 719                         def relationshipListSize = relationshipList.size()\r
 720                         if (relationshipListSize > 0) {\r
 721                                 for (i in 0..relationshipListSize-1) {\r
 722                                    def relationshipXml = XmlUtil.serialize(relationshipList[i])\r
 723                                    if (utils.getNodeText(relationshipXml, 'related-to') == "network-policy") {\r
 724                                           def relatedLink = utils.getNodeText(relationshipXml, 'related-link')\r
 725                                           if (relatedLink != null || relatedLink != "") {\r
 726                                                  rtn.add(relatedLink.substring(relatedLink.indexOf("/aai/"), relatedLink.length()))\r
 727                                           }\r
 728                                    }\r
 729                                 }\r
 730                         }\r
 731                 }\r
 732                 return rtn\r
 733         }\r
 734 \r
 735         /**\r
 736          * similar to network policymethod\r
 737         * @param xmlInput the XML document\r
 738         * @return a list of network policy values\r
 739         *            ex: ['aai/v$/network/route-table-references/route-table-reference/refFQDN1', 'aai/v$/network/route-table-references/route-table-reference/refFQDN2']\r
 740         *\r
 741         **/\r
 742         def getNetworkTableRefObject(xmlInput) {\r
 743                 //def rtn = null\r
 744                 List rtn = []\r
 745                 if (xmlInput!=null) {\r
 746                         def relationshipList = getListWithElements(xmlInput, 'relationship')\r
 747                         def relationshipListSize = relationshipList.size()\r
 748                         if (relationshipListSize > 0) {\r
 749                                 for (i in 0..relationshipListSize-1) {\r
 750                                    def relationshipXml = XmlUtil.serialize(relationshipList[i])\r
 751                                    if (utils.getNodeText(relationshipXml, 'related-to') == "route-table-reference") {\r
 752                                           def relatedLink = utils.getNodeText1(relationshipXml, 'related-link')\r
 753                                           if (relatedLink != null || relatedLink != "") {\r
 754                                                  rtn.add(relatedLink.substring(relatedLink.indexOf("/aai/"), relatedLink.length()))\r
 755                                           }\r
 756                                    }\r
 757                                 }\r
 758                         }\r
 759                 }\r
 760                 return rtn\r
 761         }\r
 762 \r
 763         /**\r
 764          * similar to network policymethod\r
 765         * @param xmlInput the XML document\r
 766         * @return a list of IDs for related VNF instances\r
 767         *\r
 768         **/\r
 769         def getRelatedVnfIdList(xmlInput) {\r
 770                 //def rtn = null\r
 771                 List rtn = []\r
 772                 if (xmlInput!=null) {\r
 773                         def relationshipList = getListWithElements(xmlInput, 'relationship')\r
 774                         def relationshipListSize = relationshipList.size()\r
 775                         if (relationshipListSize > 0) {\r
 776                                 for (i in 0..relationshipListSize-1) {\r
 777                                    def relationshipXml = XmlUtil.serialize(relationshipList[i])\r
 778                                    if (utils.getNodeText(relationshipXml, 'related-to') == "generic-vnf") {\r
 779                                           def relatedLink = utils.getNodeText1(relationshipXml, 'related-link')\r
 780                                           if (relatedLink != null || relatedLink != "") {\r
 781                                                  if (relatedLink.substring(relatedLink.indexOf("/generic-vnf/")+13, relatedLink.length()).contains('/')) {\r
 782                                                          rtn.add(relatedLink.substring(relatedLink.indexOf("/generic-vnf/")+13, relatedLink.length()-1))\r
 783                                                  } else {\r
 784                                                      rtn.add(relatedLink.substring(relatedLink.indexOf("/generic-vnf/")+13, relatedLink.length()))\r
 785                                                  }\r
 786                                           }\r
 787                                    }\r
 788                                 }\r
 789                         }\r
 790                 }\r
 791                 return rtn\r
 792         }\r
 793 \r
 794         /**\r
 795          * similar to network policymethod\r
 796         * @param xmlInput the XML document\r
 797         * @return a list of IDs for related Network instances\r
 798         *\r
 799         **/\r
 800         def getRelatedNetworkIdList(xmlInput) {\r
 801                 //def rtn = null\r
 802                 List rtn = []\r
 803                 if (xmlInput!=null) {\r
 804                         def relationshipList = getListWithElements(xmlInput, 'relationship')\r
 805                         def relationshipListSize = relationshipList.size()\r
 806                         if (relationshipListSize > 0) {\r
 807                                 for (i in 0..relationshipListSize-1) {\r
 808                                    def relationshipXml = XmlUtil.serialize(relationshipList[i])\r
 809                                    if (utils.getNodeText(relationshipXml, 'related-to') == "l3-network") {\r
 810                                           def relatedLink = utils.getNodeText1(relationshipXml, 'related-link')\r
 811                                           if (relatedLink != null || relatedLink != "") {\r
 812                                                  if (relatedLink.substring(relatedLink.indexOf("/l3-network/")+12, relatedLink.length()).contains('/')) {\r
 813                                                          rtn.add(relatedLink.substring(relatedLink.indexOf("/l3-network/")+12, relatedLink.length()-1))\r
 814                                                  } else {\r
 815                                                      rtn.add(relatedLink.substring(relatedLink.indexOf("/l3-network/")+12, relatedLink.length()))\r
 816                                                  }\r
 817                                           }\r
 818                                    }\r
 819                                 }\r
 820                         }\r
 821                 }\r
 822                 return rtn\r
 823         }\r
 824 \r
 825         def isVfRelationshipExist(xmlInput) {\r
 826                 Boolean rtn = false\r
 827                 if (xmlInput!=null) {\r
 828                         def relationshipList = getListWithElements(xmlInput, 'relationship')\r
 829                         def relationshipListSize = relationshipList.size()\r
 830                         if (relationshipListSize > 0) {\r
 831                                 for (i in 0..relationshipListSize-1) {\r
 832                                    def relationshipXml = XmlUtil.serialize(relationshipList[i])\r
 833                                    if (utils.getNodeText(relationshipXml, 'related-to') == "vf-module") {\r
 834                                              rtn = true\r
 835                                    }\r
 836                                 }\r
 837                         }\r
 838                 }\r
 839                 return rtn\r
 840 \r
 841         }\r
 842 \r
 843         def getCloudRegion(xmlInput) {\r
 844                 String lcpCloudRegion = ""\r
 845                 if (xmlInput!=null) {\r
 846                         def relationshipList = getListWithElements(xmlInput, 'relationship')\r
 847                         def relationshipListSize = relationshipList.size()\r
 848                         if (relationshipListSize > 0) {\r
 849                                 for (i in 0..relationshipListSize-1) {\r
 850                                    def relationshipXml = XmlUtil.serialize(relationshipList[i])\r
 851                                    if (utils.getNodeText(relationshipXml, 'related-to') == "cloud-region") {\r
 852                                           def relatedLink = utils.getNodeText1(relationshipXml, 'related-link')\r
 853                                           if (relatedLink != null || relatedLink != "") {\r
 854                                                  lcpCloudRegion = relatedLink.substring(relatedLink.indexOf("/att-aic/")+9, relatedLink.length())\r
 855                                                  if (lcpCloudRegion.contains('/')) {\r
 856                                                          lcpCloudRegion = relatedLink.substring(relatedLink.indexOf("/att-aic/")+9, relatedLink.length()-1)\r
 857                                                  }\r
 858                                           }\r
 859                                    }\r
 860                                 }\r
 861                         }\r
 862                 }\r
 863                 return lcpCloudRegion\r
 864         }\r
 865 \r
 866         def getTenantId(xmlInput) {\r
 867                 String tenantId = ""\r
 868                 if (xmlInput!=null) {\r
 869                         def relationshipList = getListWithElements(xmlInput, 'relationship')\r
 870                         def relationshipListSize = relationshipList.size()\r
 871                         if (relationshipListSize > 0) {\r
 872                                 for (i in 0..relationshipListSize-1) {\r
 873                                    def relationshipXml = XmlUtil.serialize(relationshipList[i])\r
 874                                    if (utils.getNodeText(relationshipXml, 'related-to') == "tenant") {\r
 875                                           def relatedLink = utils.getNodeText1(relationshipXml, 'related-link')\r
 876                                           if (relatedLink != null || relatedLink != "") {\r
 877                                                  tenantId = relatedLink.substring(relatedLink.indexOf("/tenant/")+8, relatedLink.length())\r
 878                                                  if (tenantId.contains('/')) {\r
 879                                                          tenantId = relatedLink.substring(relatedLink.indexOf("/tenant/")+8, relatedLink.length()-1)\r
 880                                                  }\r
 881                                           }\r
 882                                    }\r
 883                                 }\r
 884                         }\r
 885                 }\r
 886                 return tenantId\r
 887         }\r
 888 \r
 889         def isInstanceValueMatch(linkResource, globalSubscriberId, serviceType) {\r
 890                 Boolean rtn = false\r
 891                 try {\r
 892                         String globalSubscriberIdLink = linkResource.substring(linkResource.indexOf("/customer/")+10, linkResource.indexOf("/service-subscriptions"))\r
 893                         String serviceTypeLink = linkResource.substring(linkResource.indexOf("/service-subscription/")+22, linkResource.indexOf("/service-instances"))\r
 894                         if (globalSubscriberIdLink == globalSubscriberId) {\r
 895                                         rtn = true\r
 896                         } else {\r
 897                                 if (serviceTypeLink == serviceType) {\r
 898                                         rtn = true\r
 899                                 }\r
 900                         }\r
 901 \r
 902                 } catch (Exception ex) {\r
 903                     println 'Exception - ' + ex.getMessage()\r
 904                         return false\r
 905                 }\r
 906         return rtn\r
 907         }\r
 908 \r
 909         def getListWithElements(xmlInput, groupName) {\r
 910                 def rtn = ""\r
 911                 if (xmlInput != null) {\r
 912                         def relationshipData = new XmlSlurper().parseText(xmlInput)\r
 913                         rtn = relationshipData.'**'.findAll {it.name() == groupName}\r
 914                 }\r
 915                 return rtn\r
 916 \r
 917         }\r
 918 \r
 919         // build network single elements\r
 920         def buildNetworkElements(l3Network, createNetworkContrailResponse, networkList) {\r
 921                 def replaceNetworkId = ""\r
 922                 def replaceNeutronNetworkId = ""\r
 923                 def replaceContrailNetworkFqdn = ""\r
 924                 if (l3Network != null && createNetworkContrailResponse != null) {\r
 925                         if (utils.nodeExists(l3Network, 'heat-stack-id')) {\r
 926                                 replaceNetworkId = utils.getNodeText(l3Network, 'heat-stack-id')\r
 927                         } else {\r
 928                                 if (utils.nodeExists(createNetworkContrailResponse, 'networkStackId')) {\r
 929                                         replaceNetworkId = utils.getNodeText(createNetworkContrailResponse, 'networkStackId')\r
 930                                 }\r
 931                         }\r
 932                         if (utils.nodeExists(l3Network, 'neutron-network-id')) {\r
 933                                 replaceNeutronNetworkId = utils.getNodeText(l3Network, 'neutron-network-id')\r
 934                         } else {\r
 935                                 if (utils.nodeExists(createNetworkContrailResponse, 'neutronNetworkId')) {\r
 936                                         replaceNeutronNetworkId = utils.getNodeText(createNetworkContrailResponse, 'neutronNetworkId')\r
 937                                 }\r
 938                         }\r
 939                         if (utils.nodeExists(l3Network, 'contrail-network-fqdn')) {\r
 940                                 replaceContrailNetworkFqdn = utils.getNodeText(l3Network, 'contrail-network-fqdn')\r
 941                         } else {\r
 942                                 if (utils.nodeExists(createNetworkContrailResponse, 'networkFqdn')) {\r
 943                                         replaceContrailNetworkFqdn = utils.getNodeText(createNetworkContrailResponse, 'networkFqdn')\r
 944                                 }\r
 945                         }\r
 946                 }\r
 947 \r
 948                 String var = ""\r
 949                 def xmlNetwork = ""\r
 950                 if (l3Network != null) {\r
 951                         for (element in networkList) {\r
 952                                 def xml= new XmlSlurper().parseText(l3Network)\r
 953                                 var = xml.'**'.find {it.name() == element}\r
 954                                 if (var == null) {\r
 955                                         if (element=="orchestration-status") {\r
 956                                                 if (var.toString() == 'pending-create' || var.toString() == 'PendingCreate') {\r
 957                                                         xmlNetwork += "<"+element+">"+"Created"+"</"+element+">"\r
 958                                             } else { //pending-update or PendingUpdate\r
 959                                                         xmlNetwork += "<"+element+">"+"Active"+"</"+element+">"\r
 960                                             }\r
 961                                         }       \r
 962                                         if (element=="heat-stack-id") {\r
 963                                                 if (replaceNetworkId != "") {\r
 964                                                         xmlNetwork += "<"+element+">"+replaceNetworkId+"</"+element+">"\r
 965                                                 }\r
 966                                         }\r
 967                                         if (element=="neutron-network-id") {\r
 968                                                 if (replaceNeutronNetworkId != "") {\r
 969                                                         xmlNetwork += "<"+element+">"+replaceNeutronNetworkId+"</"+element+">"\r
 970                                                 }\r
 971                                         }\r
 972                                         if (element=="contrail-network-fqdn") {\r
 973                                                 if (replaceContrailNetworkFqdn != "") {\r
 974                                                         xmlNetwork += "<"+element+">"+replaceContrailNetworkFqdn+"</"+element+">"\r
 975                                                 }\r
 976                                         }\r
 977 \r
 978                                 } else {\r
 979                                         if (element=="orchestration-status") {\r
 980                                            if (element=="orchestration-status") {\r
 981                                                   if (var.toString() == 'pending-create' || var.toString() == 'PendingCreate') {\r
 982                                                       xmlNetwork += "<"+element+">"+"Created"+"</"+element+">"\r
 983                                                   } else { //pending-update or PendingUpdate\r
 984                                                           xmlNetwork += "<"+element+">"+"Active"+"</"+element+">"\r
 985                                                   }\r
 986                                            }   \r
 987                                     } else {\r
 988                                     xmlNetwork += "<"+element+">"+var.toString()+"</"+element+">"\r
 989                                         }\r
 990                                 }       \r
 991                          }\r
 992                 }\r
 993                 return xmlNetwork\r
 994         }\r
 995 \r
 996         def buildSubnets(requeryIdAAIResponse, createNetworkResponse) {\r
 997                 def rebuildingSubnets = ""\r
 998                 if (requeryIdAAIResponse != null && utils.nodeExists(requeryIdAAIResponse, 'subnets')) {\r
 999                         def subnetIdMapValue = ""\r
1000                         def subnetsGroup = utils.getNodeXml(requeryIdAAIResponse, "subnets", false)\r
1001                         def subnetsData = new XmlSlurper().parseText(subnetsGroup)\r
1002                         rebuildingSubnets += "<subnets>"\r
1003                         try {\r
1004                                 def subnets = subnetsData.'**'.findAll {it.name() == "subnet"}\r
1005                                 def subnetsSize = subnets.size()\r
1006                                 for (i in 0..subnetsSize-1) {\r
1007                                    def subnet = subnets[i]\r
1008                                    def subnetXml = XmlUtil.serialize(subnet)\r
1009                                    def orchestrationStatus = utils.getNodeText1(subnetXml, "orchestration-status")\r
1010                                    if (orchestrationStatus == "PendingDelete" || orchestrationStatus == "pending-delete") {\r
1011                                            // skip, do not include in processing, remove!!!\r
1012                                    } else {\r
1013                                       def subnetList = ["subnet-id", "neutron-subnet-id", "gateway-address", "network-start-address", "cidr-mask", "ip-version", "orchestration-status", "dhcp-enabled", "dhcp-start", "dhcp-end", "resource-version", "subnet-name", "ip-assignment-direction", "host-routes"]\r
1014                                       rebuildingSubnets += buildSubNetworkElements(subnetXml, createNetworkResponse, subnetList, "subnet")\r
1015                                    }      \r
1016                                 }\r
1017                                 if (utils.nodeExists(subnetsData, 'relationship')) {\r
1018                                         rebuildingSubnets = rebuildRelationship(requeryIdAAIResponse)\r
1019                                 }\r
1020 \r
1021                         } catch (Exception ex) {\r
1022                                 // error\r
1023                         } finally {\r
1024                                 rebuildingSubnets += "</subnets>"\r
1025                         }\r
1026                 }\r
1027                 return rebuildingSubnets\r
1028         }\r
1029 \r
1030         def buildSubnets(queryIdResponse) {\r
1031                 def rebuildingSubnets = ""\r
1032                 def subnetsData = new XmlSlurper().parseText(queryIdResponse)\r
1033                 //rebuildingSubnets += "<subnets>"\r
1034                 try {\r
1035                         def subnets = subnetsData.'**'.findAll {it.name() == "subnet"}\r
1036                         def subnetsSize = subnets.size()\r
1037                         for (i in 0..subnetsSize-1) {\r
1038                            def subnet = subnets[i]\r
1039                            def subnetXml = XmlUtil.serialize(subnet)\r
1040                            def orchestrationStatus = utils.getNodeText1(subnetXml, "orchestration-status")\r
1041                            if (orchestrationStatus == "pending-delete" || orchestrationStatus == "PendingDelete") {\r
1042                                    // skip, do not include in processing, remove!!!\r
1043                            } else {\r
1044                                         def subnetList = ["dhcp-start", "dhcp-end", "network-start-address", "cidr-mask", "dhcp-enabled", "gateway-address", "ip-version", "subnet-id", "subnet-name", "ip-assignment-direction", "host-routes"]\r
1045                                         rebuildingSubnets += buildSubNetworkElements(subnetXml, subnetList, "subnets")\r
1046                                         //rebuildingSubnets += buildSubNetworkElements(subnetXml, subnetList, "")\r
1047                            }    \r
1048                         }\r
1049                 } catch (Exception ex) {\r
1050                    //\r
1051                 } finally {\r
1052                   //rebuildingSubnets += "</subnets>"\r
1053                 }\r
1054                 return rebuildingSubnets\r
1055         }\r
1056 \r
1057 \r
1058         // build subnet sub-network single elements\r
1059         def buildSubNetworkElements(subnetXml, createNetworkResponse, elementList, parentName) {\r
1060                 String var = ""\r
1061                 def xmlBuild = ""\r
1062                 if (parentName != "") {\r
1063                    xmlBuild += "<"+parentName+">"\r
1064                 }\r
1065                 if (subnetXml != null) {\r
1066                         for (element in elementList) {\r
1067                           def xml= new XmlSlurper().parseText(subnetXml)\r
1068                           var = xml.'**'.find {it.name() == element}\r
1069                           if (var != null) {\r
1070                                  if (element=="orchestration-status") {\r
1071                                         if(var.toString() == 'pending-create' || var.toString() == 'PendingCreate') {   \r
1072                                                 xmlBuild += "<"+element+">"+"Created"+"</"+element+">"\r
1073                                         } else { // pending-update or PendingUpdate'\r
1074                                            xmlBuild += "<"+element+">"+"Active"+"</"+element+">"\r
1075                                         }\r
1076                                  } else { // "subnet-id", "neutron-subnet-id"\r
1077                                          if (element=="subnet-id") {\r
1078                                                  if (utils.nodeExists(createNetworkResponse, "subnetMap")) {\r
1079                                                          xmlBuild += "<"+element+">"+var.toString()+"</"+element+">"\r
1080                                                          String neutronSubnetId = extractNeutSubId(createNetworkResponse, var.toString())\r
1081                                                          xmlBuild += "<neutron-subnet-id>"+neutronSubnetId+"</neutron-subnet-id>"\r
1082                                                  }\r
1083                                          } else {\r
1084                                              if (element=="neutron-subnet-id") {\r
1085                                // skip\r
1086                                                  } else {\r
1087                                                          if (element=="host-routes") {\r
1088                                                                  if (subnetXml.contains("host-routes")) {\r
1089                                                                          List elementRoute = ["host-route-id", "route-prefix", "next-hop", "next-hop-type", "resource-version"]\r
1090                                                                          xmlBuild += buildXMLElements(subnetXml, "host-routes", "host-route", elementRoute)\r
1091                                                                  }\r
1092                                                          } else {         \r
1093                                                                 xmlBuild += "<"+element+">"+var.toString()+"</"+element+">"\r
1094                                                          }        \r
1095                                                  }\r
1096                                          }\r
1097                                  }\r
1098                           }\r
1099                         }\r
1100 \r
1101                 }\r
1102                 if (parentName != "") {\r
1103                    xmlBuild += "</"+parentName+">"\r
1104                 }\r
1105                 return xmlBuild\r
1106         }\r
1107 \r
1108         // build subnet sub-network single elements\r
1109         def buildSubNetworkElements(subnetXml, elementList, parentName) {\r
1110                 def var = ""\r
1111                 def xmlBuild = ""\r
1112                 if (parentName != "") {\r
1113                         xmlBuild += "<"+parentName+">"\r
1114                  }\r
1115                 if (subnetXml != null) {\r
1116                     def networkStartAddress = ""\r
1117                         for (element in elementList) {\r
1118                                 def xml= new XmlSlurper().parseText(subnetXml)\r
1119                                 var = xml.'**'.find {it.name() == element}\r
1120                                 if (element == "dhcp-start") {\r
1121                                         xmlBuild += "<allocationPools>"\r
1122                                         if (var.toString() == 'null') {\r
1123                                                 xmlBuild += "<start>"+""+"</start>"\r
1124                                         } else {\r
1125                                                 xmlBuild += "<start>"+var.toString()+"</start>"\r
1126                                         }\r
1127                                 }\r
1128                                 if (element == "dhcp-end") {\r
1129                                         if (var.toString() == 'null') {\r
1130                                                 xmlBuild += "<end>"+""+"</end>"\r
1131                                         } else {\r
1132                                                 xmlBuild += "<end>"+var.toString()+"</end>"\r
1133                                         }\r
1134                                         xmlBuild += "</allocationPools>"\r
1135                                 }\r
1136                                 if (element == "network-start-address" || element == "cidr-mask") {\r
1137                                         if (element == "network-start-address") {\r
1138                                                 networkStartAddress = var.toString()\r
1139                                         }\r
1140                                         if (element == "cidr-mask") {\r
1141                                                 xmlBuild += "<cidr>"+networkStartAddress+"/"+var.toString()+"</cidr>"\r
1142                                         }\r
1143                                 }\r
1144                                 if (element == "dhcp-enabled") {\r
1145                                         xmlBuild += "<enableDHCP>"+var.toString()+"</enableDHCP>"\r
1146                                 }\r
1147                                 if (element == "gateway-address") {\r
1148                                         xmlBuild += "<gatewayIp>"+var.toString()+"</gatewayIp>"\r
1149                                 }\r
1150                                 if (element == "ip-version") {\r
1151                                         String ipVersion = getIpvVersion(var.toString())\r
1152                                         xmlBuild += "<ipVersion>"+ipVersion+"</ipVersion>"\r
1153                                 }\r
1154                                 if (element == "subnet-id") {\r
1155                                         xmlBuild += "<subnetId>"+var.toString()+"</subnetId>"\r
1156                                 }\r
1157                                 if ((element == "subnet-name") && (var != null)) {\r
1158                                         xmlBuild += "<subnetName>"+var.toString()+"</subnetName>"\r
1159                                 }\r
1160                                 if ((element == "ip-assignment-direction") && (var != null)) {\r
1161                                         xmlBuild += "<addrFromStart>"+var.toString()+"</addrFromStart>"\r
1162                                 }\r
1163                                 if (element == "host-routes") {\r
1164                                         def routes = ""\r
1165                                         if (subnetXml.contains("host-routes")) {\r
1166                                                 routes = buildHostRoutes(subnetXml)\r
1167                                         }\r
1168                                         xmlBuild += routes \r
1169                                 }       \r
1170                                 \r
1171                         }\r
1172                 }\r
1173                 if (parentName != "") {\r
1174                         xmlBuild += "</"+parentName+">"\r
1175                  }\r
1176                 return xmlBuild\r
1177         }\r
1178 \r
1179         // rebuild host-routes\r
1180         def buildHostRoutes(subnetXml) {\r
1181                 List  routeElementList = ["host-route-id", "route-prefix", "next-hop", "next-hop-type", "resource-version"]\r
1182                 def hostRoutes = buildXMLElements(subnetXml, "host-routes", "host-route", routeElementList)\r
1183                 def buildHostRoutes = ""\r
1184                 def var = ""\r
1185                 if (hostRoutes!=null) {\r
1186                         def routesData = new XmlSlurper().parseText(hostRoutes)\r
1187                         def routes = routesData.'**'.findAll {it.name() == "host-route"}\r
1188                         def routesSize = routes.size()\r
1189                         for (i in 0..routesSize-1) {\r
1190                            buildHostRoutes += "<hostRoutes>"\r
1191                            def route = routes[i]\r
1192                            def routeXml = XmlUtil.serialize(route)\r
1193                            List  elementList = ["route-prefix", "next-hop"]\r
1194                            for (element in elementList) {\r
1195                                    def xml= new XmlSlurper().parseText(routeXml)\r
1196                                    var = xml.'**'.find {it.name() == element}\r
1197                                    if (element == "route-prefix") {\r
1198                                            buildHostRoutes += "<prefix>"+var.toString()+"</prefix>"\r
1199                                    }\r
1200                                    if (element == "next-hop") {\r
1201                                            buildHostRoutes += "<nextHop>"+var.toString()+"</nextHop>"\r
1202                                    }\r
1203                            }\r
1204                            buildHostRoutes += "</hostRoutes>"\r
1205                         }   \r
1206                 }               \r
1207                 return buildHostRoutes          \r
1208                 \r
1209         }\r
1210         \r
1211         // rebuild ctag-assignments\r
1212         def rebuildCtagAssignments(xmlInput) {\r
1213                 def rebuildingCtagAssignments = ""\r
1214                 if (xmlInput!=null) {\r
1215                         def ctagAssignmentsData = new XmlSlurper().parseText(xmlInput)\r
1216                         rebuildingCtagAssignments += "<ctag-assignments>"\r
1217                         def ctagAssignments = ctagAssignmentsData.'**'.findAll {it.name() == "ctag-assignment"}\r
1218                         def ctagAssignmentsSize = ctagAssignments.size()\r
1219                         for (i in 0..ctagAssignmentsSize-1) {\r
1220                                 def ctagAssignment = ctagAssignments[i]\r
1221                                 def ctagAssignmentXml = XmlUtil.serialize(ctagAssignment)\r
1222                                 rebuildingCtagAssignments += "<ctag-assignment>"\r
1223                                 List elementList = ["vlan-id-inner", "resource-version"]\r
1224                                 rebuildingCtagAssignments +=  buildXMLElements(ctagAssignmentXml, ""      , "", elementList)\r
1225                                 if (utils.nodeExists(ctagAssignmentXml, 'relationship')) {\r
1226                                         rebuildingCtagAssignments += rebuildRelationship(ctagAssignmentXml)\r
1227                                 }\r
1228                                 rebuildingCtagAssignments += "</ctag-assignment>"\r
1229                         }\r
1230                         rebuildingCtagAssignments += "</ctag-assignments>"\r
1231                 }\r
1232                 return rebuildingCtagAssignments\r
1233         }\r
1234 \r
1235         // rebuild 'relationship-list'\r
1236         def rebuildRelationship(xmlInput) {\r
1237                 def rebuildingSubnets = ""\r
1238                 if (xmlInput!=null) {\r
1239                         def subnetsData = new XmlSlurper().parseText(xmlInput)\r
1240                         rebuildingSubnets += "<relationship-list>"\r
1241                         def relationships = subnetsData.'**'.findAll {it.name() == "relationship"}\r
1242                         def relationshipsSize = relationships.size()\r
1243                         for (i in 0..relationshipsSize-1) {\r
1244                                 def relationship = relationships[i]\r
1245                                 def relationshipXml = XmlUtil.serialize(relationship)\r
1246                                 rebuildingSubnets += "<relationship>"\r
1247                                 def relationshipList = ["related-to", "related-link"]\r
1248                                 rebuildingSubnets += buildSubNetworkElements(relationshipXml, "", relationshipList, "")\r
1249                                 if (utils.nodeExists(relationshipXml, 'relationship-data')) {\r
1250                                         def relationshipDataXmlData = new XmlSlurper().parseText(relationshipXml)\r
1251                                         def relationshipsData = relationshipDataXmlData.'**'.findAll {it.name() == "relationship-data"}\r
1252                                         def relationshipsDataSize = relationshipsData.size()\r
1253                                         for (j in 0..relationshipsDataSize-1) {\r
1254                                                 def relationshipData = relationshipsData[j]\r
1255                                                 def relationshipDataXml = XmlUtil.serialize(relationshipData)\r
1256                                                 def relationshipDataList =  ["relationship-key", "relationship-value"]\r
1257                                                 rebuildingSubnets += buildXMLElements(relationshipDataXml, "", "relationship-data", relationshipDataList)\r
1258                                         }\r
1259                                 }\r
1260                                 if (utils.nodeExists(relationshipXml, 'related-to-property')) {\r
1261                                         def relationshipDataXmlData = new XmlSlurper().parseText(relationshipXml)\r
1262                                         def relationshipsData = relationshipDataXmlData.'**'.findAll {it.name() == "related-to-property"}\r
1263                                         def relationshipsDataSize = relationshipsData.size()\r
1264                                         for (j in 0..relationshipsDataSize-1) {\r
1265                                                 def relationshipData = relationshipsData[j]\r
1266                                                 def relationshipDataXml = XmlUtil.serialize(relationshipData)\r
1267                                                 def relationshipDataList =  ["property-key", "property-value"]\r
1268                                                 rebuildingSubnets += buildXMLElements(relationshipDataXml, "", "related-to-property", relationshipDataList)\r
1269                                         }\r
1270                                 }\r
1271 \r
1272                                 rebuildingSubnets += "</relationship>"\r
1273                         }\r
1274                         rebuildingSubnets += "</relationship-list>"\r
1275                 }\r
1276                 return rebuildingSubnets\r
1277         }\r
1278 \r
1279         def buildVlans(queryIdResponse) {\r
1280                 def rebuildingSubnets = "<vlans>"\r
1281                 def subnetsData = new XmlSlurper().parseText(queryIdResponse)\r
1282 \r
1283                 try {\r
1284                         def subnets = subnetsData.'**'.findAll {it.name() == "segmentation-assignments"}\r
1285                         def subnetsSize = subnets.size()\r
1286                         for (i in 0..subnetsSize-1) {\r
1287                            def subnet = subnets[i]\r
1288                            def subnetXml = XmlUtil.serialize(subnet)\r
1289 \r
1290                            String vlan = utils.getNodeText1(subnetXml, "segmentation-id")\r
1291                            if (i>0){\r
1292                                    rebuildingSubnets += ","\r
1293                            }\r
1294                            rebuildingSubnets += vlan\r
1295                         }\r
1296                 } catch (Exception ex) {\r
1297                    //\r
1298                 } finally {\r
1299                   //rebuildingSubnets += "</subnets>"\r
1300                 rebuildingSubnets += "</vlans>"\r
1301                 }\r
1302                 return rebuildingSubnets\r
1303         }\r
1304 \r
1305         /* Utility code to rebuild xml/elements in a list:\r
1306          * rebuild xml with 1) unbounded groups of elements; or\r
1307          *                  2) one group of elements; or\r
1308          *                  3) just one or more elements (in a list as argument)\r
1309          * @param xmlInput the XML document\r
1310          * @param parentName the parent name  (ex: 'inputs')\r
1311          * @param childrenName the chilrendName (ex: 'entry' as unbounded/occurs>1)\r
1312          * @param elementList the element list of children (ex: 'key', 'value')\r
1313          * @return a string of rebuild xml\r
1314          *\r
1315          * Ex 1: xmlInput:\r
1316          *    <ws:inputs>\r
1317          *       <ws:entry>\r
1318          *          <ws:key>name</ws:key>\r
1319          *          <ws:value>Edward</ws:value>\r
1320          *       </ws:entry>\r
1321          *       <ws:entry>\r
1322          *          <ws:key>age</ws:key>\r
1323          *          <ws:value>30</ws:value>\r
1324          *       </ws:entry>\r
1325          *       <ws:entry>\r
1326          *          <ws:key>age</ws:key>\r
1327          *          <ws:value>30</ws:value>\r
1328          *       </ws:entry>\r
1329          *    <ws:/inputs>\r
1330          * Usage:\r
1331          * List elementList = ["key", "value"]\r
1332          * String rebuild =  buildXMLElements(xmlInput, "inputs", "entry", elementList)\r
1333          *\r
1334          * Ex 2: xmlInput // no parent tag\r
1335          *   <ws:sdnc-request-header>\r
1336          *    <ws:svc-request-id>fec8ec88-151a-45c9-ad60-8233e0fc8ff2</ws:svc-request-id>\r
1337          *    <ws:svc-notification-url>https://msojra.mtsnj.aic.cip.openecomp.com:8443/adapters/rest/SDNCNotify</ws:svc-notification-url>\r
1338          *    <ws:svc-action>assign</ws:svc-action>\r
1339          *   </ws:sdnc-request-header>\r
1340          * Usage:\r
1341          * List elementList = ["svc-request-id", "svc-notification-url", "svc-action"]\r
1342          * String rebuild =  buildXMLElements(xmlInput, ""      , "sdnc-request-header", elementList)  // no parent tag\r
1343          *\r
1344          * Ex 3: xmlInput // elements one after another (with no parent & children tag)\r
1345          * <ws:test-id>myTestid</ws:test-id>\r
1346          * <ws:test-user>myUser</ws:test-user>\r
1347          * Usage:\r
1348          * List elementList = ["test-id", "test-user"]\r
1349          * String rebuild =  buildXMLElements(xmlInput, ""      , "", elementList)\r
1350          *\r
1351          */\r
1352         def buildXMLElements(xmlInput, parentName, childrenName, elementList) {\r
1353                 def varChildren = ""\r
1354                 def var = ""\r
1355                 def xmlBuildUnbounded = ""\r
1356                 if (parentName!="") {xmlBuildUnbounded += "<"+parentName+">" +'\n'}\r
1357                 if (xmlInput != null) {\r
1358                         def xml= new XmlSlurper().parseText(xmlInput)\r
1359                         if (childrenName!="") {\r
1360                                 varChildren = xml.'**'.findAll {it.name() == childrenName}\r
1361                                 for (i in 0..varChildren.size()-1) {\r
1362                                         xmlBuildUnbounded += "<"+childrenName+">" +'\n'\r
1363                                         for (element in elementList) {\r
1364                                                 var = varChildren[i].'*'.find {it.name() == element}\r
1365                                            if (var != null) {\r
1366                                                   xmlBuildUnbounded += "<"+element+">"+var.toString()+"</"+element+">" +'\n'\r
1367                                            }\r
1368                                         }\r
1369                                         xmlBuildUnbounded += "</"+childrenName+">" +'\n'\r
1370                                 }\r
1371                         } else {\r
1372                                 for (element in elementList) {\r
1373                                         var = xml.'*'.find {it.name() == element}\r
1374                                         if (var != null) {\r
1375                                                 xmlBuildUnbounded += "<"+element+">"+var.toString()+"</"+element+">" +'\n'\r
1376                                         }\r
1377                                 }\r
1378                         }\r
1379 \r
1380                 }\r
1381                 if (parentName!="") {xmlBuildUnbounded += "</"+parentName+">" +'\n'}\r
1382                 return xmlBuildUnbounded\r
1383          }\r
1384 \r
1385         def getFirstNodeXml(xmlInput, element){\r
1386                 def nodeAsText = ""\r
1387                 def nodeToSerialize =  ""\r
1388                 if (xmlInput != null) {\r
1389                         def fxml= new XmlSlurper().parseText(xmlInput)\r
1390                         if (utils.nodeExists(xmlInput, "payload")) {\r
1391                                 nodeToSerialize = fxml.'payload'.'l3-network'.'*'.find {it.name() == element}\r
1392                                 if (nodeToSerialize!=null) {\r
1393                                         nodeAsText = XmlUtil.serialize(nodeToSerialize)\r
1394                                 } else {\r
1395                                     nodeAsText = ""\r
1396                                 }\r
1397 \r
1398                         } else {\r
1399                                 nodeToSerialize = fxml.'*'.find {it.name() == element}\r
1400                                 if (nodeToSerialize!=null) {\r
1401                                         nodeAsText = XmlUtil.serialize(nodeToSerialize)\r
1402                                 } else {\r
1403                                         nodeAsText = ""\r
1404                                 }\r
1405 \r
1406                         }\r
1407                 }\r
1408                 return nodeAsText\r
1409 \r
1410         }\r
1411 \r
1412 //TODO: This method still needs to be tested before using.\r
1413         /**\r
1414          *\r
1415          * This method is similar to the gennetwork:ContrailNetworUpdateCompletedObject\r
1416          * BPEL method.  It extracts all of the required subnet information\r
1417          * for each subnet listed with an orch status equal to the one provided\r
1418          * and puts the corresponding infomation with the appropriate node for\r
1419          * updating aai. The method sets the orch status for each subnet to active\r
1420          *\r
1421          * @param subnetsXml the entire subnets xml\r
1422          * @param requestInput the request in the process\r
1423          * @param queryIdResponse the response of REST AAI query by Id\r
1424          * @param queryVpnBindingResponse the response of REST AAI query by vpn binding\r
1425          * @param routeCollection the collection of vpnBinding's 'global-route-target'\r
1426          * @return String request\r
1427          */\r
1428         public String networkUpdateSubnetInfo(String subnetsXml, String networkResponseXml){\r
1429 \r
1430                         String subnets = ""\r
1431                         StringBuilder sb = new StringBuilder()\r
1432                         InputSource source = new InputSource(new StringReader(subnetsXml));\r
1433                         DocumentBuilderFactory docFactory = DocumentBuilderFactory.newInstance();\r
1434                         docFactory.setNamespaceAware(true)\r
1435                         DocumentBuilder docBuilder = docFactory.newDocumentBuilder()\r
1436                         Document xml = docBuilder.parse(source)\r
1437                         NodeList nodeList = xml.getElementsByTagNameNS("*", "subnet")\r
1438                         for (int x = 0; x < nodeList.getLength(); x++) {\r
1439                                 Node node = nodeList.item(x)\r
1440                                 String subnet = ""\r
1441                                 if (node.getNodeType() == Node.ELEMENT_NODE) {\r
1442                                         Element eElement = (Element) node\r
1443                                         String subnetOrchStatus = eElement.getElementsByTagNameNS("*", "orchestration-status").item(0).getTextContent()\r
1444                                         if(subnetOrchStatus.equals("pending-create")){\r
1445 \r
1446                                                 String subnetId = eElement.getElementsByTagNameNS("*", "subnet-id").item(0).getTextContent()\r
1447                                                 def netAddress = eElement.getElementsByTagNameNS("*", "network-start-address").item(0).getTextContent()\r
1448                                                 def mask = eElement.getElementsByTagNameNS("*", "cidr-mask").item(0).getTextContent()\r
1449                                                 def dhcpEnabledSubnet = eElement.getElementsByTagNameNS("*", "dhcp-enabled").item(0).getTextContent()\r
1450                                                 def gatewayAddress = eElement.getElementsByTagNameNS("*", "gateway-address").item(0).getTextContent()\r
1451                                                 def ipVersion = eElement.getElementsByTagNameNS("*", "ip-version").item(0).getTextContent()\r
1452                                                 def relationshipList =  eElement.getElementsByTagNameNS("*", "relationship-list").item(0).getTextContent() //TODO: test this\r
1453                                                 String neutronSubnetId = extractNeutSubId(networkResponseXml, subnetId)\r
1454                                                 subnet =\r
1455                                                 """<subnet>\r
1456                                         <subnetId>${subnetId}</subnetId>\r
1457                                         <neutron-subnet-id>${neutronSubnetId}</neutron-subnet-id>\r
1458                                         <gateway-address>${gatewayAddress}</gateway-address>\r
1459                                         <network-start-address>${netAddress}</network-start-address>\r
1460                                         <cidr-mask>${mask}</cidr-mask>\r
1461                                         <ip-Version>${ipVersion}</ip-Version>\r
1462                                         <orchestration-status>active</orchestration-status>\r
1463                                         <dhcp-enabled>${dhcpEnabledSubnet}</dhcp-enabled>\r
1464                                         <relationship-list>${relationshipList}</relationship-list>\r
1465                                         </subnet>"""\r
1466 \r
1467                                         }else if(subnetOrchStatus.equals("pending-delete")){\r
1468                                                 StringWriter writer = new StringWriter()\r
1469                                                 Transformer transformer = TransformerFactory.newInstance().newTransformer()\r
1470                                                 transformer.transform(new DOMSource(node), new StreamResult(writer))\r
1471                                                 subnet = writer.toString()\r
1472 \r
1473                                         }else{\r
1474                                                 subnet = ""\r
1475                                         }\r
1476                                 }\r
1477                                 subnets = sb.append(subnet)\r
1478                         }\r
1479 \r
1480                         subnets = utils.removeXmlPreamble(subnets)\r
1481 \r
1482                         String subnetsList =\r
1483                         """<subnets>\r
1484                         ${subnets}\r
1485                         </subnets>"""\r
1486 \r
1487                         return subnetsList\r
1488         }\r
1489 \r
1490 \r
1491         /**\r
1492          *\r
1493          * This method extracts the "value" node text for the the given subnet Id.\r
1494          *\r
1495          * @param String inputSource - xml that contains the subnet id key and value\r
1496          * @param String subnetId - for which you want the value of\r
1497 \r
1498          * @return String value - node text of node named value associated with the given subnet id\r
1499          */\r
1500         public String extractNeutSubId(String inputSource, String subnetId){\r
1501 \r
1502                                 String value = ""\r
1503                                 InputSource source = new InputSource(new StringReader(inputSource));\r
1504                                 DocumentBuilderFactory docFactory = DocumentBuilderFactory.newInstance();\r
1505                                 docFactory.setNamespaceAware(true)\r
1506                                 DocumentBuilder docBuilder = docFactory.newDocumentBuilder()\r
1507                                 Document xml = docBuilder.parse(source)\r
1508                                 NodeList nodeList = xml.getElementsByTagNameNS("*", "entry")\r
1509                                 for (int x = 0; x < nodeList.getLength(); x++) {\r
1510                                         Node node = nodeList.item(x)\r
1511                                         String subnet = ""\r
1512                                         if (node.getNodeType() == Node.ELEMENT_NODE) {\r
1513                                                 Element eElement = (Element) node\r
1514                                                 String key = eElement.getElementsByTagNameNS("*", "key").item(0).getTextContent()\r
1515                                                 if(key.equals(subnetId)){\r
1516                                                         value = eElement.getElementsByTagNameNS("*", "value").item(0).getTextContent()\r
1517                                                 }\r
1518                                         }\r
1519                                 }\r
1520                                 return value\r
1521                         }\r
1522 \r
1523         public boolean isRollbackEnabled (DelegateExecution execution, String payloadXml) {\r
1524 \r
1525                 def rollbackEnabled = false\r
1526                 def rollbackValueSet = false\r
1527                 if (utils.nodeExists(payloadXml, "backout-on-failure")) {\r
1528                         String backoutValue = utils.getNodeText1(payloadXml, "backout-on-failure")\r
1529                         if (backoutValue != null && !backoutValue.isEmpty()) {\r
1530                                 if (backoutValue.equalsIgnoreCase("false")) {\r
1531                                         rollbackEnabled = false\r
1532                                 }\r
1533                                 else {\r
1534                                         rollbackEnabled = true\r
1535                                 }\r
1536                                 rollbackValueSet = true;\r
1537                         }\r
1538                 }\r
1539 \r
1540                 if (!rollbackValueSet) {\r
1541                         if (execution.getVariable("URN_mso_rollback") != null) {\r
1542                             rollbackEnabled = execution.getVariable("URN_mso_rollback").toBoolean()\r
1543                         }\r
1544                 }\r
1545                 return rollbackEnabled\r
1546         }\r
1547         \r
1548         \r
1549         /**\r
1550          * This method extracts the version for the the given ip-version.\r
1551          *\r
1552          * @param String ipvVersion - IP protocols version (ex: ipv4 or ipv6 or 4 or 6)\r
1553          * @return String version - digit version (ex: 4 or 6)\r
1554          */\r
1555         \r
1556         public String getIpvVersion (String ipvVersion) {\r
1557                 \r
1558                 String version = ""\r
1559                 try {\r
1560                         if (ipvVersion.isNumber()) {\r
1561                                 version = ipvVersion\r
1562                         } else {\r
1563                                 version = ipvVersion.substring(ipvVersion.indexOf("ipv")+3)\r
1564                                 if (!version.isNumber()) {\r
1565                                         version = ipvVersion\r
1566                                 }\r
1567                         }\r
1568                 } catch (Exception ex) {\r
1569                         version = ipvVersion  \r
1570                 }\r
1571                 return version\r
1572         }\r
1573 }\r