catalog-be/src/main/java/org/openecomp/sdc/be/servlets/TypesFetchServlet.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.jcabi.aspects.Loggable;
  24 import fj.data.Either;
  25 import io.swagger.annotations.Api;
  26 import io.swagger.annotations.ApiOperation;
  27 import io.swagger.annotations.ApiResponse;
  28 import io.swagger.annotations.ApiResponses;
  29 import org.apache.commons.collections4.ListUtils;
  30 import org.openecomp.sdc.be.components.impl.CapabilitiesBusinessLogic;
  31 import org.openecomp.sdc.be.components.impl.ComponentBusinessLogic;
  32 import org.openecomp.sdc.be.components.impl.InterfaceOperationBusinessLogic;
  33 import org.openecomp.sdc.be.components.impl.PropertyBusinessLogic;
  34 import org.openecomp.sdc.be.components.impl.RelationshipTypeBusinessLogic;
  35 import org.openecomp.sdc.be.config.BeEcompErrorManager;
  36 import org.openecomp.sdc.be.dao.api.ActionStatus;
  37 import org.openecomp.sdc.be.datamodel.api.HighestFilterEnum;
  38 import org.openecomp.sdc.be.datatypes.components.ResourceMetadataDataDefinition;
  39 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
  40 import org.openecomp.sdc.be.model.CapabilityTypeDefinition;
  41 import org.openecomp.sdc.be.model.Component;
  42 import org.openecomp.sdc.be.model.DataTypeDefinition;
  43 import org.openecomp.sdc.be.model.InterfaceDefinition;
  44 import org.openecomp.sdc.be.model.RelationshipTypeDefinition;
  45 import org.openecomp.sdc.be.model.User;
  46 import org.openecomp.sdc.common.api.Constants;
  47 import org.openecomp.sdc.common.datastructure.Wrapper;
  48 import org.openecomp.sdc.common.log.wrappers.Logger;
  49 import org.openecomp.sdc.exception.ResponseFormat;
  50
  51 import javax.inject.Singleton;
  52 import javax.servlet.ServletContext;
  53 import javax.servlet.http.HttpServletRequest;
  54 import javax.ws.rs.Consumes;
  55 import javax.ws.rs.GET;
  56 import javax.ws.rs.HeaderParam;
  57 import javax.ws.rs.Path;
  58 import javax.ws.rs.Produces;
  59 import javax.ws.rs.core.Context;
  60 import javax.ws.rs.core.MediaType;
  61 import javax.ws.rs.core.Response;
  62 import java.util.HashMap;
  63 import java.util.List;
  64 import java.util.Map;
  65 import java.util.stream.Collectors;
  66
  67
  68 @Loggable(prepend = true, value = Loggable.DEBUG, trim = false)
  69 @Path("/v1/catalog")
  70 @Api(value = "Types Fetch Servlet", description = "Types Fetch Servlet")
  71 @Singleton
  72 public class TypesFetchServlet extends AbstractValidationsServlet {
  73
  74     private static final Logger log = Logger.getLogger(TypesFetchServlet.class);
  75     private static final String FAILED_TO_GET_ALL_NON_ABSTRACT = "failed to get all non abstract {}";
  76
  77     @GET
  78     @Path("dataTypes")
  79     @Consumes(MediaType.APPLICATION_JSON)
  80     @Produces(MediaType.APPLICATION_JSON)
  81     @ApiOperation(value = "Get data types", httpMethod = "GET", notes = "Returns data types", response = Response.class)
  82     @ApiResponses(value = { @ApiResponse(code = 200, message = "datatypes"), @ApiResponse(code = 403, message = "Restricted operation"), @ApiResponse(code = 400, message = "Invalid content / Missing content"),
  83             @ApiResponse(code = 404, message = "Data types not found") })
  84     public Response getAllDataTypesServlet(@Context final HttpServletRequest request, @HeaderParam(value = Constants.USER_ID_HEADER) String userId) {
  85
  86         Wrapper<Response> responseWrapper = new Wrapper<>();
  87         Wrapper<User> userWrapper = new Wrapper<>();
  88         ServletContext context = request.getSession().getServletContext();
  89
  90         try {
  91             init();
  92             validateUserExist(responseWrapper, userWrapper, userId);
  93
  94             if (responseWrapper.isEmpty()) {
  95                 String url = request.getMethod() + " " + request.getRequestURI();
  96                 log.debug("Start handle request of {} | modifier id is {}", url, userId);
  97
  98                 PropertyBusinessLogic businessLogic = getPropertyBL(context);
  99                 Either<Map<String, DataTypeDefinition>, ResponseFormat> allDataTypes = businessLogic.getAllDataTypes();
 100
 101                 if (allDataTypes.isRight()) {
 102                     log.info("Failed to get all dara types. Reason - {}", allDataTypes.right().value());
 103                     Response errorResponse = buildErrorResponse(allDataTypes.right().value());
 104                     responseWrapper.setInnerElement(errorResponse);
 105
 106                 } else {
 107
 108                     Map<String, DataTypeDefinition> dataTypes = allDataTypes.left().value();
 109                     String dataTypeJson = gson.toJson(dataTypes);
 110                     Response okResponse = buildOkResponse(getComponentsUtils().getResponseFormat(ActionStatus.OK), dataTypeJson);
 111                     responseWrapper.setInnerElement(okResponse);
 112
 113                 }
 114             }
 115
 116             return responseWrapper.getInnerElement();
 117         } catch (Exception e) {
 118             BeEcompErrorManager.getInstance().logBeRestApiGeneralError("Get Property");
 119             log.debug("get all data types failed with exception", e);
 120             ResponseFormat responseFormat = getComponentsUtils().getResponseFormat(ActionStatus.GENERAL_ERROR);
 121             return buildErrorResponse(responseFormat);
 122         }
 123     }
 124
 125     @GET
 126     @Path("interfaceLifecycleTypes")
 127     @Consumes(MediaType.APPLICATION_JSON)
 128     @Produces(MediaType.APPLICATION_JSON)
 129     @ApiOperation(value = "Get interface lifecycle types", httpMethod = "GET", notes = "Returns interface lifecycle types", response = Response.class)
 130     @ApiResponses(value = {
 131         @ApiResponse(code = 200, message = "Interface lifecycle types"),
 132         @ApiResponse(code = 403, message = "Restricted operation"),
 133         @ApiResponse(code = 400, message = "Invalid content / Missing content"),
 134         @ApiResponse(code = 404, message = "Interface lifecycle types not found")
 135     })
 136     public Response getInterfaceLifecycleTypes(@Context final HttpServletRequest request, @HeaderParam(value = Constants.USER_ID_HEADER) String userId) {
 137
 138         Wrapper<Response> responseWrapper = new Wrapper<>();
 139         Wrapper<User> userWrapper = new Wrapper<>();
 140         ServletContext context = request.getSession().getServletContext();
 141
 142         try {
 143             validateUserExist(responseWrapper, userWrapper, userId);
 144
 145             if (responseWrapper.isEmpty()) {
 146                 String url = request.getMethod() + " " + request.getRequestURI();
 147                 log.info("Start handle request of {} | modifier id is {}", url, userId);
 148
 149                 InterfaceOperationBusinessLogic businessLogic = getInterfaceOperationBL(context);
 150                 Either<Map<String, InterfaceDefinition>, ResponseFormat> allInterfaceLifecycleTypes =
 151                     businessLogic.getAllInterfaceLifecycleTypes();
 152
 153                 if (allInterfaceLifecycleTypes.isRight()) {
 154                     log.info("Failed to get all interface lifecycle types. Reason - {}",
 155                         allInterfaceLifecycleTypes.right().value());
 156                     Response errorResponse = buildErrorResponse(allInterfaceLifecycleTypes.right().value());
 157                     responseWrapper.setInnerElement(errorResponse);
 158
 159                 } else {
 160                     String interfaceLifecycleTypeJson = gson.toJson(allInterfaceLifecycleTypes.left().value());
 161                     Response okResponse = buildOkResponse(getComponentsUtils().getResponseFormat(ActionStatus.OK), interfaceLifecycleTypeJson);
 162                     responseWrapper.setInnerElement(okResponse);
 163
 164                 }
 165             }
 166
 167             return responseWrapper.getInnerElement();
 168         } catch (Exception e) {
 169             log.debug("get all interface lifecycle types failed with exception", e);
 170             ResponseFormat responseFormat = getComponentsUtils().getResponseFormat(ActionStatus.GENERAL_ERROR);
 171             return buildErrorResponse(responseFormat);
 172         }
 173     }
 174     @GET
 175     @Path("capabilityTypes")
 176     @Consumes(MediaType.APPLICATION_JSON)
 177     @Produces(MediaType.APPLICATION_JSON)
 178     @ApiOperation(value = "Get capability types", httpMethod = "GET", notes = "Returns capability types", response =
 179             Response.class)
 180     @ApiResponses(value = {@ApiResponse(code = 200, message = "capabilityTypes"),
 181             @ApiResponse(code = 403, message = "Restricted operation"),
 182             @ApiResponse(code = 400, message = "Invalid content / Missing content"),
 183             @ApiResponse(code = 404, message = "Capability types not found")})
 184     public Response getAllCapabilityTypesServlet(@Context final HttpServletRequest request, @HeaderParam(value =
 185             Constants.USER_ID_HEADER) String userId) {
 186
 187         Wrapper<Response> responseWrapper = new Wrapper<>();
 188         Wrapper<User> userWrapper = new Wrapper<>();
 189         ServletContext context = request.getSession().getServletContext();
 190
 191         try {
 192             init();
 193             validateUserExist(responseWrapper, userWrapper, userId);
 194
 195             if (responseWrapper.isEmpty()) {
 196                 String url = request.getMethod() + " " + request.getRequestURI();
 197                 log.debug("Start handle request of {} | modifier id is {}", url, userId);
 198
 199                 CapabilitiesBusinessLogic businessLogic = getCapabilitiesBL(context);
 200                 Either<Map<String, CapabilityTypeDefinition>, ResponseFormat> allDataTypes =
 201                         businessLogic.getAllCapabilityTypes();
 202
 203                 if (allDataTypes.isRight()) {
 204                     log.info("Failed to get all capability types. Reason - {}", allDataTypes.right().value());
 205                     Response errorResponse = buildErrorResponse(allDataTypes.right().value());
 206                     responseWrapper.setInnerElement(errorResponse);
 207
 208                 } else {
 209
 210                     Map<String, CapabilityTypeDefinition> dataTypes = allDataTypes.left().value();
 211                     String dataTypeJson = gson.toJson(dataTypes);
 212                     Response okResponse =
 213                             buildOkResponse(getComponentsUtils().getResponseFormat(ActionStatus.OK), dataTypeJson);
 214                     responseWrapper.setInnerElement(okResponse);
 215
 216                 }
 217             }
 218
 219             return responseWrapper.getInnerElement();
 220         } catch (Exception e) {
 221             BeEcompErrorManager.getInstance().logBeRestApiGeneralError("Get Capability Types");
 222             log.debug("get all capability types failed with exception", e);
 223             ResponseFormat responseFormat = getComponentsUtils().getResponseFormat(ActionStatus.GENERAL_ERROR);
 224             return buildErrorResponse(responseFormat);
 225         }
 226     }
 227
 228     @GET
 229     @Path("relationshipTypes")
 230     @Consumes(MediaType.APPLICATION_JSON)
 231     @Produces(MediaType.APPLICATION_JSON)
 232     @ApiOperation(value = "Get relationship types", httpMethod = "GET", notes = "Returns relationship types", response =
 233             Response.class)
 234     @ApiResponses(value = {@ApiResponse(code = 200, message = "relationshipTypes"),
 235             @ApiResponse(code = 403, message = "Restricted operation"),
 236             @ApiResponse(code = 400, message = "Invalid content / Missing content"),
 237             @ApiResponse(code = 404, message = "Relationship types not found")})
 238     public Response getAllRelationshipTypesServlet(@Context final HttpServletRequest request, @HeaderParam(value =
 239             Constants.USER_ID_HEADER) String userId) {
 240
 241         Wrapper<Response> responseWrapper = new Wrapper<>();
 242         Wrapper<User> userWrapper = new Wrapper<>();
 243         ServletContext context = request.getSession().getServletContext();
 244
 245         try {
 246             init();
 247             validateUserExist(responseWrapper, userWrapper, userId);
 248
 249             if (responseWrapper.isEmpty()) {
 250                 String url = request.getMethod() + " " + request.getRequestURI();
 251                 log.debug("Start handle request of {} | modifier id is {}", url, userId);
 252
 253                 RelationshipTypeBusinessLogic businessLogic = getRelationshipTypeBL(context);
 254                 Either<Map<String, RelationshipTypeDefinition>, ResponseFormat> allDataTypes =
 255                         businessLogic.getAllRelationshipTypes();
 256
 257                 if (allDataTypes.isRight()) {
 258                     log.info("Failed to get all relationship types. Reason - {}", allDataTypes.right().value());
 259                     Response errorResponse = buildErrorResponse(allDataTypes.right().value());
 260                     responseWrapper.setInnerElement(errorResponse);
 261
 262                 } else {
 263
 264                     Map<String, RelationshipTypeDefinition> dataTypes = allDataTypes.left().value();
 265                     String dataTypeJson = gson.toJson(dataTypes);
 266                     Response okResponse =
 267                             buildOkResponse(getComponentsUtils().getResponseFormat(ActionStatus.OK), dataTypeJson);
 268                     responseWrapper.setInnerElement(okResponse);
 269
 270                 }
 271             }
 272
 273             return responseWrapper.getInnerElement();
 274         } catch (Exception e) {
 275             BeEcompErrorManager.getInstance().logBeRestApiGeneralError("Get Relationship Types");
 276             log.debug("get all relationship types failed with exception", e);
 277             ResponseFormat responseFormat = getComponentsUtils().getResponseFormat(ActionStatus.GENERAL_ERROR);
 278             return buildErrorResponse(responseFormat);
 279         }
 280     }
 281
 282     @GET
 283     @Path("nodeTypes")
 284     @Consumes(MediaType.APPLICATION_JSON)
 285     @Produces(MediaType.APPLICATION_JSON)
 286     @ApiOperation(value = "Get node types", httpMethod = "GET", notes = "Returns node types", response = Response.class)
 287     @ApiResponses(value = {@ApiResponse(code = 200, message = "nodeTypes"), @ApiResponse(code = 403, message =
 288             "Restricted operation"), @ApiResponse(code = 400, message = "Invalid content / Missing content"),
 289             @ApiResponse(code = 404, message = "Node types not found")})
 290     public Response getAllNodeTypesServlet(@Context final HttpServletRequest request, @HeaderParam(value =
 291             Constants.USER_ID_HEADER) String userId) {
 292
 293         Wrapper<Response> responseWrapper = new Wrapper<>();
 294         Wrapper<User> userWrapper = new Wrapper<>();
 295         ServletContext context = request.getSession().getServletContext();
 296         Either<Map<String, Component>, Response> response;
 297         Map<String, Component> componentMap;
 298
 299         try {
 300             init();
 301             validateUserExist(responseWrapper, userWrapper, userId);
 302
 303             if (responseWrapper.isEmpty()) {
 304                 String url = request.getMethod() + " " + request.getRequestURI();
 305                 log.debug("Start handle request of {} | modifier id is {}", url, userId);
 306
 307                 ComponentBusinessLogic resourceBL = getComponentBL(ComponentTypeEnum.RESOURCE, context);
 308                 response = getComponent(resourceBL, true, userId);
 309                 if (response.isRight()) {
 310                     return response.right().value();
 311                 }
 312                 componentMap = new HashMap<>(response.left().value());
 313
 314                 response = getComponent(resourceBL, false, userId);
 315                 if (response.isRight()) {
 316                     return response.right().value();
 317                 }
 318                 componentMap.putAll(response.left().value());
 319
 320                 String nodeTypesJson = gson.toJson(componentMap);
 321                 Response okResponse =
 322                         buildOkResponse(getComponentsUtils().getResponseFormat(ActionStatus.OK), nodeTypesJson);
 323                 responseWrapper.setInnerElement(okResponse);
 324             }
 325
 326             return responseWrapper.getInnerElement();
 327         } catch (Exception e) {
 328             BeEcompErrorManager.getInstance().logBeRestApiGeneralError("Get Node Types");
 329             log.debug("get all node types failed with exception", e);
 330             ResponseFormat responseFormat = getComponentsUtils().getResponseFormat(ActionStatus.GENERAL_ERROR);
 331             return buildErrorResponse(responseFormat);
 332         }
 333     }
 334
 335     private Either<Map<String, Component>, Response> getComponent(ComponentBusinessLogic resourceBL, boolean isAbstract,
 336                                                                   String userId) {
 337         Either<List<Component>, ResponseFormat> actionResponse;
 338         List<Component> componentList;
 339
 340         actionResponse =
 341                 resourceBL.getLatestVersionNotAbstractComponentsMetadata(isAbstract, HighestFilterEnum.HIGHEST_ONLY
 342                         , ComponentTypeEnum.RESOURCE, null, userId);
 343         if (actionResponse.isRight()) {
 344             log.debug(FAILED_TO_GET_ALL_NON_ABSTRACT, ComponentTypeEnum.RESOURCE.getValue());
 345             return Either.right(buildErrorResponse(actionResponse.right().value()));
 346         }
 347
 348         componentList = actionResponse.left().value();
 349
 350         return Either.left(ListUtils.emptyIfNull(componentList).stream()
 351                 .filter(component -> ((ResourceMetadataDataDefinition) component
 352                         .getComponentMetadataDefinition().getMetadataDataDefinition()).getToscaResourceName() != null)
 353                 .collect(Collectors.toMap(
 354                         component -> ((ResourceMetadataDataDefinition) component
 355                                 .getComponentMetadataDefinition().getMetadataDataDefinition()).getToscaResourceName(),
 356                         component -> component, (component1, component2) -> component1)));
 357     }
 358 }