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