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