catalog-be/src/main/java/org/openecomp/sdc/be/servlets/ServiceServlet.java

   1 /*-\r
   2  * ============LICENSE_START=======================================================\r
   3  * SDC\r
   4  * ================================================================================\r
   5  * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.\r
   6  * ================================================================================\r
   7  * Licensed under the Apache License, Version 2.0 (the "License");\r
   8  * you may not use this file except in compliance with the License.\r
   9  * You may obtain a copy of the License at\r
  10  * \r
  11  *      http://www.apache.org/licenses/LICENSE-2.0\r
  12  * \r
  13  * Unless required by applicable law or agreed to in writing, software\r
  14  * distributed under the License is distributed on an "AS IS" BASIS,\r
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
  16  * See the License for the specific language governing permissions and\r
  17  * limitations under the License.\r
  18  * ============LICENSE_END=========================================================\r
  19  */\r
  20 \r
  21 package org.openecomp.sdc.be.servlets;\r
  22 \r
  23 import com.fasterxml.jackson.databind.ObjectMapper;\r
  24 import com.google.gson.reflect.TypeToken;\r
  25 import com.jcabi.aspects.Loggable;\r
  26 import fj.data.Either;\r
  27 import io.swagger.v3.oas.annotations.OpenAPIDefinition;\r
  28 import io.swagger.v3.oas.annotations.Operation;\r
  29 import io.swagger.v3.oas.annotations.Parameter;\r
  30 import io.swagger.v3.oas.annotations.info.Info;\r
  31 import io.swagger.v3.oas.annotations.media.ArraySchema;\r
  32 import io.swagger.v3.oas.annotations.media.Content;\r
  33 import io.swagger.v3.oas.annotations.media.Schema;\r
  34 import io.swagger.v3.oas.annotations.responses.ApiResponse;\r
  35 import io.swagger.v3.oas.annotations.responses.ApiResponses;\r
  36 import javax.inject.Inject;\r
  37 import javax.ws.rs.Consumes;\r
  38 import javax.ws.rs.DELETE;\r
  39 import javax.ws.rs.GET;\r
  40 import javax.ws.rs.HeaderParam;\r
  41 import javax.ws.rs.POST;\r
  42 import javax.ws.rs.PUT;\r
  43 import javax.ws.rs.Path;\r
  44 import javax.ws.rs.PathParam;\r
  45 import javax.ws.rs.Produces;\r
  46 import org.apache.http.HttpStatus;\r
  47 import org.openecomp.sdc.be.components.impl.ComponentInstanceBusinessLogic;\r
  48 import org.openecomp.sdc.be.components.impl.ResourceBusinessLogic;\r
  49 import org.openecomp.sdc.be.components.impl.ResourceImportManager;\r
  50 import org.openecomp.sdc.be.components.impl.ServiceBusinessLogic;\r
  51 import org.openecomp.sdc.be.components.lifecycle.LifecycleChangeInfoWithAction;\r
  52 import org.openecomp.sdc.be.config.BeEcompErrorManager;\r
  53 import org.openecomp.sdc.be.dao.api.ActionStatus;\r
  54 import org.openecomp.sdc.be.datamodel.ServiceRelations;\r
  55 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;\r
  56 import org.openecomp.sdc.be.impl.ComponentsUtils;\r
  57 import org.openecomp.sdc.be.impl.ServletUtils;\r
  58 import org.openecomp.sdc.be.model.DistributionStatusEnum;\r
  59 import org.openecomp.sdc.be.model.GroupInstanceProperty;\r
  60 import org.openecomp.sdc.be.model.Resource;\r
  61 import org.openecomp.sdc.be.model.Service;\r
  62 import org.openecomp.sdc.be.model.User;\r
  63 import org.openecomp.sdc.be.resources.data.auditing.AuditingActionEnum;\r
  64 import org.openecomp.sdc.be.user.UserBusinessLogic;\r
  65 import org.openecomp.sdc.common.api.Constants;\r
  66 import org.openecomp.sdc.common.datastructure.Wrapper;\r
  67 import org.openecomp.sdc.common.log.wrappers.Logger;\r
  68 import org.openecomp.sdc.exception.ResponseFormat;\r
  69 \r
  70 import javax.inject.Singleton;\r
  71 import javax.servlet.ServletContext;\r
  72 import javax.servlet.http.HttpServletRequest;\r
  73 import javax.ws.rs.core.Context;\r
  74 import javax.ws.rs.core.MediaType;\r
  75 import javax.ws.rs.core.Response;\r
  76 import java.lang.reflect.Type;\r
  77 import java.util.ArrayList;\r
  78 import java.util.List;\r
  79 import java.util.Map;\r
  80 \r
  81 @Loggable(prepend = true, value = Loggable.DEBUG, trim = false)\r
  82 @Path("/v1/catalog")\r
  83 @OpenAPIDefinition(info = @Info(title = "Service Catalog", description = "Service Servlet"))\r
  84 @Singleton\r
  85 public class ServiceServlet extends AbstractValidationsServlet {\r
  86 \r
  87     private static final Logger log = Logger.getLogger(ServiceServlet.class);\r
  88     private final ServiceBusinessLogic serviceBusinessLogic;\r
  89     private final ResourceBusinessLogic resourceBusinessLogic;\r
  90 \r
  91     @Inject\r
  92     public ServiceServlet(UserBusinessLogic userBusinessLogic,\r
  93         ComponentInstanceBusinessLogic componentInstanceBL,\r
  94         ComponentsUtils componentsUtils, ServletUtils servletUtils,\r
  95         ResourceImportManager resourceImportManager,\r
  96         ServiceBusinessLogic serviceBusinessLogic,\r
  97         ResourceBusinessLogic resourceBusinessLogic) {\r
  98         super(userBusinessLogic, componentInstanceBL, componentsUtils, servletUtils, resourceImportManager);\r
  99         this.serviceBusinessLogic = serviceBusinessLogic;\r
 100         this.resourceBusinessLogic = resourceBusinessLogic;\r
 101     }\r
 102 \r
 103     @POST\r
 104     @Path("/services")\r
 105     @Consumes(MediaType.APPLICATION_JSON)\r
 106     @Produces(MediaType.APPLICATION_JSON)\r
 107     @Operation(description = "Create Service", method = "POST", summary = "Returns created service",\r
 108             responses = @ApiResponse(\r
 109                     content = @Content(array = @ArraySchema(schema = @Schema(implementation = Service.class)))))\r
 110     @ApiResponses(value = {@ApiResponse(responseCode = "201", description = "Service created"),\r
 111             @ApiResponse(responseCode = "403", description = "Restricted operation"),\r
 112             @ApiResponse(responseCode = "400", description = "Invalid content / Missing content"),\r
 113             @ApiResponse(responseCode = "409", description = "Service already exist")})\r
 114     public Response createService(@Parameter(description = "Service object to be created", required = true) String data,\r
 115             @Context final HttpServletRequest request, @HeaderParam(value = Constants.USER_ID_HEADER) String userId) {\r
 116 \r
 117         String url = request.getMethod() + " " + request.getRequestURI();\r
 118         log.debug("Start handle request of {}", url);\r
 119 \r
 120         User modifier = new User();\r
 121         modifier.setUserId(userId);\r
 122         log.debug("modifier id is {}", userId);\r
 123 \r
 124         Response response = null;\r
 125         try {\r
 126             Either<Service, ResponseFormat> convertResponse = parseToService(data, modifier);\r
 127             if (convertResponse.isRight()) {\r
 128                 log.debug("failed to parse service");\r
 129                 response = buildErrorResponse(convertResponse.right().value());\r
 130                 return response;\r
 131             }\r
 132 \r
 133             Service service = convertResponse.left().value();\r
 134             Either<Service, ResponseFormat> actionResponse = serviceBusinessLogic.createService(service, modifier);\r
 135 \r
 136             if (actionResponse.isRight()) {\r
 137                 log.debug("Failed to create service");\r
 138                 response = buildErrorResponse(actionResponse.right().value());\r
 139                 return response;\r
 140             }\r
 141 \r
 142             Object result = RepresentationUtils.toRepresentation(actionResponse.left().value());\r
 143             response = buildOkResponse(getComponentsUtils().getResponseFormat(ActionStatus.CREATED), result);\r
 144             return response;\r
 145 \r
 146         } catch (Exception e) {\r
 147             BeEcompErrorManager.getInstance().logBeRestApiGeneralError("Create Service");\r
 148             log.debug("create service failed with exception", e);\r
 149             response = buildErrorResponse(getComponentsUtils().getResponseFormat(ActionStatus.GENERAL_ERROR));\r
 150             return response;\r
 151         }\r
 152     }\r
 153 \r
 154     public Either<Service, ResponseFormat> parseToService(String serviceJson, User user) {\r
 155         return getComponentsUtils().convertJsonToObjectUsingObjectMapper(serviceJson, user, Service.class, AuditingActionEnum.CREATE_RESOURCE, ComponentTypeEnum.SERVICE);\r
 156     }\r
 157 \r
 158     @GET\r
 159     @Path("/services/validate-name/{serviceName}")\r
 160     @Consumes(MediaType.APPLICATION_JSON)\r
 161     @Produces(MediaType.APPLICATION_JSON)\r
 162     @Operation(description = "validate service name", method = "GET",\r
 163             summary = "checks if the chosen service name is available ", responses = @ApiResponse(\r
 164                     content = @Content(array = @ArraySchema(schema = @Schema(implementation = Response.class)))))\r
 165     @ApiResponses(value = {@ApiResponse(responseCode = "200", description = "Service found"),\r
 166             @ApiResponse(responseCode = "403", description = "Restricted operation")})\r
 167     public Response validateServiceName(@PathParam("serviceName") final String serviceName,\r
 168             @Context final HttpServletRequest request, @HeaderParam(value = Constants.USER_ID_HEADER) String userId) {\r
 169         String url = request.getMethod() + " " + request.getRequestURI();\r
 170         log.debug("Start handle request of {}", url);\r
 171 \r
 172         // get modifier id\r
 173         User modifier = new User();\r
 174         modifier.setUserId(userId);\r
 175         log.debug("modifier id is {}", userId);\r
 176         Response response = null;\r
 177         try {\r
 178             Either<Map<String, Boolean>, ResponseFormat> actionResponse =\r
 179                     serviceBusinessLogic.validateServiceNameExists(serviceName, userId);\r
 180 \r
 181             if (actionResponse.isRight()) {\r
 182                 log.debug("failed to get validate service name");\r
 183                 response = buildErrorResponse(actionResponse.right().value());\r
 184                 return response;\r
 185             }\r
 186             return buildOkResponse(getComponentsUtils().getResponseFormat(ActionStatus.OK),\r
 187                     actionResponse.left().value());\r
 188         } catch (Exception e) {\r
 189             BeEcompErrorManager.getInstance().logBeRestApiGeneralError("Validate Service Name");\r
 190             log.debug("validate service name failed with exception", e);\r
 191             return buildErrorResponse(getComponentsUtils().getResponseFormat(ActionStatus.GENERAL_ERROR));\r
 192         }\r
 193     }\r
 194 \r
 195     @GET\r
 196     @Path("/audit-records/{componentType}/{componentUniqueId}")\r
 197     @Consumes(MediaType.APPLICATION_JSON)\r
 198     @Produces(MediaType.APPLICATION_JSON)\r
 199     @Operation(description = "get component audit records", method = "GET",\r
 200             summary = "get audit records for a service or a resource", responses = @ApiResponse(\r
 201                     content = @Content(array = @ArraySchema(schema = @Schema(implementation = Response.class)))))\r
 202     @ApiResponses(value = {@ApiResponse(responseCode = "200", description = "Service found"),\r
 203             @ApiResponse(responseCode = "403", description = "Restricted operation")})\r
 204     public Response getComponentAuditRecords(@PathParam("componentType") final String componentType,\r
 205             @PathParam("componentUniqueId") final String componentUniqueId, @Context final HttpServletRequest request,\r
 206             @HeaderParam(value = Constants.USER_ID_HEADER) String userId) {\r
 207         init();\r
 208         ServletContext context = request.getSession().getServletContext();\r
 209         String url = request.getMethod() + " " + request.getRequestURI();\r
 210         log.debug("Start handle request of {}", url);\r
 211 \r
 212         User modifier = new User();\r
 213         modifier.setUserId(userId);\r
 214         log.debug("modifier id is {}", userId);\r
 215         Wrapper<Response> responseWrapper = new Wrapper<>();\r
 216         Wrapper<String> uuidWrapper = new Wrapper<>();\r
 217         Wrapper<String> versionWrapper = new Wrapper<>();\r
 218         Wrapper<User> userWrapper = new Wrapper<>();\r
 219         Wrapper<ComponentTypeEnum> componentWrapper = new Wrapper<>();\r
 220         try {\r
 221             validateUserExist(responseWrapper, userWrapper, userId);\r
 222 \r
 223             if (responseWrapper.isEmpty()) {\r
 224                 validateComponentType(responseWrapper, componentWrapper, componentType);\r
 225             }\r
 226 \r
 227             if (responseWrapper.isEmpty()) {\r
 228                 fillUUIDAndVersion(responseWrapper, uuidWrapper, versionWrapper, userWrapper.getInnerElement(),\r
 229                         componentWrapper.getInnerElement(), componentUniqueId, context);\r
 230             }\r
 231 \r
 232             if (responseWrapper.isEmpty()) {\r
 233                 Either<List<Map<String, Object>>, ResponseFormat> eitherServiceAudit =\r
 234                         serviceBusinessLogic.getComponentAuditRecords(versionWrapper.getInnerElement(),\r
 235                                 uuidWrapper.getInnerElement(), userId);\r
 236 \r
 237                 if (eitherServiceAudit.isRight()) {\r
 238                     Response errorResponse = buildErrorResponse(eitherServiceAudit.right().value());\r
 239                     responseWrapper.setInnerElement(errorResponse);\r
 240                 } else {\r
 241                     List<Map<String, Object>> auditRecords = eitherServiceAudit.left().value();\r
 242                     Response okResponse =\r
 243                             buildOkResponse(getComponentsUtils().getResponseFormat(ActionStatus.OK), auditRecords);\r
 244                     responseWrapper.setInnerElement(okResponse);\r
 245 \r
 246                 }\r
 247             }\r
 248 \r
 249         } catch (Exception e) {\r
 250             BeEcompErrorManager.getInstance().logBeRestApiGeneralError("Validate Service Name");\r
 251             log.debug("get Service Audit Records failed with exception", e);\r
 252             Response errorResponse =\r
 253                     buildErrorResponse(getComponentsUtils().getResponseFormat(ActionStatus.GENERAL_ERROR));\r
 254             responseWrapper.setInnerElement(errorResponse);\r
 255         }\r
 256         return responseWrapper.getInnerElement();\r
 257     }\r
 258 \r
 259     private void fillUUIDAndVersion(Wrapper<Response> responseWrapper, Wrapper<String> uuidWrapper, Wrapper<String> versionWrapper, User user, final ComponentTypeEnum componentTypeEnum, final String componentUniqueId, ServletContext context) {\r
 260 \r
 261         if (componentTypeEnum == ComponentTypeEnum.RESOURCE) {\r
 262             Either<Resource, ResponseFormat> eitherResource = resourceBusinessLogic.getResource(componentUniqueId, user);\r
 263             if (eitherResource.isLeft()) {\r
 264                 uuidWrapper.setInnerElement(eitherResource.left().value().getUUID());\r
 265                 versionWrapper.setInnerElement(eitherResource.left().value().getVersion());\r
 266             } else {\r
 267                 responseWrapper.setInnerElement(buildErrorResponse(eitherResource.right().value()));\r
 268             }\r
 269 \r
 270         } else {\r
 271             Either<Service, ResponseFormat> eitherService = serviceBusinessLogic.getService(componentUniqueId, user);\r
 272             if (eitherService.isLeft()) {\r
 273                 uuidWrapper.setInnerElement(eitherService.left().value().getUUID());\r
 274                 versionWrapper.setInnerElement(eitherService.left().value().getVersion());\r
 275             } else {\r
 276                 responseWrapper.setInnerElement(buildErrorResponse(eitherService.right().value()));\r
 277 \r
 278             }\r
 279         }\r
 280     }\r
 281 \r
 282     @DELETE\r
 283     @Path("/services/{serviceId}")\r
 284     public Response deleteService(@PathParam("serviceId") final String serviceId, @Context final HttpServletRequest request) {\r
 285         String url = request.getMethod() + " " + request.getRequestURI();\r
 286         log.debug("Start handle request of {}", url);\r
 287 \r
 288         // get modifier id\r
 289         String userId = request.getHeader(Constants.USER_ID_HEADER);\r
 290         User modifier = new User();\r
 291         modifier.setUserId(userId);\r
 292         log.debug("modifier id is {}", userId);\r
 293 \r
 294         Response response = null;\r
 295 \r
 296         try {\r
 297             String serviceIdLower = serviceId.toLowerCase();\r
 298             ResponseFormat actionResponse = serviceBusinessLogic.deleteService(serviceIdLower, modifier);\r
 299 \r
 300             if (actionResponse.getStatus() != HttpStatus.SC_NO_CONTENT) {\r
 301                 log.debug("failed to delete service");\r
 302                 response = buildErrorResponse(actionResponse);\r
 303                 return response;\r
 304             }\r
 305             response = buildOkResponse(getComponentsUtils().getResponseFormat(ActionStatus.NO_CONTENT), null);\r
 306             return response;\r
 307 \r
 308         } catch (Exception e) {\r
 309             BeEcompErrorManager.getInstance().logBeRestApiGeneralError("Delete Service");\r
 310             log.debug("delete service failed with exception", e);\r
 311             response = buildErrorResponse(getComponentsUtils().getResponseFormat(ActionStatus.GENERAL_ERROR));\r
 312             return response;\r
 313 \r
 314         }\r
 315     }\r
 316 \r
 317     @DELETE\r
 318     @Path("/services/{serviceName}/{version}")\r
 319     public Response deleteServiceByNameAndVersion(@PathParam("serviceName") final String serviceName, @PathParam("version") final String version, @Context final HttpServletRequest request) {\r
 320         String url = request.getMethod() + " " + request.getRequestURI();\r
 321         log.debug("Start handle request of {}", url);\r
 322 \r
 323         // get modifier id\r
 324         String userId = request.getHeader(Constants.USER_ID_HEADER);\r
 325         User modifier = new User();\r
 326         modifier.setUserId(userId);\r
 327         log.debug("modifier id is {}", userId);\r
 328 \r
 329         Response response = null;\r
 330 \r
 331         try {\r
 332             ResponseFormat actionResponse = serviceBusinessLogic.deleteServiceByNameAndVersion(serviceName, version, modifier);\r
 333 \r
 334             if (actionResponse.getStatus() != HttpStatus.SC_NO_CONTENT) {\r
 335                 log.debug("failed to delete service");\r
 336                 response = buildErrorResponse(actionResponse);\r
 337                 return response;\r
 338             }\r
 339             response = buildOkResponse(getComponentsUtils().getResponseFormat(ActionStatus.NO_CONTENT), null);\r
 340             return response;\r
 341 \r
 342         } catch (Exception e) {\r
 343             BeEcompErrorManager.getInstance().logBeRestApiGeneralError("Delete Service");\r
 344             log.debug("delete service failed with exception", e);\r
 345             response = buildErrorResponse(getComponentsUtils().getResponseFormat(ActionStatus.GENERAL_ERROR));\r
 346             return response;\r
 347 \r
 348         }\r
 349     }\r
 350 \r
 351     @PUT\r
 352     @Path("/services/{serviceId}/metadata")\r
 353     @Consumes(MediaType.APPLICATION_JSON)\r
 354     @Produces(MediaType.APPLICATION_JSON)\r
 355     @Operation(description = "Update Service Metadata", method = "PUT", summary = "Returns updated service",\r
 356             responses = @ApiResponse(\r
 357                     content = @Content(array = @ArraySchema(schema = @Schema(implementation = Service.class)))))\r
 358     @ApiResponses(value = {@ApiResponse(responseCode = "200", description = "Service Updated"),\r
 359             @ApiResponse(responseCode = "403", description = "Restricted operation"),\r
 360             @ApiResponse(responseCode = "400", description = "Invalid content / Missing content")})\r
 361     public Response updateServiceMetadata(@PathParam("serviceId") final String serviceId,\r
 362             @Parameter(description = "Service object to be Updated", required = true) String data,\r
 363             @Context final HttpServletRequest request, @HeaderParam(value = Constants.USER_ID_HEADER) String userId) {\r
 364 \r
 365         ServletContext context = request.getSession().getServletContext();\r
 366         String url = request.getMethod() + " " + request.getRequestURI();\r
 367         log.debug("Start handle request of {}", url);\r
 368 \r
 369         User modifier = new User();\r
 370         modifier.setUserId(userId);\r
 371         log.debug("modifier id is {}", userId);\r
 372 \r
 373         Response response = null;\r
 374 \r
 375         try {\r
 376             String serviceIdLower = serviceId.toLowerCase();\r
 377 \r
 378             Either<Service, ResponseFormat> convertResponse = parseToService(data, modifier);\r
 379             if (convertResponse.isRight()) {\r
 380                 log.debug("failed to parse service");\r
 381                 response = buildErrorResponse(convertResponse.right().value());\r
 382                 return response;\r
 383             }\r
 384             Service updatedService = convertResponse.left().value();\r
 385             Either<Service, ResponseFormat> actionResponse =\r
 386                     serviceBusinessLogic.updateServiceMetadata(serviceIdLower, updatedService, modifier);\r
 387 \r
 388             if (actionResponse.isRight()) {\r
 389                 log.debug("failed to update service");\r
 390                 response = buildErrorResponse(actionResponse.right().value());\r
 391                 return response;\r
 392             }\r
 393 \r
 394             Service service = actionResponse.left().value();\r
 395             Object result = RepresentationUtils.toRepresentation(service);\r
 396             return buildOkResponse(getComponentsUtils().getResponseFormat(ActionStatus.OK), result);\r
 397 \r
 398         } catch (Exception e) {\r
 399             BeEcompErrorManager.getInstance().logBeRestApiGeneralError("Update Service Metadata");\r
 400             log.debug("update service metadata failed with exception", e);\r
 401             response = buildErrorResponse(getComponentsUtils().getResponseFormat(ActionStatus.GENERAL_ERROR));\r
 402             return response;\r
 403 \r
 404         }\r
 405     }\r
 406     /**\r
 407      * updates group instance property values\r
 408      * Note, than in case of group instance updated successfully, related resourceInstance and containing component modification time will be updated\r
 409      * @param serviceId\r
 410      * @param componentInstanceId\r
 411      * @param groupInstanceId\r
 412      * @param data\r
 413      * @param request\r
 414      * @param userId\r
 415      * @return\r
 416      */\r
 417     @PUT\r
 418     @Path("/{containerComponentType}/{serviceId}/resourceInstance/{componentInstanceId}/groupInstance/{groupInstanceId}")\r
 419     @Consumes(MediaType.APPLICATION_JSON)\r
 420     @Produces(MediaType.APPLICATION_JSON)\r
 421     @Operation(description = "Update Group Instance Property Values", method = "PUT",\r
 422             summary = "Returns updated group instance", responses = @ApiResponse(\r
 423                     content = @Content(array = @ArraySchema(schema = @Schema(implementation = Service.class)))))\r
 424     @ApiResponses(value = {@ApiResponse(responseCode = "200", description = "Group Instance Property Values Updated"),\r
 425             @ApiResponse(responseCode = "403", description = "Restricted operation"),\r
 426             @ApiResponse(responseCode = "400", description = "Invalid content / Missing content")})\r
 427     public Response updateGroupInstancePropertyValues(@PathParam("serviceId") final String serviceId,\r
 428             @PathParam("componentInstanceId") final String componentInstanceId,\r
 429             @PathParam("groupInstanceId") final String groupInstanceId,\r
 430             @Parameter(description = "Group instance object to be Updated", required = true) String data,\r
 431             @Context final HttpServletRequest request, @HeaderParam(value = Constants.USER_ID_HEADER) String userId) {\r
 432 \r
 433         Response response = null;\r
 434         String url = request.getMethod() + " " + request.getRequestURI();\r
 435         log.debug("Start handle request of {}", url);\r
 436 \r
 437         User modifier = new User();\r
 438         modifier.setUserId(userId);\r
 439         log.debug("modifier id is {}",userId);\r
 440 \r
 441         Either<List<GroupInstanceProperty>, ResponseFormat> actionResponse = null;\r
 442         try {\r
 443             List<GroupInstanceProperty> updatedProperties;\r
 444             Type listType = new TypeToken<ArrayList<GroupInstanceProperty>>(){}.getType();\r
 445             ArrayList<GroupInstanceProperty> newProperties = gson.fromJson(data, listType);\r
 446             if (newProperties == null) {\r
 447                 actionResponse = Either.right(getComponentsUtils().getResponseFormat(ActionStatus.INVALID_CONTENT));\r
 448             }\r
 449             if(actionResponse == null){\r
 450                 log.debug("Start handle update group instance property values request. Received group instance is {}", groupInstanceId);\r
 451                 actionResponse = serviceBusinessLogic.updateGroupInstancePropertyValues(modifier, serviceId, componentInstanceId, groupInstanceId, newProperties);\r
 452                 if(actionResponse.isRight()){\r
 453                     actionResponse = Either.right(actionResponse.right().value());\r
 454                 }\r
 455             }\r
 456             if(actionResponse.isLeft()){\r
 457                 updatedProperties = actionResponse.left().value();\r
 458                 ObjectMapper mapper = new ObjectMapper();\r
 459                 String result = mapper.writeValueAsString(updatedProperties);\r
 460                 response =  buildOkResponse(getComponentsUtils().getResponseFormat(ActionStatus.OK), result);\r
 461             }\r
 462             else{\r
 463                 response = buildErrorResponse(actionResponse.right().value());\r
 464             }\r
 465         } catch (Exception e) {\r
 466             log.error("Exception occured during update Group Instance property values: {}", e.getMessage(), e);\r
 467             response = buildErrorResponse(getComponentsUtils().getResponseFormat(ActionStatus.GENERAL_ERROR));\r
 468         }\r
 469         return response;\r
 470     }\r
 471 \r
 472     @GET\r
 473     @Path("/services/{serviceId}")\r
 474     @Consumes(MediaType.APPLICATION_JSON)\r
 475     @Produces(MediaType.APPLICATION_JSON)\r
 476     @Operation(description = "Retrieve Service", method = "GET", summary = "Returns service according to serviceId",\r
 477             responses = @ApiResponse(\r
 478                     content = @Content(array = @ArraySchema(schema = @Schema(implementation = Service.class)))))\r
 479     @ApiResponses(value = {@ApiResponse(responseCode = "200", description = "Service found"),\r
 480             @ApiResponse(responseCode = "403", description = "Restricted operation"),\r
 481             @ApiResponse(responseCode = "404", description = "Service not found")})\r
 482     public Response getServiceById(@PathParam("serviceId") final String serviceId,\r
 483             @Context final HttpServletRequest request, @HeaderParam(value = Constants.USER_ID_HEADER) String userId) {\r
 484 \r
 485         String url = request.getMethod() + " " + request.getRequestURI();\r
 486         log.debug("Start handle request of {}", url);\r
 487 \r
 488         // get modifier id\r
 489         User modifier = new User();\r
 490         modifier.setUserId(userId);\r
 491         log.debug("modifier id is {}", userId);\r
 492 \r
 493         Response response = null;\r
 494         try {\r
 495             String serviceIdLower = serviceId.toLowerCase();\r
 496             log.debug("get service with id {}", serviceId);\r
 497             Either<Service, ResponseFormat> actionResponse = serviceBusinessLogic.getService(serviceIdLower, modifier);\r
 498 \r
 499             if (actionResponse.isRight()) {\r
 500                 log.debug("failed to get service");\r
 501                 response = buildErrorResponse(actionResponse.right().value());\r
 502                 return response;\r
 503             }\r
 504 \r
 505             Service service = actionResponse.left().value();\r
 506             Object result = RepresentationUtils.toRepresentation(service);\r
 507 \r
 508             return buildOkResponse(getComponentsUtils().getResponseFormat(ActionStatus.OK), result);\r
 509 \r
 510         } catch (Exception e) {\r
 511             BeEcompErrorManager.getInstance().logBeRestApiGeneralError("Get Service");\r
 512             log.debug("get service failed with exception", e);\r
 513             return buildErrorResponse(getComponentsUtils().getResponseFormat(ActionStatus.GENERAL_ERROR));\r
 514 \r
 515         }\r
 516     }\r
 517 \r
 518     @GET\r
 519     @Path("/services/serviceName/{serviceName}/serviceVersion/{serviceVersion}")\r
 520     @Consumes(MediaType.APPLICATION_JSON)\r
 521     @Produces(MediaType.APPLICATION_JSON)\r
 522     @Operation(description = "Retrieve Service", method = "GET",\r
 523             summary = "Returns service according to name and version", responses = @ApiResponse(\r
 524                     content = @Content(array = @ArraySchema(schema = @Schema(implementation = Service.class)))))\r
 525     @ApiResponses(value = {@ApiResponse(responseCode = "200", description = "Service found"),\r
 526             @ApiResponse(responseCode = "403", description = "Restricted operation"),\r
 527             @ApiResponse(responseCode = "404", description = "Service not found")})\r
 528     public Response getServiceByNameAndVersion(@PathParam("serviceName") final String serviceName,\r
 529             @PathParam("serviceVersion") final String serviceVersion, @Context final HttpServletRequest request,\r
 530             @HeaderParam(value = Constants.USER_ID_HEADER) String userId) {\r
 531 \r
 532         // get modifier id\r
 533         User modifier = new User();\r
 534         modifier.setUserId(userId);\r
 535         log.debug("modifier id is {}", userId);\r
 536 \r
 537         Response response = null;\r
 538         try {\r
 539             Either<Service, ResponseFormat> actionResponse = serviceBusinessLogic.getServiceByNameAndVersion(serviceName, serviceVersion, userId);\r
 540 \r
 541             if (actionResponse.isRight()) {\r
 542                 response = buildErrorResponse(actionResponse.right().value());\r
 543                 return response;\r
 544             }\r
 545 \r
 546             Service service = actionResponse.left().value();\r
 547             Object result = RepresentationUtils.toRepresentation(service);\r
 548 \r
 549             return buildOkResponse(getComponentsUtils().getResponseFormat(ActionStatus.OK), result);\r
 550 \r
 551         } catch (Exception e) {\r
 552             BeEcompErrorManager.getInstance().logBeRestApiGeneralError("Get Service by name and version");\r
 553             log.debug("get service failed with exception", e);\r
 554             return buildErrorResponse(getComponentsUtils().getResponseFormat(ActionStatus.GENERAL_ERROR));\r
 555 \r
 556         }\r
 557     }\r
 558 \r
 559     @POST\r
 560     @Path("/services/{serviceId}/distribution-state/{state}")\r
 561     @Consumes(MediaType.APPLICATION_JSON)\r
 562     @Produces(MediaType.APPLICATION_JSON)\r
 563     @Operation(description = "Update Service Distribution State", method = "POST",\r
 564             summary = "service with the changed distribution status")\r
 565     @ApiResponses(value = {@ApiResponse(responseCode = "200", description = "Service distribution state changed"),\r
 566             @ApiResponse(responseCode = "409", description = "Restricted operation"),\r
 567             @ApiResponse(responseCode = "403", description = "Service is not available for distribution"),\r
 568             @ApiResponse(responseCode = "400", description = "Invalid content / Missing content"),\r
 569             @ApiResponse(responseCode = "404", description = "Requested service was not found"),\r
 570             @ApiResponse(responseCode = "500", description = "Internal Server Error. Please try again later.")})\r
 571     public Response updateServiceDistributionState(\r
 572             @Parameter(description = "DistributionChangeInfo - get comment out of body",\r
 573                     required = true) LifecycleChangeInfoWithAction jsonChangeInfo,\r
 574             @PathParam("serviceId") final String serviceId,\r
 575             @Parameter(schema = @Schema(allowableValues = {"approve", "reject"}),\r
 576                     required = true) @PathParam("state") final String state,\r
 577             @Context final HttpServletRequest request, @HeaderParam(value = Constants.USER_ID_HEADER) String userId) {\r
 578 \r
 579         String url = request.getMethod() + " " + request.getRequestURI();\r
 580         log.debug("Start handle request of {}", url);\r
 581 \r
 582         User modifier = new User();\r
 583         modifier.setUserId(userId);\r
 584         log.debug("modifier id is {}", userId);\r
 585 \r
 586         Response response = null;\r
 587         try {\r
 588             Either<Service, ResponseFormat> actionResponse = serviceBusinessLogic.changeServiceDistributionState(serviceId, state, jsonChangeInfo, modifier);\r
 589 \r
 590             if (actionResponse.isRight()) {\r
 591                 log.debug("failed to Update Service Distribution State");\r
 592                 response = buildErrorResponse(actionResponse.right().value());\r
 593                 return response;\r
 594             }\r
 595             Service service = actionResponse.left().value();\r
 596             Object result = RepresentationUtils.toRepresentation(service);\r
 597 \r
 598             return buildOkResponse(getComponentsUtils().getResponseFormat(ActionStatus.OK), result);\r
 599         } catch (Exception e) {\r
 600             BeEcompErrorManager.getInstance().logBeRestApiGeneralError("Update Service Distribution State");\r
 601             log.debug("updateServiceDistributionState failed with exception", e);\r
 602             response = buildErrorResponse(getComponentsUtils().getResponseFormat(ActionStatus.GENERAL_ERROR));\r
 603             return response;\r
 604         }\r
 605     }\r
 606 \r
 607     @POST\r
 608     @Path("/services/{serviceId}/distribution/{env}/activate")\r
 609     @Consumes(MediaType.APPLICATION_JSON)\r
 610     @Produces(MediaType.APPLICATION_JSON)\r
 611     @Operation(description = "Activate distribution", method = "POST", summary = "activate distribution")\r
 612     @ApiResponses(value = {@ApiResponse(responseCode = "200", description = "OK"),\r
 613             @ApiResponse(responseCode = "409",\r
 614                     description = "Service cannot be distributed due to missing deployment artifacts"),\r
 615             @ApiResponse(responseCode = "404", description = "Requested service was not found"),\r
 616             @ApiResponse(responseCode = "500", description = "Internal Server Error. Please try again later.")})\r
 617     public Response activateDistribution(@PathParam("serviceId") final String serviceId,\r
 618             @PathParam("env") final String env, @Context final HttpServletRequest request,\r
 619             @HeaderParam(value = Constants.USER_ID_HEADER) String userId) {\r
 620 \r
 621         String url = request.getMethod() + " " + request.getRequestURI();\r
 622         log.debug("Start handle request of {}", url);\r
 623 \r
 624         User modifier = new User();\r
 625         modifier.setUserId(userId);\r
 626         log.debug("modifier id is {}", userId);\r
 627 \r
 628         Response response = null;\r
 629         try {\r
 630             Either<Service, ResponseFormat> distResponse = serviceBusinessLogic.activateDistribution(serviceId, env, modifier, request);\r
 631 \r
 632             if (distResponse.isRight()) {\r
 633                 log.debug("failed to activate service distribution");\r
 634                 response = buildErrorResponse(distResponse.right().value());\r
 635                 return response;\r
 636             }\r
 637             Service service = distResponse.left().value();\r
 638             Object result = RepresentationUtils.toRepresentation(service);\r
 639             return buildOkResponse(getComponentsUtils().getResponseFormat(ActionStatus.OK), result);\r
 640         } catch (Exception e) {\r
 641             BeEcompErrorManager.getInstance().logBeRestApiGeneralError("Activate Distribution");\r
 642             log.debug("activate distribution failed with exception", e);\r
 643             response = buildErrorResponse(getComponentsUtils().getResponseFormat(ActionStatus.GENERAL_ERROR));\r
 644             return response;\r
 645         }\r
 646     }\r
 647 \r
 648     @POST\r
 649     @Path("/services/{serviceId}/distribution/{did}/markDeployed")\r
 650     @Consumes(MediaType.APPLICATION_JSON)\r
 651     @Produces(MediaType.APPLICATION_JSON)\r
 652     @Operation(description = "Mark distribution as deployed", method = "POST",\r
 653             summary = "relevant audit record will be created")\r
 654     @ApiResponses(value = {@ApiResponse(responseCode = "200", description = "Service was marked as deployed"),\r
 655             @ApiResponse(responseCode = "409", description = "Restricted operation"),\r
 656             @ApiResponse(responseCode = "403", description = "Service is not available"),\r
 657             @ApiResponse(responseCode = "400", description = "Invalid content / Missing content"),\r
 658             @ApiResponse(responseCode = "404", description = "Requested service was not found"),\r
 659             @ApiResponse(responseCode = "500", description = "Internal Server Error. Please try again later.")})\r
 660     public Response markDistributionAsDeployed(@PathParam("serviceId") final String serviceId,\r
 661             @PathParam("did") final String did, @Context final HttpServletRequest request,\r
 662             @HeaderParam(value = Constants.USER_ID_HEADER) String userId) {\r
 663 \r
 664         String url = request.getMethod() + " " + request.getRequestURI();\r
 665         log.debug("Start handle request of {}", url);\r
 666 \r
 667         User modifier = new User();\r
 668         modifier.setUserId(userId);\r
 669         log.debug("modifier id is {}", userId);\r
 670 \r
 671         Response response = null;\r
 672         try {\r
 673             Either<Service, ResponseFormat> distResponse = serviceBusinessLogic.markDistributionAsDeployed(serviceId, did, modifier);\r
 674 \r
 675             if (distResponse.isRight()) {\r
 676                 log.debug("failed to mark distribution as deployed");\r
 677                 response = buildErrorResponse(distResponse.right().value());\r
 678                 return response;\r
 679             }\r
 680             Service service = distResponse.left().value();\r
 681             Object result = RepresentationUtils.toRepresentation(service);\r
 682             return buildOkResponse(getComponentsUtils().getResponseFormat(ActionStatus.OK), result);\r
 683         } catch (Exception e) {\r
 684             BeEcompErrorManager.getInstance().logBeRestApiGeneralError("Mark Distribution As Deployed");\r
 685             log.debug("mark distribution as deployed failed with exception", e);\r
 686             response = buildErrorResponse(getComponentsUtils().getResponseFormat(ActionStatus.GENERAL_ERROR));\r
 687             return response;\r
 688         }\r
 689     }\r
 690 \r
 691     @POST\r
 692     @Path("/services/{serviceId}/tempUrlToBeDeleted")\r
 693     @Consumes(MediaType.APPLICATION_JSON)\r
 694     @Produces(MediaType.APPLICATION_JSON)\r
 695     @ApiResponses(value = { @ApiResponse(responseCode = "200", description = "OK"), @ApiResponse(responseCode = "500", description = "Internal Server Error. Please try again later.") })\r
 696     public Response tempUrlToBeDeleted(@PathParam("serviceId") final String serviceId, @Context final HttpServletRequest request, @HeaderParam(value = Constants.USER_ID_HEADER) String userId) {\r
 697 \r
 698         ServletContext context = request.getSession().getServletContext();\r
 699         String url = request.getMethod() + " " + request.getRequestURI();\r
 700         log.debug("Start handle request of {}", url);\r
 701 \r
 702         User modifier = new User();\r
 703         modifier.setUserId(userId);\r
 704         log.debug("modifier id is {}", userId);\r
 705 \r
 706         Response response;\r
 707         try {\r
 708             Service service = (serviceBusinessLogic.getService(serviceId, modifier)).left().value();\r
 709             Either<Service, ResponseFormat> res = serviceBusinessLogic.updateDistributionStatusForActivation(service, modifier, DistributionStatusEnum.DISTRIBUTED);\r
 710 \r
 711             if (res.isRight()) {\r
 712                 response = buildErrorResponse(getComponentsUtils().getResponseFormat(ActionStatus.GENERAL_ERROR));\r
 713             }\r
 714             return buildOkResponse(getComponentsUtils().getResponseFormat(ActionStatus.OK), null);\r
 715         } catch (Exception e) {\r
 716             BeEcompErrorManager.getInstance().logBeRestApiGeneralError("tempUrlToBeDeleted");\r
 717             log.debug("failed with exception", e);\r
 718             response = buildErrorResponse(getComponentsUtils().getResponseFormat(ActionStatus.GENERAL_ERROR));\r
 719             return response;\r
 720         }\r
 721     }\r
 722 \r
 723 \r
 724     @GET\r
 725     @Path("/services/{serviceId}/linksMap")\r
 726     @Consumes(MediaType.APPLICATION_JSON)\r
 727     @Produces(MediaType.APPLICATION_JSON)\r
 728     @Operation(description = "Retrieve Service component relations map", method = "GET",\r
 729             summary = "Returns service components relations",responses = @ApiResponse(\r
 730                     content = @Content(array = @ArraySchema(schema = @Schema(implementation = ServiceRelations.class)))))\r
 731     @ApiResponses(value = {@ApiResponse(responseCode = "200", description = "Service found"),\r
 732             @ApiResponse(responseCode = "403", description = "Restricted operation"),\r
 733             @ApiResponse(responseCode = "404", description = "Service not found")})\r
 734     public Response getServiceComponentRelationMap(@PathParam("serviceId") final String serviceId,\r
 735             @Context final HttpServletRequest request, @HeaderParam(value = Constants.USER_ID_HEADER) String userId) {\r
 736 \r
 737         String url = request.getMethod() + " " + request.getRequestURI();\r
 738         log.debug("Start handle request of {}", url);\r
 739 \r
 740         // get modifier id\r
 741         User modifier = new User();\r
 742         modifier.setUserId(userId);\r
 743         log.debug("modifier id is {}", userId);\r
 744 \r
 745         Response response = null;\r
 746         try {\r
 747             String serviceIdLower = serviceId.toLowerCase();\r
 748             log.debug("get service components relations with id {}", serviceId);\r
 749             Either<ServiceRelations, ResponseFormat> actionResponse = serviceBusinessLogic.getServiceComponentsRelations(serviceIdLower, modifier);\r
 750 \r
 751             if (actionResponse.isRight()) {\r
 752                 log.debug("failed to get service relations data");\r
 753                 response = buildErrorResponse(actionResponse.right().value());\r
 754                 return response;\r
 755             }\r
 756 \r
 757             ServiceRelations serviceRelations = actionResponse.left().value();\r
 758             Object result = RepresentationUtils.toRepresentation(serviceRelations);\r
 759 \r
 760             return buildOkResponse(getComponentsUtils().getResponseFormat(ActionStatus.OK), result);\r
 761 \r
 762         } catch (Exception e) {\r
 763             BeEcompErrorManager.getInstance().logBeRestApiGeneralError("Get Service");\r
 764             log.debug("get service relations data failed with exception", e);\r
 765             return buildErrorResponse(getComponentsUtils().getResponseFormat(ActionStatus.GENERAL_ERROR));\r
 766 \r
 767         }\r
 768     }\r
 769 \r
 770 }\r