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