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