bpmn/MSOCommonBPMN/src/main/groovy/org/openecomp/mso/bpmn/common/scripts/MsoUtils.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 groovy.xml.XmlUtil\r
  24 \r
  25 import java.text.SimpleDateFormat\r
  26 \r
  27 import org.apache.commons.codec.binary.Base64\r
  28 import org.openecomp.mso.bpmn.core.BPMNLogger\r
  29 import org.openecomp.mso.bpmn.core.xml.XmlTool\r
  30 import org.openecomp.mso.logger.MessageEnum\r
  31 import org.openecomp.mso.logger.MsoLogger\r
  32 import org.openecomp.mso.utils.CryptoUtils\r
  33 import org.slf4j.MDC\r
  34 import org.w3c.dom.Element\r
  35 \r
  36 class MsoUtils {\r
  37         def initializeEndPoints(execution){\r
  38                 // use this placeholder to initialize end points, if called independently, this need to be set\r
  39                 execution.setVariable("AAIEndPoint","http://localhost:28080/SoapUIMocks")                       \r
  40         }\r
  41         \r
  42         /**\r
  43          * Use getNodeText1 Instead!\r
  44          */\r
  45         @Deprecated\r
  46         def getNodeText(xmlInput,element){\r
  47                 def rtn=null\r
  48                 if(xmlInput!=null){\r
  49                         def xml= new XmlSlurper().parseText(xmlInput)\r
  50                         rtn= xml.'**'.find{node->node.name()==element}.text()\r
  51                 }\r
  52                 return rtn\r
  53         }\r
  54         def getMultNodes(xmlInput, element){\r
  55                 def nodes=null\r
  56                 if(xmlInput!=null){\r
  57                         def xml= new XmlSlurper().parseText(xmlInput)\r
  58                         nodes = xml.'**'.findAll{ node-> node.name() == element }*.text()\r
  59                 }\r
  60                 return nodes\r
  61         }\r
  62         def getNodeText1(xmlInput,element){\r
  63                 def rtn=null\r
  64                 if(xmlInput!=null){\r
  65                         def xml= new XmlSlurper().parseText(xmlInput)\r
  66                         rtn= xml.'**'.find{node->node.name()==element}\r
  67                         if (rtn != null){\r
  68                                 rtn=rtn.text()\r
  69                         }\r
  70                 }\r
  71                 return rtn\r
  72         }       \r
  73         def getNodeXml(xmlInput,element){\r
  74                 return getNodeXml(xmlInput, element, true)\r
  75         }\r
  76         def getNodeXml(xmlInput,element,incPreamble){\r
  77                 def fxml= new XmlSlurper().parseText(xmlInput)\r
  78                 def nodeToSerialize = fxml.'**'.find {it.name() == element}\r
  79                 if(nodeToSerialize==null){\r
  80                         return ""\r
  81                 }\r
  82                 def nodeAsText = XmlUtil.serialize(nodeToSerialize)\r
  83                 if (!incPreamble) {\r
  84                         nodeAsText = removeXmlPreamble(nodeAsText)\r
  85                 }\r
  86                 return nodeAsText               \r
  87         }\r
  88         def nodeExists(xmlInput,element){\r
  89                 try {\r
  90                         def fxml= new XmlSlurper().parseText(xmlInput)\r
  91                         def nodeToSerialize = fxml.'**'.find {it.name() == element}\r
  92                         return nodeToSerialize!=null\r
  93                 } catch(Exception e) {\r
  94                         return false\r
  95                 }\r
  96         }\r
  97 \r
  98         \r
  99         /***** Utilities when using XmlParser *****/\r
 100         \r
 101         /**\r
 102          * Convert a Node into a String by deserializing it and formatting it.\r
 103          *\r
 104          * @param node Node to be converted.\r
 105          * @return the Node as a String.\r
 106          */\r
 107         def String nodeToString(Node node) {\r
 108                 def String nodeAsString = groovy.xml.XmlUtil.serialize(node)\r
 109                 nodeAsString = removeXmlPreamble(nodeAsString)\r
 110                 return formatXml(nodeAsString)\r
 111         }\r
 112         \r
 113         /**\r
 114          * Get the specified child Node of the specified parent. If there are\r
 115          * multiple children of the same name, only the first one is returned.\r
 116          * If there are no children with the specified name, 'null' is returned.\r
 117          * \r
 118          * @param parent Parent Node in which to find a child.\r
 119          * @param childNodeName Name of the child Node to get.\r
 120          * @return the (first) child Node with the specified name or 'null'\r
 121          * if a child Node with the specified name does not exist.\r
 122          */\r
 123         def Node getChildNode(Node parent, String childNodeName) {\r
 124                 def NodeList nodeList = getIdenticalChildren(parent, childNodeName)\r
 125                 if (nodeList.size() == 0) {\r
 126                         return null\r
 127                 } else {\r
 128                         return nodeList.get(0)\r
 129                 }\r
 130         }\r
 131         \r
 132         /**\r
 133          * Get the textual value of the specified child Node of the specified parent.\r
 134          * If there are no children with the specified name, 'null' is returned.\r
 135          * \r
 136          * @param parent Parent Node in which to find a child.\r
 137          * @param childNodeName Name of the child Node whose value to get.\r
 138          * @return the textual value of child Node with the specified name or 'null'\r
 139          * if a child Node with the specified name does not exist.\r
 140          */\r
 141         def String getChildNodeText(Node parent, String childNodeName) {\r
 142                 def Node childNode = getChildNode(parent, childNodeName)\r
 143                 if (childNode == null) {\r
 144                         return null\r
 145                 } else {\r
 146                         return childNode.text()\r
 147                 }\r
 148         }\r
 149         \r
 150         /**\r
 151          * Get all of the child nodes from the specified parent that have the\r
 152          * specified name.  The returned NodeList could be empty.\r
 153          * \r
 154          * @param parent Parent Node in which to find children.\r
 155          * @param childNodeName Name of the children to get.\r
 156          * @return a NodeList of all the children from the parent with the specified\r
 157          * name. The list could be empty.\r
 158          */\r
 159         def NodeList getIdenticalChildren(Node parent, String childNodeName) {\r
 160                 return (NodeList) parent.get(childNodeName)\r
 161         }\r
 162 \r
 163         /***** End of Utilities when using XmlParser *****/\r
 164 \r
 165         \r
 166         /** these are covered under the common function above**/\r
 167         def getSubscriberName(xmlInput,element){\r
 168                 def rtn=null\r
 169                 if(xmlInput!=null){\r
 170                         def xml= new XmlSlurper().parseText(xmlInput)\r
 171                         rtn= xml.'**'.find{node->node.name()==element}.text()\r
 172                 } \r
 173                 return rtn\r
 174         }\r
 175         def getTenantInformation(xmlInput,element){\r
 176                 def xml= new XmlSlurper().parseText(xmlInput)\r
 177                 def nodeToSerialize = xml.'**'.find {it.name() == 'service-information'}\r
 178                 def nodeAsText = XmlUtil.serialize(nodeToSerialize)\r
 179                 return nodeAsText\r
 180         }\r
 181         def getServiceInstanceId(xmlInput,element){\r
 182                 def xml= new XmlSlurper().parseText(xmlInput)\r
 183                 return ( xml.'**'.find{node->node.name()==element}.text() )\r
 184         }\r
 185         //for aai tenant url\r
 186         def searchResourceLink(xmlInput, resourceType){\r
 187                 def fxml= new XmlSlurper().parseText(xmlInput)\r
 188                 def element = fxml.'**'.find {it.'resource-type' == resourceType}\r
 189                 return (element == null) ? null : element.'resource-link'.text()\r
 190         }\r
 191 \r
 192         def searchMetaData(xmlInput, searchName, searchValue){\r
 193                 def fxml= new XmlSlurper().parseText(xmlInput)\r
 194                 def ret = fxml.'**'.find {it.metaname.text() == searchName && it.metaval.text() == searchValue}\r
 195                 if(ret != null){\r
 196                         return ret.parent().parent()\r
 197                 }\r
 198                 return ret\r
 199         }\r
 200         \r
 201         def searchMetaDataNode(fxml, searchName, searchValue){\r
 202                 def ret = fxml.'**'.find {it.metaname.text() == searchName && it.metaval.text() == searchValue}\r
 203                 if(ret != null){\r
 204                         return ret.parent().parent()\r
 205                 }\r
 206                 return ret\r
 207         }\r
 208         \r
 209         // for Trinity L3 add/delete bonding\r
 210         def getPBGFList(isDebugLogEnabled, xmlInput){\r
 211                 xmlInput = xmlInput.replaceAll("&amp;", "&")\r
 212                 xmlInput = xmlInput.replaceAll("&lt;", "<")\r
 213                 xmlInput = xmlInput.replaceAll("&gt;", ">")\r
 214                 log("DEBUG", "getPBGFList: xmlInput " + xmlInput,isDebugLogEnabled)\r
 215                 ArrayList myNodes = new ArrayList()\r
 216                 if(nodeExists(xmlInput,"nbnc-response-information")){\r
 217                 def respInfo=getNodeXml(xmlInput,"nbnc-response-information", false)\r
 218                 if(respInfo!=null){\r
 219                         def fxml= new XmlSlurper().parseText(respInfo)\r
 220                         fxml.'virtual-datacenter-list'.each { vdc ->\r
 221                                 //we only want to add two BGF per VDC, BGF1 and BGF2\r
 222                                         def routerList = vdc.'router-list'.first()\r
 223                                         routerList.each{ myList ->\r
 224                                                 def physNodes  = myList.'**'.findAll {it.'border-element-tangibility'.text() =~ /PHYSICAL/}\r
 225                                                 def nodeToAdd\r
 226                                                 physNodes.each{\r
 227                                                         if(nodeToAdd==null){\r
 228                                                                 nodeToAdd = it\r
 229                                                         }else{\r
 230                                                                 def beid = nodeToAdd.'border-element-id'.text() +\r
 231                                                                          " " + nodeToAdd.'border-element-type'.text() +\r
 232                                                                          " and " +\r
 233                                                                          it.'border-element-id'.text() +\r
 234                                                                          " " + it.'border-element-type'.text()\r
 235                                                                 def mytag = nodeToAdd.'border-element-id'\r
 236                                                                 mytag[0].replaceBody(beid)\r
 237                                                         }\r
 238                                                 }\r
 239                                                 def mytag = nodeToAdd.'vlan-id'\r
 240                                                 def ind = mytag.text().indexOf('.')\r
 241                                                 if(ind >= 0){\r
 242                                                         def vlan = mytag.text().substring(0,ind)\r
 243                                                         mytag[0].replaceBody(vlan)\r
 244                                                 }\r
 245                                                 myNodes.add(XmlUtil.serialize(nodeToAdd))\r
 246                                         }\r
 247                                         \r
 248                         }\r
 249                 }\r
 250                                 \r
 251                         return myNodes\r
 252                 }else{\r
 253                         return null\r
 254                 }\r
 255         }\r
 256         \r
 257         def getPBGFList(xmlInput){\r
 258                 getPBGFList("false", xmlInput)\r
 259         }\r
 260         \r
 261         def String decodeXML(xml) {\r
 262                 def String decodedXml = xml.replaceAll("&amp;", "&")\r
 263                 decodedXml = decodedXml.replaceAll("&lt;", "<")\r
 264                 decodedXml = decodedXml.replaceAll("&gt;", ">")\r
 265         }\r
 266         \r
 267         def getMetaVal(node, name){\r
 268                 try{\r
 269                         return node.'**'.find {it.metaname.text() == name}.metaval.text()\r
 270                 }catch(Exception e){\r
 271                         return null\r
 272                 }\r
 273         }\r
 274         def getRelationshipVal(node, name){\r
 275                 try{\r
 276                         return node.'**'.find {it.'relationship-key'.text() == name}.'relationship-value'.text()\r
 277                 }catch(Exception e){\r
 278                         return null\r
 279                 }\r
 280         }\r
 281 \r
 282         \r
 283         def log(logmode,logtxt,isDebugLogEnabled="false"){\r
 284                 MsoLogger msoLogger = MsoLogger.getMsoLogger(MsoLogger.Catalog.BPEL);\r
 285                 if ("INFO"==logmode) {\r
 286                         msoLogger.info(MessageEnum.BPMN_GENERAL_EXCEPTION_ARG, logtxt);\r
 287                 } else if ("WARN"==logmode) {\r
 288                         // to see the warning text displayed in the log entry, the text must also be passed as arg0 (2nd argument) to invoke the correct MsoLogger warn() method\r
 289                         msoLogger.warn (MessageEnum.BPMN_GENERAL_WARNING, logtxt, "BPMN", MsoLogger.getServiceName(), MsoLogger.ErrorCode.UnknownError, logtxt);\r
 290                 } else if ("ERROR"==logmode) {\r
 291                         // to see the error text displayed in the log entry, the text must also be passed as arg0 (2nd argument) to invoke the correct MsoLogger error() method\r
 292                     msoLogger.error(MessageEnum.BPMN_GENERAL_EXCEPTION_ARG, logtxt, "BPMN", MsoLogger.getServiceName(), MsoLogger.ErrorCode.UnknownError, logtxt);\r
 293 \r
 294                 } else {\r
 295                         BPMNLogger.debug(isDebugLogEnabled, logtxt);\r
 296                 }\r
 297         }\r
 298         \r
 299         def logContext(requestId, serviceInstanceId){\r
 300             MsoLogger msoLogger = MsoLogger.getMsoLogger(MsoLogger.Catalog.BPEL);\r
 301                 msoLogger.setLogContext(requestId, serviceInstanceId);\r
 302         }\r
 303         \r
 304         def logMetrics(elapsedTime, logtxt){\r
 305                 MsoLogger metricsLogger = MsoLogger.getMsoLogger(MsoLogger.Catalog.BPEL);\r
 306                 \r
 307                 metricsLogger.recordMetricEvent (elapsedTime, MsoLogger.StatusCode.COMPLETE, MsoLogger.ResponseCode.Suc,\r
 308                         logtxt, "BPMN", MsoLogger.getServiceName(), null);\r
 309         }\r
 310         \r
 311         def logAudit(logtxt){\r
 312                 MsoLogger auditLogger = MsoLogger.getMsoLogger(MsoLogger.Catalog.BPEL);\r
 313                 long startTime = System.currentTimeMillis();\r
 314                 \r
 315                 auditLogger.recordAuditEvent (startTime, MsoLogger.StatusCode.COMPLETE, MsoLogger.ResponseCode.Suc, logtxt);\r
 316         }\r
 317         \r
 318         // headers: header - name-value\r
 319         def getHeaderNameValue(xmlInput, nameAttribute){\r
 320                 def rtn=null\r
 321                 if(xmlInput!=null){\r
 322                         def xml= new XmlSlurper().parseText(xmlInput)\r
 323                         rtn= xml.'**'.find {header->header.'@name'.text() == nameAttribute}.'@value'\r
 324                 }\r
 325                 return rtn\r
 326         }\r
 327         \r
 328         /**\r
 329          * Gets the children of the specified element.\r
 330          */\r
 331         public String getChildNodes(xmlInput, element) {\r
 332                 def xml= new XmlSlurper().parseText(xmlInput)\r
 333                 def thisElement = xml.'**'.find {it.name() == element}\r
 334                 StringBuilder out = new StringBuilder()\r
 335                 if (thisElement != null) {\r
 336                         thisElement.children().each() {\r
 337                                 String nodeAsText = removeXmlPreamble(XmlUtil.serialize(it))\r
 338                                 if (out.length() > 0) {\r
 339                                         out.append(System.lineSeparator())\r
 340                                 }\r
 341                                 out.append(nodeAsText)\r
 342                         }\r
 343                 }\r
 344                 return out.toString();\r
 345         }\r
 346         \r
 347         /**\r
 348          * Encodes a value so it can be used inside an XML text element.\r
 349          * @param s the string to encode\r
 350          * @return the encoded string\r
 351          */\r
 352         public String xmlEncode(Object value) {\r
 353                 return XmlTool.encode(value)\r
 354         }\r
 355         \r
 356         /**\r
 357          * Encodes a value so it can be used inside an XML attribute.\r
 358          * @param s the string to encode\r
 359          * @return the encoded string\r
 360          */\r
 361         public String xmlEncodeAttr(Object value) {\r
 362                 return XmlTool.encodeAttr(value)\r
 363         }\r
 364         \r
 365         /**\r
 366          * Decodes XML entities in a string value\r
 367          * @param value a value with embedded XML entities\r
 368          * @return the decoded string\r
 369          */\r
 370         public String xmlDecode(Object value) {\r
 371                 return XmlTool.decode(value)\r
 372         }\r
 373         \r
 374         /**\r
 375          * Removes the preamble, if present, from an XML document.\r
 376          * Also, for historical reasons, this also trims leading and trailing\r
 377          * whitespace from the resulting document.  TODO: remove the trimming\r
 378          * and fix unit tests that depend on EXACT xml format.\r
 379          * @param xml the XML document\r
 380          * @return a possibly modified document\r
 381          */\r
 382         public String removeXmlPreamble(def xml) {\r
 383                 if (xml == null) {\r
 384                         return null\r
 385                 }\r
 386 \r
 387                 return XmlTool.removePreamble(xml).trim()\r
 388         }\r
 389 \r
 390         /**\r
 391          * Removes namespaces and namespace declarations from an XML document.\r
 392          * @param xml the XML document\r
 393          * @return a possibly modified document\r
 394          */\r
 395         public String removeXmlNamespaces(def xml) {\r
 396                 return XmlTool.removeNamespaces(xml);\r
 397         }\r
 398 \r
 399         /**\r
 400          * Use formatXml instead.  Note: this method inserts an XML preamble.\r
 401          */\r
 402         @Deprecated\r
 403         def formatXML(xmlInput) {\r
 404                 def parseXml = null\r
 405                 def formatXml = null\r
 406                 if (xmlInput !=null) {\r
 407                         parseXml = new XmlParser().parseText(xmlInput)\r
 408                         formatXml = XmlUtil.serialize(parseXml)\r
 409                 }\r
 410         }\r
 411 \r
 412         /**\r
 413          * Reformats an XML document. The result will not contain an XML preamble\r
 414          * or a trailing newline.\r
 415          * @param xml the XML document\r
 416          * @return a reformatted document\r
 417          */\r
 418         public String formatXml(def xml) {\r
 419                 return XmlTool.normalize(xml);\r
 420         }\r
 421         \r
 422         // build single elements\r
 423         def buildElements(xmlInput, elementList, parentName) {\r
 424                 String var = ""\r
 425                 def xmlBuild = ""\r
 426                 if (parentName != "") {\r
 427                    xmlBuild += "<tns2:"+parentName+">"\r
 428                 }   \r
 429                 if (xmlInput != null) {\r
 430                            for (element in elementList) {\r
 431                               def xml= new XmlSlurper().parseText(xmlInput)\r
 432                               var = xml.'**'.find {it.name() == element}\r
 433                                   if (var != null) {\r
 434                                  xmlBuild += "<tns2:"+element+">"+var.toString()+"</tns2:"+element+">"\r
 435                                   } \r
 436                            }\r
 437                 }\r
 438                 if (parentName != "") {\r
 439                    xmlBuild += "</tns2:"+parentName+">"\r
 440                 }   \r
 441                 return xmlBuild\r
 442         }\r
 443         \r
 444         // build the Unbounded elements\r
 445         def buildElementsUnbounded(xmlInput, elementList, parentName) {\r
 446                 def varParents = ""\r
 447                 def var = ""\r
 448                 def xmlBuildUnbounded = ""\r
 449                 if (xmlInput != null) {\r
 450                         def xml= new XmlSlurper().parseText(xmlInput)\r
 451                         varParents = xml.'**'.findAll {it.name() == parentName}\r
 452                         //println " Unbounded ${parentName} - varParent.Size() - " + varParents.size()\r
 453                         for (i in 0..varParents.size()-1) {\r
 454                                 if (parentName != "") {\r
 455                                         xmlBuildUnbounded += "<tns2:"+parentName+">"\r
 456                                  }\r
 457                                 for (element in elementList) {\r
 458                                         var = varParents[i].'*'.find {it.name() == element}\r
 459                                    if (var != null) {\r
 460                                           xmlBuildUnbounded += "<tns2:"+element+">"+var.toString()+"</tns2:"+element+">"\r
 461                                           //println " i = " + i + ", element: " + element + " = " + var.toString()\r
 462                                    }\r
 463                                 }\r
 464                                 if (parentName != "") {\r
 465                                         xmlBuildUnbounded += "</tns2:"+parentName+">"\r
 466                                  }\r
 467                         }\r
 468                 }\r
 469                 return xmlBuildUnbounded\r
 470          }\r
 471         \r
 472         // Build l2-homing-information\r
 473         def buildL2HomingInformation(xmlInput) {\r
 474                 def elementsL2HomingList = ["evc-name", "topology", "preferred-aic-clli"]\r
 475                 def rebuildL2Home = ''\r
 476                 if (xmlInput != null) {\r
 477                         rebuildL2Home = buildElements(xmlInput, elementsL2HomingList, "l2-homing-information")\r
 478                 }\r
 479                 return rebuildL2Home\r
 480         }\r
 481         \r
 482         // Build internet-evc-access-information\r
 483         def buildInternetEvcAccessInformation(xmlInput) {\r
 484                 def elementsInternetEvcAccessInformationList = ["internet-evc-speed-value", "internet-evc-speed-units", "ip-version"]\r
 485                 def rebuildInternetEvcAccess = ''\r
 486                 if (xmlInput != null) {\r
 487                         rebuildInternetEvcAccess = buildElements(xmlInput, elementsInternetEvcAccessInformationList, "internet-evc-access-information")\r
 488                 }\r
 489                 return rebuildInternetEvcAccess\r
 490         }\r
 491         \r
 492         // Build ucpe-vms-service-information\r
 493         def buildUcpeVmsServiceInformation(xmlInput) {\r
 494                 def rebuildUcpeVmsServiceInformation = ''\r
 495                 if (xmlInput != null) {\r
 496                         def ucpeVmsServiceInformation = getNodeXml(xmlInput, "ucpe-vms-service-information").drop(38).trim()\r
 497                         rebuildUcpeVmsServiceInformation = "<tns2:ucpe-vms-service-information>"\r
 498                         // transport-service-information\r
 499                         rebuildUcpeVmsServiceInformation += "<tns2:transport-service-information>"\r
 500                         def transportServiceInformation = getNodeXml(ucpeVmsServiceInformation, "transport-service-information").drop(38).trim()\r
 501                         def elementsTransportServiceInformationList = ["transport-service-type"]\r
 502                         rebuildUcpeVmsServiceInformation += buildElements(transportServiceInformation, elementsTransportServiceInformationList, "")\r
 503                         try { // optional\r
 504                                 def accessCircuitInfoList = ["access-circuit-id", "dual-mode"]\r
 505                                 rebuildUcpeVmsServiceInformation += buildElementsUnbounded(transportServiceInformation, accessCircuitInfoList, "access-circuit-info")\r
 506                         } catch (Exception e) {\r
 507                            log("ERROR", " Optional - Exception ACCESS-CIRCUIT-INFO - 'access-circuit-info' ")\r
 508                         }\r
 509                         rebuildUcpeVmsServiceInformation += "</tns2:transport-service-information>"\r
 510                         // ucpe-information\r
 511                         def elementsUcpeInformationList = ["ucpe-host-name", "ucpe-activation-code", "out-of-band-management-modem" ]\r
 512                         rebuildUcpeVmsServiceInformation += buildElements(ucpeVmsServiceInformation, elementsUcpeInformationList, "ucpe-information")\r
 513                         // vnf-list\r
 514                         rebuildUcpeVmsServiceInformation += "<tns2:vnf-list>"\r
 515                         def vnfListList = ["vnf-instance-id", "vnf-sequence-number", "vnf-type", "vnf-vendor", "vnf-model", "vnf-id", "prov-status", "operational-state", "orchestration-status", "equipment-role" ]\r
 516                         rebuildUcpeVmsServiceInformation += buildElementsUnbounded(ucpeVmsServiceInformation, vnfListList, "vnf-information")\r
 517                         rebuildUcpeVmsServiceInformation += "</tns2:vnf-list>"\r
 518                         rebuildUcpeVmsServiceInformation += "</tns2:ucpe-vms-service-information>"\r
 519                 }\r
 520                 log("DEBUG", " rebuildUcpeVmsServiceInformation - " + rebuildUcpeVmsServiceInformation)\r
 521                 return rebuildUcpeVmsServiceInformation\r
 522         }\r
 523         \r
 524     // Build internet-service-change-details\r
 525         def buildInternetServiceChangeDetails(xmlInput) {\r
 526                 def rebuildInternetServiceChangeDetails = ""\r
 527                 if (xmlInput != null) {\r
 528                     try { // optional\r
 529                                 def internetServiceChangeDetails = getNodeXml(xmlInput, "internet-service-change-details").drop(38).trim()\r
 530                                 rebuildInternetServiceChangeDetails = "<tns:internet-service-change-details>"\r
 531                                 rebuildInternetServiceChangeDetails += buildElements(internetServiceChangeDetails, ["internet-evc-speed-value"], "")\r
 532                                 rebuildInternetServiceChangeDetails += buildElements(internetServiceChangeDetails, ["internet-evc-speed-units"], "")\r
 533                                 try { // optional\r
 534                                    def tProvidedV4LanPublicPrefixesChangesList = ["request-index", "v4-next-hop-address", "v4-lan-public-prefix", "v4-lan-public-prefix-length"]\r
 535                                    rebuildInternetServiceChangeDetails += buildElementsUnbounded(internetServiceChangeDetails, tProvidedV4LanPublicPrefixesChangesList, "t-provided-v4-lan-public-prefixes")\r
 536                                 } catch (Exception e) {\r
 537                                    log("ERROR"," Optional - Exception in INTERNET-SERVICE-CHANGE-DETAILS 't-provided-v4-lan-public-prefixes ")\r
 538                             }\r
 539                                 try { // optional\r
 540                                   def tProvidedV6LanPublicPrefixesChangesList = ["request-index", "v6-next-hop-address", "v6-lan-public-prefix", "v6-lan-public-prefix-length"]\r
 541                                   rebuildInternetServiceChangeDetails += buildElementsUnbounded(internetServiceChangeDetails, tProvidedV6LanPublicPrefixesChangesList, "t-provided-v6-lan-public-prefixes")\r
 542                                 } catch (Exception e) {\r
 543                                         log("ERROR"," Optional - Exception INTERNET-SERVICE-CHANGE-DETAILS 't-provided-v6-lan-public-prefixes ")\r
 544                                 }\r
 545                                 rebuildInternetServiceChangeDetails += "</tns:internet-service-change-details>"\r
 546                         } catch (Exception e) {\r
 547                                 log("ERROR", " Optional - Exception INTERNET-SERVICE-CHANGE-DETAILS 'internet-service-change-details' ")\r
 548                         }\r
 549                 }\r
 550             return rebuildInternetServiceChangeDetails\r
 551         }               \r
 552         \r
 553         // Build vr-lan \r
 554         def buildVrLan(xmlInput) {\r
 555                 \r
 556                 def rebuildVrLan = ''\r
 557                 if (xmlInput != null) {\r
 558                         \r
 559                         rebuildVrLan = "<tns2:vr-lan>"\r
 560                         def vrLan = getNodeXml(xmlInput, "vr-lan").drop(38).trim()\r
 561                         rebuildVrLan += buildElements(vrLan, ["routing-protocol"], "")\r
 562                         \r
 563                         // vr-lan-interface\r
 564                         def rebuildVrLanInterface = "<tns2:vr-lan-interface>"\r
 565                         def vrLanInterface = getNodeXml(vrLan, "vr-lan-interface").drop(38).trim()\r
 566                         rebuildVrLanInterface += buildVrLanInterfacePartial(vrLanInterface)\r
 567                         \r
 568                          // dhcp\r
 569                          def dhcp = getNodeXml(vrLan, "dhcp").drop(38).trim()\r
 570                          def rebuildDhcp = buildDhcp(dhcp)\r
 571                          rebuildVrLanInterface += rebuildDhcp\r
 572                          \r
 573                          // pat\r
 574                          def pat = getNodeXml(vrLan, "pat").drop(38).trim()\r
 575                          def rebuildPat = buildPat(pat)\r
 576                          rebuildVrLanInterface += rebuildPat\r
 577                          \r
 578                          // nat\r
 579                          def rebuildNat = ""\r
 580                          try { // optional\r
 581                                 def nat = getNodeXml(vrLan, "nat").drop(38).trim()\r
 582                                 rebuildNat = buildNat(nat)\r
 583                          } catch (Exception e) {\r
 584                                  log("ERROR", " Optional - Exception 'nat' ")\r
 585                          }\r
 586                          rebuildVrLanInterface += rebuildNat\r
 587                                                                                 \r
 588                          // firewall-lite\r
 589                          def firewallLite = getNodeXml(vrLan, "firewall-lite").drop(38).trim()\r
 590                          def rebuildFirewallLite = buildFirewallLite(firewallLite)\r
 591                          rebuildVrLanInterface += rebuildFirewallLite\r
 592                          \r
 593                          // static-routes\r
 594                          def rebuildStaticRoutes = ""\r
 595                          try { // optional \r
 596                                  def staticRoutes = getNodeXml(vrLan, "static-routes").drop(38).trim()\r
 597                                  rebuildStaticRoutes = buildStaticRoutes(staticRoutes)\r
 598                         } catch (Exception e) {\r
 599                                  log("ERROR", " Optional - Exception 'static-routes' ")\r
 600                         }\r
 601                         rebuildVrLanInterface += rebuildStaticRoutes\r
 602                          \r
 603                    rebuildVrLan += rebuildVrLanInterface\r
 604                    rebuildVrLan += "</tns2:vr-lan-interface>"\r
 605                    rebuildVrLan += "</tns2:vr-lan>"\r
 606                         \r
 607                 }\r
 608                 log("DEBUG", " rebuildVrLan - " + rebuildVrLan)\r
 609                 return rebuildVrLan             \r
 610         }\r
 611         \r
 612         // Build vr-lan-interface\r
 613         def buildVrLanInterfacePartial(xmlInput) {\r
 614                 def rebuildingVrLanInterface = ''\r
 615                 if (xmlInput != null) {\r
 616                         def vrLanInterfaceList = ["vr-designation", "v4-vr-lan-prefix", "v4-vr-lan-address", "v4-vr-lan-prefix-length", "v6-vr-lan-prefix", "v6-vr-lan-address", "v6-vr-lan-prefix-length", "v4-vce-loopback-address", "v6-vce-wan-address"]\r
 617                         rebuildingVrLanInterface += buildElements(xmlInput, vrLanInterfaceList, "")\r
 618                         rebuildingVrLanInterface += "<tns2:v4-public-lan-prefixes>"\r
 619                         try { // optional\r
 620                                 def tProvidedV4LanPublicPrefixes = getNodeXml(xmlInput, "v4-public-lan-prefixes").drop(38).trim()\r
 621                                 def tProvidedV4LanPublicPrefixesList = ["request-index", "v4-next-hop-address", "v4-lan-public-prefix", "v4-lan-public-prefix-length" ]\r
 622                                 rebuildingVrLanInterface += buildElementsUnbounded(xmlInput, tProvidedV4LanPublicPrefixesList, "t-provided-v4-lan-public-prefixes")\r
 623                         } catch (Exception ex) {\r
 624                                 log("ERROR", " Optional - Exception VR-LAN INTERFACE 'v4-public-lan-prefixes' ")\r
 625                         }\r
 626                         rebuildingVrLanInterface += "</tns2:v4-public-lan-prefixes>"\r
 627                         rebuildingVrLanInterface += "<tns2:v6-public-lan-prefixes>"\r
 628                         try { // optional\r
 629                                 def tProvidedV6LanPublicPrefixes = getNodeXml(xmlInput, "v6-public-lan-prefixes").drop(38).trim()\r
 630                                 def tProvidedV6LanPublicPrefixesList = ["request-index", "v6-next-hop-address", "v6-lan-public-prefix", "v6-lan-public-prefix-length" ]\r
 631                                 rebuildingVrLanInterface += buildElementsUnbounded(xmlInput, tProvidedV6LanPublicPrefixesList, "t-provided-v6-lan-public-prefixes")\r
 632                         } catch (Exception e) {\r
 633                                 log("ERROR", " Optional - Exception VR-LAN INTERFACE 'v6-public-lan-prefixes' ")\r
 634                         }\r
 635                         rebuildingVrLanInterface += "</tns2:v6-public-lan-prefixes>"\r
 636                 }\r
 637                 log("DEBUG", " rebuildingVrLanInterface - " + rebuildingVrLanInterface)\r
 638                 return rebuildingVrLanInterface\r
 639         }\r
 640         \r
 641         // Build dhcp\r
 642         def buildDhcp(xmlInput) {\r
 643                 def rebuildingDhcp = ''\r
 644                 if (xmlInput != null) {\r
 645                         def dhcpData = new XmlSlurper().parseText(xmlInput)\r
 646                         rebuildingDhcp = "<tns2:dhcp>"\r
 647                         def dhcpList1 = ["v4-dhcp-server-enabled", "v6-dhcp-server-enabled", "use-v4-default-pool", "v4-dhcp-default-pool-prefix", "v4-dhcp-default-pool-prefix-length"]\r
 648                         rebuildingDhcp += buildElements(xmlInput, dhcpList1, "")\r
 649                         try { // optional\r
 650                                 def excludedV4DhcpAddressesFromDefaultPoolList = ["excluded-v4-address"]\r
 651                                 rebuildingDhcp += buildElementsUnbounded(xmlInput, excludedV4DhcpAddressesFromDefaultPoolList, "excluded-v4-dhcp-addresses-from-default-pool")\r
 652                         } catch (Exception e) {\r
 653                                 log("ERROR", " Optional - Exception DHCP 'excluded-v4-dhcp-addresses-from-default-pool' ")\r
 654                         }\r
 655                         try { // optional\r
 656                                 def v4DhcpPools = dhcpData.'**'.findAll {it.name() == "v4-dhcp-pools"}\r
 657                                 def v4DhcpPoolsSize = v4DhcpPools.size()\r
 658                                 // println " v4DhcpPoolsSize = " + v4DhcpPools.size()\r
 659                                 for (i in 0..v4DhcpPoolsSize-1) {\r
 660                                         def v4DhcpPool = v4DhcpPools[i]\r
 661                                         def v4DhcpPoolXml = XmlUtil.serialize(v4DhcpPool)\r
 662                                         rebuildingDhcp += "<tns2:v4-dhcp-pools>"\r
 663                                         def v4DhcpPoolsList1 = ["v4-dhcp-pool-prefix", "v4-dhcp-pool-prefix-length" ]\r
 664                                         rebuildingDhcp += buildElements(v4DhcpPoolXml, v4DhcpPoolsList1, "")\r
 665                                         try { // optional\r
 666                                            def excludedV4AddressesList = ["excluded-v4-address"]\r
 667                                            rebuildingDhcp += buildElementsUnbounded(v4DhcpPoolXml, excludedV4AddressesList, "excluded-v4-addresses")\r
 668                                         } catch (Exception e) {\r
 669                                            log("ERROR", " Optional - Exception DHCP 'excluded-v4-addresses' ")\r
 670                                         }\r
 671                                         def v4DhcpPoolsList2 = ["v4-dhcp-relay-gateway-address", "v4-dhcp-relay-next-hop-address"]\r
 672                                         rebuildingDhcp += buildElements(v4DhcpPoolXml, v4DhcpPoolsList2, "")\r
 673                                         rebuildingDhcp += "</tns2:v4-dhcp-pools>"\r
 674                                  }\r
 675                          } catch (Exception e) {\r
 676                                   log("ERROR"," Optional - Exception DHCP 'v4-dhcp-pools' ")\r
 677                          }\r
 678                          def dhcpList2 = ["use-v6-default-pool", "v6-dhcp-default-pool-prefix", "v6-dhcp-default-pool-prefix-length"]\r
 679                          rebuildingDhcp += buildElements(xmlInput, dhcpList2, "")\r
 680                          try { // optional\r
 681                                  def excludedV6DhcpAddressesFromDdefaultPoolList = ["excluded-v6-address"]\r
 682                                  rebuildingDhcp += buildElementsUnbounded(xmlInput, excludedV6DhcpAddressesFromDdefaultPoolList, "excluded-v6-dhcp-addresses-from-default-pool")\r
 683                          } catch (Exception e) {\r
 684                            log("ERROR", " Optional - Exception DHCP 'excluded-v6-dhcp-addresses-from-default-pool' ")\r
 685                          }\r
 686                          try { // optional\r
 687                                  def v6DhcpPools = dhcpData.'**'.findAll {it.name() == "v6-dhcp-pools"}\r
 688                                  def v6DhcpPoolsSize = v6DhcpPools.size()\r
 689                                  //println " v6DhcpPoolsSize = " + v6DhcpPools.size()\r
 690                                  for (i in 0..v6DhcpPoolsSize-1) {\r
 691                                         def v6DhcpPool = v6DhcpPools[i]\r
 692                                         def v6DhcpPoolXml = XmlUtil.serialize(v6DhcpPool)\r
 693                                         rebuildingDhcp += "<tns2:v6-dhcp-pools>"\r
 694                                         def v6DhcpPoolsList1 = ["v6-dhcp-pool-prefix", "v6-dhcp-pool-prefix-length"]\r
 695                                         rebuildingDhcp += buildElements(v6DhcpPoolXml, v6DhcpPoolsList1, "")\r
 696                                         try { // optional\r
 697                                                 def excludedV6AddressesList = ["excluded-v6-address"]\r
 698                                                 rebuildingDhcp += buildElementsUnbounded(v6DhcpPoolXml, excludedV6AddressesList, "excluded-v6-addresses")\r
 699                                         } catch (Exception e) {\r
 700                                                          log("ERROR", " Optional - Exception DHCP 'excluded-v6-addresses' ")\r
 701                                         }\r
 702                                         def v6DhcpPoolsList2 = ["v6-dhcp-relay-gateway-address", "v6-dhcp-relay-next-hop-address"]\r
 703                                         rebuildingDhcp += buildElements(v6DhcpPoolXml, v6DhcpPoolsList2, "")\r
 704                                         rebuildingDhcp += "</tns2:v6-dhcp-pools>"\r
 705                                  }\r
 706                          } catch (Exception e) {\r
 707                                  log("ERROR", " Optional - Exception DHCP 'v6-dhcp-pools' ")\r
 708                          }\r
 709                          rebuildingDhcp += "</tns2:dhcp>"\r
 710                 }        \r
 711                 log("DEBUG", " rebuildingDhcp - " + rebuildingDhcp)\r
 712                 return rebuildingDhcp\r
 713         }       \r
 714 \r
 715         // Build pat\r
 716         def buildPat(xmlInput) {\r
 717                  def rebuildingPat = ''\r
 718                  if (xmlInput != null) {\r
 719                          rebuildingPat = "<tns2:pat>"\r
 720                          def patList = ["v4-pat-enabled", "use-v4-default-pool", "v4-pat-default-pool-prefix", "v4-pat-default-pool-prefix-length"]\r
 721                          rebuildingPat += buildElements(xmlInput, patList, "")\r
 722                          try { // optional\r
 723                                  def v4PatPools = getNodeXml(xmlInput, "v4-pat-pools").drop(38).trim()\r
 724                                  def v4PatPoolsList = ["v4-pat-pool-prefix", "v4-pat-pool-prefix-length", "v4-pat-pool-next-hop-address"]\r
 725                                  rebuildingPat += buildElementsUnbounded(xmlInput, v4PatPoolsList, "v4-pat-pools")\r
 726                          } catch (Exception e) {\r
 727                                 log("ERROR", " Optional - Exception 'v4-pat-pool-next-hop-address' ")\r
 728                          }\r
 729                          rebuildingPat += "</tns2:pat>"\r
 730                  }\r
 731                  log("DEBUG", " rebuildingPat - " + rebuildingPat)\r
 732              return rebuildingPat\r
 733     }\r
 734         \r
 735         // Build nat\r
 736         def buildNat(xmlInput) {\r
 737                 def rebuildingNat = ''\r
 738                 if (xmlInput != null) {\r
 739                         rebuildingNat = "<tns2:nat>"\r
 740                         rebuildingNat += buildElements(xmlInput, ["v4-nat-enabled"], "")\r
 741                         try { // optional\r
 742                          def v4NatMappingEntries = getNodeXml(xmlInput, "v4-nat-mapping-entries").drop(38).trim()\r
 743                          def v4NatMappingEntriesList = ["v4-nat-internal", "v4-nat-next-hop-address", "v4-nat-external"]\r
 744                          rebuildingNat += buildElementsUnbounded(xmlInput, v4NatMappingEntriesList, "v4-nat-mapping-entries")\r
 745                         } catch (Exception e) {\r
 746                            log("ERROR", " Optional - Exception 'v4-nat-external' ")\r
 747                         }\r
 748                         rebuildingNat += "</tns2:nat>"\r
 749                 }\r
 750                 log("DEBUG", " rebuildingNat - " + rebuildingNat)\r
 751             return rebuildingNat\r
 752         }                               \r
 753         \r
 754         // Build firewall-lite\r
 755         def buildFirewallLite(xmlInput) {\r
 756                 def rebuildingFirewallLite = ''\r
 757                 \r
 758                 if (xmlInput != null) {\r
 759                         \r
 760                         def firewallLiteData = new XmlSlurper().parseText(xmlInput)\r
 761                         rebuildingFirewallLite = "<tns2:firewall-lite>"\r
 762                         def firewallLiteList = ["stateful-firewall-lite-v4-enabled", "stateful-firewall-lite-v6-enabled"]\r
 763                         rebuildingFirewallLite += buildElements(xmlInput, firewallLiteList, "")\r
 764                         \r
 765                          try { // optional\r
 766                                  def v4FirewallPacketFilters = firewallLiteData.'**'.findAll {it.name() == "v4-firewall-packet-filters"}\r
 767                                  def v4FirewallPacketFiltersSize = v4FirewallPacketFilters.size()\r
 768                                  //println " v4FirewallPacketFiltersSize = " + v4FirewallPacketFilters.size()\r
 769                                  for (i in 0..v4FirewallPacketFiltersSize-1) {\r
 770                                def v4FirewallPacketFilter = v4FirewallPacketFilters[i]\r
 771                                def v4FirewallPacketFilterXml = XmlUtil.serialize(v4FirewallPacketFilter)\r
 772                                    rebuildingFirewallLite += "<tns2:v4-firewall-packet-filters>"\r
 773                                    def v4FirewallPacketFiltersList = ["v4-firewall-prefix", "v4-firewall-prefix-length", "allow-icmp-ping"]\r
 774                                    rebuildingFirewallLite += buildElements(v4FirewallPacketFilterXml, v4FirewallPacketFiltersList, "")\r
 775                                    try {  // optional\r
 776                                   def udpPortsList = ["port-number"]\r
 777                                           rebuildingFirewallLite += buildElementsUnbounded(v4FirewallPacketFilterXml, udpPortsList, "udp-ports")\r
 778                                    } catch (Exception e) {\r
 779                                           log("ERROR", " Optional - Exception FIREWALL-LITE v4 'udp-ports' ")\r
 780                                    }\r
 781                                    try {  // optional\r
 782                                           def tcpPortsList =  ["port-number"]\r
 783                                           rebuildingFirewallLite += buildElementsUnbounded(v4FirewallPacketFilterXml, tcpPortsList, "tcp-ports")\r
 784                                    } catch (Exception e) {\r
 785                                       log("ERROR", " Optional - Exception FIREWALL-LITE v4 'tcp-ports' ")\r
 786                                    }\r
 787                                    rebuildingFirewallLite += "</tns2:v4-firewall-packet-filters>"\r
 788                                  }\r
 789                          } catch (Exception e) {\r
 790                                  log("ERROR", " Optional - Exception FIREWALL-LITE 'v4-firewall-packet-filters' ")\r
 791                          }\r
 792                          \r
 793                          try { // optional\r
 794                                  def v6FirewallPacketFilters = firewallLiteData.'**'.findAll {it.name() == "v6-firewall-packet-filters"}\r
 795                                  def v6FirewallPacketFiltersSize = v6FirewallPacketFilters.size()\r
 796                                  //println " v6FirewallPacketFiltersSize = " + v6FirewallPacketFilters.size()\r
 797                                  for (i in 0..v6FirewallPacketFiltersSize-1) {\r
 798                                         def v6FirewallPacketFilter = v6FirewallPacketFilters[i]\r
 799                                         def v6FirewallPacketFilterXml = XmlUtil.serialize(v6FirewallPacketFilter)\r
 800                                         rebuildingFirewallLite += "<tns2:v6-firewall-packet-filters>"\r
 801                                         def v6FirewallPacketFiltersList = ["v6-firewall-prefix", "v6-firewall-prefix-length", "allow-icmp-ping"]\r
 802                                         rebuildingFirewallLite += buildElements(v6FirewallPacketFilterXml, v6FirewallPacketFiltersList, "")\r
 803                                         try { // optional\r
 804                                                 def udpPortsList = ["port-number"]\r
 805                                                 rebuildingFirewallLite += buildElementsUnbounded(v6FirewallPacketFilterXml, udpPortsList, "udp-ports")\r
 806                                         } catch (Exception e) {\r
 807                                       log("ERROR", " Optional - Exception FIREWALL-LITE v6 'udp-ports' ")\r
 808                                         }\r
 809                                         try { // optional\r
 810                                                 def tcpPortsList =  ["port-number"]\r
 811                                                 rebuildingFirewallLite += buildElementsUnbounded(v6FirewallPacketFilterXml, tcpPortsList, "tcp-ports")\r
 812                                         } catch (Exception e) {\r
 813                                         log("ERROR", " Optional - Exception FIREWALL-LITE v6 'tcp-ports' ")\r
 814                                         }\r
 815                                rebuildingFirewallLite += "</tns2:v6-firewall-packet-filters>"\r
 816                                  }\r
 817                          } catch (Exception e) {\r
 818                                  log("ERROR", " Optional - Exception FIREWALL-LITE 'v6-firewall-packet-filters' ")\r
 819                          }\r
 820                          rebuildingFirewallLite+= "</tns2:firewall-lite>"\r
 821                 }\r
 822                 log("DEBUG", " rebuildingFirewallLite - " + rebuildingFirewallLite)\r
 823                 return rebuildingFirewallLite\r
 824      }\r
 825         \r
 826         def buildStaticRoutes(xmlInput) {\r
 827                 def rebuildingStaticRoutes = ''\r
 828                 if (xmlInput != null) {\r
 829                         rebuildingStaticRoutes = "<tns2:static-routes>"\r
 830                         def v4StaticRouteslist = ["v4-static-route-prefix","v4-static-route-prefix-length", "v4-next-hop-address"]\r
 831                         rebuildingStaticRoutes += buildElementsUnbounded(xmlInput, v4StaticRouteslist, "v4-static-routes")\r
 832                         def v6StaticRouteslist = ["v6-static-route-prefix","v6-static-route-prefix-length", "v6-next-hop-address"]\r
 833                         rebuildingStaticRoutes += buildElementsUnbounded(xmlInput, v6StaticRouteslist, "v6-static-routes")\r
 834                         rebuildingStaticRoutes += "</tns2:static-routes>"\r
 835                 }\r
 836                 log("DEBUG", " rebuildingStaticRoutes - " + rebuildingStaticRoutes)\r
 837                 return rebuildingStaticRoutes\r
 838         }\r
 839         \r
 840         public String generateCurrentTimeInUtc(){\r
 841                 final  SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'");\r
 842                 sdf.setTimeZone(TimeZone.getTimeZone("UTC"));\r
 843                 final String utcTime = sdf.format(new Date());\r
 844                 return utcTime;\r
 845         }\r
 846         \r
 847         public String generateCurrentTimeInGMT(){\r
 848                 final  SimpleDateFormat sdf = new SimpleDateFormat("E, d MMM yyyy h:m:s z");\r
 849                 sdf.setTimeZone(TimeZone.getTimeZone("GMT"));\r
 850                 final String utcTime = sdf.format(new Date());\r
 851                 return utcTime;\r
 852         }\r
 853         \r
 854 \r
 855         /**\r
 856          * @param encryptedAuth: encrypted credentials from urn properties\r
 857          * @param msoKey: key to use to decrypt from urn properties\r
 858          * @return base 64 encoded basic auth credentials\r
 859          */\r
 860         def getBasicAuth(encryptedAuth, msoKey){\r
 861                 if ((encryptedAuth == null || encryptedAuth.isEmpty()) || (msoKey == null || msoKey.isEmpty()))\r
 862                         return null\r
 863                 try {\r
 864                         def auth = decrypt(encryptedAuth, msoKey)\r
 865                         byte[] encoded = Base64.encodeBase64(auth.getBytes())\r
 866                         String encodedString = new String(encoded)\r
 867                         encodedString = "Basic " + encodedString\r
 868                         return encodedString\r
 869                 } catch (Exception ex) {\r
 870                         log("ERROR", "Unable to encode basic auth")\r
 871                         throw ex\r
 872                 }\r
 873         }\r
 874         \r
 875         def encrypt(toEncrypt, msokey){\r
 876                 try {\r
 877                         String result = CryptoUtils.encrypt(toEncrypt, msokey);\r
 878                         return result\r
 879                 }\r
 880                 catch (Exception e) {\r
 881                         log("ERROR", "Failed to encrypt credentials")\r
 882                 }\r
 883         }\r
 884         \r
 885         def decrypt(toDecrypt, msokey){\r
 886                 try {\r
 887                         String result = CryptoUtils.decrypt(toDecrypt, msokey);\r
 888                         return result\r
 889                 }\r
 890                 catch (Exception e) {\r
 891                         log("ERROR", "Failed to decrypt credentials")\r
 892                         throw e\r
 893                 }\r
 894         }\r
 895         \r
 896         /**\r
 897          * Return URL with qualified host name (if any) or urn mapping\r
 898          * @param  String url from urn mapping\r
 899          * @return String url with qualified host name\r
 900          */\r
 901         public String getQualifiedHostNameForCallback(String urnCallbackUrl) {\r
 902                 def callbackUrlToUse = urnCallbackUrl\r
 903                 try{\r
 904                         //swap host name with qualified host name from the jboss properties\r
 905                         def qualifiedHostName = System.getProperty("jboss.qualified.host.name")\r
 906                         if(qualifiedHostName!=null){\r
 907                                 log("DEBUG", "qualifiedHostName:\n" + qualifiedHostName)\r
 908                                 callbackUrlToUse = callbackUrlToUse.replaceAll("(http://)(.*)(:28080*)", {orig, first, torepl, last -> "${first}${qualifiedHostName}${last}"})\r
 909                         }\r
 910                 }catch(Exception e){\r
 911                                 log("DEBUG", "unable to grab qualified host name, using what's in urn properties for callbackurl. Exception was: " + e.printStackTrace())\r
 912                 }\r
 913                 return callbackUrlToUse\r
 914                 \r
 915         }\r
 916         \r
 917         /**\r
 918          * Retrieves text context of the element if the element exists, returns empty string otherwise\r
 919          * @param com.sun.org.apache.xerces.internal.dom.DeferredElementNSImpl element to parse\r
 920          * param String tagName tagName\r
 921          * @return String text content of the element\r
 922          */\r
 923          public String getElementText(Element element, String tagName) {\r
 924                 String text = ""\r
 925                 org.w3c.dom.NodeList nodeList = element.getElementsByTagNameNS("*", tagName)\r
 926                 if (nodeList != null && nodeList.length > 0) {\r
 927                         text = nodeList.item(0).getTextContent()\r
 928                 }\r
 929                 return text\r
 930          }\r
 931          \r
 932          /**\r
 933           *\r
 934           * Find the lowest unused module-index value in a given xml\r
 935           */\r
 936          public String getLowestUnusedIndex(String xml) {\r
 937                  if (xml == null || xml.isEmpty()) {\r
 938                          return "0"\r
 939                  }               \r
 940                  def moduleIndexList = getMultNodes(xml, "module-index") \r
 941                  if (moduleIndexList == null || moduleIndexList.size() == 0) {                  \r
 942                          return "0"\r
 943                  }\r
 944                  def sortedModuleIndexList = moduleIndexList.sort { a, b -> a.compareTo b }\r
 945                 \r
 946                  for (i in 0..sortedModuleIndexList.size()-1) {\r
 947                          if (Integer.parseInt(sortedModuleIndexList[i]) != i) {\r
 948                                  return i.toString()\r
 949                          }\r
 950                  }\r
 951                  return sortedModuleIndexList.size().toString()\r
 952          }\r
 953         /**\r
 954          * This utility checks if there is transaction id already present in MDC.\r
 955          * If found, it returns same else creates new, sets in MDC for future use before returning\r
 956          * @return String RequestId in UUID format.\r
 957          */\r
 958         public String getRequestID()\r
 959         {\r
 960                 String requestId = MDC.get("RequestId")\r
 961                 if(requestId == null || requestId.isEmpty())\r
 962                 {\r
 963                         requestId = java.util.UUID.randomUUID()\r
 964                         MDC.put("RequestId",requestId)\r
 965                         log("DEBUG","MsoUtils - Created new RequestId: " + requestId)\r
 966                 }\r
 967                 else\r
 968                 {\r
 969                         log("DEBUG","MsoUtils - Using existing RequestId: " + requestId)\r
 970                 }\r
 971 \r
 972                 return requestId\r
 973         }\r
 974 }\r