test-apis-ci/src/main/java/org/openecomp/sdc/ci/tests/utils/rest/LifecycleRestUtils.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * SDC
   4  * ================================================================================
   5  * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END=========================================================
  19  */
  20
  21 package org.openecomp.sdc.ci.tests.utils.rest;
  22
  23 import java.io.FileNotFoundException;
  24 import java.io.IOException;
  25 import java.util.HashMap;
  26 import java.util.Map;
  27
  28 import org.json.simple.JSONObject;
  29 import org.openecomp.sdc.be.datatypes.enums.AssetTypeEnum;
  30 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
  31 import org.openecomp.sdc.be.model.Component;
  32 import org.openecomp.sdc.be.model.DistributionStatusEnum;
  33 import org.openecomp.sdc.be.model.LifecycleStateEnum;
  34 import org.openecomp.sdc.be.model.Product;
  35 import org.openecomp.sdc.be.model.User;
  36 import org.openecomp.sdc.ci.tests.api.Urls;
  37 import org.openecomp.sdc.ci.tests.config.Config;
  38 import org.openecomp.sdc.ci.tests.datatypes.ProductReqDetails;
  39 import org.openecomp.sdc.ci.tests.datatypes.ResourceReqDetails;
  40 import org.openecomp.sdc.ci.tests.datatypes.ServiceReqDetails;
  41 import org.openecomp.sdc.ci.tests.datatypes.enums.LifeCycleStatesEnum;
  42 import org.openecomp.sdc.ci.tests.datatypes.enums.UserRoleEnum;
  43 import org.openecomp.sdc.ci.tests.datatypes.http.HttpHeaderEnum;
  44 import org.openecomp.sdc.ci.tests.datatypes.http.HttpRequest;
  45 import org.openecomp.sdc.ci.tests.datatypes.http.RestResponse;
  46 import org.openecomp.sdc.ci.tests.utils.Utils;
  47 import org.openecomp.sdc.ci.tests.utils.general.ElementFactory;
  48 import org.slf4j.Logger;
  49 import org.slf4j.LoggerFactory;
  50
  51 public class LifecycleRestUtils extends BaseRestUtils {
  52         private static Logger logger = LoggerFactory.getLogger(LifecycleRestUtils.class.getName());
  53         public static final String COMMENT = "comment";
  54
  55         // External APIs
  56         public static RestResponse checkInResource(String resourceUUID, User sdncModifierDetails) throws IOException {
  57                 String comment = "Chekin resource: " + resourceUUID;
  58                 return changeLifeCycleOfAsset(resourceUUID, AssetTypeEnum.RESOURCES, LifeCycleStatesEnum.CHECKIN, sdncModifierDetails, comment);
  59         }
  60
  61         public static RestResponse checkInService(String serviceUUID, User sdncModifierDetails) throws IOException {
  62                 String comment = "Chekin service: " + serviceUUID;
  63                 return changeLifeCycleOfAsset(serviceUUID, AssetTypeEnum.SERVICES, LifeCycleStatesEnum.CHECKIN, sdncModifierDetails, comment);
  64         }
  65
  66         public static RestResponse checkOutResource(String resourceUUID, User sdncModifierDetails) throws IOException {
  67                 String comment = "CheckOut resource: " + resourceUUID;
  68                 return changeLifeCycleOfAsset(resourceUUID, AssetTypeEnum.RESOURCES, LifeCycleStatesEnum.CHECKOUT, sdncModifierDetails, comment);
  69         }
  70
  71         public static RestResponse checkOutService(String serviceUUID, User sdncModifierDetails) throws IOException {
  72                 String comment = "CheckOut service: " + serviceUUID;
  73                 return changeLifeCycleOfAsset(serviceUUID, AssetTypeEnum.SERVICES, LifeCycleStatesEnum.CHECKOUT, sdncModifierDetails, comment);
  74         }
  75
  76         public static RestResponse certificationRequestService(String serviceUUID, User sdncModifierDetails) throws IOException {
  77                 String comment = "Certification request service: " + serviceUUID;
  78                 return changeLifeCycleOfAsset(serviceUUID, AssetTypeEnum.SERVICES, LifeCycleStatesEnum.CERTIFICATIONREQUEST, sdncModifierDetails, comment);
  79         }
  80
  81         public static RestResponse certificationRequestResource(String resourceUUID, User sdncModifierDetails) throws IOException {
  82                 String comment = "Certification request resource: " + resourceUUID;
  83                 return changeLifeCycleOfAsset(resourceUUID, AssetTypeEnum.RESOURCES, LifeCycleStatesEnum.CERTIFICATIONREQUEST, sdncModifierDetails, comment);
  84         }
  85
  86         public static RestResponse startTestingService(String serviceUUID, User sdncModifierDetails) throws IOException {
  87                 String comment = "Start testing request service: " + serviceUUID;
  88                 return changeLifeCycleOfAsset(serviceUUID, AssetTypeEnum.SERVICES, LifeCycleStatesEnum.STARTCERTIFICATION, sdncModifierDetails, comment);
  89         }
  90
  91         public static RestResponse startTestingResource(String resourceUUID, User sdncModifierDetails) throws IOException {
  92                 String comment = "Start testing request resource: " + resourceUUID;
  93                 return changeLifeCycleOfAsset(resourceUUID, AssetTypeEnum.RESOURCES, LifeCycleStatesEnum.STARTCERTIFICATION, sdncModifierDetails, comment);
  94         }
  95
  96         public static RestResponse certifyService(String serviceUUID, User sdncModifierDetails) throws IOException {
  97                 String comment = "Certify request service: " + serviceUUID;
  98                 return changeLifeCycleOfAsset(serviceUUID, AssetTypeEnum.SERVICES, LifeCycleStatesEnum.CERTIFY, sdncModifierDetails, comment);
  99         }
 100
 101         public static RestResponse certifyResource(String resourceUUID, User sdncModifierDetails) throws IOException {
 102                 String comment = "Certify request resource: " + resourceUUID;
 103                 return changeLifeCycleOfAsset(resourceUUID, AssetTypeEnum.RESOURCES, LifeCycleStatesEnum.CERTIFY, sdncModifierDetails, comment);
 104         }
 105
 106
 107
 108
 109
 110         private static RestResponse changeLifeCycleOfAsset(String assetUUID, AssetTypeEnum assetTypeEnum, LifeCycleStatesEnum lifeCycleStatesEnum, User sdncModifierDetails, String comment) throws IOException {
 111                 Config config = Utils.getConfig();
 112                 String url = String.format(Urls.POST_EXTERNAL_API_CHANGE_LIFE_CYCLE_OF_ASSET, config.getCatalogBeHost(), config.getCatalogBePort(), assetTypeEnum.getValue(), assetUUID, lifeCycleStatesEnum.getState());
 113
 114                 Map<String, String> additionalHeaders = new HashMap<String, String>();
 115
 116                 additionalHeaders.put(HttpHeaderEnum.AUTHORIZATION.getValue(), authorizationHeader);
 117                 additionalHeaders.put(HttpHeaderEnum.X_ECOMP_INSTANCE_ID.getValue(), "ci");
 118
 119                 String jsonBody = "{\"userRemarks\": \"" + comment + "\"}";
 120
 121                 RestResponse res = sendPost(url, jsonBody, sdncModifierDetails.getUserId(), acceptHeaderData, additionalHeaders);
 122
 123                 return res;
 124         }
 125
 126         ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 127
 128         public static RestResponse changeResourceState(ResourceReqDetails resourceDetails, User sdncModifierDetails,
 129                         String version, LifeCycleStatesEnum LifeCycleStatesEnum) throws IOException {
 130                 return changeResourceState(resourceDetails, sdncModifierDetails, LifeCycleStatesEnum,
 131                                 createLifecycleCommentJson(COMMENT));
 132         }
 133
 134         public static RestResponse changeResourceState(ResourceReqDetails resourceDetails, User sdncModifierDetails,
 135                         String version, LifeCycleStatesEnum LifeCycleStatesEnum, String LifecycleChangeInfo) throws IOException {
 136
 137                 return changeResourceState(resourceDetails, sdncModifierDetails, LifeCycleStatesEnum, LifecycleChangeInfo);
 138
 139         }
 140
 141         public static RestResponse changeResourceState(ResourceReqDetails resourceDetails, User sdncModifierDetails,
 142                         LifeCycleStatesEnum LifeCycleStatesEnum) throws IOException {
 143
 144                 return changeResourceState(resourceDetails, sdncModifierDetails, LifeCycleStatesEnum,
 145                                 createLifecycleCommentJson(COMMENT));
 146
 147         }
 148
 149         public static RestResponse changeResourceState(ResourceReqDetails resourceDetails, String modifierUserId,
 150                         LifeCycleStatesEnum LifeCycleStatesEnum) throws IOException {
 151                 User user = new User();
 152                 user.setUserId(modifierUserId);
 153                 return changeResourceState(resourceDetails, user, LifeCycleStatesEnum, createLifecycleCommentJson(COMMENT));
 154         }
 155
 156         private static RestResponse changeResourceState(ResourceReqDetails resourceDetails, User sdncModifierDetails,
 157                         LifeCycleStatesEnum LifeCycleStatesEnum, String LifecycleChangeInfo) throws IOException {
 158                 Config config = Utils.getConfig();
 159                 String url = String.format(Urls.CHANGE_RESOURCE_LIFECYCLE_STATE, config.getCatalogBeHost(),
 160                                 config.getCatalogBePort(), resourceDetails.getUniqueId(), LifeCycleStatesEnum);
 161                 // System.out.println("url: " + url);
 162
 163                 RestResponse LifeCycleStatesEnumResourceResponse = sendPost(url, LifecycleChangeInfo,
 164                                 sdncModifierDetails.getUserId(), acceptHeaderData);
 165                 if (LifeCycleStatesEnumResourceResponse.getErrorCode() == STATUS_CODE_SUCCESS) {
 166                         String stateFromJsonResponse = ResponseParser
 167                                         .getValueFromJsonResponse(LifeCycleStatesEnumResourceResponse.getResponse(), "lifecycleState");
 168                         resourceDetails.setVersion(ResponseParser.getVersionFromResponse(LifeCycleStatesEnumResourceResponse));
 169                         resourceDetails.setUniqueId(ResponseParser.getUniqueIdFromResponse(LifeCycleStatesEnumResourceResponse));
 170                         if (stateFromJsonResponse != null) {
 171                                 resourceDetails.setLifecycleState(LifecycleStateEnum.valueOf(stateFromJsonResponse));
 172                         }
 173                 }
 174                 return LifeCycleStatesEnumResourceResponse;
 175         }
 176
 177         public static RestResponse changeServiceState(ServiceReqDetails serviceDetails, User sdncModifierDetails,
 178                         String version, LifeCycleStatesEnum LifeCycleStatesEnum) throws Exception {
 179                 {
 180                         return changeServiceState(serviceDetails, sdncModifierDetails, version, LifeCycleStatesEnum,
 181                                         createLifecycleCommentJson(COMMENT));
 182                 }
 183         }
 184
 185         public static RestResponse changeServiceState(ServiceReqDetails serviceDetails, User sdncModifierDetails,
 186                         LifeCycleStatesEnum LifeCycleStatesEnum) throws Exception {
 187                 {
 188                         return changeServiceState(serviceDetails, sdncModifierDetails, null, LifeCycleStatesEnum,
 189                                         createLifecycleCommentJson(COMMENT));
 190                 }
 191         }
 192
 193         public static RestResponse changeServiceState(ServiceReqDetails serviceDetails, User sdncModifierDetails,
 194                         LifeCycleStatesEnum LifeCycleStatesEnum, String lifecycleChangeInfo) throws Exception {
 195                 {
 196                         return changeServiceState(serviceDetails, sdncModifierDetails, null, LifeCycleStatesEnum,
 197                                         lifecycleChangeInfo);
 198                 }
 199         }
 200
 201         public static RestResponse changeServiceState(ServiceReqDetails serviceDetails, User sdncModifierDetails,
 202                         String version, LifeCycleStatesEnum LifeCycleStatesEnum, String lifecycleChangeInfo) throws Exception {
 203
 204                 Config config = Utils.getConfig();
 205                 Map<String, String> headersMap = prepareHeadersMap(sdncModifierDetails);
 206                 HttpRequest http = new HttpRequest();
 207                 String url = String.format(Urls.CHANGE_SERVICE_LIFECYCLE_STATE, config.getCatalogBeHost(),
 208                                 config.getCatalogBePort(), serviceDetails.getUniqueId(), LifeCycleStatesEnum);
 209                 // System.out.println("url: " + url);
 210                 RestResponse LifeCycleStatesEnumServiceResponse = http.httpSendPost(url, lifecycleChangeInfo, headersMap);
 211                 if (LifeCycleStatesEnumServiceResponse.getErrorCode() == STATUS_CODE_SUCCESS) {
 212                         String serviceUniqueId = ResponseParser
 213                                         .getValueFromJsonResponse(LifeCycleStatesEnumServiceResponse.getResponse(), "uniqueId");
 214                         serviceDetails.setUniqueId(serviceUniqueId);
 215                         String serviceVersion = ResponseParser
 216                                         .getValueFromJsonResponse(LifeCycleStatesEnumServiceResponse.getResponse(), "version");
 217                         serviceDetails.setVersion(serviceVersion);
 218                         String stateFromJsonResponse = ResponseParser
 219                                         .getValueFromJsonResponse(LifeCycleStatesEnumServiceResponse.getResponse(), "lifecycleState");
 220                         serviceDetails.setLifecycleState(LifecycleStateEnum.valueOf(stateFromJsonResponse));
 221                 }
 222                 return LifeCycleStatesEnumServiceResponse;
 223         }
 224
 225         public static RestResponse changeProductState(Product product, User sdncModifierDetails,
 226                         LifeCycleStatesEnum LifeCycleStatesEnum, String lifecycleChangeInfo) throws Exception {
 227                 {
 228                         return _changeProductState(product, sdncModifierDetails, LifeCycleStatesEnum, lifecycleChangeInfo);
 229                 }
 230         }
 231
 232         public static RestResponse changeProductState(Product product, User sdncModifierDetails,
 233                         LifeCycleStatesEnum LifeCycleStatesEnum) throws Exception {
 234                 {
 235                         return _changeProductState(product, sdncModifierDetails, LifeCycleStatesEnum, COMMENT);
 236                 }
 237         }
 238
 239         public static RestResponse changeProductState(ProductReqDetails productDetails, User sdncModifierDetails,
 240                         LifeCycleStatesEnum LifeCycleStatesEnum) throws Exception {
 241                 Config config = Utils.getConfig();
 242                 String url = String.format(Urls.CHANGE_PRODUCT_LIFECYCLE_STATE, config.getCatalogBeHost(),
 243                                 config.getCatalogBePort(), productDetails.getUniqueId(), LifeCycleStatesEnum);
 244                 RestResponse LifeCycleStatesEnumServiceResponse = sendPost(url, createLifecycleCommentJson(COMMENT),
 245                                 sdncModifierDetails.getUserId(), acceptHeaderData);
 246                 if (LifeCycleStatesEnumServiceResponse.getErrorCode() == STATUS_CODE_SUCCESS) {
 247                         String productUniqueId = ResponseParser
 248                                         .getValueFromJsonResponse(LifeCycleStatesEnumServiceResponse.getResponse(), "uniqueId");
 249                         productDetails.setUniqueId(productUniqueId);
 250                         String productVersion = ResponseParser
 251                                         .getValueFromJsonResponse(LifeCycleStatesEnumServiceResponse.getResponse(), "version");
 252                         productDetails.setVersion(productVersion);
 253                         String newLifecycleState = ResponseParser
 254                                         .getValueFromJsonResponse(LifeCycleStatesEnumServiceResponse.getResponse(), "lifecycleState");
 255                         productDetails.setLifecycleState(LifecycleStateEnum.valueOf(newLifecycleState));
 256                 }
 257                 return LifeCycleStatesEnumServiceResponse;
 258
 259         }
 260
 261         public static RestResponse changeComponentState(Component component, User sdncModifierDetails,
 262                         LifeCycleStatesEnum LifeCycleStatesEnum) throws Exception {
 263                 Config config = Utils.getConfig();
 264                 String url = String.format(Urls.CHANGE_COMPONENT_LIFECYCLE_STATE, config.getCatalogBeHost(),
 265                                 config.getCatalogBePort(), ComponentTypeEnum.findParamByType(component.getComponentType()), component.getUniqueId(), LifeCycleStatesEnum);
 266                 RestResponse LifeCycleStatesEnumServiceResponse = sendPost(url, createLifecycleCommentJson(COMMENT), sdncModifierDetails.getUserId(), acceptHeaderData);
 267                 if (LifeCycleStatesEnumServiceResponse.getErrorCode() == STATUS_CODE_SUCCESS) {
 268                         String productUniqueId = ResponseParser.getValueFromJsonResponse(LifeCycleStatesEnumServiceResponse.getResponse(), "uniqueId");
 269                         component.setUniqueId(productUniqueId);
 270                         String productVersion = ResponseParser.getValueFromJsonResponse(LifeCycleStatesEnumServiceResponse.getResponse(), "version");
 271                         component.setVersion(productVersion);
 272                         String newLifecycleState = ResponseParser.getValueFromJsonResponse(LifeCycleStatesEnumServiceResponse.getResponse(), "lifecycleState");
 273                         component.setLifecycleState(LifecycleStateEnum.valueOf(newLifecycleState));
 274                 }
 275                 return LifeCycleStatesEnumServiceResponse;
 276
 277         }
 278
 279         public static RestResponse certifyResource(ResourceReqDetails resourceDetails) throws Exception {
 280                 RestResponse restResponseResource = LifecycleRestUtils.changeResourceState(resourceDetails,
 281                                 ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), LifeCycleStatesEnum.CHECKIN);
 282                 // if (restResponseResource.getErrorCode() == 200){
 283                 restResponseResource = LifecycleRestUtils.changeResourceState(resourceDetails,
 284                                 ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), LifeCycleStatesEnum.CERTIFICATIONREQUEST);
 285                 // }else
 286                 // return restResponseResource;
 287                 User testerDetails = ElementFactory.getDefaultUser(UserRoleEnum.TESTER);
 288                 if (restResponseResource.getErrorCode() == 200) {
 289                         restResponseResource = LifecycleRestUtils.changeResourceState(resourceDetails, testerDetails,
 290                                         LifeCycleStatesEnum.STARTCERTIFICATION);
 291                 } else
 292                         return restResponseResource;
 293                 if (restResponseResource.getErrorCode() == 200) {
 294                         restResponseResource = LifecycleRestUtils.changeResourceState(resourceDetails, testerDetails,
 295                                         LifeCycleStatesEnum.CERTIFY);
 296                         if (restResponseResource.getErrorCode() == 200) {
 297                                 String newVersion = ResponseParser.getVersionFromResponse(restResponseResource);
 298                                 resourceDetails.setVersion(newVersion);
 299                                 resourceDetails.setLifecycleState(LifecycleStateEnum.CERTIFIED);
 300                                 resourceDetails.setLastUpdaterUserId(testerDetails.getUserId());
 301                                 resourceDetails.setLastUpdaterFullName(testerDetails.getFullName());
 302                                 String uniqueIdFromRresponse = ResponseParser.getUniqueIdFromResponse(restResponseResource);
 303                                 resourceDetails.setUniqueId(uniqueIdFromRresponse);
 304                         }
 305                 }
 306                 return restResponseResource;
 307         }
 308
 309         public static RestResponse certifyService(ServiceReqDetails serviceDetails) throws Exception {
 310                 RestResponse restResponseService = LifecycleRestUtils.changeServiceState(serviceDetails,
 311                                 ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), LifeCycleStatesEnum.CHECKIN);
 312                 // if (restResponseService.getErrorCode() == 200){
 313                 restResponseService = LifecycleRestUtils.changeServiceState(serviceDetails,
 314                                 ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), LifeCycleStatesEnum.CERTIFICATIONREQUEST);
 315                 // }else
 316                 // return restResponseService;
 317                 if (restResponseService.getErrorCode() == 200) {
 318                         restResponseService = LifecycleRestUtils.changeServiceState(serviceDetails,
 319                                         ElementFactory.getDefaultUser(UserRoleEnum.TESTER), LifeCycleStatesEnum.STARTCERTIFICATION);
 320                 } else
 321                         return restResponseService;
 322                 if (restResponseService.getErrorCode() == 200) {
 323                         User testerDetails = ElementFactory.getDefaultUser(UserRoleEnum.TESTER);
 324                         restResponseService = LifecycleRestUtils.changeServiceState(serviceDetails, testerDetails,
 325                                         LifeCycleStatesEnum.CERTIFY);
 326                         if (restResponseService.getErrorCode() == 200) {
 327                                 String newVersion = ResponseParser.getVersionFromResponse(restResponseService);
 328                                 serviceDetails.setVersion(newVersion);
 329                                 serviceDetails.setLifecycleState(LifecycleStateEnum.CERTIFIED);
 330                                 serviceDetails.setLastUpdaterUserId(testerDetails.getUserId());
 331                                 serviceDetails.setLastUpdaterFullName(testerDetails.getFullName());
 332                                 String uniqueIdFromRresponse = ResponseParser.getUniqueIdFromResponse(restResponseService);
 333                                 serviceDetails.setUniqueId(uniqueIdFromRresponse);
 334                         }
 335                 }
 336                 return restResponseService;
 337         }
 338
 339         private static RestResponse _changeProductState(Product product, User sdncModifierDetails,
 340                         LifeCycleStatesEnum LifeCycleStatesEnum, String lifecycleChangeInfo) throws Exception {
 341
 342                 Config config = Utils.getConfig();
 343                 String url = String.format(Urls.CHANGE_PRODUCT_LIFECYCLE_STATE, config.getCatalogBeHost(),
 344                                 config.getCatalogBePort(), product.getUniqueId(), LifeCycleStatesEnum);
 345                 RestResponse LifeCycleStatesEnumServiceResponse = sendPost(url, createLifecycleCommentJson(lifecycleChangeInfo),
 346                                 sdncModifierDetails.getUserId(), acceptHeaderData);
 347
 348                 return LifeCycleStatesEnumServiceResponse;
 349         }
 350
 351         public static String createLifecycleCommentJson(String commentContent) {
 352                 String res = null;
 353                 if (commentContent != null) {
 354                         res = "{\"userRemarks\": \"" + commentContent + "\"}";
 355                 }
 356                 return res;
 357         }
 358
 359         public static void checkLCS_Response(RestResponse response) {
 360                 checkStatusCode(response, "change lifecycle request failed", false, STATUS_CODE_SUCCESS);
 361         }
 362
 363         private static Map<String, String> prepareHeadersMap(User sdncModifierDetails) {
 364                 Map<String, String> headersMap = new HashMap<String, String>();
 365                 headersMap.put(HttpHeaderEnum.CONTENT_TYPE.getValue(), contentTypeHeaderData);
 366                 headersMap.put(HttpHeaderEnum.ACCEPT.getValue(), acceptHeaderData);
 367                 headersMap.put(HttpHeaderEnum.USER_ID.getValue(), sdncModifierDetails.getUserId());
 368                 return headersMap;
 369         }
 370
 371         public static RestResponse changeDistributionStatus(ServiceReqDetails serviceDetails, String version, User user,
 372                         String userRemarks, DistributionStatusEnum reqDistributionStatus) throws Exception {
 373                 String uniqueId = serviceDetails.getUniqueId();
 374                 Config config = Utils.getConfig();
 375                 String environmentName = "PROD-Andreys-Only";
 376 //              String environmentName = ConfigurationManager.getConfigurationManager().getDistributionEngineConfiguration().getEnvironments().get(0);
 377                 DistributionStatusEnum distributionStatusEnum = DistributionStatusEnum.findState(reqDistributionStatus.getValue());
 378                 switch(distributionStatusEnum){
 379                         case DISTRIBUTION_APPROVED:
 380                                 return sendApproveDistribution(user, uniqueId, userRemarks);
 381                         case DISTRIBUTED:
 382                                 String url = String.format(Urls.ACTIVATE_DISTRIBUTION, config.getCatalogBeHost(), config.getCatalogBePort(), uniqueId, environmentName);
 383                                 return sendDistrState(user, userRemarks, url);
 384                         case DISTRIBUTION_REJECTED:
 385                                 return rejectDistribution(user, userRemarks, uniqueId);
 386                         default:
 387                                 return null;
 388
 389                 }
 390
 391 //              if (reqDistributionStatus == DistributionStatusEnum.DISTRIBUTION_APPROVED) {
 392 //                      return sendApproveDistribution(user, uniqueId, userRemarks);
 393 //              } else if (reqDistributionStatus == DistributionStatusEnum.DISTRIBUTION_REJECTED) {
 394 //                      return rejectDistribution(user, userRemarks, uniqueId);
 395 //              } else if (reqDistributionStatus == DistributionStatusEnum.DISTRIBUTED) {
 396 //                      Config config = Utils.getConfig();
 397 //                      // String url =
 398 //                      // String.format("http://%s:%s/sdc2/rest/v1/catalog/services/%s/tempUrlToBeDeleted",
 399 //                      // config.getCatalogBeHost(), config.getCatalogBePort(), uniqueId);
 400 //                      String url = String.format(Urls.ACTIVATE_DISTRIBUTION, config.getCatalogBeHost(), config.getCatalogBePort(),
 401 //                                      uniqueId, "PROD");
 402 //                      return sendDistrState(user, userRemarks, url);
 403 //              } else
 404 //                      return null;
 405
 406         }
 407
 408         public static RestResponse sendApproveDistribution(User sdncModifierDetails, String uniqueId, String userRemarks)
 409                         throws FileNotFoundException, IOException {
 410                 Config config = Utils.getConfig();
 411                 String url = String.format(Urls.APPROVE_DISTRIBUTION, config.getCatalogBeHost(), config.getCatalogBePort(),
 412                                 uniqueId);
 413                 return sendDistrState(sdncModifierDetails, userRemarks, url);
 414         }
 415
 416         public static RestResponse rejectDistribution(ServiceReqDetails serviceDetails, String version, User user,
 417                         String userRemarks) throws Exception {
 418                 return rejectDistribution(user, userRemarks, serviceDetails.getUniqueId());
 419         }
 420
 421         public static RestResponse rejectDistribution(User user, String userRemarks, String uniqueId)
 422                         throws FileNotFoundException, IOException {
 423                 Config config = Utils.getConfig();
 424                 String url = String.format(Urls.REJECT_DISTRIBUTION, config.getCatalogBeHost(), config.getCatalogBePort(),
 425                                 uniqueId);
 426                 return sendDistrState(user, userRemarks, url);
 427         }
 428
 429         private static RestResponse sendDistrState(User user, String userRemarks, String url) throws IOException {
 430                 Map<String, String> headersMap = prepareHeadersMap(user);
 431                 Map<String, String> userRemarksMap = new HashMap<String, String>();
 432                 userRemarksMap.put("userRemarks", userRemarks);
 433
 434                 String serviceBodyJson = new JSONObject().toJSONString(userRemarksMap);
 435
 436                 HttpRequest httpRequest = new HttpRequest();
 437                 logger.debug(url);
 438                 logger.debug("Send POST request to create service: {}", url);
 439                 logger.debug("Service body: {}", serviceBodyJson);
 440                 logger.debug("Service headers: {}", headersMap);
 441                 RestResponse rejectDistributionResponse = httpRequest.httpSendPost(url, serviceBodyJson, headersMap);
 442
 443                 return rejectDistributionResponse;
 444         }
 445
 446 }