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()), 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));
275 return LifeCycleStatesEnumServiceResponse;
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);
286 // return restResponseResource;
287 User testerDetails = ElementFactory.getDefaultUser(UserRoleEnum.TESTER);
288 if (restResponseResource.getErrorCode() == 200) {
289 restResponseResource = LifecycleRestUtils.changeResourceState(resourceDetails, testerDetails,
290 LifeCycleStatesEnum.STARTCERTIFICATION);
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);
306 return restResponseResource;
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);
316 // return restResponseService;
317 if (restResponseService.getErrorCode() == 200) {
318 restResponseService = LifecycleRestUtils.changeServiceState(serviceDetails,
319 ElementFactory.getDefaultUser(UserRoleEnum.TESTER), LifeCycleStatesEnum.STARTCERTIFICATION);
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);
336 return restResponseService;
339 private static RestResponse _changeProductState(Product product, User sdncModifierDetails,
340 LifeCycleStatesEnum LifeCycleStatesEnum, String lifecycleChangeInfo) throws Exception {
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);
348 return LifeCycleStatesEnumServiceResponse;
351 public static String createLifecycleCommentJson(String commentContent) {
353 if (commentContent != null) {
354 res = "{\"userRemarks\": \"" + commentContent + "\"}";
359 public static void checkLCS_Response(RestResponse response) {
360 checkStatusCode(response, "change lifecycle request failed", false, STATUS_CODE_SUCCESS);
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());
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);
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);
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();
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);
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(),
413 return sendDistrState(sdncModifierDetails, userRemarks, url);
416 public static RestResponse rejectDistribution(ServiceReqDetails serviceDetails, String version, User user,
417 String userRemarks) throws Exception {
418 return rejectDistribution(user, userRemarks, serviceDetails.getUniqueId());
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(),
426 return sendDistrState(user, userRemarks, url);
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);
434 String serviceBodyJson = new JSONObject().toJSONString(userRemarksMap);
436 HttpRequest httpRequest = new HttpRequest();
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);
443 return rejectDistributionResponse;