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

   1 /*
   2  * Copyright © 2016-2018 European Support Limited
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 package org.openecomp.sdc.be.servlets;
  18
  19 import com.jcabi.aspects.Loggable;
  20 import fj.data.Either;
  21 import io.swagger.annotations.Api;
  22 import io.swagger.annotations.ApiOperation;
  23 import io.swagger.annotations.ApiParam;
  24 import io.swagger.annotations.ApiResponse;
  25 import io.swagger.annotations.ApiResponses;
  26 import org.openecomp.sdc.be.components.impl.CapabilitiesBusinessLogic;
  27 import org.openecomp.sdc.be.config.BeEcompErrorManager;
  28 import org.openecomp.sdc.be.dao.api.ActionStatus;
  29 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
  30 import org.openecomp.sdc.be.model.CapabilityDefinition;
  31 import org.openecomp.sdc.be.model.User;
  32 import org.openecomp.sdc.be.resources.data.auditing.AuditingActionEnum;
  33 import org.openecomp.sdc.be.ui.model.UiComponentDataTransfer;
  34 import org.openecomp.sdc.common.api.Constants;
  35 import org.openecomp.sdc.common.log.wrappers.Logger;
  36 import org.openecomp.sdc.exception.ResponseFormat;
  37
  38 import javax.inject.Singleton;
  39 import javax.servlet.ServletContext;
  40 import javax.servlet.http.HttpServletRequest;
  41 import javax.ws.rs.Consumes;
  42 import javax.ws.rs.DELETE;
  43 import javax.ws.rs.GET;
  44 import javax.ws.rs.HeaderParam;
  45 import javax.ws.rs.POST;
  46 import javax.ws.rs.PUT;
  47 import javax.ws.rs.Path;
  48 import javax.ws.rs.PathParam;
  49 import javax.ws.rs.Produces;
  50 import javax.ws.rs.core.Context;
  51 import javax.ws.rs.core.MediaType;
  52 import javax.ws.rs.core.Response;
  53 import java.util.List;
  54 import java.util.Optional;
  55
  56 @Loggable(prepend = true, value = Loggable.DEBUG, trim = false)
  57 @Path("/v1/catalog")
  58 @Consumes(MediaType.APPLICATION_JSON)
  59 @Produces(MediaType.APPLICATION_JSON)
  60 @Api(value = "Capability Servlet", description = "Capability Servlet")
  61 @Singleton
  62 public class CapabilityServlet extends AbstractValidationsServlet {
  63     private static final Logger LOGGER = Logger.getLogger(CapabilityServlet.class);
  64
  65     @POST
  66     @Consumes(MediaType.APPLICATION_JSON)
  67     @Produces(MediaType.APPLICATION_JSON)
  68     @Path("/resources/{resourceId}/capabilities")
  69     @ApiOperation(value = "Create Capabilities on resource", httpMethod = "POST",
  70             notes = "Create Capabilities on resource", response = Response.class)
  71     @ApiResponses(value = {@ApiResponse(code = 201, message = "Create Capabilities"),
  72             @ApiResponse(code = 403, message = "Restricted operation"),
  73             @ApiResponse(code = 400, message = "Invalid content / Missing content"),
  74             @ApiResponse(code = 409, message = "Capability already exist")})
  75     public Response createCapabilitiesOnResource(
  76             @ApiParam(value = "Capability to create", required = true) String data,
  77             @ApiParam(value = "Resource Id") @PathParam("resourceId") String resourceId,
  78             @Context final HttpServletRequest request,
  79             @HeaderParam(value = Constants.USER_ID_HEADER) String userId) {
  80         return createOrUpdate(data, "resources" , resourceId,
  81                 request, userId, false, "createCapabilities");
  82     }
  83
  84     @PUT
  85     @Consumes(MediaType.APPLICATION_JSON)
  86     @Produces(MediaType.APPLICATION_JSON)
  87     @Path("/resources/{resourceId}/capabilities")
  88     @ApiOperation(value = "Update Capabilities on resource", httpMethod = "PUT",
  89             notes = "Update Capabilities on resource", response = CapabilityDefinition.class)
  90     @ApiResponses(value = {@ApiResponse(code = 201, message = "Update Capabilities"),
  91             @ApiResponse(code = 403, message = "Restricted operation"),
  92             @ApiResponse(code = 400, message = "Invalid content / Missing content")})
  93     public Response updateCapabilitiesOnResource(
  94             @ApiParam(value = "Capabilities to update", required = true) String data,
  95             @ApiParam(value = "Component Id") @PathParam("resourceId") String resourceId,
  96             @Context final HttpServletRequest request,
  97             @HeaderParam(value = Constants.USER_ID_HEADER) String userId) {
  98         return createOrUpdate(data, "resources", resourceId,
  99                 request, userId, true, "updateCapabilities");
 100     }
 101
 102     @GET
 103     @Consumes(MediaType.APPLICATION_JSON)
 104     @Produces(MediaType.APPLICATION_JSON)
 105     @Path("/resources/{resourceId}/capabilities/{capabilityId}")
 106     @ApiOperation(value = "Get Capability from resource", httpMethod = "GET",
 107             notes = "GET Capability from resource", response = CapabilityDefinition.class)
 108     @ApiResponses(value = {@ApiResponse(code = 201, message = "GET Capability"),
 109             @ApiResponse(code = 403, message = "Restricted operation"),
 110             @ApiResponse(code = 400, message = "Invalid content / Missing content")})
 111     public Response getCapabilityOnResource(
 112             @ApiParam(value = "Resource Id") @PathParam("resourceId") String resourceId,
 113             @ApiParam(value = "Capability Id") @PathParam("capabilityId") String capabilityId,
 114             @Context final HttpServletRequest request,
 115             @HeaderParam(value = Constants.USER_ID_HEADER) String userId) {
 116
 117         return get(capabilityId, resourceId, request, userId);
 118     }
 119
 120     @DELETE
 121     @Consumes(MediaType.APPLICATION_JSON)
 122     @Produces(MediaType.APPLICATION_JSON)
 123     @Path("/resources/{resourceId}/capabilities/{capabilityId}")
 124     @ApiOperation(value = "Delete capability from resource", httpMethod = "DELETE",
 125             notes = "Delete capability from resource", response = CapabilityDefinition.class)
 126     @ApiResponses(value = {@ApiResponse(code = 201, message = "Delete capability"),
 127             @ApiResponse(code = 403, message = "Restricted operation"),
 128             @ApiResponse(code = 400, message = "Invalid content / Missing content")})
 129     public Response deleteCapabilityOnResource(
 130             @ApiParam(value = "capability Id") @PathParam("capabilityId") String capabilityId,
 131             @ApiParam(value = "Resource Id") @PathParam("resourceId") String resourceId,
 132             @Context final HttpServletRequest request,
 133             @HeaderParam(value = Constants.USER_ID_HEADER) String userId) {
 134         return delete(capabilityId, resourceId, request, userId);
 135     }
 136
 137     @POST
 138     @Consumes(MediaType.APPLICATION_JSON)
 139     @Produces(MediaType.APPLICATION_JSON)
 140     @Path("/services/{serviceId}/capabilities")
 141     @ApiOperation(value = "Create Capabilities on service", httpMethod = "POST",
 142             notes = "Create Capabilities on service", response = Response.class)
 143     @ApiResponses(value = {@ApiResponse(code = 201, message = "Create Capabilities"),
 144             @ApiResponse(code = 403, message = "Restricted operation"),
 145             @ApiResponse(code = 400, message = "Invalid content / Missing content"),
 146             @ApiResponse(code = 409, message = "Capability already exist")})
 147     public Response createCapabilitiesOnService(
 148             @ApiParam(value = "Capability to create", required = true) String data,
 149             @ApiParam(value = "Service Id") @PathParam("serviceId") String serviceId,
 150             @Context final HttpServletRequest request,
 151             @HeaderParam(value = Constants.USER_ID_HEADER) String userId) {
 152         return createOrUpdate(data, "services" , serviceId,
 153                 request, userId, false, "createCapabilities");
 154     }
 155
 156     @PUT
 157     @Consumes(MediaType.APPLICATION_JSON)
 158     @Produces(MediaType.APPLICATION_JSON)
 159     @Path("/services/{serviceId}/capabilities")
 160     @ApiOperation(value = "Update Capabilities on service", httpMethod = "PUT",
 161             notes = "Update Capabilities on service", response = CapabilityDefinition.class)
 162     @ApiResponses(value = {@ApiResponse(code = 201, message = "Update Capabilities"),
 163             @ApiResponse(code = 403, message = "Restricted operation"),
 164             @ApiResponse(code = 400, message = "Invalid content / Missing content")})
 165     public Response updateCapabilitiesOnService(
 166             @ApiParam(value = "Capabilities to update", required = true) String data,
 167             @ApiParam(value = "Component Id") @PathParam("serviceId") String serviceId,
 168             @Context final HttpServletRequest request,
 169             @HeaderParam(value = Constants.USER_ID_HEADER) String userId) {
 170         return createOrUpdate(data, "services", serviceId,
 171                 request, userId, true, "updateCapabilities");
 172     }
 173
 174     @GET
 175     @Consumes(MediaType.APPLICATION_JSON)
 176     @Produces(MediaType.APPLICATION_JSON)
 177     @Path("/services/{serviceId}/capabilities/{capabilityId}")
 178     @ApiOperation(value = "Get Capability from service", httpMethod = "GET",
 179             notes = "GET Capability from service", response = CapabilityDefinition.class)
 180     @ApiResponses(value = {@ApiResponse(code = 201, message = "GET Capability"),
 181             @ApiResponse(code = 403, message = "Restricted operation"),
 182             @ApiResponse(code = 400, message = "Invalid content / Missing content")})
 183     public Response getCapabilityOnService(
 184             @ApiParam(value = "Service Id") @PathParam("serviceId") String serviceId,
 185             @ApiParam(value = "Capability Id") @PathParam("capabilityId") String capabilityId,
 186             @Context final HttpServletRequest request,
 187             @HeaderParam(value = Constants.USER_ID_HEADER) String userId) {
 188
 189         return get(capabilityId, serviceId, request, userId);
 190     }
 191
 192     @DELETE
 193     @Consumes(MediaType.APPLICATION_JSON)
 194     @Produces(MediaType.APPLICATION_JSON)
 195     @Path("/services/{serviceId}/capabilities/{capabilityId}")
 196     @ApiOperation(value = "Delete capability from service", httpMethod = "DELETE",
 197             notes = "Delete capability from service", response = CapabilityDefinition.class)
 198     @ApiResponses(value = {@ApiResponse(code = 201, message = "Delete capability"),
 199             @ApiResponse(code = 403, message = "Restricted operation"),
 200             @ApiResponse(code = 400, message = "Invalid content / Missing content")})
 201     public Response deleteCapabilityOnService(
 202             @ApiParam(value = "capability Id") @PathParam("capabilityId") String capabilityId,
 203             @ApiParam(value = "Service Id") @PathParam("serviceId") String serviceId,
 204             @Context final HttpServletRequest request,
 205             @HeaderParam(value = Constants.USER_ID_HEADER) String userId) {
 206         return delete(capabilityId, serviceId, request, userId);
 207     }
 208
 209     private Response createOrUpdate (String data, String componentType, String componentId,
 210                                      HttpServletRequest request,
 211                                      String userId,
 212                                      boolean isUpdate,
 213                                      String errorContext) {
 214         ServletContext context = request.getSession().getServletContext();
 215         String url = request.getMethod() + " " + request.getRequestURI();
 216
 217         User modifier = new User();
 218         modifier.setUserId(userId);
 219         LOGGER.debug("Start create or update request of {} with modifier id {}", url, userId);
 220         try {
 221             String componentIdLower = componentId.toLowerCase();
 222             CapabilitiesBusinessLogic businessLogic = getCapabilitiesBL(context);
 223
 224             Either<List<CapabilityDefinition>, ResponseFormat> mappedCapabilitiesDataEither
 225                     = getMappedCapabilitiesData(data, modifier, ComponentTypeEnum.findByParamName(componentType));
 226             if(mappedCapabilitiesDataEither.isRight()) {
 227                 LOGGER.error("Failed to create or update capabilities");
 228                 buildErrorResponse(mappedCapabilitiesDataEither.right().value());
 229             }
 230             List<CapabilityDefinition> mappedCapabilitiesData = mappedCapabilitiesDataEither.left().value();
 231             Either<List<CapabilityDefinition>, ResponseFormat> actionResponse;
 232             if(isUpdate) {
 233                 actionResponse = businessLogic.updateCapabilities(componentIdLower,
 234                         mappedCapabilitiesData, modifier, errorContext, true);
 235             } else {
 236                 actionResponse = businessLogic.createCapabilities(componentIdLower,
 237                         mappedCapabilitiesData, modifier, errorContext, true);
 238             }
 239             if (actionResponse.isRight()) {
 240                 LOGGER.error("Failed to create or update capabilities");
 241                 return buildErrorResponse(actionResponse.right().value());
 242             }
 243             return buildOkResponse(getComponentsUtils().getResponseFormat(ActionStatus.OK),
 244                     actionResponse.left().value());
 245         } catch (Exception e) {
 246             BeEcompErrorManager.getInstance().logBeRestApiGeneralError("Capabilities create or update");
 247             LOGGER.error("Failed to create or update capabilities with an error", e);
 248             return buildErrorResponse(getComponentsUtils().getResponseFormat(ActionStatus.GENERAL_ERROR));
 249         }
 250     }
 251
 252     private Response get (String capabilityIdToGet,  String componentId,
 253                           HttpServletRequest request, String userId){
 254         ServletContext context = request.getSession().getServletContext();
 255         String url = request.getMethod() + " " + request.getRequestURI();
 256
 257         User modifier = new User();
 258         modifier.setUserId(userId);
 259         LOGGER.debug("Start get request of {} with modifier id {}", url, userId);
 260
 261         try {
 262             String componentIdLower = componentId.toLowerCase();
 263             CapabilitiesBusinessLogic businessLogic = getCapabilitiesBL(context);
 264
 265             Either<CapabilityDefinition, ResponseFormat> actionResponse = businessLogic
 266                     .getCapability(componentIdLower, capabilityIdToGet, modifier, true);
 267             if (actionResponse.isRight()) {
 268                 LOGGER.error("failed to get capability");
 269                 return buildErrorResponse(actionResponse.right().value());
 270             }
 271             Object result = RepresentationUtils.toFilteredRepresentation(actionResponse.left().value());
 272             return buildOkResponse(getComponentsUtils().getResponseFormat(ActionStatus.OK), result);
 273         } catch (Exception e) {
 274             BeEcompErrorManager.getInstance().logBeRestApiGeneralError("Get capability");
 275             LOGGER.error("get capabilities failed with exception", e);
 276             return buildErrorResponse(getComponentsUtils().getResponseFormat(ActionStatus.GENERAL_ERROR));
 277         }
 278     }
 279
 280     private Response delete (String capabilityId, String componentId, HttpServletRequest
 281             request, String userId){
 282
 283         ServletContext context = request.getSession().getServletContext();
 284         String url = request.getMethod() + " " + request.getRequestURI();
 285
 286         User modifier = new User();
 287         modifier.setUserId(userId);
 288         LOGGER.debug("Start delete request of {} with modifier id {}", url, userId);
 289
 290         try {
 291             String componentIdLower = componentId.toLowerCase();
 292             CapabilitiesBusinessLogic businessLogic = getCapabilitiesBL(context);
 293
 294             Either<CapabilityDefinition, ResponseFormat> actionResponse = businessLogic
 295                     .deleteCapability(componentIdLower, capabilityId, modifier, true);
 296             if (actionResponse.isRight()) {
 297                 LOGGER.error("failed to delete capability");
 298                 return buildErrorResponse(actionResponse.right().value());
 299             }
 300             Object result = RepresentationUtils.toRepresentation(actionResponse.left().value());
 301             return buildOkResponse(getComponentsUtils().getResponseFormat(ActionStatus.OK), result);
 302         } catch (Exception e) {
 303             BeEcompErrorManager.getInstance().logBeRestApiGeneralError("Delete capability");
 304             LOGGER.error("Delete capability failed with an error", e);
 305             return buildErrorResponse(getComponentsUtils().getResponseFormat(ActionStatus.GENERAL_ERROR));
 306         }
 307     }
 308
 309     private Either<List<CapabilityDefinition>, ResponseFormat> getMappedCapabilitiesData(String inputJson, User user,
 310                                                                  ComponentTypeEnum componentTypeEnum){
 311         Either<UiComponentDataTransfer, ResponseFormat> mappedData = getComponentsUtils()
 312                 .convertJsonToObjectUsingObjectMapper(inputJson, user, UiComponentDataTransfer.class,
 313                         AuditingActionEnum.CREATE_RESOURCE, componentTypeEnum);
 314         Optional<List<CapabilityDefinition>> capabilityDefinitionList =
 315                 mappedData.left().value().getCapabilities().values().stream().findFirst();
 316         return capabilityDefinitionList.<Either<List<CapabilityDefinition>, ResponseFormat>>
 317                 map(Either::left).orElseGet(() -> Either.right(getComponentsUtils()
 318                 .getResponseFormat(ActionStatus.GENERAL_ERROR)));
 319     }
 320 }