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

   1 /*-\r
   2  * ============LICENSE_START=======================================================\r
   3  * ONAP - SO\r
   4  * ================================================================================\r
   5  * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.\r
   6  * ================================================================================\r
   7  * Licensed under the Apache License, Version 2.0 (the "License");\r
   8  * you may not use this file except in compliance with the License.\r
   9  * You may obtain a copy of the License at\r
  10  *\r
  11  *      http://www.apache.org/licenses/LICENSE-2.0\r
  12  *\r
  13  * Unless required by applicable law or agreed to in writing, software\r
  14  * distributed under the License is distributed on an "AS IS" BASIS,\r
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
  16  * See the License for the specific language governing permissions and\r
  17  * limitations under the License.\r
  18  * ============LICENSE_END=========================================================\r
  19  */\r
  20 \r
  21 package org.openecomp.mso.bpmn.common.scripts\r
  22 \r
  23 import org.json.JSONObject;\r
  24 import org.json.JSONArray;\r
  25 import org.json.XML;\r
  26 import org.springframework.web.util.UriUtils;\r
  27 \r
  28 import org.openecomp.mso.bpmn.core.json.JsonUtils\r
  29 \r
  30 \r
  31 import groovy.json.JsonBuilder\r
  32 import groovy.json.JsonSlurper\r
  33 import groovy.util.slurpersupport.GPathResult\r
  34 import groovy.xml.QName;\r
  35 \r
  36 import org.camunda.bpm.engine.runtime.Execution\r
  37 \r
  38 import org.openecomp.mso.logger.MsoLogger;\r
  39 import org.openecomp.mso.rest.APIResponse;\r
  40 import org.openecomp.mso.rest.RESTClient\r
  41 import org.openecomp.mso.rest.RESTConfig\r
  42 \r
  43 \r
  44 /***\r
  45  * Utilities for accessing Catalog DB Adapter to retrieve Networks, VNF/VFModules, AllottedResources and complete ServiceResources information\r
  46  *\r
  47  */\r
  48 \r
  49 class CatalogDbUtils {\r
  50         \r
  51         MsoUtils utils = new MsoUtils()\r
  52         JsonUtils jsonUtils = new JsonUtils()\r
  53         MsoLogger msoLogger = MsoLogger.getMsoLogger(MsoLogger.Catalog.BPEL);\r
  54         static private String defaultDbAdapterVersion = "v2"\r
  55 \r
  56         public JSONArray getAllNetworksByServiceModelUuid(Execution execution, String serviceModelUuid) {\r
  57                 JSONArray networksList = null           \r
  58                 String endPoint = "/serviceNetworks?serviceModelUuid=" + UriUtils.encode(serviceModelUuid, "UTF-8")\r
  59                 try {\r
  60                         String catalogDbResponse = getResponseFromCatalogDb(execution, endPoint)\r
  61 \r
  62                         if (catalogDbResponse != null) {\r
  63                                 networksList = parseNetworksJson(catalogDbResponse, "serviceNetworks", "v1")\r
  64                         }\r
  65 \r
  66                 }\r
  67                 catch (Exception e) {\r
  68                         utils.log("ERROR", "Exception in Querying Catalog DB: " + e.message)\r
  69                 }\r
  70 \r
  71                 return networksList\r
  72         }\r
  73 \r
  74         public JSONArray getAllNetworksByServiceModelUuid(Execution execution, String serviceModelUuid, String catalogUtilsVersion) {\r
  75                 JSONArray networksList = null           \r
  76                 String endPoint = "/serviceNetworks?serviceModelUuid=" + UriUtils.encode(serviceModelUuid, "UTF-8")\r
  77                 try {\r
  78                         String catalogDbResponse = getResponseFromCatalogDb(execution, endPoint)\r
  79 \r
  80                         if (catalogDbResponse != null) {\r
  81                                 if (!catalogUtilsVersion.equals("v1")) {\r
  82                                         JSONObject responseJson = new JSONObject(catalogDbResponse)\r
  83                                         networksList = responseJson.getJSONArray("serviceNetworks")\r
  84                                 }\r
  85                                 else {\r
  86                                         networksList = parseNetworksJson(catalogDbResponse, "serviceNetworks", catalogUtilsVersion)\r
  87                                 }\r
  88                         }\r
  89 \r
  90                 }\r
  91                 catch (Exception e) {\r
  92                         utils.log("ERROR", "Exception in Querying Catalog DB: " + e.message)\r
  93                 }\r
  94 \r
  95                 return networksList\r
  96         }\r
  97 \r
  98         public JSONArray getAllNetworksByServiceModelInvariantUuid(Execution execution, String serviceModelInvariantUuid) {\r
  99                 JSONArray networksList = null           \r
 100                 String endPoint = "/serviceNetworks?serviceModelInvariantUuid=" + UriUtils.encode(serviceModelInvariantUuid, "UTF-8")\r
 101                 try {\r
 102                         String catalogDbResponse = getResponseFromCatalogDb(execution, endPoint)\r
 103 \r
 104                         if (catalogDbResponse != null) {\r
 105                                 networksList = parseNetworksJson(catalogDbResponse, "serviceNetworks", "v1")\r
 106                         }\r
 107 \r
 108                 }\r
 109                 catch (Exception e) {\r
 110                         utils.log("ERROR", "Exception in Querying Catalog DB: " + e.message)\r
 111                 }\r
 112 \r
 113                 return networksList\r
 114         }\r
 115 \r
 116         public JSONArray getAllNetworksByServiceModelInvariantUuid(Execution execution, String serviceModelInvariantUuid, String catalogUtilsVersion) {\r
 117                 JSONArray networksList = null           \r
 118                 String endPoint = "/serviceNetworks?serviceModelInvariantUuid=" + UriUtils.encode(serviceModelInvariantUuid, "UTF-8")\r
 119                 try {\r
 120                         String catalogDbResponse = getResponseFromCatalogDb(execution, endPoint)\r
 121 \r
 122                         if (catalogDbResponse != null) {\r
 123                                 if (!catalogUtilsVersion.equals("v1")) {\r
 124                                         JSONObject responseJson = new JSONObject(catalogDbResponse)\r
 125                                         networksList = responseJson.getJSONArray("serviceNetworks")\r
 126                                 }\r
 127                                 else {\r
 128                                         networksList = parseNetworksJson(catalogDbResponse, "serviceNetworks", catalogUtilsVersion)\r
 129                                 }\r
 130                         }\r
 131 \r
 132                 }\r
 133                 catch (Exception e) {\r
 134                         utils.log("ERROR", "Exception in Querying Catalog DB: " + e.message)\r
 135                 }\r
 136 \r
 137                 return networksList\r
 138         }\r
 139 \r
 140         public JSONArray getAllNetworksByServiceModelInvariantUuidAndServiceModelVersion(Execution execution, String serviceModelInvariantUuid, String serviceModelVersion) {\r
 141                 JSONArray networksList = null           \r
 142                 String endPoint = "/serviceNetworks?serviceModelInvariantUuid=" + UriUtils.encode(serviceModelInvariantUuid, "UTF-8") + "&serviceModelVersion=" + UriUtils.encode(serviceModelVersion, "UTF-8")\r
 143                 try {\r
 144                         String catalogDbResponse = getResponseFromCatalogDb(execution, endPoint)\r
 145 \r
 146                         if (catalogDbResponse != null) {\r
 147                                 networksList = parseNetworksJson(catalogDbResponse, "serviceNetworks", "v1")\r
 148                         }\r
 149 \r
 150                 }\r
 151                 catch (Exception e) {\r
 152                         utils.log("ERROR", "Exception in Querying Catalog DB: " + e.message)\r
 153                 }\r
 154 \r
 155                 return networksList\r
 156         }\r
 157 \r
 158         public JSONArray getAllNetworksByServiceModelInvariantUuidAndServiceModelVersion(Execution execution, String serviceModelInvariantUuid, String serviceModelVersion, String catalogUtilsVersion) {\r
 159                 JSONArray networksList = null           \r
 160                 String endPoint = "/serviceNetworks?serviceModelInvariantUuid=" + UriUtils.encode(serviceModelInvariantUuid, "UTF-8") + "&serviceModelVersion=" + UriUtils.encode(serviceModelVersion, "UTF-8")\r
 161                 try {\r
 162                         String catalogDbResponse = getResponseFromCatalogDb(execution, endPoint)\r
 163 \r
 164                         if (catalogDbResponse != null) {\r
 165                                 if (!catalogUtilsVersion.equals("v1")) {\r
 166                                         JSONObject responseJson = new JSONObject(catalogDbResponse)\r
 167                                         networksList = responseJson.getJSONArray("serviceNetworks")\r
 168                                 }\r
 169                                 else {\r
 170                                         networksList = parseNetworksJson(catalogDbResponse, "serviceNetworks", catalogUtilsVersion)\r
 171                                 }\r
 172                         }\r
 173 \r
 174                 }\r
 175                 catch (Exception e) {\r
 176                         utils.log("ERROR", "Exception in Querying Catalog DB: " + e.message)\r
 177                 }\r
 178 \r
 179                 return networksList\r
 180         }\r
 181 \r
 182         public JSONArray getAllNetworksByNetworkModelCustomizationUuid(Execution execution, String networkModelCustomizationUuid) {\r
 183                 JSONArray networksList = null           \r
 184                 String endPoint = "/serviceNetworks?networkModelCustomizationUuid=" + UriUtils.encode(networkModelCustomizationUuid, "UTF-8")\r
 185                 try {\r
 186                         String catalogDbResponse = getResponseFromCatalogDb(execution, endPoint)\r
 187 \r
 188                         if (catalogDbResponse != null) {\r
 189                                 networksList = parseNetworksJson(catalogDbResponse, "serviceNetworks", "v1")\r
 190                         }\r
 191 \r
 192                 }\r
 193                 catch (Exception e) {\r
 194                         utils.log("ERROR", "Exception in Querying Catalog DB: " + e.message)\r
 195                 }\r
 196 \r
 197                 return networksList\r
 198         }\r
 199 \r
 200         public JSONArray getAllNetworksByNetworkModelCustomizationUuid(Execution execution, String networkModelCustomizationUuid, String catalogUtilsVersion) {\r
 201                 JSONArray networksList = null           \r
 202                 String endPoint = "/serviceNetworks?networkModelCustomizationUuid=" + UriUtils.encode(networkModelCustomizationUuid, "UTF-8")\r
 203                 try {\r
 204                         String catalogDbResponse = getResponseFromCatalogDb(execution, endPoint)\r
 205 \r
 206                         if (catalogDbResponse != null) {\r
 207                                 if (!catalogUtilsVersion.equals("v1")) {\r
 208                                         JSONObject responseJson = new JSONObject(catalogDbResponse)\r
 209                                         networksList = responseJson.getJSONArray("serviceNetworks")\r
 210                                 }\r
 211                                 else {\r
 212                                         networksList = parseNetworksJson(catalogDbResponse, "serviceNetworks", catalogUtilsVersion)\r
 213                                 }\r
 214                         }\r
 215 \r
 216                 }\r
 217                 catch (Exception e) {\r
 218                         utils.log("ERROR", "Exception in Querying Catalog DB: " + e.message)\r
 219                 }\r
 220 \r
 221                 return networksList\r
 222         }\r
 223 \r
 224         public JSONArray getAllNetworksByNetworkType(Execution execution, String networkType) {\r
 225                 JSONArray networksList = null           \r
 226                 String endPoint = "/serviceNetworks?networkType=" + UriUtils.encode(networkType, "UTF-8")\r
 227                 try {\r
 228                         String catalogDbResponse = getResponseFromCatalogDb(execution, endPoint)\r
 229 \r
 230                         if (catalogDbResponse != null) {\r
 231                                 networksList = parseNetworksJson(catalogDbResponse, "serviceNetworks", "v1")\r
 232                         }\r
 233 \r
 234                 }\r
 235                 catch (Exception e) {\r
 236                         utils.log("ERROR", "Exception in Querying Catalog DB: " + e.message)\r
 237                 }\r
 238 \r
 239                 return networksList\r
 240         }\r
 241 \r
 242         public JSONArray getAllNetworksByNetworkType(Execution execution, String networkType, String catalogUtilsVersion) {\r
 243                 JSONArray networksList = null           \r
 244                 String endPoint = "/serviceNetworks?networkType=" + UriUtils.encode(networkType, "UTF-8")\r
 245                 try {\r
 246                         String catalogDbResponse = getResponseFromCatalogDb(execution, endPoint)\r
 247 \r
 248                         if (catalogDbResponse != null) {\r
 249                                 if (!catalogUtilsVersion.equals("v1")) {\r
 250                                         JSONObject responseJson = new JSONObject(catalogDbResponse)\r
 251                                         networksList = responseJson.getJSONArray("serviceNetworks")\r
 252                                 }\r
 253                                 else {\r
 254                                         networksList = parseNetworksJson(catalogDbResponse, "serviceNetworks", catalogUtilsVersion)\r
 255                                 }\r
 256                         }\r
 257 \r
 258                 }\r
 259                 catch (Exception e) {\r
 260                         utils.log("ERROR", "Exception in Querying Catalog DB: " + e.message)\r
 261                 }\r
 262 \r
 263                 return networksList\r
 264         }\r
 265 \r
 266 \r
 267         public JSONArray getAllVnfsByServiceModelUuid(Execution execution, String serviceModelUuid) {\r
 268                 JSONArray vnfsList = null               \r
 269                 String endPoint = "/serviceVnfs?serviceModelUuid=" + UriUtils.encode(serviceModelUuid, "UTF-8")\r
 270                 try {\r
 271                         msoLogger.debug("ENDPOINT: " + endPoint)\r
 272                         String catalogDbResponse = getResponseFromCatalogDb(execution, endPoint)\r
 273 \r
 274                         if (catalogDbResponse != null) {\r
 275                                 vnfsList = parseVnfsJson(catalogDbResponse, "serviceVnfs", "v1")\r
 276                         }\r
 277 \r
 278                 }\r
 279                 catch (Exception e) {\r
 280                         utils.log("ERROR", "Exception in Querying Catalog DB: " + e.message)\r
 281                 }\r
 282 \r
 283                 return vnfsList\r
 284         }\r
 285 \r
 286         public JSONArray getAllVnfsByServiceModelUuid(Execution execution, String serviceModelUuid, String catalogUtilsVersion) {\r
 287                 JSONArray vnfsList = null               \r
 288                 String endPoint = "/serviceVnfs?serviceModelUuid=" + UriUtils.encode(serviceModelUuid, "UTF-8")\r
 289                 try {\r
 290                         msoLogger.debug("ENDPOINT: " + endPoint)\r
 291                         String catalogDbResponse = getResponseFromCatalogDb(execution, endPoint)\r
 292 \r
 293                         if (catalogDbResponse != null) {\r
 294                                 if (!catalogUtilsVersion.equals("v1")) {\r
 295                                         JSONObject responseJson = new JSONObject(catalogDbResponse)\r
 296                                         vnfsList = responseJson.getJSONArray("serviceVnfs")\r
 297                                 }\r
 298                                 else {\r
 299                                         vnfsList = parseVnfsJson(catalogDbResponse, "serviceVnfs", catalogUtilsVersion)\r
 300                                 }\r
 301                         }\r
 302 \r
 303                 }\r
 304                 catch (Exception e) {\r
 305                         utils.log("ERROR", "Exception in Querying Catalog DB: " + e.message)\r
 306                 }\r
 307 \r
 308                 return vnfsList\r
 309         }\r
 310 \r
 311         public JSONArray getAllVnfsByServiceModelInvariantUuid(Execution execution, String serviceModelInvariantUuid) {\r
 312                 JSONArray vnfsList = null               \r
 313                 String endPoint ="/serviceVnfs?serviceModelInvariantUuid=" + UriUtils.encode(serviceModelInvariantUuid, "UTF-8")\r
 314                 try {\r
 315                         msoLogger.debug("ENDPOINT: " + endPoint)\r
 316                         String catalogDbResponse = getResponseFromCatalogDb(execution, endPoint)\r
 317 \r
 318                         if (catalogDbResponse != null) {\r
 319                                 vnfsList = parseVnfsJson(catalogDbResponse, "serviceVnfs", "v1")\r
 320                         }\r
 321 \r
 322                 }\r
 323                 catch (Exception e) {\r
 324                         utils.log("ERROR", "Exception in Querying Catalog DB: " + e.message)\r
 325                 }\r
 326 \r
 327                 return vnfsList\r
 328         }\r
 329 \r
 330         public JSONArray getAllVnfsByServiceModelInvariantUuid(Execution execution, String serviceModelInvariantUuid, String catalogUtilsVersion) {\r
 331                 JSONArray vnfsList = null               \r
 332                 String endPoint = "/serviceVnfs?serviceModelInvariantUuid=" + UriUtils.encode(serviceModelInvariantUuid, "UTF-8")\r
 333                 try {\r
 334                         msoLogger.debug("ENDPOINT: " + endPoint)\r
 335                         String catalogDbResponse = getResponseFromCatalogDb(execution, endPoint)\r
 336 \r
 337                         if (catalogDbResponse != null) {\r
 338                                 if (!catalogUtilsVersion.equals("v1")) {\r
 339                                         JSONObject responseJson = new JSONObject(catalogDbResponse)\r
 340                                         vnfsList = responseJson.getJSONArray("serviceVnfs")\r
 341                                 }\r
 342                                 else {\r
 343                                         vnfsList = parseVnfsJson(catalogDbResponse, "serviceVnfs", catalogUtilsVersion)\r
 344                                 }\r
 345                         }\r
 346 \r
 347                 }\r
 348                 catch (Exception e) {\r
 349                         utils.log("ERROR", "Exception in Querying Catalog DB: " + e.message)\r
 350                 }\r
 351 \r
 352                 return vnfsList\r
 353         }\r
 354 \r
 355         public JSONArray getAllVnfsByServiceModelInvariantUuidAndServiceModelVersion(Execution execution, String serviceModelInvariantUuid, String serviceModelVersion) {\r
 356                 JSONArray vnfsList = null               \r
 357                 String endPoint =  "/serviceVnfs?serviceModelInvariantUuid=" + UriUtils.encode(serviceModelInvariantUuid, "UTF-8") + "&serviceModelVersion=" + UriUtils.encode(serviceModelVersion, "UTF-8")\r
 358                 try {\r
 359                         msoLogger.debug("ENDPOINT: " + endPoint)\r
 360                         String catalogDbResponse = getResponseFromCatalogDb(execution, endPoint)\r
 361 \r
 362                         if (catalogDbResponse != null) {\r
 363                                 vnfsList = parseVnfsJson(catalogDbResponse, "serviceVnfs", "v1")\r
 364                         }\r
 365 \r
 366                 }\r
 367                 catch (Exception e) {\r
 368                         utils.log("ERROR", "Exception in Querying Catalog DB: " + e.message)\r
 369                 }\r
 370 \r
 371                 return vnfsList\r
 372         }\r
 373 \r
 374         public JSONArray getAllVnfsByServiceModelInvariantUuidAndServiceModelVersion(Execution execution, String serviceModelInvariantUuid, String serviceModelVersion, String catalogUtilsVersion) {\r
 375                 JSONArray vnfsList = null               \r
 376                 String endPoint = "/serviceVnfs?serviceModelInvariantUuid=" + UriUtils.encode(serviceModelInvariantUuid, "UTF-8") + "&serviceModelVersion=" + UriUtils.encode(serviceModelVersion, "UTF-8")\r
 377                 try {\r
 378                         msoLogger.debug("ENDPOINT: " + endPoint)\r
 379                         String catalogDbResponse = getResponseFromCatalogDb(execution, endPoint)\r
 380 \r
 381                         if (catalogDbResponse != null) {\r
 382                                 if (!catalogUtilsVersion.equals("v1")) {\r
 383                                         JSONObject responseJson = new JSONObject(catalogDbResponse)\r
 384                                         vnfsList = responseJson.getJSONArray("serviceVnfs")\r
 385                                 }\r
 386                                 else {\r
 387                                         vnfsList = parseVnfsJson(catalogDbResponse, "serviceVnfs", catalogUtilsVersion)\r
 388                                 }\r
 389                         }\r
 390 \r
 391                 }\r
 392                 catch (Exception e) {\r
 393                         utils.log("ERROR", "Exception in Querying Catalog DB: " + e.message)\r
 394                 }\r
 395 \r
 396                 return vnfsList\r
 397         }\r
 398 \r
 399         public JSONArray getAllVnfsByVnfModelCustomizationUuid(Execution execution, String vnfModelCustomizationUuid) {\r
 400                 JSONArray vnfsList = null               \r
 401                 String endPoint = "/serviceVnfs?vnfModelCustomizationUuid=" + UriUtils.encode(vnfModelCustomizationUuid, "UTF-8")\r
 402                 try {\r
 403                         msoLogger.debug("ENDPOINT: " + endPoint)\r
 404                         String catalogDbResponse = getResponseFromCatalogDb(execution, endPoint)\r
 405 \r
 406                         if (catalogDbResponse != null) {\r
 407                                 vnfsList = parseVnfsJson(catalogDbResponse, "serviceVnfs", "v1")\r
 408                         }\r
 409 \r
 410                 }\r
 411                 catch (Exception e) {\r
 412                         utils.log("ERROR", "Exception in Querying Catalog DB: " + e.message)\r
 413                 }\r
 414 \r
 415                 return vnfsList\r
 416         }\r
 417         \r
 418         /**\r
 419          * This method gets a all vnfs for a particular\r
 420          * service from the catalog database using the\r
 421          * service model's model name.\r
 422          *\r
 423          * @param catalogDbEndpoint\r
 424          * @param serviceModelModelName\r
 425          * @return vnfsList      *\r
 426          * \r
 427          */\r
 428         public JSONArray getAllVnfsByServiceModelModelName(Execution execution, String serviceModelModelName) {\r
 429                 JSONArray vnfsList = null\r
 430                 String endPoint = "/serviceVnfs?serviceModelName=" + UriUtils.encode(serviceModelModelName, "UTF-8")\r
 431                 try {\r
 432                         msoLogger.debug("ENDPOINT: " + endPoint)\r
 433                         String catalogDbResponse = getResponseFromCatalogDb(execution, endPoint)\r
 434 \r
 435                         if (catalogDbResponse != null) {\r
 436                                 vnfsList = parseVnfsJson(catalogDbResponse, "serviceVnfs", defaultDbAdapterVersion)\r
 437                         }\r
 438                 }catch (Exception e) {\r
 439                         utils.log("ERROR", "Exception in Querying Catalog DB: " + e.message)\r
 440                 }\r
 441                 return vnfsList\r
 442         }\r
 443 \r
 444         public JSONArray getAllVnfsByVnfModelCustomizationUuid(Execution execution, String vnfModelCustomizationUuid, String catalogUtilsVersion) {\r
 445                 JSONArray vnfsList = null               \r
 446                 String endPoint = "/serviceVnfs?vnfModelCustomizationUuid=" + UriUtils.encode(vnfModelCustomizationUuid, "UTF-8")\r
 447                 try {\r
 448                         msoLogger.debug("ENDPOINT: " + endPoint)\r
 449                         String catalogDbResponse = getResponseFromCatalogDb(execution, endPoint)\r
 450 \r
 451                         if (catalogDbResponse != null) {\r
 452                                 if (!catalogUtilsVersion.equals("v1")) {\r
 453                                         JSONObject responseJson = new JSONObject(catalogDbResponse)\r
 454                                         vnfsList = responseJson.getJSONArray("serviceVnfs")\r
 455                                 }\r
 456                                 else {\r
 457                                         vnfsList = parseVnfsJson(catalogDbResponse, "serviceVnfs", catalogUtilsVersion)\r
 458                                 }\r
 459                         }\r
 460 \r
 461                 }\r
 462                 catch (Exception e) {\r
 463                         utils.log("ERROR", "Exception in Querying Catalog DB: " + e.message)\r
 464                 }\r
 465 \r
 466                 return vnfsList\r
 467         }\r
 468 \r
 469         /**\r
 470          * This method gets a single vf module from\r
 471          * the catalog database using the vf module's\r
 472          * model name. It returns that vf module as\r
 473          * a JSONObject\r
 474          *\r
 475          * @param catalogDbEndpoint\r
 476          * @param vfModuleModelName\r
 477          * @return vfModule\r
 478          */\r
 479         public JSONObject getVfModuleByVfModuleModelName(Execution execution, String vfModuleModelName) {\r
 480                 JSONObject vfModule = null              \r
 481                 String endPoint = "/vfModules?vfModuleModelName=" + UriUtils.encode(vfModuleModelName, "UTF-8")\r
 482                 try{\r
 483                         msoLogger.debug("Get VfModule By VfModule ModelName Endpoint is: " + endPoint)\r
 484                         String catalogDbResponse = getResponseFromCatalogDb(execution, endPoint)\r
 485 \r
 486                         if (catalogDbResponse != null) {\r
 487                                 vfModule = parseVfModuleJson(catalogDbResponse, "vfModules", "v1")\r
 488                         }\r
 489                 }\r
 490                 catch(Exception e){\r
 491                         utils.log("ERROR", "Exception in Querying Catalog DB: " + e.message)\r
 492                 }\r
 493 \r
 494                 return vfModule\r
 495         }\r
 496 \r
 497         /**\r
 498          * This method gets a single vf module from\r
 499          * the catalog database using the vf module's\r
 500          * model name. It returns that vf module as\r
 501          * a JSONObject\r
 502          *\r
 503          * @param catalogDbEndpoint\r
 504          * @param vfModuleModelName\r
 505          * @param catalogUtilsVersion\r
 506          * @return vfModules\r
 507          */\r
 508         public JSONObject getVfModuleByVfModuleModelName(Execution execution, String vfModuleModelName, String catalogUtilsVersion)  {\r
 509                 JSONObject vfModule = null\r
 510                 String endPoint = "/vfModules?vfModuleModelName=" + UriUtils.encode(vfModuleModelName, "UTF-8")\r
 511                 try{\r
 512                         msoLogger.debug("Get VfModule By VfModule ModelName Endpoint is: " + endPoint)\r
 513                         String catalogDbResponse = getResponseFromCatalogDb(execution, endPoint)\r
 514 \r
 515                         if (catalogDbResponse != null) {\r
 516                                 vfModule = parseVfModuleJson(catalogDbResponse, "vfModules", "v1")\r
 517                         }\r
 518                 }\r
 519                 catch(Exception e){\r
 520                         utils.log("ERROR", "Exception in Querying Catalog DB: " + e.message)\r
 521                 }\r
 522 \r
 523                 return vfModule\r
 524         }\r
 525 \r
 526 \r
 527         public JSONArray getAllottedResourcesByServiceModelUuid(Execution execution, String serviceModelUuid) {\r
 528                 JSONArray vnfsList = null\r
 529                 String endPoint = "/ServiceAllottedResources?serviceModelUuid=" + UriUtils.encode(serviceModelUuid, "UTF-8")\r
 530                 try {\r
 531                         String catalogDbResponse = getResponseFromCatalogDb(execution, endPoint)\r
 532 \r
 533                         if (catalogDbResponse != null) {\r
 534                                 vnfsList = parseAllottedResourcesJson(catalogDbResponse, "serviceAllottedResources", "v1")\r
 535                         }\r
 536 \r
 537                 }\r
 538                 catch (Exception e) {\r
 539                         utils.log("ERROR", "Exception in Querying Catalog DB: " + e.message)\r
 540                 }\r
 541 \r
 542                 return vnfsList\r
 543         }\r
 544 \r
 545         public JSONArray getAllottedResourcesByServiceModelUuid(Execution execution, String serviceModelUuid, String catalogUtilsVersion) {\r
 546                 JSONArray vnfsList = null\r
 547                 String endPoint = "/ServiceAllottedResources?serviceModelUuid=" + UriUtils.encode(serviceModelUuid, "UTF-8")\r
 548                 try {\r
 549                         String catalogDbResponse = getResponseFromCatalogDb(execution, endPoint)\r
 550 \r
 551                         if (catalogDbResponse != null) {\r
 552                                 if (!catalogUtilsVersion.equals("v1")) {\r
 553                                         JSONObject responseJson = new JSONObject(catalogDbResponse)\r
 554                                         vnfsList = responseJson.getJSONArray("serviceAllottedResources")\r
 555                                 }\r
 556                                 else {\r
 557                                         vnfsList = parseAllottedResourcesJson(catalogDbResponse, "serviceAllottedResources", catalogUtilsVersion)\r
 558                                 }\r
 559                         }\r
 560 \r
 561                 }\r
 562                 catch (Exception e) {\r
 563                         utils.log("ERROR", "Exception in Querying Catalog DB: " + e.message)\r
 564                 }\r
 565 \r
 566                 return vnfsList\r
 567         }\r
 568 \r
 569         public JSONArray getAllottedResourcesByServiceModelInvariantUuid(Execution execution, String serviceModelInvariantUuid) {\r
 570                 JSONArray vnfsList = null\r
 571                 String endPoint = "/serviceAllottedResources?serviceModelInvariantUuid=" + UriUtils.encode(serviceModelInvariantUuid, "UTF-8")\r
 572                 try {\r
 573                         String catalogDbResponse = getResponseFromCatalogDb(execution, endPoint)\r
 574 \r
 575                         if (catalogDbResponse != null) {\r
 576                                 vnfsList = parseAllottedResourcesJson(catalogDbResponse, "serviceAllottedResources", "v1")\r
 577                         }\r
 578 \r
 579                 }\r
 580                 catch (Exception e) {\r
 581                         utils.log("ERROR", "Exception in Querying Catalog DB: " + e.message)\r
 582                 }\r
 583 \r
 584                 return vnfsList\r
 585         }\r
 586 \r
 587         public JSONArray getAllottedResourcesByServiceModelInvariantUuid(Execution execution, String serviceModelInvariantUuid, String catalogUtilsVersion) {\r
 588                 JSONArray vnfsList = null\r
 589                 String endPoint = "/serviceAllottedResources?serviceModelInvariantUuid=" + UriUtils.encode(serviceModelInvariantUuid, "UTF-8")\r
 590                 try {\r
 591                         String catalogDbResponse = getResponseFromCatalogDb(execution, endPoint)\r
 592 \r
 593                         if (catalogDbResponse != null) {\r
 594                                 if (!catalogUtilsVersion.equals("v1")) {\r
 595                                         JSONObject responseJson = new JSONObject(catalogDbResponse)\r
 596                                         vnfsList = responseJson.getJSONArray()\r
 597                                 }\r
 598                                 else {\r
 599                                         vnfsList = parseAllottedResourcesJson(catalogDbResponse, "serviceAllottedResources", catalogUtilsVersion)\r
 600                                 }\r
 601                         }\r
 602 \r
 603                 }\r
 604                 catch (Exception e) {\r
 605                         utils.log("ERROR", "Exception in Querying Catalog DB: " + e.message)\r
 606                         utils.log("ERROR", "Exception in Querying Catalog DB: " + e.getStackTrace())\r
 607                 }\r
 608 \r
 609                 return vnfsList\r
 610         }\r
 611 \r
 612         public JSONArray getAllottedResourcesByServiceModelInvariantUuidAndServiceModelVersion(Execution execution, String serviceModelInvariantUuid, String serviceModelVersion) {\r
 613                 JSONArray vnfsList = null\r
 614                 String endPoint = "/serviceAllottedResources?serviceModelInvariantUuid=" + UriUtils.encode(serviceModelInvariantUuid, "UTF-8") + "&serviceModelVersion=" + UriUtils.encode(serviceModelVersion, "UTF-8")\r
 615                 try {\r
 616                         String catalogDbResponse = getResponseFromCatalogDb(execution, endPoint)\r
 617 \r
 618                         if (catalogDbResponse != null) {\r
 619                                 vnfsList = parseAllottedResourcesJson(catalogDbResponse, "serviceAllottedResources", "v1")\r
 620                         }\r
 621 \r
 622                 }\r
 623                 catch (Exception e) {\r
 624                         utils.log("ERROR", "Exception in Querying Catalog DB: " + e.message)\r
 625                 }\r
 626 \r
 627                 return vnfsList\r
 628         }\r
 629 \r
 630         public JSONArray getAllottedResourcesByServiceModelInvariantUuidAndServiceModelVersion(Execution execution, String serviceModelInvariantUuid, String serviceModelVersion, String catalogUtilsVersion) {\r
 631                 JSONArray vnfsList = null\r
 632                 String endPoint = "/serviceAllottedResources?serviceModelInvariantUuid=" + UriUtils.encode(serviceModelInvariantUuid, "UTF-8") + "&serviceModelVersion=" + UriUtils.encode(serviceModelVersion, "UTF-8")\r
 633                 try {\r
 634                         String catalogDbResponse = getResponseFromCatalogDb(execution, endPoint)\r
 635 \r
 636                         if (catalogDbResponse != null) {\r
 637                                 if (!catalogUtilsVersion.equals("v1")) {\r
 638                                         JSONObject responseJson = new JSONObject(catalogDbResponse)\r
 639                                         vnfsList = responseJson.getJSONArray("serviceAllottedResources")\r
 640                                 }\r
 641                                 else {\r
 642                                         vnfsList = parseAllottedResourcesJson(catalogDbResponse, "serviceAllottedResources", catalogUtilsVersion)\r
 643                                 }\r
 644                         }\r
 645 \r
 646                 }\r
 647                 catch (Exception e) {\r
 648                         utils.log("ERROR", "Exception in Querying Catalog DB: " + e.message)\r
 649                 }\r
 650 \r
 651                 return vnfsList\r
 652         }\r
 653 \r
 654 \r
 655         public JSONArray getAllottedResourcesByArModelCustomizationUuid(Execution execution, String arModelCustomizationUuid) {\r
 656                 JSONArray vnfsList = null\r
 657                 String endPoint = "/serviceAllottedResources?serviceModelCustomizationUuid=" + UriUtils.encode(arModelCustomizationUuid, "UTF-8")\r
 658                 try {\r
 659                         String catalogDbResponse = getResponseFromCatalogDb(execution, endPoint)\r
 660 \r
 661                         if (catalogDbResponse != null) {\r
 662                                 vnfsList = parseAllottedResourcesJson(catalogDbResponse, "serviceAllottedResources", "v1")\r
 663                         }\r
 664 \r
 665                 }\r
 666                 catch (Exception e) {\r
 667                         utils.log("ERROR", "Exception in Querying Catalog DB: " + e.message)\r
 668                 }\r
 669 \r
 670                 return vnfsList\r
 671         }\r
 672 \r
 673         public JSONArray getAllottedResourcesByArModelCustomizationUuid(Execution execution, String arModelCustomizationUuid, String catalogUtilsVersion) {\r
 674                 JSONArray vnfsList = null\r
 675                 String endPoint = "/serviceAllottedResources?serviceModelCustomizationUuid=" + UriUtils.encode(arModelCustomizationUuid, "UTF-8")\r
 676                 try {\r
 677                         String catalogDbResponse = getResponseFromCatalogDb(execution, endPoint)\r
 678 \r
 679                         if (catalogDbResponse != null) {\r
 680                                 if (!catalogUtilsVersion.equals("v1")) {\r
 681                                         JSONObject responseJson = new JSONObject(catalogDbResponse)\r
 682                                         vnfsList = responseJson.getJSONArray("serviceAllottedResources")\r
 683                                 }\r
 684                                 else {\r
 685                                         vnfsList = parseAllottedResourcesJson(catalogDbResponse, "serviceAllottedResources", catalogUtilsVersion)\r
 686                                 }\r
 687                         }\r
 688 \r
 689                 }\r
 690                 catch (Exception e) {\r
 691                         utils.log("ERROR", "Exception in Querying Catalog DB: " + e.message)\r
 692                 }\r
 693 \r
 694                 return vnfsList\r
 695         }\r
 696 \r
 697         public JSONObject getServiceResourcesByServiceModelInvariantUuid(Execution execution, String serviceModelInvariantUuid) {\r
 698                 JSONObject resources = null\r
 699                 String endPoint = "/serviceResources?serviceModelInvariantUuid=" + UriUtils.encode(serviceModelInvariantUuid, "UTF-8")\r
 700                 try {\r
 701                         String catalogDbResponse = getResponseFromCatalogDb(execution, endPoint)\r
 702 \r
 703                         if (catalogDbResponse != null) {\r
 704 \r
 705                                 resources = parseServiceResourcesJson(catalogDbResponse, "v1")\r
 706                         }\r
 707 \r
 708                 }\r
 709                 catch (Exception e) {\r
 710                         utils.log("ERROR", "Exception in Querying Catalog DB: " + e.message)\r
 711                 }\r
 712 \r
 713                 return resources\r
 714         }\r
 715 \r
 716         public JSONObject getServiceResourcesByServiceModelInvariantUuid(Execution execution, String serviceModelInvariantUuid, String catalogUtilsVersion) {\r
 717                 JSONObject resources = null\r
 718                 String endPoint = "/serviceResources?serviceModelInvariantUuid=" + UriUtils.encode(serviceModelInvariantUuid, "UTF-8")\r
 719                 try {\r
 720                         String catalogDbResponse = getResponseFromCatalogDb(execution, endPoint)\r
 721 \r
 722                         if (catalogDbResponse != null) {\r
 723                                 if (!catalogUtilsVersion.equals("v1")) {\r
 724                                         resources = new JSONObject(catalogDbResponse)\r
 725                                 }\r
 726                                 else {\r
 727                                         resources = parseServiceResourcesJson(catalogDbResponse, catalogUtilsVersion)\r
 728                                 }\r
 729                         }\r
 730 \r
 731                 }\r
 732                 catch (Exception e) {\r
 733                         utils.log("ERROR", "Exception in Querying Catalog DB: " + e.message)\r
 734                 }\r
 735 \r
 736                 return resources\r
 737         }\r
 738 \r
 739 \r
 740         public JSONObject getServiceResourcesByServiceModelInvariantUuidAndServiceModelVersion(Execution execution, String serviceModelInvariantUuid, String serviceModelVersion) {\r
 741                 JSONObject resources = null\r
 742                 String endPoint = "/serviceResources?serviceModelInvariantUuid=" + UriUtils.encode(serviceModelInvariantUuid, "UTF-8") + "&serviceModelVersion=" + UriUtils.encode(serviceModelVersion, "UTF-8")\r
 743                 try {\r
 744                         String catalogDbResponse = getResponseFromCatalogDb(execution, endPoint)\r
 745 \r
 746                         if (catalogDbResponse != null) {\r
 747                                 resources = parseServiceResourcesJson(catalogDbResponse)\r
 748                         }\r
 749 \r
 750                 }\r
 751                 catch (Exception e) {\r
 752                         utils.log("ERROR", "Exception in Querying Catalog DB: " + e.message)\r
 753                 }\r
 754 \r
 755                 return resources\r
 756         }\r
 757 \r
 758         public JSONObject getServiceResourcesByServiceModelInvariantUuidAndServiceModelVersion(Execution execution, String serviceModelInvariantUuid, String serviceModelVersion, String catalogUtilsVersion) {\r
 759                 JSONObject resources = null\r
 760                 String endPoint = "/serviceResources?serviceModelInvariantUuid=" + UriUtils.encode(serviceModelInvariantUuid, "UTF-8") + "&serviceModelVersion=" + UriUtils.encode(serviceModelVersion, "UTF-8")\r
 761                 try {\r
 762                         String catalogDbResponse = getResponseFromCatalogDb(execution, endPoint)\r
 763 \r
 764                         if (catalogDbResponse != null) {\r
 765                                 if (!catalogUtilsVersion.equals("v1")) {\r
 766                                         resources = new JSONObject(catalogDbResponse)\r
 767                                 }\r
 768                                 else {\r
 769                                         resources = parseServiceResourcesJson(catalogDbResponse, catalogUtilsVersion)\r
 770                                 }\r
 771                         }\r
 772 \r
 773                 }\r
 774                 catch (Exception e) {\r
 775                         utils.log("ERROR", "Exception in Querying Catalog DB: " + e.message)\r
 776                 }\r
 777 \r
 778                 return resources\r
 779         }\r
 780 \r
 781 \r
 782 \r
 783         private JSONArray parseNetworksJson (String catalogDbResponse, String arrayName, String catalogUtilsVersion) {\r
 784                 JSONArray modelInfos = null\r
 785 \r
 786                 msoLogger.debug("parseNetworksJson - catalogUtilsVersion is " + catalogUtilsVersion)\r
 787                 try {\r
 788                         // Create array of jsons\r
 789 \r
 790                         JSONObject responseJson = new JSONObject(catalogDbResponse)\r
 791                         JSONArray networks = responseJson.getJSONArray(arrayName)\r
 792                         modelInfos = new JSONArray()\r
 793 \r
 794                         for (int i = 0; i < networks.length(); i++) {\r
 795 \r
 796                                 JSONObject network = networks.getJSONObject(i)\r
 797                                 JSONObject modelJson = new JSONObject()\r
 798                                 JSONObject modelInfo = buildModelInfo("network", network, catalogUtilsVersion)\r
 799                                 modelJson.put("modelInfo", modelInfo)\r
 800                                 String networkType = jsonUtils.getJsonValueForKey(network, "networkType")\r
 801                                 modelJson.put("networkType", networkType)\r
 802 \r
 803                                 switch (catalogUtilsVersion) {\r
 804                                         case "v1":\r
 805                                                 break\r
 806                                         default:\r
 807                                                 String toscaNodeType = jsonUtils.getJsonValueForKey(network, "toscaNodeType")\r
 808                                                 modelJson.put("toscaNodeType", toscaNodeType)\r
 809                                                 String networkTechnology = jsonUtils.getJsonValueForKey(network, "networkTechnology")\r
 810                                                 modelJson.put("networkTechnology", networkTechnology)\r
 811                                                 String networkRole = jsonUtils.getJsonValueForKey(network, "networkRole")\r
 812                                                 modelJson.put("networkRole", networkRole)\r
 813                                                 String networkScope = jsonUtils.getJsonValueForKey(network, "networkScope")\r
 814                                                 modelJson.put("networkScope", networkScope)\r
 815                                                 break\r
 816                                 }\r
 817                                 modelInfos.put(modelJson)\r
 818                         }\r
 819 \r
 820                         String modelInfosString = modelInfos.toString()\r
 821                         msoLogger.debug("Returning networks JSON: " + modelInfosString)\r
 822 \r
 823                 } catch (Exception e) {\r
 824                         utils.log("ERROR", "Exception in parsing Catalog DB Response: " + e.message)\r
 825                 }\r
 826 \r
 827                 return modelInfos\r
 828         }\r
 829 \r
 830         private JSONArray parseVnfsJson (String catalogDbResponse, String arrayName, String catalogUtilsVersion) {\r
 831                 JSONArray modelInfos = null\r
 832 \r
 833                 msoLogger.debug("parseVnfsJson - catalogUtilsVersion is " + catalogUtilsVersion)\r
 834 \r
 835                 try {\r
 836                         // Create array of jsons\r
 837 \r
 838                         JSONObject responseJson = new JSONObject(catalogDbResponse)\r
 839                         JSONArray vnfs = responseJson.getJSONArray(arrayName)\r
 840                         modelInfos = new JSONArray()\r
 841 \r
 842                         for (int i = 0; i < vnfs.length(); i++) {\r
 843                                 JSONObject vnf = vnfs.getJSONObject(i)\r
 844 \r
 845                                 msoLogger.debug(vnf.toString(2))\r
 846                                 JSONObject modelInfo = buildModelInfo("vnf", vnf, catalogUtilsVersion)\r
 847                                 JSONObject modelJson = new JSONObject()\r
 848                                 modelJson.put("modelInfo", modelInfo)\r
 849                                 switch(catalogUtilsVersion) {\r
 850                                         case "v1":\r
 851                                                 break\r
 852                                         default:\r
 853                                                 String toscaNodeType = jsonUtils.getJsonValueForKey(vnf, "toscaNodeType")\r
 854                                                 modelJson.put("toscaNodeType", toscaNodeType)\r
 855                                                 String nfType = jsonUtils.getJsonValueForKey(vnf, "nfType")\r
 856                                                 modelJson.put("nfType", nfType)\r
 857                                                 String nfRole = jsonUtils.getJsonValueForKey(vnf, "nfRole")\r
 858                                                 modelJson.put("nfRole", nfRole)\r
 859                                                 String nfCode = jsonUtils.getJsonValueForKey(vnf, "nfCode")\r
 860                                                 modelJson.put("nfNamingCode", nfCode)\r
 861                                                 String nfFunction = jsonUtils.getJsonValueForKey(vnf, "nfFunction")\r
 862                                                 modelJson.put("nfFunction", nfFunction)\r
 863                                                 break\r
 864                                 }\r
 865                                 \r
 866                                 JSONArray vfModules = null\r
 867                                 try {\r
 868                                         vfModules = vnf.getJSONArray("vfModules")\r
 869                                 } catch (Exception e)\r
 870                                 {\r
 871                                         msoLogger.debug("Cannot find VF MODULE ARRAY: " + i + ", exception is " + e.message)\r
 872                                 }\r
 873 \r
 874                                 if (vfModules != null) {\r
 875                                         JSONArray vfModuleInfo = new JSONArray()\r
 876                                         for (int j = 0; j < vfModules.length(); j++) {\r
 877                                                 JSONObject vfModule = vfModules.getJSONObject(j)\r
 878                                                 JSONObject vfModuleModelInfo = buildModelInfo("vfModule", vfModule, catalogUtilsVersion)\r
 879                                                 JSONObject vfModuleModelJson = new JSONObject()\r
 880                                                 vfModuleModelJson.put("modelInfo", vfModuleModelInfo)\r
 881                                                 String vfModuleType = jsonUtils.getJsonValueForKey(vfModule, "type")\r
 882                                                 vfModuleModelJson.put("vfModuleType", vfModuleType)\r
 883                                                 switch(catalogUtilsVersion) {\r
 884                                                         case "v1":\r
 885                                                                 Integer isBase = jsonUtils.getJsonIntValueForKey(vfModule, "isBase")\r
 886                                                                 if (isBase.intValue() == 1) {\r
 887                                                                         vfModuleModelJson.put("isBase", "true")\r
 888                                                                 }\r
 889                                                                 else {\r
 890                                                                         vfModuleModelJson.put("isBase", "false")\r
 891                                                                 }\r
 892                                                                 break\r
 893                                                         default:\r
 894                                                                 boolean isBase = jsonUtils.getJsonBooleanValueForKey(vfModule, "isBase")\r
 895                                                                 vfModuleModelJson.put("isBase", isBase)\r
 896                                                                 break\r
 897                                                 }\r
 898                                                 String vfModuleLabel = jsonUtils.getJsonValueForKey(vfModule, "label")\r
 899                                                 vfModuleModelJson.put("vfModuleLabel", vfModuleLabel)\r
 900                                                 Integer initialCount = jsonUtils.getJsonIntValueForKey(vfModule, "initialCount")\r
 901                                                 vfModuleModelJson.put("initialCount", initialCount.intValue())\r
 902                                                 vfModuleInfo.put(vfModuleModelJson)\r
 903                                         }\r
 904                                         modelJson.put("vfModules", vfModuleInfo)\r
 905                                 }\r
 906                                 modelInfos.put(modelJson)\r
 907                         }\r
 908 \r
 909                         String modelInfosString = modelInfos.toString()\r
 910                         msoLogger.debug("Returning vnfs JSON: " + modelInfosString)\r
 911 \r
 912                 } catch (Exception e) {\r
 913                         utils.log("ERROR", "Exception in parsing Catalog DB Response: " + e.message)\r
 914                 }\r
 915 \r
 916                 return modelInfos\r
 917         }\r
 918 \r
 919         /**\r
 920          * This method parses a Vf Module from the\r
 921          * Vf Modules array\r
 922          *\r
 923          * @param catalogDbResponse\r
 924          * @param arrayName\r
 925          * @param catalogUtilsVersion\r
 926          * @return vfModulelJson\r
 927          */\r
 928         private JSONObject parseVfModuleJson (String catalogDbResponse, String arrayName, String catalogUtilsVersion) {\r
 929                 JSONObject vfModulelJson = new JSONObject()\r
 930                 msoLogger.debug("Started Parse Vf Module Json")\r
 931                 try {\r
 932                         JSONObject responseJson = new JSONObject(catalogDbResponse)\r
 933                         JSONArray vfModules = responseJson.getJSONArray(arrayName)\r
 934                         if(vfModules != null){\r
 935                                 JSONObject vfModuleInfo = new JSONObject()\r
 936                                 for (int i = 0; i < vfModules.length(); i++) {\r
 937                                         JSONObject vfModule = vfModules.getJSONObject(i)\r
 938                                         JSONObject vfModuleModelInfo = buildModelInfo("vfModule", vfModule, catalogUtilsVersion)\r
 939                                         vfModulelJson.put("modelInfo", vfModuleModelInfo)\r
 940                                         String vfModuleType = jsonUtils.getJsonValueForKey(vfModule, "type")\r
 941                                         vfModulelJson.put("vfModuleType", vfModuleType)\r
 942                                         switch(catalogUtilsVersion) {\r
 943                                                 case "v1":\r
 944                                                         Integer isBase = jsonUtils.getJsonIntValueForKey(vfModule, "isBase")\r
 945                                                         if (isBase.intValue() == 1) {\r
 946                                                                 vfModulelJson.put("isBase", "true")\r
 947                                                         }\r
 948                                                         else {\r
 949                                                                 vfModulelJson.put("isBase", "false")\r
 950                                                         }\r
 951                                                         break\r
 952                                                 default:\r
 953                                                         boolean isBase = jsonUtils.getJsonBooleanValueForKey(vfModule, "isBase")\r
 954                                                         vfModulelJson.put("isBase", isBase)\r
 955                                                         break\r
 956                                         }\r
 957                                         String vfModuleLabel = jsonUtils.getJsonValueForKey(vfModule, "label")\r
 958                                         vfModulelJson.put("vfModuleLabel", vfModuleLabel)\r
 959                                         Integer initialCount = jsonUtils.getJsonIntValueForKey(vfModule, "initialCount")\r
 960                                         vfModulelJson.put("initialCount", initialCount.intValue())\r
 961                                 }\r
 962                         }\r
 963                         msoLogger.debug("Completed Parsing Vf Module: " + vfModulelJson.toString())\r
 964                 }catch (Exception e){\r
 965                         utils.log("DEBUG", "Exception while parsing Vf Modules from Catalog DB Response: " + e.message)\r
 966                 }\r
 967 \r
 968                 return vfModulelJson\r
 969         }\r
 970 \r
 971         private JSONArray parseAllottedResourcesJson (String catalogDbResponse, String arrayName, String catalogUtilsVersion) {\r
 972                 JSONArray modelInfos = null\r
 973 \r
 974                 msoLogger.debug("parseAllottedResourcesJson - catalogUtilsVersion is " + catalogUtilsVersion)\r
 975 \r
 976                 try {\r
 977                         // Create array of jsons\r
 978 \r
 979                         JSONObject responseJson = new JSONObject(catalogDbResponse)\r
 980                         JSONArray allottedResources = responseJson.getJSONArray(arrayName)\r
 981                         modelInfos = new JSONArray()\r
 982 \r
 983                         for (int i = 0; i < allottedResources.length(); i++) {\r
 984                                 JSONObject allottedResource = allottedResources.getJSONObject(i)\r
 985                                 JSONObject modelInfo = buildModelInfo("allottedResource", allottedResource, catalogUtilsVersion)\r
 986                                 JSONObject modelJson = new JSONObject()\r
 987                                 modelJson.put("modelInfo", modelInfo)\r
 988                                 switch(catalogUtilsVersion) {\r
 989                                         case "v1":\r
 990                                                 break\r
 991                                         default:\r
 992                                                 String toscaNodeType = jsonUtils.getJsonValueForKey(allottedResource, "toscaNodeType")\r
 993                                                 modelJson.put("toscaNodeType", toscaNodeType)\r
 994                                                 String nfType = jsonUtils.getJsonValueForKey(allottedResource, "nfType")\r
 995                                                 modelJson.put("nfType", nfType)\r
 996                                                 String nfRole = jsonUtils.getJsonValueForKey(allottedResource, "nfRole")\r
 997                                                 modelJson.put("nfRole", nfRole)\r
 998                                                 String nfCode = jsonUtils.getJsonValueForKey(allottedResource, "nfCode")\r
 999                                                 modelJson.put("nfNamingCode", nfCode)\r
1000                                                 String nfFunction = jsonUtils.getJsonValueForKey(allottedResource, "nfFunction")\r
1001                                                 modelJson.put("nfFunction", nfFunction)\r
1002                                                 String parentServiceModelUuid = jsonUtils.getJsonValueForKey(allottedResource, "parentServiceModelUuid")\r
1003                                                 modelJson.put("parentServiceModelUuid", parentServiceModelUuid)\r
1004                                                 break\r
1005                                 }\r
1006 \r
1007 \r
1008                                 modelInfos.put(modelJson)\r
1009                         }\r
1010 \r
1011                         String modelInfosString = modelInfos.toString()\r
1012                         msoLogger.debug("Returning allottedResources JSON: " + modelInfosString)\r
1013 \r
1014                 } catch (Exception e) {\r
1015                         utils.log("ERROR", "Exception in parsing Catalog DB Response: " + e.message)\r
1016                 }\r
1017 \r
1018                 return modelInfos\r
1019         }\r
1020 \r
1021         private JSONObject parseServiceResourcesJson (String catalogDbResponse) {\r
1022                 JSONObject serviceResources = new JSONObject()\r
1023                 String catalogUtilsVersion = "v1"\r
1024 \r
1025                 try {\r
1026                         // Create array of jsons\r
1027 \r
1028                         JSONObject responseJson = new JSONObject(catalogDbResponse)\r
1029                         JSONObject serviceResourcesRoot = responseJson.getJSONObject("serviceResources")\r
1030                         JSONArray vnfsArray = parseVnfsJson(serviceResourcesRoot.toString(), "vnfResources", catalogUtilsVersion)\r
1031                         serviceResources.put("vnfs", vnfsArray)\r
1032                         JSONArray networksArray = parseNetworksJson(serviceResourcesRoot.toString(), "networkResourceCustomization", catalogUtilsVersion)\r
1033                         serviceResources.put("networks", networksArray)\r
1034                         JSONArray allottedResourcesArray = parseAllottedResourcesJson(serviceResourcesRoot.toString(), "allottedResourceCustomization", catalogUtilsVersion)\r
1035                         serviceResources.put("allottedResources", allottedResourcesArray)\r
1036 \r
1037                         String serviceResourcesString = serviceResources.toString()\r
1038                         msoLogger.debug("Returning serviceResources JSON: " + serviceResourcesString)\r
1039 \r
1040                 } catch (Exception e) {\r
1041                         utils.log("ERROR", "Exception in parsing Catalog DB Response: " + e.message)\r
1042                 }\r
1043 \r
1044                 return serviceResources\r
1045         }\r
1046 \r
1047         private JSONObject parseServiceResourcesJson (String catalogDbResponse, String catalogUtilsVersion) {\r
1048                 JSONObject serviceResources = new JSONObject()\r
1049                 JSONObject serviceResourcesObject = new JSONObject()\r
1050                 String serviceResourcesString = ""\r
1051 \r
1052                 try {\r
1053                         // Create array of jsons\r
1054 \r
1055                         JSONObject responseJson = new JSONObject(catalogDbResponse)\r
1056                         JSONObject serviceResourcesRoot = responseJson.getJSONObject("serviceResources")\r
1057                         JSONObject modelInfo = buildModelInfo("", serviceResourcesRoot, catalogUtilsVersion)\r
1058                         serviceResources.put("modelInfo", modelInfo)\r
1059                         JSONArray vnfsArray = parseVnfsJson(serviceResourcesRoot.toString(), "serviceVnfs", catalogUtilsVersion)\r
1060                         serviceResources.put("serviceVnfs", vnfsArray)\r
1061                         JSONArray networksArray = parseNetworksJson(serviceResourcesRoot.toString(), "serviceNetworks", catalogUtilsVersion)\r
1062                         serviceResources.put("serviceNetworks", networksArray)\r
1063                         JSONArray allottedResourcesArray = parseAllottedResourcesJson(serviceResourcesRoot.toString(), "serviceAllottedResources", catalogUtilsVersion)\r
1064                         serviceResources.put("serviceAllottedResources", allottedResourcesArray)\r
1065                         serviceResourcesObject.put("serviceResources", serviceResources)\r
1066 \r
1067                         serviceResourcesString = serviceResourcesObject.toString()\r
1068                         msoLogger.debug("Returning serviceResources JSON: " + serviceResourcesString)\r
1069 \r
1070                 } catch (Exception e) {\r
1071                         utils.log("ERROR", "Exception in parsing Catalog DB Response: " + e.message)\r
1072                 }\r
1073 \r
1074                 return serviceResourcesObject\r
1075         }\r
1076 \r
1077         private JSONObject buildModelInfo(String modelType, JSONObject modelFromDb, String catalogUtilsVersion) {\r
1078                 JSONObject modelInfo = null\r
1079                 try {\r
1080                         modelInfo = new JSONObject()\r
1081                         modelInfo.put("modelType", modelType)\r
1082                         String modelInvariantId = jsonUtils.getJsonValueForKey(modelFromDb, "modelInvariantUuid")\r
1083                         modelInfo.put("modelInvariantId", modelInvariantId)\r
1084                         if(modelType.equalsIgnoreCase("allottedResource")){\r
1085                                 String modelInstanceName = jsonUtils.getJsonValueForKey(modelFromDb, "modelInstanceName")\r
1086                                 modelInfo.put("modelInstanceName", modelInstanceName)\r
1087                         }\r
1088                         if ((!"vfModule".equals(modelType) && !"vnf".equals(modelType)) || !catalogUtilsVersion.equals("v1")) {\r
1089                                 String modelVersionId = jsonUtils.getJsonValueForKey(modelFromDb, "modelUuid")\r
1090                                 modelInfo.put("modelVersionId", modelVersionId)\r
1091                         }\r
1092                         else {\r
1093                                 String modelVersionId = jsonUtils.getJsonValueForKey(modelFromDb, "asdcUuid")\r
1094                                 modelInfo.put("modelVersionId", modelVersionId)\r
1095                         }\r
1096                         String modelName = jsonUtils.getJsonValueForKey(modelFromDb, "modelName")\r
1097                         modelInfo.put("modelName", modelName)\r
1098                         String modelVersion = jsonUtils.getJsonValueForKey(modelFromDb, "modelVersion")\r
1099                         modelInfo.put("modelVersion", modelVersion)\r
1100                         if (!"vfModule".equals(modelType)) {\r
1101                                 String modelCustomizationName = jsonUtils.getJsonValueForKey(modelFromDb, "modelCustomizationName")\r
1102                                 modelInfo.put("modelCustomizationName", modelCustomizationName)\r
1103                         }\r
1104                         String modelCustomizationId = jsonUtils.getJsonValueForKey(modelFromDb, "modelCustomizationUuid")\r
1105                         switch (catalogUtilsVersion) {\r
1106                                 case "v1":\r
1107                                         modelInfo.put("modelCustomizationId", modelCustomizationId)\r
1108                                         break\r
1109                                 default:\r
1110                                         modelInfo.put("modelCustomizationUuid", modelCustomizationId)\r
1111                                         break\r
1112                         }\r
1113                         JSONObject modelJson = new JSONObject()\r
1114                         modelJson.put("modelInfo", modelInfo)\r
1115                 }\r
1116                 catch (Exception e) {\r
1117                         utils.log("ERROR", "Exception while parsing model information: " + e.message)\r
1118                 }\r
1119                 return modelInfo\r
1120         }\r
1121 \r
1122         private String getResponseFromCatalogDb (Execution execution, String endPoint) {\r
1123                 try {\r
1124                         String catalogDbEndpoint = execution.getVariable("URN_mso_catalog_db_endpoint")\r
1125                         String queryEndpoint = catalogDbEndpoint + "/" + defaultDbAdapterVersion + endPoint\r
1126                         RESTConfig config = new RESTConfig(queryEndpoint);\r
1127                         def responseData = ''\r
1128                         def bpmnRequestId = UUID.randomUUID().toString()\r
1129                         RESTClient client = new RESTClient(config).\r
1130                                         addHeader('X-TransactionId', bpmnRequestId).\r
1131                                         addHeader('X-FromAppId', 'BPMN').\r
1132                                         addHeader('Content-Type', 'application/json').\r
1133                                         addHeader('Accept','application/json');\r
1134                                         \r
1135                         String basicAuthCred = execution.getVariable("BasicAuthHeaderValueDB")\r
1136                         if (basicAuthCred != null && !"".equals(basicAuthCred)) {\r
1137                                         client.addAuthorizationHeader(basicAuthCred)\r
1138                         }\r
1139                         msoLogger.debug('sending GET to Catalog DB endpoint: ' + endPoint)\r
1140                         APIResponse response = client.httpGet()\r
1141 \r
1142                         responseData = response.getResponseBodyAsString()\r
1143                         if (responseData != null) {\r
1144                                 msoLogger.debug("Received data from Catalog DB: " + responseData)\r
1145                         }\r
1146 \r
1147                         msoLogger.debug('Response code:' + response.getStatusCode())\r
1148                         msoLogger.debug('Response:' + System.lineSeparator() + responseData)\r
1149                         if (response.getStatusCode() == 200) {\r
1150                                 // parse response as needed\r
1151                                 return responseData\r
1152                         }\r
1153                         else {\r
1154                                 return null\r
1155                         }\r
1156                 }\r
1157                 catch (Exception e) {\r
1158                         msoLogger.debug("ERROR WHILE QUERYING CATALOG DB: " + e.message)\r
1159                         return null\r
1160                 }\r
1161 \r
1162         }\r
1163 }