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