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