catalog-be/src/main/java/org/openecomp/sdc/be/servlets/InterfaceOperationServlet.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.google.common.collect.ImmutableMap;
  20 import com.jcabi.aspects.Loggable;
  21 import fj.data.Either;
  22 import io.swagger.annotations.Api;
  23 import io.swagger.annotations.ApiOperation;
  24 import io.swagger.annotations.ApiParam;
  25 import io.swagger.annotations.ApiResponse;
  26 import io.swagger.annotations.ApiResponses;
  27 import java.io.IOException;
  28 import java.util.ArrayList;
  29 import java.util.Collections;
  30 import java.util.List;
  31 import java.util.Map;
  32 import javax.inject.Singleton;
  33 import javax.servlet.ServletContext;
  34 import javax.servlet.http.HttpServletRequest;
  35 import javax.ws.rs.Consumes;
  36 import javax.ws.rs.DELETE;
  37 import javax.ws.rs.GET;
  38 import javax.ws.rs.HeaderParam;
  39 import javax.ws.rs.POST;
  40 import javax.ws.rs.PUT;
  41 import javax.ws.rs.Path;
  42 import javax.ws.rs.PathParam;
  43 import javax.ws.rs.Produces;
  44 import javax.ws.rs.core.Context;
  45 import javax.ws.rs.core.MediaType;
  46 import javax.ws.rs.core.Response;
  47 import org.openecomp.sdc.be.components.impl.InterfaceOperationBusinessLogic;
  48 import org.openecomp.sdc.be.config.BeEcompErrorManager;
  49 import org.openecomp.sdc.be.dao.api.ActionStatus;
  50 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
  51 import org.openecomp.sdc.be.datatypes.enums.JsonPresentationFields;
  52 import org.openecomp.sdc.be.model.InterfaceDefinition;
  53 import org.openecomp.sdc.be.model.User;
  54 import org.openecomp.sdc.be.resources.data.auditing.AuditingActionEnum;
  55 import org.openecomp.sdc.be.ui.model.UiComponentDataTransfer;
  56 import org.openecomp.sdc.common.api.Constants;
  57 import org.openecomp.sdc.exception.ResponseFormat;
  58 import org.slf4j.Logger;
  59 import org.slf4j.LoggerFactory;
  60
  61 @Loggable(prepend = true, value = Loggable.DEBUG, trim = false)
  62 @Path("/v1/catalog")
  63 @Consumes(MediaType.APPLICATION_JSON)
  64 @Produces(MediaType.APPLICATION_JSON)
  65 @Api(value = "Interface Operation Servlet", description = "Interface Operation Servlet")
  66 @Singleton
  67 public class InterfaceOperationServlet extends AbstractValidationsServlet {
  68
  69     private static final Logger log = LoggerFactory.getLogger(InterfaceOperationServlet.class);
  70
  71     @POST
  72     @Consumes(MediaType.APPLICATION_JSON)
  73     @Produces(MediaType.APPLICATION_JSON)
  74     @Path("/resources/{resourceId}/interfaceOperations")
  75     @ApiOperation(value = "Create Interface Operations on Resource", httpMethod = "POST",
  76             notes = "Create Interface Operations on Resource", response = InterfaceDefinition.class, responseContainer = "List")
  77     @ApiResponses(value = {@ApiResponse(code = 201, message = "Create Interface Operations on Resource"),
  78             @ApiResponse(code = 400, message = "Invalid content / Missing content"),
  79             @ApiResponse(code = 403, message = "Restricted operation"),
  80             @ApiResponse(code = 404, message = "Resource not found"),
  81             @ApiResponse(code = 409, message = "Interface Operation already exist")})
  82     public Response createInterfaceOperationsOnResource(
  83             @ApiParam(value = "Interface Operations to create", required = true) String data,
  84             @ApiParam(value = "Resource Id") @PathParam("resourceId") String resourceId,
  85             @HeaderParam(value = Constants.USER_ID_HEADER) String userId, @Context final HttpServletRequest request) {
  86         return createOrUpdate(data, ComponentTypeEnum.RESOURCE, resourceId, request, userId, false);
  87     }
  88
  89     private Response createOrUpdate(String data, ComponentTypeEnum componentType, String componentId,
  90             HttpServletRequest request, String userId, boolean isUpdate) {
  91         ServletContext context = request.getSession().getServletContext();
  92         String url = request.getMethod() + " " + request.getRequestURI();
  93
  94         User modifier = new User();
  95         modifier.setUserId(userId);
  96         log.debug("Start create or update request of {} with modifier id {}", url, userId);
  97
  98         try {
  99             String componentIdLower = componentId.toLowerCase();
 100             InterfaceOperationBusinessLogic businessLogic = getInterfaceOperationBL(context);
 101
 102             List<InterfaceDefinition> mappedInterfaceData = getMappedInterfaceData(data, modifier, componentType);
 103             Either<List<InterfaceDefinition>, ResponseFormat> actionResponse;
 104             if (isUpdate) {
 105                 actionResponse =
 106                         businessLogic.updateInterfaceOperation(componentIdLower, mappedInterfaceData, modifier, true);
 107             } else {
 108                 actionResponse =
 109                         businessLogic.createInterfaceOperation(componentIdLower, mappedInterfaceData, modifier, true);
 110             }
 111
 112             if (actionResponse.isRight()) {
 113                 log.error("failed to create or update interface operation");
 114                 return buildErrorResponse(actionResponse.right().value());
 115             }
 116
 117             return buildOkResponse(getComponentsUtils().getResponseFormat(ActionStatus.OK),
 118                     getFormattedResponse(actionResponse.left().value()));
 119         } catch (Exception e) {
 120             BeEcompErrorManager.getInstance().logBeRestApiGeneralError("Interface Operation Creation or update");
 121             log.error("create or update interface Operation with an error", e);
 122             return buildErrorResponse(getComponentsUtils().getResponseFormat(ActionStatus.GENERAL_ERROR));
 123         }
 124     }
 125
 126     private List<InterfaceDefinition> getMappedInterfaceData(String inputJson, User user,
 127             ComponentTypeEnum componentTypeEnum) {
 128         Either<UiComponentDataTransfer, ResponseFormat> uiComponentEither =
 129                 getComponentsUtils().convertJsonToObjectUsingObjectMapper(inputJson, user,
 130                         UiComponentDataTransfer.class, AuditingActionEnum.CREATE_RESOURCE, componentTypeEnum);
 131         return new ArrayList<>(uiComponentEither.left().value().getInterfaces().values());
 132     }
 133
 134     private Object getFormattedResponse(List<InterfaceDefinition> interfaceDefinitions) throws IOException {
 135         Map<String, List<InterfaceDefinition>> allInterfaces =
 136                 ImmutableMap.of(JsonPresentationFields.INTERFACES.getPresentation(), interfaceDefinitions);
 137         return RepresentationUtils.toFilteredRepresentation(allInterfaces);
 138     }
 139
 140     @PUT
 141     @Consumes(MediaType.APPLICATION_JSON)
 142     @Produces(MediaType.APPLICATION_JSON)
 143     @Path("/resources/{resourceId}/interfaceOperations")
 144     @ApiOperation(value = "Update Interface Operations on Resource", httpMethod = "PUT",
 145             notes = "Update Interface Operations on Resource", response = InterfaceDefinition.class, responseContainer = "List")
 146     @ApiResponses(value = {@ApiResponse(code = 201, message = "Update Interface Operations on Resource"),
 147             @ApiResponse(code = 400, message = "Invalid content / Missing content"),
 148             @ApiResponse(code = 403, message = "Restricted operation"),
 149             @ApiResponse(code = 404, message = "Resource not found")})
 150     public Response updateInterfaceOperationsOnResource(
 151             @ApiParam(value = "Interface Operations to update", required = true) String data,
 152             @ApiParam(value = "Resource Id") @PathParam("resourceId") String resourceId,
 153             @HeaderParam(value = Constants.USER_ID_HEADER) String userId, @Context final HttpServletRequest request) {
 154         return createOrUpdate(data, ComponentTypeEnum.RESOURCE, resourceId, request, userId, true);
 155     }
 156
 157     @DELETE
 158     @Consumes(MediaType.APPLICATION_JSON)
 159     @Produces(MediaType.APPLICATION_JSON)
 160     @Path("/resources/{resourceId}/interfaces/{interfaceId}/operations/{operationId}")
 161     @ApiOperation(value = "Delete Interface Operation from Resource", httpMethod = "DELETE",
 162             notes = "Delete Interface Operation from Resource", response = InterfaceDefinition.class, responseContainer = "List")
 163     @ApiResponses(value = {@ApiResponse(code = 201, message = "Delete Interface Operation from Resource"),
 164             @ApiResponse(code = 400, message = "Invalid content / Missing content"),
 165             @ApiResponse(code = 403, message = "Restricted operation"),
 166             @ApiResponse(code = 404, message = "Resource not found")})
 167     public Response deleteInterfaceOperationsFromResource(
 168             @ApiParam(value = "Resource Id") @PathParam("resourceId") String resourceId,
 169             @ApiParam(value = "Interface Id") @PathParam("interfaceId") String interfaceId,
 170             @ApiParam(value = "Operation Id") @PathParam("operationId") String operationId,
 171             @HeaderParam(value = Constants.USER_ID_HEADER) String userId, @Context final HttpServletRequest request) {
 172         return delete(interfaceId, operationId, resourceId, request, userId);
 173     }
 174
 175     private Response delete(String interfaceId, String operationId, String componentId, HttpServletRequest request,
 176             String userId) {
 177
 178         ServletContext context = request.getSession().getServletContext();
 179         String url = request.getMethod() + " " + request.getRequestURI();
 180
 181         User modifier = new User();
 182         modifier.setUserId(userId);
 183         log.debug("Start delete request of {} with modifier id {}", url, userId);
 184
 185         try {
 186             String componentIdLower = componentId.toLowerCase();
 187             InterfaceOperationBusinessLogic businessLogic = getInterfaceOperationBL(context);
 188             Either<List<InterfaceDefinition>, ResponseFormat> actionResponse = businessLogic.deleteInterfaceOperation(
 189                     componentIdLower, interfaceId, Collections.singletonList(operationId), modifier, true);
 190             if (actionResponse.isRight()) {
 191                 log.error("failed to delete interface operation");
 192                 return buildErrorResponse(actionResponse.right().value());
 193             }
 194
 195             return buildOkResponse(getComponentsUtils().getResponseFormat(ActionStatus.OK),
 196                     getFormattedResponse(actionResponse.left().value()));
 197         } catch (Exception e) {
 198             BeEcompErrorManager.getInstance().logBeRestApiGeneralError("Delete Interface Operation");
 199             log.error("Delete interface operation with an error", e);
 200             return buildErrorResponse(getComponentsUtils().getResponseFormat(ActionStatus.GENERAL_ERROR));
 201         }
 202     }
 203
 204     @GET
 205     @Consumes(MediaType.APPLICATION_JSON)
 206     @Produces(MediaType.APPLICATION_JSON)
 207     @Path("/resources/{resourceId}/interfaces/{interfaceId}/operations/{operationId}")
 208     @ApiOperation(value = "Get Interface Operation from Resource", httpMethod = "GET",
 209             notes = "GET Interface Operation from Resource", response = InterfaceDefinition.class, responseContainer = "List")
 210     @ApiResponses(value = {@ApiResponse(code = 201, message = "Delete Interface Operation from Resource"),
 211             @ApiResponse(code = 400, message = "Invalid content / Missing content"),
 212             @ApiResponse(code = 403, message = "Restricted operation"),
 213             @ApiResponse(code = 404, message = "Resource not found")})
 214     public Response getInterfaceOperationsFromResource(
 215             @ApiParam(value = "Resource Id") @PathParam("resourceId") String resourceId,
 216             @ApiParam(value = "Interface Id") @PathParam("interfaceId") String interfaceId,
 217             @ApiParam(value = "Operation Id") @PathParam("operationId") String operationId,
 218             @HeaderParam(value = Constants.USER_ID_HEADER) String userId, @Context final HttpServletRequest request) {
 219         return get(interfaceId, operationId, resourceId, request, userId);
 220     }
 221
 222     private Response get(String interfaceId, String operationId, String componentId, HttpServletRequest request,
 223             String userId) {
 224         ServletContext context = request.getSession().getServletContext();
 225         String url = request.getMethod() + " " + request.getRequestURI();
 226
 227         User modifier = new User();
 228         modifier.setUserId(userId);
 229         log.debug("Start get request of {} with modifier id {}", url, userId);
 230
 231         try {
 232             String componentIdLower = componentId.toLowerCase();
 233             InterfaceOperationBusinessLogic businessLogic = getInterfaceOperationBL(context);
 234             Either<List<InterfaceDefinition>, ResponseFormat> actionResponse = businessLogic.getInterfaceOperation(
 235                     componentIdLower, interfaceId, Collections.singletonList(operationId), modifier, true);
 236             if (actionResponse.isRight()) {
 237                 log.error("failed to get interface operation");
 238                 return buildErrorResponse(actionResponse.right().value());
 239             }
 240
 241             return buildOkResponse(getComponentsUtils().getResponseFormat(ActionStatus.OK),
 242                     getFormattedResponse(actionResponse.left().value()));
 243         } catch (Exception e) {
 244             BeEcompErrorManager.getInstance().logBeRestApiGeneralError("Get Component interface operations");
 245             log.error("get component interface operations failed with exception", e);
 246             return buildErrorResponse(getComponentsUtils().getResponseFormat(ActionStatus.GENERAL_ERROR));
 247         }
 248     }
 249
 250     @POST
 251     @Consumes(MediaType.APPLICATION_JSON)
 252     @Produces(MediaType.APPLICATION_JSON)
 253     @Path("/services/{serviceId}/interfaceOperations")
 254     @ApiOperation(value = "Create Interface Operations on Service", httpMethod = "POST",
 255             notes = "Create Interface Operations on Service", response = InterfaceDefinition.class, responseContainer = "List")
 256     @ApiResponses(value = {@ApiResponse(code = 201, message = "Create Interface Operations on Service"),
 257             @ApiResponse(code = 400, message = "Invalid content / Missing content"),
 258             @ApiResponse(code = 403, message = "Restricted operation"),
 259             @ApiResponse(code = 404, message = "Service not found"),
 260             @ApiResponse(code = 409, message = "Interface Operation already exist")})
 261     public Response createInterfaceOperationsOnService(
 262             @ApiParam(value = "Interface Operations to create", required = true) String data,
 263             @ApiParam(value = "Service Id") @PathParam("serviceId") String serviceId,
 264             @HeaderParam(value = Constants.USER_ID_HEADER) String userId, @Context final HttpServletRequest request) {
 265         return createOrUpdate(data, ComponentTypeEnum.SERVICE, serviceId, request, userId, false);
 266     }
 267
 268     @PUT
 269     @Consumes(MediaType.APPLICATION_JSON)
 270     @Produces(MediaType.APPLICATION_JSON)
 271     @Path("/services/{serviceId}/interfaceOperations")
 272     @ApiOperation(value = "Update Interface Operations on Service", httpMethod = "PUT",
 273             notes = "Update Interface Operations on Service", response = InterfaceDefinition.class, responseContainer = "List")
 274     @ApiResponses(value = {@ApiResponse(code = 201, message = "Update Interface Operations on Service"),
 275             @ApiResponse(code = 400, message = "Invalid content / Missing content"),
 276             @ApiResponse(code = 403, message = "Restricted operation"),
 277             @ApiResponse(code = 404, message = "Service not found")})
 278     public Response updateInterfaceOperationsOnService(
 279             @ApiParam(value = "Interface Operations to update", required = true) String data,
 280             @ApiParam(value = "Service Id") @PathParam("serviceId") String serviceId,
 281             @HeaderParam(value = Constants.USER_ID_HEADER) String userId, @Context final HttpServletRequest request) {
 282         return createOrUpdate(data, ComponentTypeEnum.SERVICE, serviceId, request, userId, true);
 283     }
 284
 285     @DELETE
 286     @Consumes(MediaType.APPLICATION_JSON)
 287     @Produces(MediaType.APPLICATION_JSON)
 288     @Path("/services/{serviceId}/interfaces/{interfaceId}/operations/{operationId}")
 289     @ApiOperation(value = "Delete Interface Operation from Service", httpMethod = "DELETE",
 290             notes = "Delete Interface Operation from Service", response = InterfaceDefinition.class, responseContainer = "List")
 291     @ApiResponses(value = {@ApiResponse(code = 201, message = "Delete Interface Operation from Service"),
 292             @ApiResponse(code = 400, message = "Invalid content / Missing content"),
 293             @ApiResponse(code = 403, message = "Restricted operation"),
 294             @ApiResponse(code = 404, message = "Service not found")})
 295     public Response deleteInterfaceOperationsFromService(
 296             @ApiParam(value = "Service Id") @PathParam("serviceId") String serviceId,
 297             @ApiParam(value = "Interface Id") @PathParam("interfaceId") String interfaceId,
 298             @ApiParam(value = "Operation Id") @PathParam("operationId") String operationId,
 299             @HeaderParam(value = Constants.USER_ID_HEADER) String userId, @Context final HttpServletRequest request) {
 300         return delete(interfaceId, operationId, serviceId, request, userId);
 301     }
 302
 303     @GET
 304     @Consumes(MediaType.APPLICATION_JSON)
 305     @Produces(MediaType.APPLICATION_JSON)
 306     @Path("/services/{serviceId}/interfaces/{interfaceId}/operations/{operationId}")
 307     @ApiOperation(value = "Get Interface Operation from Service", httpMethod = "GET",
 308             notes = "GET Interface Operation from Service", response = InterfaceDefinition.class, responseContainer = "List")
 309     @ApiResponses(value = {@ApiResponse(code = 201, message = "Get Interface Operation from Service"),
 310             @ApiResponse(code = 400, message = "Invalid content / Missing content"),
 311             @ApiResponse(code = 403, message = "Restricted operation"),
 312             @ApiResponse(code = 404, message = "Service not found")})
 313     public Response getInterfaceOperationsFromService(
 314             @ApiParam(value = "Service Id") @PathParam("serviceId") String serviceId,
 315             @ApiParam(value = "Interface Id") @PathParam("interfaceId") String interfaceId,
 316             @ApiParam(value = "Operation Id") @PathParam("operationId") String operationId,
 317             @HeaderParam(value = Constants.USER_ID_HEADER) String userId, @Context final HttpServletRequest request) {
 318         return get(interfaceId, operationId, serviceId, request, userId);
 319     }
 320
 321 }
 322