2 * ============LICENSE_START=======================================================
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
11 * http://www.apache.org/licenses/LICENSE-2.0
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=========================================================
21 package org.openecomp.sdc.ci.tests.utils.rest;
23 import java.io.FileNotFoundException;
24 import java.io.IOException;
25 import java.util.HashMap;
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;
51 public class LifecycleRestUtils extends BaseRestUtils {
52 private static Logger logger = LoggerFactory.getLogger(LifecycleRestUtils.class.getName());
53 public static final String COMMENT = "comment";
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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());
114 Map<String, String> additionalHeaders = new HashMap<String, String>();
116 additionalHeaders.put(HttpHeaderEnum.AUTHORIZATION.getValue(), authorizationHeader);
117 additionalHeaders.put(HttpHeaderEnum.X_ECOMP_INSTANCE_ID.getValue(), "ci");
119 String jsonBody = "{\"userRemarks\": \"" + comment + "\"}";
121 RestResponse res = sendPost(url, jsonBody, sdncModifierDetails.getUserId(), acceptHeaderData, additionalHeaders);
126 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
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));
134 public static RestResponse changeResourceState(ResourceReqDetails resourceDetails, User sdncModifierDetails,
135 String version, LifeCycleStatesEnum LifeCycleStatesEnum, String LifecycleChangeInfo) throws IOException {
137 return changeResourceState(resourceDetails, sdncModifierDetails, LifeCycleStatesEnum, LifecycleChangeInfo);
141 public static RestResponse changeResourceState(ResourceReqDetails resourceDetails, User sdncModifierDetails,
142 LifeCycleStatesEnum LifeCycleStatesEnum) throws IOException {
144 return changeResourceState(resourceDetails, sdncModifierDetails, LifeCycleStatesEnum,
145 createLifecycleCommentJson(COMMENT));
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));
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);
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));
174 return LifeCycleStatesEnumResourceResponse;
177 public static RestResponse changeServiceState(ServiceReqDetails serviceDetails, User sdncModifierDetails,
178 String version, LifeCycleStatesEnum LifeCycleStatesEnum) throws Exception {
180 return changeServiceState(serviceDetails, sdncModifierDetails, version, LifeCycleStatesEnum,
181 createLifecycleCommentJson(COMMENT));
185 public static RestResponse changeServiceState(ServiceReqDetails serviceDetails, User sdncModifierDetails,
186 LifeCycleStatesEnum LifeCycleStatesEnum) throws Exception {
188 return changeServiceState(serviceDetails, sdncModifierDetails, null, LifeCycleStatesEnum,
189 createLifecycleCommentJson(COMMENT));
193 public static RestResponse changeServiceState(ServiceReqDetails serviceDetails, User sdncModifierDetails,
194 LifeCycleStatesEnum LifeCycleStatesEnum, String lifecycleChangeInfo) throws Exception {
196 return changeServiceState(serviceDetails, sdncModifierDetails, null, LifeCycleStatesEnum,
197 lifecycleChangeInfo);
201 public static RestResponse changeServiceState(ServiceReqDetails serviceDetails, User sdncModifierDetails,
202 String version, LifeCycleStatesEnum LifeCycleStatesEnum, String lifecycleChangeInfo) throws Exception {
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));
222 return LifeCycleStatesEnumServiceResponse;
225 public static RestResponse changeProductState(Product product, User sdncModifierDetails,
226 LifeCycleStatesEnum LifeCycleStatesEnum, String lifecycleChangeInfo) throws Exception {
228 return _changeProductState(product, sdncModifierDetails, LifeCycleStatesEnum, lifecycleChangeInfo);
232 public static RestResponse changeProductState(Product product, User sdncModifierDetails,
233 LifeCycleStatesEnum LifeCycleStatesEnum) throws Exception {
235 return _changeProductState(product, sdncModifierDetails, LifeCycleStatesEnum, COMMENT);
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));
257 return LifeCycleStatesEnumServiceResponse;
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()),
266 component.getUniqueId(), LifeCycleStatesEnum);
267 RestResponse LifeCycleStatesEnumServiceResponse = sendPost(url, createLifecycleCommentJson(COMMENT),
268 sdncModifierDetails.getUserId(), acceptHeaderData);
269 if (LifeCycleStatesEnumServiceResponse.getErrorCode() == STATUS_CODE_SUCCESS) {
270 String productUniqueId = ResponseParser
271 .getValueFromJsonResponse(LifeCycleStatesEnumServiceResponse.getResponse(), "uniqueId");
272 component.setUniqueId(productUniqueId);
273 String productVersion = ResponseParser
274 .getValueFromJsonResponse(LifeCycleStatesEnumServiceResponse.getResponse(), "version");
275 component.setVersion(productVersion);
276 String newLifecycleState = ResponseParser
277 .getValueFromJsonResponse(LifeCycleStatesEnumServiceResponse.getResponse(), "lifecycleState");
278 component.setLifecycleState(LifecycleStateEnum.valueOf(newLifecycleState));
280 return LifeCycleStatesEnumServiceResponse;
284 public static RestResponse certifyResource(ResourceReqDetails resourceDetails) throws Exception {
285 RestResponse restResponseResource = LifecycleRestUtils.changeResourceState(resourceDetails,
286 ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), LifeCycleStatesEnum.CHECKIN);
287 // if (restResponseResource.getErrorCode() == 200){
288 restResponseResource = LifecycleRestUtils.changeResourceState(resourceDetails,
289 ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), LifeCycleStatesEnum.CERTIFICATIONREQUEST);
291 // return restResponseResource;
292 User testerDetails = ElementFactory.getDefaultUser(UserRoleEnum.TESTER);
293 if (restResponseResource.getErrorCode() == 200) {
294 restResponseResource = LifecycleRestUtils.changeResourceState(resourceDetails, testerDetails,
295 LifeCycleStatesEnum.STARTCERTIFICATION);
297 return restResponseResource;
298 if (restResponseResource.getErrorCode() == 200) {
299 restResponseResource = LifecycleRestUtils.changeResourceState(resourceDetails, testerDetails,
300 LifeCycleStatesEnum.CERTIFY);
301 if (restResponseResource.getErrorCode() == 200) {
302 String newVersion = ResponseParser.getVersionFromResponse(restResponseResource);
303 resourceDetails.setVersion(newVersion);
304 resourceDetails.setLifecycleState(LifecycleStateEnum.CERTIFIED);
305 resourceDetails.setLastUpdaterUserId(testerDetails.getUserId());
306 resourceDetails.setLastUpdaterFullName(testerDetails.getFullName());
307 String uniqueIdFromRresponse = ResponseParser.getUniqueIdFromResponse(restResponseResource);
308 resourceDetails.setUniqueId(uniqueIdFromRresponse);
311 return restResponseResource;
314 public static RestResponse certifyService(ServiceReqDetails serviceDetails) throws Exception {
315 RestResponse restResponseService = LifecycleRestUtils.changeServiceState(serviceDetails,
316 ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), LifeCycleStatesEnum.CHECKIN);
317 // if (restResponseService.getErrorCode() == 200){
318 restResponseService = LifecycleRestUtils.changeServiceState(serviceDetails,
319 ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), LifeCycleStatesEnum.CERTIFICATIONREQUEST);
321 // return restResponseService;
322 if (restResponseService.getErrorCode() == 200) {
323 restResponseService = LifecycleRestUtils.changeServiceState(serviceDetails,
324 ElementFactory.getDefaultUser(UserRoleEnum.TESTER), LifeCycleStatesEnum.STARTCERTIFICATION);
326 return restResponseService;
327 if (restResponseService.getErrorCode() == 200) {
328 User testerDetails = ElementFactory.getDefaultUser(UserRoleEnum.TESTER);
329 restResponseService = LifecycleRestUtils.changeServiceState(serviceDetails, testerDetails,
330 LifeCycleStatesEnum.CERTIFY);
331 if (restResponseService.getErrorCode() == 200) {
332 String newVersion = ResponseParser.getVersionFromResponse(restResponseService);
333 serviceDetails.setVersion(newVersion);
334 serviceDetails.setLifecycleState(LifecycleStateEnum.CERTIFIED);
335 serviceDetails.setLastUpdaterUserId(testerDetails.getUserId());
336 serviceDetails.setLastUpdaterFullName(testerDetails.getFullName());
337 String uniqueIdFromRresponse = ResponseParser.getUniqueIdFromResponse(restResponseService);
338 serviceDetails.setUniqueId(uniqueIdFromRresponse);
341 return restResponseService;
344 private static RestResponse _changeProductState(Product product, User sdncModifierDetails,
345 LifeCycleStatesEnum LifeCycleStatesEnum, String lifecycleChangeInfo) throws Exception {
347 Config config = Utils.getConfig();
348 String url = String.format(Urls.CHANGE_PRODUCT_LIFECYCLE_STATE, config.getCatalogBeHost(),
349 config.getCatalogBePort(), product.getUniqueId(), LifeCycleStatesEnum);
350 RestResponse LifeCycleStatesEnumServiceResponse = sendPost(url, createLifecycleCommentJson(lifecycleChangeInfo),
351 sdncModifierDetails.getUserId(), acceptHeaderData);
353 return LifeCycleStatesEnumServiceResponse;
356 public static String createLifecycleCommentJson(String commentContent) {
358 if (commentContent != null) {
359 res = "{\"userRemarks\": \"" + commentContent + "\"}";
364 public static void checkLCS_Response(RestResponse response) {
365 checkStatusCode(response, "change lifecycle request failed", false, STATUS_CODE_SUCCESS);
368 private static Map<String, String> prepareHeadersMap(User sdncModifierDetails) {
369 Map<String, String> headersMap = new HashMap<String, String>();
370 headersMap.put(HttpHeaderEnum.CONTENT_TYPE.getValue(), contentTypeHeaderData);
371 headersMap.put(HttpHeaderEnum.ACCEPT.getValue(), acceptHeaderData);
372 headersMap.put(HttpHeaderEnum.USER_ID.getValue(), sdncModifierDetails.getUserId());
376 public static RestResponse changeDistributionStatus(ServiceReqDetails serviceDetails, String version, User user,
377 String userRemarks, DistributionStatusEnum reqDistributionStatus) throws Exception {
378 String uniqueId = serviceDetails.getUniqueId();
379 Config config = Utils.getConfig();
380 String environmentName = "PROD-Andreys-Only";
381 // String environmentName = ConfigurationManager.getConfigurationManager().getDistributionEngineConfiguration().getEnvironments().get(0);
382 DistributionStatusEnum distributionStatusEnum = DistributionStatusEnum.findState(reqDistributionStatus.getValue());
383 switch(distributionStatusEnum){
384 case DISTRIBUTION_APPROVED:
385 return sendApproveDistribution(user, uniqueId, userRemarks);
387 String url = String.format(Urls.ACTIVATE_DISTRIBUTION, config.getCatalogBeHost(), config.getCatalogBePort(), uniqueId, environmentName);
388 return sendDistrState(user, userRemarks, url);
389 case DISTRIBUTION_REJECTED:
390 return rejectDistribution(user, userRemarks, uniqueId);
396 // if (reqDistributionStatus == DistributionStatusEnum.DISTRIBUTION_APPROVED) {
397 // return sendApproveDistribution(user, uniqueId, userRemarks);
398 // } else if (reqDistributionStatus == DistributionStatusEnum.DISTRIBUTION_REJECTED) {
399 // return rejectDistribution(user, userRemarks, uniqueId);
400 // } else if (reqDistributionStatus == DistributionStatusEnum.DISTRIBUTED) {
401 // Config config = Utils.getConfig();
403 // // String.format("http://%s:%s/sdc2/rest/v1/catalog/services/%s/tempUrlToBeDeleted",
404 // // config.getCatalogBeHost(), config.getCatalogBePort(), uniqueId);
405 // String url = String.format(Urls.ACTIVATE_DISTRIBUTION, config.getCatalogBeHost(), config.getCatalogBePort(),
406 // uniqueId, "PROD");
407 // return sendDistrState(user, userRemarks, url);
413 public static RestResponse sendApproveDistribution(User sdncModifierDetails, String uniqueId, String userRemarks)
414 throws FileNotFoundException, IOException {
415 Config config = Utils.getConfig();
416 String url = String.format(Urls.APPROVE_DISTRIBUTION, config.getCatalogBeHost(), config.getCatalogBePort(),
418 return sendDistrState(sdncModifierDetails, userRemarks, url);
421 public static RestResponse rejectDistribution(ServiceReqDetails serviceDetails, String version, User user,
422 String userRemarks) throws Exception {
423 return rejectDistribution(user, userRemarks, serviceDetails.getUniqueId());
426 public static RestResponse rejectDistribution(User user, String userRemarks, String uniqueId)
427 throws FileNotFoundException, IOException {
428 Config config = Utils.getConfig();
429 String url = String.format(Urls.REJECT_DISTRIBUTION, config.getCatalogBeHost(), config.getCatalogBePort(),
431 return sendDistrState(user, userRemarks, url);
434 private static RestResponse sendDistrState(User user, String userRemarks, String url) throws IOException {
435 Map<String, String> headersMap = prepareHeadersMap(user);
436 Map<String, String> userRemarksMap = new HashMap<String, String>();
437 userRemarksMap.put("userRemarks", userRemarks);
439 String serviceBodyJson = new JSONObject().toJSONString(userRemarksMap);
441 HttpRequest httpRequest = new HttpRequest();
443 logger.debug("Send POST request to create service: {}", url);
444 logger.debug("Service body: {}", serviceBodyJson);
445 logger.debug("Service headers: {}", headersMap);
446 RestResponse rejectDistributionResponse = httpRequest.httpSendPost(url, serviceBodyJson, headersMap);
448 return rejectDistributionResponse;