catalog-be/src/main/java/org/openecomp/sdc/be/servlets/ResourceInterfaceOperationServlet.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.Sets;
  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 org.apache.commons.collections.CollectionUtils;
  28 import org.apache.commons.collections.MapUtils;
  29 import org.openecomp.sdc.be.components.impl.InterfaceOperationBusinessLogic;
  30 import org.openecomp.sdc.be.components.impl.ResourceBusinessLogic;
  31 import org.openecomp.sdc.be.config.BeEcompErrorManager;
  32 import org.openecomp.sdc.be.dao.api.ActionStatus;
  33 import org.openecomp.sdc.be.datamodel.utils.InterfaceUIDataConverter;
  34 import org.openecomp.sdc.be.datatypes.elements.InterfaceOperationDataDefinition;
  35 import org.openecomp.sdc.be.datatypes.enums.ComponentFieldsEnum;
  36 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
  37 import org.openecomp.sdc.be.model.InterfaceDefinition;
  38 import org.openecomp.sdc.be.model.Operation;
  39 import org.openecomp.sdc.be.model.Resource;
  40 import org.openecomp.sdc.be.model.User;
  41 import org.openecomp.sdc.be.model.jsontitan.utils.InterfaceUtils;
  42 import org.openecomp.sdc.be.resources.data.auditing.AuditingActionEnum;
  43 import org.openecomp.sdc.be.ui.model.UiComponentDataTransfer;
  44 import org.openecomp.sdc.be.ui.model.UiResourceDataTransfer;
  45 import org.openecomp.sdc.common.api.Constants;
  46 import org.openecomp.sdc.exception.ResponseFormat;
  47 import org.slf4j.Logger;
  48 import org.slf4j.LoggerFactory;
  49
  50 import javax.inject.Singleton;
  51 import javax.servlet.ServletContext;
  52 import javax.servlet.http.HttpServletRequest;
  53 import javax.ws.rs.Consumes;
  54 import javax.ws.rs.DELETE;
  55 import javax.ws.rs.GET;
  56 import javax.ws.rs.HeaderParam;
  57 import javax.ws.rs.POST;
  58 import javax.ws.rs.PUT;
  59 import javax.ws.rs.Path;
  60 import javax.ws.rs.PathParam;
  61 import javax.ws.rs.Produces;
  62 import javax.ws.rs.core.Context;
  63 import javax.ws.rs.core.MediaType;
  64 import javax.ws.rs.core.Response;
  65 import java.util.Collections;
  66 import java.util.HashMap;
  67 import java.util.List;
  68 import java.util.Map;
  69 import java.util.Optional;
  70 import java.util.UUID;
  71
  72 @Loggable(prepend = true, value = Loggable.DEBUG, trim = false)
  73 @Path("/v1/catalog/resources/{resourceId}/interfaceOperations")
  74 @Consumes(MediaType.APPLICATION_JSON)
  75 @Produces(MediaType.APPLICATION_JSON)
  76 @Api(value = "Interface Operation", description = "Interface Operation Servlet")
  77 @Singleton
  78 public class ResourceInterfaceOperationServlet extends AbstractValidationsServlet {
  79
  80   private static final Logger log = LoggerFactory.getLogger(ResourceInterfaceOperationServlet.class);
  81
  82   @POST
  83   @Consumes(MediaType.APPLICATION_JSON)
  84   @Produces(MediaType.APPLICATION_JSON)
  85   @Path("/")
  86   @ApiOperation(value = "Create Interface Operation", httpMethod = "POST", notes = "Create Interface Operation", response = InterfaceOperationDataDefinition.class)
  87   @ApiResponses(value = {@ApiResponse(code = 201, message = "Create Interface Operation"),
  88       @ApiResponse(code = 403, message = "Restricted operation"),
  89       @ApiResponse(code = 400, message = "Invalid content / Missing content"),
  90       @ApiResponse(code = 409, message = "Interface Operation already exist")})
  91   public Response createInterfaceOperation(
  92       @ApiParam(value = "Interface Operation to create", required = true) String data,
  93       @ApiParam(value = "Resource Id") @PathParam("resourceId") String resourceId,
  94       @Context final HttpServletRequest request,
  95       @HeaderParam(value = Constants.USER_ID_HEADER) String userId) {
  96     return createOrUpdate(data, resourceId, request, userId, false);
  97   }
  98
  99
 100   @PUT
 101   @Consumes(MediaType.APPLICATION_JSON)
 102   @Produces(MediaType.APPLICATION_JSON)
 103   @Path("/")
 104   @ApiOperation(value = "Update Interface Operation", httpMethod = "PUT", notes = "Update Interface Operation", response = InterfaceOperationDataDefinition.class)
 105   @ApiResponses(value = {@ApiResponse(code = 201, message = "Update Interface Operation"),
 106       @ApiResponse(code = 403, message = "Restricted operation"),
 107       @ApiResponse(code = 400, message = "Invalid content / Missing content")})
 108   public Response updateInterfaceOperation(
 109       @ApiParam(value = "Interface Operation to update", required = true) String data,
 110       @ApiParam(value = "Resource Id") @PathParam("resourceId") String resourceId,
 111       @Context final HttpServletRequest request,
 112       @HeaderParam(value = Constants.USER_ID_HEADER) String userId) {
 113     return createOrUpdate(data, resourceId, request, userId, true);
 114   }
 115
 116
 117   @DELETE
 118   @Consumes(MediaType.APPLICATION_JSON)
 119   @Produces(MediaType.APPLICATION_JSON)
 120   @Path("/{interfaceOperationId}")
 121   @ApiOperation(value = "Delete Interface Operation", httpMethod = "DELETE", notes = "Delete Interface Operation", response = InterfaceOperationDataDefinition.class)
 122   @ApiResponses(value = {@ApiResponse(code = 201, message = "Delete Interface Operation"),
 123       @ApiResponse(code = 403, message = "Restricted operation"),
 124       @ApiResponse(code = 400, message = "Invalid content / Missing content")})
 125   public Response deleteInterfaceOperation(
 126       @ApiParam(value = "Interface Operation Id") @PathParam("interfaceOperationId") String interfaceOperationId,
 127       @ApiParam(value = "Resource Id") @PathParam("resourceId") String resourceId,
 128       @Context final HttpServletRequest request,
 129       @HeaderParam(value = Constants.USER_ID_HEADER) String userId) {
 130     return delete(interfaceOperationId, resourceId, request, userId);
 131   }
 132
 133   @GET
 134   @Consumes(MediaType.APPLICATION_JSON)
 135   @Produces(MediaType.APPLICATION_JSON)
 136   @Path("/{interfaceOperationId}")
 137   @ApiOperation(value = "Get Interface Operation", httpMethod = "GET", notes = "GET Interface Operation", response = InterfaceOperationDataDefinition.class)
 138   @ApiResponses(value = {@ApiResponse(code = 201, message = "Get Interface Operation"),
 139       @ApiResponse(code = 403, message = "Restricted operation"),
 140       @ApiResponse(code = 400, message = "Invalid content / Missing content")})
 141   public Response getInterfaceOperation(
 142       @ApiParam(value = "Interface Operation Id") @PathParam("interfaceOperationId") String interfaceOperationId,
 143       @ApiParam(value = "Resource Id") @PathParam("resourceId") String resourceId,
 144       @Context final HttpServletRequest request,
 145       @HeaderParam(value = Constants.USER_ID_HEADER) String userId) {
 146
 147     return get(interfaceOperationId, resourceId, request, userId);
 148   }
 149
 150   private Response get (String interfaceOperationId, String resourceId, HttpServletRequest request, String userId){
 151     ServletContext context = request.getSession().getServletContext();
 152     String url = request.getMethod() + " " + request.getRequestURI();
 153
 154     User modifier = new User();
 155     modifier.setUserId(userId);
 156     log.debug("Start get request of {} with modifier id {}", url, userId);
 157
 158     try {
 159       InterfaceOperationBusinessLogic businessLogic = getInterfaceOperationBL(context);
 160       Either<UiComponentDataTransfer, ResponseFormat> resourceResponse = businessLogic.getComponentDataFilteredByParams(resourceId, modifier, Collections
 161           .singletonList(ComponentFieldsEnum.INTERFACES.getValue()));
 162       if (resourceResponse.isRight()) {
 163         return buildErrorResponse(resourceResponse.right().value());
 164       }
 165
 166       UiResourceDataTransfer uiResourceDataTransfer = (UiResourceDataTransfer) resourceResponse.left().value();
 167       InterfaceOperationDataDefinition interfaceOperationDataDefinition = getInterfaceOperationForResponse(interfaceOperationId, uiResourceDataTransfer.getInterfaces());
 168
 169       return buildOkResponse(getComponentsUtils().getResponseFormat(ActionStatus.OK), RepresentationUtils.toFilteredRepresentation(interfaceOperationDataDefinition));
 170
 171     } catch (Exception e) {
 172       BeEcompErrorManager.getInstance().logBeRestApiGeneralError("Get Resource interface operations");
 173       log.debug("get resource interface operations failed with exception", e);
 174       return buildErrorResponse(getComponentsUtils().getResponseFormat(ActionStatus.GENERAL_ERROR));
 175     }
 176   }
 177
 178   private Response delete (String interfaceOperationId, String resourceId, HttpServletRequest
 179       request, String userId){
 180
 181     ServletContext context = request.getSession().getServletContext();
 182     String url = request.getMethod() + " " + request.getRequestURI();
 183
 184     User modifier = new User();
 185     modifier.setUserId(userId);
 186     log.debug("Start delete request of {} with modifier id {}", url, userId);
 187
 188     Response response;
 189
 190     try {
 191       String resourceIdLower = resourceId.toLowerCase();
 192       InterfaceOperationBusinessLogic businessLogic = getInterfaceOperationBL(context);
 193
 194       Either<Resource, ResponseFormat> actionResponse = businessLogic.deleteInterfaceOperation(resourceIdLower, Sets.newHashSet(interfaceOperationId), modifier, true);
 195
 196       if (actionResponse.isRight()) {
 197         log.debug("failed to delete interface operation");
 198         response = buildErrorResponse(actionResponse.right().value());
 199         return response;
 200       }
 201
 202       Resource resource = actionResponse.left().value();
 203       InterfaceOperationDataDefinition interfaceOperationDataDefinition = getInterfaceOperationForResponse(interfaceOperationId, resource.getInterfaces());
 204       Object result = RepresentationUtils.toFilteredRepresentation(interfaceOperationDataDefinition);
 205       return buildOkResponse(getComponentsUtils().getResponseFormat(ActionStatus.OK), result);
 206
 207     } catch (Exception e) {
 208       BeEcompErrorManager.getInstance().logBeRestApiGeneralError("Delete Interface Operation");
 209       log.debug("Delete interface operation with an error", e);
 210       response = buildErrorResponse(getComponentsUtils().getResponseFormat(ActionStatus.GENERAL_ERROR));
 211       return response;
 212
 213     }
 214   }
 215
 216   private Response createOrUpdate (String data, String resourceId, HttpServletRequest request, String userId, boolean isUpdate) {
 217     ServletContext context = request.getSession().getServletContext();
 218     String url = request.getMethod() + " " + request.getRequestURI();
 219
 220     User modifier = new User();
 221     modifier.setUserId(userId);
 222     log.debug("Start create or update request of {} with modifier id {}", url, userId);
 223
 224     Response response;
 225     try {
 226       String resourceIdLower = resourceId.toLowerCase();
 227       InterfaceOperationBusinessLogic businessLogic = getInterfaceOperationBL(context);
 228
 229       Either<Resource, ResponseFormat> resourceEither = businessLogic.getResourceDetails(resourceId);
 230       Resource origResource = resourceEither.left().value();
 231
 232       Either<Resource, ResponseFormat> convertResponse = parseToResource(data, origResource, isUpdate, modifier);
 233       if (convertResponse.isRight()) {
 234         log.debug("failed to parse resource");
 235         response = buildErrorResponse(convertResponse.right().value());
 236         return response;
 237       }
 238
 239       Resource updatedResource = convertResponse.left().value();
 240       Either<Resource, ResponseFormat> actionResponse ;
 241       if (isUpdate) {
 242         actionResponse = businessLogic.updateInterfaceOperation(resourceIdLower, updatedResource, modifier, true);
 243       } else {
 244         actionResponse = businessLogic.createInterfaceOperation(resourceIdLower, updatedResource, modifier, true);
 245       }
 246
 247       if (actionResponse.isRight()) {
 248         log.debug("failed to update or create interface operation");
 249         response = buildErrorResponse(actionResponse.right().value());
 250         return response;
 251       }
 252
 253       Resource resource = actionResponse.left().value();
 254       List<Operation> operationData = InterfaceUtils.getOperationsFromInterface(updatedResource.getInterfaces());
 255       InterfaceOperationDataDefinition interfaceOperationDataDefinition = getInterfaceOperationForResponse(operationData.get(0).getUniqueId(), resource.getInterfaces());
 256
 257       Object result = RepresentationUtils.toFilteredRepresentation(interfaceOperationDataDefinition);
 258       return buildOkResponse(getComponentsUtils().getResponseFormat(ActionStatus.OK), result);
 259
 260     } catch (Exception e) {
 261       BeEcompErrorManager.getInstance().logBeRestApiGeneralError("Interface Operation Creation or update");
 262       log.debug("create or update interface Operation with an error", e);
 263       response = buildErrorResponse(getComponentsUtils().getResponseFormat(ActionStatus.GENERAL_ERROR));
 264       return response;
 265
 266     }
 267   }
 268
 269   private Either<Resource, ResponseFormat> parseToResource(String resourceJson, Resource origResource, boolean isUpdate, User user) {
 270
 271     Resource resource = convertToResourceObject(resourceJson, user).left().value();
 272
 273     Either<UiResourceDataTransfer, ResponseFormat> uiResourceEither = getComponentsUtils().convertJsonToObjectUsingObjectMapper(resourceJson, user, UiResourceDataTransfer.class, AuditingActionEnum.CREATE_RESOURCE, ComponentTypeEnum.RESOURCE);
 274     Optional<InterfaceOperationDataDefinition> opDef = uiResourceEither.left().value().getInterfaceOperations().values().stream().findFirst();
 275     InterfaceOperationDataDefinition interfaceOperationDataDefinition;
 276     if(opDef.isPresent()) {
 277       interfaceOperationDataDefinition = opDef.get();
 278
 279       if(!isUpdate)
 280         interfaceOperationDataDefinition.setUniqueId(UUID.randomUUID().toString());
 281
 282       Map<String, Operation> interfaceOperations = new HashMap<>();
 283       interfaceOperations.put(interfaceOperationDataDefinition.getUniqueId(), InterfaceUIDataConverter.convertInterfaceDataToOperationData(interfaceOperationDataDefinition));
 284       InterfaceDefinition interfaceDefinition = new InterfaceDefinition();
 285       interfaceDefinition.setUniqueId(UUID.randomUUID().toString());
 286       interfaceDefinition.setToscaResourceName(InterfaceUtils.createInterfaceToscaResourceName(origResource.getName()));
 287       interfaceDefinition.setOperationsMap(interfaceOperations);
 288
 289       Map<String, InterfaceDefinition> interfaceMap = new HashMap<>();
 290       interfaceMap.put(interfaceDefinition.getUniqueId(), interfaceDefinition);
 291
 292       resource.setInterfaces(interfaceMap);
 293     }
 294
 295     return Either.left(resource);
 296   }
 297
 298   private Either<Resource, ResponseFormat> convertToResourceObject(String resourceJson, User user) {
 299     return getComponentsUtils().convertJsonToObjectUsingObjectMapper(resourceJson, user, Resource.class, AuditingActionEnum.CREATE_RESOURCE, ComponentTypeEnum.RESOURCE);
 300   }
 301
 302   private InterfaceOperationDataDefinition getInterfaceOperationForResponse(String interfaceOperationId, Map<String, InterfaceDefinition> interfaces){
 303     InterfaceOperationDataDefinition interfaceOperationDataDefinition = new InterfaceOperationDataDefinition();
 304     if(!MapUtils.isEmpty(interfaces)){
 305       List<Operation> operationData = InterfaceUtils.getOperationsFromInterface(interfaces);
 306       if(CollectionUtils.isNotEmpty(operationData)){
 307         Optional<Operation> matchedOp = operationData.stream().filter(a -> a.getUniqueId().equals(interfaceOperationId)).findAny();
 308         if(matchedOp.isPresent()) {
 309           interfaceOperationDataDefinition = InterfaceUIDataConverter.convertOperationDataToInterfaceData(matchedOp.get());
 310         }
 311       }
 312     }
 313     return interfaceOperationDataDefinition;
 314   }
 315
 316 }
 317