catalog-be/src/main/java/org/openecomp/sdc/be/servlets/TypesUploadServlet.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 java.io.File;
  24 import java.io.IOException;
  25 import java.util.List;
  26 import java.util.Map;
  27 import java.util.Set;
  28 import java.util.function.Supplier;
  29 import java.util.stream.Collectors;
  30
  31 import javax.annotation.Resource;
  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.HeaderParam;
  37 import javax.ws.rs.POST;
  38 import javax.ws.rs.Path;
  39 import javax.ws.rs.Produces;
  40 import javax.ws.rs.core.Context;
  41 import javax.ws.rs.core.MediaType;
  42 import javax.ws.rs.core.Response;
  43
  44 import org.apache.commons.lang3.tuple.ImmutablePair;
  45 import org.codehaus.jackson.JsonGenerationException;
  46 import org.codehaus.jackson.map.JsonMappingException;
  47 import org.glassfish.jersey.media.multipart.FormDataParam;
  48 import org.openecomp.sdc.be.components.impl.CapabilityTypeImportManager;
  49 import org.openecomp.sdc.be.components.impl.CategoriesImportManager;
  50 import org.openecomp.sdc.be.components.impl.DataTypeImportManager;
  51 import org.openecomp.sdc.be.components.impl.GroupTypeImportManager;
  52 import org.openecomp.sdc.be.components.impl.InterfaceLifecycleTypeImportManager;
  53 import org.openecomp.sdc.be.components.impl.PolicyTypeImportManager;
  54 import org.openecomp.sdc.be.config.BeEcompErrorManager;
  55 import org.openecomp.sdc.be.dao.api.ActionStatus;
  56 import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
  57 import org.openecomp.sdc.be.impl.WebAppContextWrapper;
  58 import org.openecomp.sdc.be.model.DataTypeDefinition;
  59 import org.openecomp.sdc.be.model.GroupTypeDefinition;
  60 import org.openecomp.sdc.be.model.PolicyTypeDefinition;
  61 import org.openecomp.sdc.be.model.User;
  62 import org.openecomp.sdc.common.api.Constants;
  63 import org.openecomp.sdc.common.datastructure.Wrapper;
  64 import org.openecomp.sdc.common.datastructure.FunctionalInterfaces.ConsumerTwoParam;
  65 import org.openecomp.sdc.exception.ResponseFormat;
  66 import org.slf4j.Logger;
  67 import org.slf4j.LoggerFactory;
  68 import org.springframework.web.context.WebApplicationContext;
  69
  70 import com.jcabi.aspects.Loggable;
  71 import io.swagger.annotations.Api;
  72 import io.swagger.annotations.ApiOperation;
  73 import io.swagger.annotations.ApiParam;
  74 import io.swagger.annotations.ApiResponse;
  75 import io.swagger.annotations.ApiResponses;
  76
  77 import fj.data.Either;
  78
  79 @Loggable(prepend = true, value = Loggable.DEBUG, trim = false)
  80 @Path("/v1/catalog/uploadType")
  81 @Api(value = "Catalog Types Upload", description = "Upload Type from yaml")
  82 @Singleton
  83 public class TypesUploadServlet extends AbstractValidationsServlet {
  84         @Resource
  85         private CapabilityTypeImportManager capabilityTypeImportManager;
  86
  87         @Resource
  88         private InterfaceLifecycleTypeImportManager interfaceLifecycleTypeImportManager;
  89
  90         @Resource
  91         private CategoriesImportManager categoriesImportManager;
  92
  93         @Resource
  94         private DataTypeImportManager dataTypeImportManager;
  95
  96         @Resource
  97         private GroupTypeImportManager groupTypeImportManager;
  98
  99         @Resource
 100         private PolicyTypeImportManager policyTypeImportManager;
 101
 102         private static Logger log = LoggerFactory.getLogger(TypesUploadServlet.class.getName());
 103
 104         @POST
 105         @Path("/capability")
 106         @Consumes(MediaType.MULTIPART_FORM_DATA)
 107         @Produces(MediaType.APPLICATION_JSON)
 108         @ApiOperation(value = "Create Capability Type from yaml", httpMethod = "POST", notes = "Returns created Capability Type", response = Response.class)
 109         @ApiResponses(value = { @ApiResponse(code = 201, message = "Capability Type created"), @ApiResponse(code = 403, message = "Restricted operation"), @ApiResponse(code = 400, message = "Invalid content / Missing content"),
 110         @ApiResponse(code = 409, message = "Capability Type already exist") })
 111         public Response uploadCapabilityType(@ApiParam("FileInputStream") @FormDataParam("capabilityTypeZip") File file, @Context final HttpServletRequest request, @HeaderParam("USER_ID") String creator) {
 112                 capabilityTypeImportManager = initElementTypeImportManager(request.getSession().getServletContext(), () -> CapabilityTypeImportManager.class);
 113                 ConsumerTwoParam<Wrapper<Response>, String> createElementsMethod = (responseWrapper, ymlPayload) -> createElementsType(responseWrapper, () -> capabilityTypeImportManager.createCapabilityTypes(ymlPayload));
 114                 return uploadElementTypeServletLogic(createElementsMethod, file, request, creator, NodeTypeEnum.CapabilityType.name());
 115         }
 116
 117         @POST
 118         @Path("/interfaceLifecycle")
 119         @Consumes(MediaType.MULTIPART_FORM_DATA)
 120         @Produces(MediaType.APPLICATION_JSON)
 121         @ApiOperation(value = "Create Interface Lyfecycle Type from yaml", httpMethod = "POST", notes = "Returns created Interface Lifecycle Type", response = Response.class)
 122         @ApiResponses(value = { @ApiResponse(code = 201, message = "Interface Lifecycle Type created"), @ApiResponse(code = 403, message = "Restricted operation"), @ApiResponse(code = 400, message = "Invalid content / Missing content"),
 123         @ApiResponse(code = 409, message = "Interface Lifecycle Type already exist") })
 124         public Response uploadInterfaceLifecycleType(@ApiParam("FileInputStream") @FormDataParam("interfaceLifecycleTypeZip") File file, @Context final HttpServletRequest request, @HeaderParam("USER_ID") String creator) {
 125                 interfaceLifecycleTypeImportManager = initElementTypeImportManager(request.getSession().getServletContext(), () -> InterfaceLifecycleTypeImportManager.class);
 126                 ConsumerTwoParam<Wrapper<Response>, String> createElementsMethod = (responseWrapper, ymlPayload) -> createElementsType(responseWrapper, () -> interfaceLifecycleTypeImportManager.createLifecycleTypes(ymlPayload));
 127                 return uploadElementTypeServletLogic(createElementsMethod, file, request, creator, "Interface Types");
 128         }
 129
 130         @POST
 131         @Path("/categories")
 132         @Consumes(MediaType.MULTIPART_FORM_DATA)
 133         @Produces(MediaType.APPLICATION_JSON)
 134         @ApiOperation(value = "Create Categories from yaml", httpMethod = "POST", notes = "Returns created categories", response = Response.class)
 135         @ApiResponses(value = { @ApiResponse(code = 201, message = "Categories created"), @ApiResponse(code = 403, message = "Restricted operation"), @ApiResponse(code = 400, message = "Invalid content / Missing content"),
 136         @ApiResponse(code = 409, message = "Category already exist") })
 137         public Response uploadCategories(@ApiParam("FileInputStream") @FormDataParam("categoriesZip") File file, @Context final HttpServletRequest request, @HeaderParam("USER_ID") String creator) {
 138                 categoriesImportManager = initElementTypeImportManager(request.getSession().getServletContext(), () -> CategoriesImportManager.class);
 139                 ConsumerTwoParam<Wrapper<Response>, String> createElementsMethod = (responseWrapper, ymlPayload) -> createElementsType(responseWrapper, () -> categoriesImportManager.createCategories(ymlPayload));
 140                 return uploadElementTypeServletLogic(createElementsMethod, file, request, creator, "categories");
 141         }
 142
 143         @POST
 144         @Path("/datatypes")
 145         @Consumes(MediaType.MULTIPART_FORM_DATA)
 146         @Produces(MediaType.APPLICATION_JSON)
 147         @ApiOperation(value = "Create Categories from yaml", httpMethod = "POST", notes = "Returns created data types", response = Response.class)
 148         @ApiResponses(value = { @ApiResponse(code = 201, message = "Data types created"), @ApiResponse(code = 403, message = "Restricted operation"), @ApiResponse(code = 400, message = "Invalid content / Missing content"),
 149         @ApiResponse(code = 409, message = "Data types already exist") })
 150         public Response uploadDataTypes(@ApiParam("FileInputStream") @FormDataParam("dataTypesZip") File file, @Context final HttpServletRequest request, @HeaderParam("USER_ID") String creator) {
 151                 dataTypeImportManager = initElementTypeImportManager(request.getSession().getServletContext(), () -> DataTypeImportManager.class);
 152                 ConsumerTwoParam<Wrapper<Response>, String> createElementsMethod = (responseWrapper, ymlPayload) -> createDataTypes(responseWrapper, ymlPayload);
 153                 return uploadElementTypeServletLogic(createElementsMethod, file, request, creator, NodeTypeEnum.DataType.getName());
 154         }
 155
 156         @POST
 157         @Path("/grouptypes")
 158         @Consumes(MediaType.MULTIPART_FORM_DATA)
 159         @Produces(MediaType.APPLICATION_JSON)
 160         @ApiOperation(value = "Create GroupTypes from yaml", httpMethod = "POST", notes = "Returns created group types", response = Response.class)
 161         @ApiResponses(value = { @ApiResponse(code = 201, message = "group types created"), @ApiResponse(code = 403, message = "Restricted operation"), @ApiResponse(code = 400, message = "Invalid content / Missing content"),
 162         @ApiResponse(code = 409, message = "group types already exist") })
 163         public Response uploadGroupTypes(@ApiParam("FileInputStream") @FormDataParam("groupTypesZip") File file, @Context final HttpServletRequest request, @HeaderParam("USER_ID") String creator) {
 164                 groupTypeImportManager = initElementTypeImportManager(request.getSession().getServletContext(), () -> GroupTypeImportManager.class);
 165                 ConsumerTwoParam<Wrapper<Response>, String> createElementsMethod = (responseWrapper, ymlPayload) -> createGroupTypes(responseWrapper, ymlPayload);
 166                 return uploadElementTypeServletLogic(createElementsMethod, file, request, creator, NodeTypeEnum.GroupType.getName());
 167         }
 168
 169         @POST
 170         @Path("/policytypes")
 171         @Consumes(MediaType.MULTIPART_FORM_DATA)
 172         @Produces(MediaType.APPLICATION_JSON)
 173         @ApiOperation(value = "Create PolicyTypes from yaml", httpMethod = "POST", notes = "Returns created policy types", response = Response.class)
 174         @ApiResponses(value = { @ApiResponse(code = 201, message = "policy types created"), @ApiResponse(code = 403, message = "Restricted operation"), @ApiResponse(code = 400, message = "Invalid content / Missing content"),
 175         @ApiResponse(code = 409, message = "policy types already exist") })
 176         public Response uploadPolicyTypes(@ApiParam("FileInputStream") @FormDataParam("policyTypesZip") File file, @Context final HttpServletRequest request, @HeaderParam("USER_ID") String creator) {
 177                 policyTypeImportManager = initElementTypeImportManager(request.getSession().getServletContext(), () -> PolicyTypeImportManager.class);
 178                 ConsumerTwoParam<Wrapper<Response>, String> createElementsMethod = (responseWrapper, ymlPayload) -> createPolicyTypes(responseWrapper, ymlPayload);
 179                 return uploadElementTypeServletLogic(createElementsMethod, file, request, creator, NodeTypeEnum.PolicyType.getName());
 180         }
 181
 182         private Response uploadElementTypeServletLogic(ConsumerTwoParam<Wrapper<Response>, String> createElementsMethod, File file, final HttpServletRequest request, String creator, String elementTypeName) {
 183                 init(log);
 184                 String userId = initHeaderParam(creator, request, Constants.USER_ID_HEADER);
 185                 try {
 186                         Wrapper<Response> responseWrapper = new Wrapper<>();
 187                         Wrapper<User> userWrapper = new Wrapper<>();
 188                         Wrapper<String> yamlStringWrapper = new Wrapper<>();
 189
 190                         String url = request.getMethod() + " " + request.getRequestURI();
 191                         log.debug("Start handle request of {}", url);
 192
 193                         validateUserExist(responseWrapper, userWrapper, userId);
 194
 195                         if (responseWrapper.isEmpty()) {
 196                                 validateUserRole(responseWrapper, userWrapper.getInnerElement());
 197                         }
 198
 199                         if (responseWrapper.isEmpty()) {
 200                                 validateDataNotNull(responseWrapper, file);
 201                         }
 202
 203                         if (responseWrapper.isEmpty()) {
 204                                 fillZipContents(yamlStringWrapper, file);
 205                         }
 206
 207                         if (responseWrapper.isEmpty()) {
 208                                 createElementsMethod.accept(responseWrapper, yamlStringWrapper.getInnerElement());
 209                         }
 210
 211                         return responseWrapper.getInnerElement();
 212
 213                 } catch (Exception e) {
 214                         log.debug("create {} failed with exception:", elementTypeName, e);
 215                         BeEcompErrorManager.getInstance().logBeRestApiGeneralError("Create " + elementTypeName);
 216                         return buildErrorResponse(getComponentsUtils().getResponseFormat(ActionStatus.GENERAL_ERROR));
 217                 }
 218         }
 219
 220         private <T> void createElementsType(Wrapper<Response> responseWrapper, Supplier<Either<T, ResponseFormat>> elementsCreater) {
 221                 Either<T, ResponseFormat> eitherResult = elementsCreater.get();
 222                 if (eitherResult.isRight()) {
 223                         Response response = buildErrorResponse(eitherResult.right().value());
 224                         responseWrapper.setInnerElement(response);
 225                 } else {
 226                         try {
 227                                 Response response = buildOkResponse(getComponentsUtils().getResponseFormat(ActionStatus.CREATED), RepresentationUtils.toRepresentation(eitherResult.left().value()));
 228                                 responseWrapper.setInnerElement(response);
 229                         } catch (Exception e) {
 230                                 Response response = buildErrorResponse(getComponentsUtils().getResponseFormat(ActionStatus.GENERAL_ERROR));
 231                                 responseWrapper.setInnerElement(response);
 232                         }
 233                 }
 234         }
 235
 236         // data types
 237         private void createDataTypes(Wrapper<Response> responseWrapper, String dataTypesYml) {
 238                 final Supplier<Either<List<ImmutablePair<DataTypeDefinition, Boolean>>, ResponseFormat>> generateElementTypeFromYml = () -> dataTypeImportManager.createDataTypes(dataTypesYml);
 239                 buildStatusForElementTypeCreate(responseWrapper, generateElementTypeFromYml, ActionStatus.DATA_TYPE_ALREADY_EXIST, NodeTypeEnum.DataType.name());
 240         }
 241
 242         // group types
 243         private void createGroupTypes(Wrapper<Response> responseWrapper, String groupTypesYml) {
 244                 final Supplier<Either<List<ImmutablePair<GroupTypeDefinition, Boolean>>, ResponseFormat>> generateElementTypeFromYml = () -> groupTypeImportManager.createGroupTypes(groupTypesYml);
 245                 buildStatusForElementTypeCreate(responseWrapper, generateElementTypeFromYml, ActionStatus.GROUP_TYPE_ALREADY_EXIST, NodeTypeEnum.GroupType.name());
 246         }
 247
 248         // policy types
 249         private void createPolicyTypes(Wrapper<Response> responseWrapper, String policyTypesYml) {
 250                 final Supplier<Either<List<ImmutablePair<PolicyTypeDefinition, Boolean>>, ResponseFormat>> generateElementTypeFromYml = () -> policyTypeImportManager.createPolicyTypes(policyTypesYml);
 251                 buildStatusForElementTypeCreate(responseWrapper, generateElementTypeFromYml, ActionStatus.POLICY_TYPE_ALREADY_EXIST, NodeTypeEnum.PolicyType.name());
 252         }
 253
 254         // data types
 255         private <ElementTypeDefinition> void buildStatusForElementTypeCreate(Wrapper<Response> responseWrapper, Supplier<Either<List<ImmutablePair<ElementTypeDefinition, Boolean>>, ResponseFormat>> generateElementTypeFromYml, ActionStatus alreadyExistStatus, String elementTypeName) {
 256                 Either<List<ImmutablePair<ElementTypeDefinition, Boolean>>, ResponseFormat> eitherResult = generateElementTypeFromYml.get();
 257
 258                 if (eitherResult.isRight()) {
 259                         Response response = buildErrorResponse(eitherResult.right().value());
 260                         responseWrapper.setInnerElement(response);
 261                 } else {
 262                         Object representation;
 263                         try {
 264                                 List<ImmutablePair<ElementTypeDefinition, Boolean>> list = eitherResult.left().value();
 265                                 ActionStatus status = ActionStatus.OK;
 266                                 if (list != null) {
 267
 268                                         // Group result by the right value - true or false.
 269                                         // I.e., get the number of data types which are new and
 270                                         // which are old.
 271                                         Map<Boolean, List<ImmutablePair<ElementTypeDefinition, Boolean>>> collect = list.stream().collect(Collectors.groupingBy(ImmutablePair<ElementTypeDefinition, Boolean>::getRight));
 272                                         if (collect != null) {
 273                                                 Set<Boolean> keySet = collect.keySet();
 274                                                 if (keySet.size() == 1) {
 275                                                         Boolean isNew = keySet.iterator().next();
 276                                                         if (isNew.booleanValue() == true) {
 277                                                                 // all data types created at the first time
 278                                                                 status = ActionStatus.CREATED;
 279                                                         } else {
 280                                                                 // All data types already exists
 281
 282                                                                 status = alreadyExistStatus;
 283                                                         }
 284                                                 }
 285                                         }
 286                                 }
 287                                 representation = RepresentationUtils.toRepresentation(eitherResult.left().value());
 288
 289                                 Response response = buildOkResponse(getComponentsUtils().getResponseFormat(status), representation);
 290                                 responseWrapper.setInnerElement(response);
 291
 292                         } catch (IOException e) {
 293                                 BeEcompErrorManager.getInstance().logBeRestApiGeneralError("Create " + elementTypeName);
 294                                 log.debug("failed to convert {} to json", elementTypeName, e);
 295                                 Response response = buildErrorResponse(getComponentsUtils().getResponseFormat(ActionStatus.GENERAL_ERROR));
 296                                 responseWrapper.setInnerElement(response);
 297                         }
 298                 }
 299         }
 300
 301         private <T> T initElementTypeImportManager(ServletContext context, Supplier<Class<T>> classGetter) {
 302                 WebAppContextWrapper webApplicationContextWrapper = (WebAppContextWrapper) context.getAttribute(Constants.WEB_APPLICATION_CONTEXT_WRAPPER_ATTR);
 303                 WebApplicationContext webApplicationContext = webApplicationContextWrapper.getWebAppContext(context);
 304                 T elementTypeImortManager = webApplicationContext.getBean(classGetter.get());
 305                 return elementTypeImortManager;
 306         }
 307
 308 }