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 package org.openecomp.sdc.be.servlets;
  21
  22 import com.google.gson.reflect.TypeToken;
  23 import com.jcabi.aspects.Loggable;
  24 import fj.data.Either;
  25 import io.swagger.v3.oas.annotations.Operation;
  26 import io.swagger.v3.oas.annotations.Parameter;
  27 import io.swagger.v3.oas.annotations.media.ArraySchema;
  28 import io.swagger.v3.oas.annotations.media.Content;
  29 import io.swagger.v3.oas.annotations.media.Schema;
  30 import io.swagger.v3.oas.annotations.responses.ApiResponse;
  31 import io.swagger.v3.oas.annotations.servers.Server;
  32 import io.swagger.v3.oas.annotations.tags.Tag;
  33 import java.io.File;
  34 import java.io.IOException;
  35 import java.util.List;
  36 import java.util.Map;
  37 import java.util.Set;
  38 import java.util.function.Supplier;
  39 import java.util.stream.Collectors;
  40 import javax.inject.Inject;
  41 import javax.servlet.http.HttpServletRequest;
  42 import javax.ws.rs.Consumes;
  43 import javax.ws.rs.HeaderParam;
  44 import javax.ws.rs.POST;
  45 import javax.ws.rs.Path;
  46 import javax.ws.rs.Produces;
  47 import javax.ws.rs.core.Context;
  48 import javax.ws.rs.core.MediaType;
  49 import javax.ws.rs.core.Response;
  50 import org.apache.commons.lang3.tuple.ImmutablePair;
  51 import org.glassfish.jersey.media.multipart.FormDataParam;
  52 import org.openecomp.sdc.be.components.impl.CapabilityTypeImportManager;
  53 import org.openecomp.sdc.be.components.impl.CategoriesImportManager;
  54 import org.openecomp.sdc.be.components.impl.ComponentInstanceBusinessLogic;
  55 import org.openecomp.sdc.be.components.impl.DataTypeImportManager;
  56 import org.openecomp.sdc.be.components.impl.GroupTypeImportManager;
  57 import org.openecomp.sdc.be.components.impl.InterfaceLifecycleTypeImportManager;
  58 import org.openecomp.sdc.be.components.impl.PolicyTypeImportManager;
  59 import org.openecomp.sdc.be.components.impl.RelationshipTypeImportManager;
  60 import org.openecomp.sdc.be.components.impl.ResourceImportManager;
  61 import org.openecomp.sdc.be.components.impl.aaf.AafPermission;
  62 import org.openecomp.sdc.be.components.impl.aaf.PermissionAllowed;
  63 import org.openecomp.sdc.be.components.impl.model.ToscaTypeImportData;
  64 import org.openecomp.sdc.be.config.BeEcompErrorManager;
  65 import org.openecomp.sdc.be.dao.api.ActionStatus;
  66 import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
  67 import org.openecomp.sdc.be.datatypes.tosca.ToscaDataDefinition;
  68 import org.openecomp.sdc.be.impl.ComponentsUtils;
  69 import org.openecomp.sdc.be.impl.ServletUtils;
  70 import org.openecomp.sdc.be.model.DataTypeDefinition;
  71 import org.openecomp.sdc.be.model.GroupTypeDefinition;
  72 import org.openecomp.sdc.be.model.PolicyTypeDefinition;
  73 import org.openecomp.sdc.be.model.RelationshipTypeDefinition;
  74 import org.openecomp.sdc.be.model.User;
  75 import org.openecomp.sdc.be.model.normatives.ToscaTypeMetadata;
  76 import org.openecomp.sdc.be.user.UserBusinessLogic;
  77 import org.openecomp.sdc.common.api.Constants;
  78 import org.openecomp.sdc.common.datastructure.FunctionalInterfaces.ConsumerFourParam;
  79 import org.openecomp.sdc.common.datastructure.FunctionalInterfaces.ConsumerTwoParam;
  80 import org.openecomp.sdc.common.datastructure.Wrapper;
  81 import org.openecomp.sdc.common.log.wrappers.Logger;
  82 import org.openecomp.sdc.exception.ResponseFormat;
  83 import org.springframework.stereotype.Controller;
  84
  85 @Loggable(prepend = true, value = Loggable.DEBUG, trim = false)
  86 @Path("/v1/catalog/uploadType")
  87 @Consumes(MediaType.MULTIPART_FORM_DATA)
  88 @Produces(MediaType.APPLICATION_JSON)
  89 @Tag(name = "SDCE-2 APIs")
  90 @Server(url = "/sdc2/rest")
  91 @Controller
  92 public class TypesUploadServlet extends AbstractValidationsServlet {
  93
  94     private static final String CREATE = "Create ";
  95     private static final String START_HANDLE_REQUEST_OF = "Start handle request of {}";
  96     private static final String CREATE_FAILED_WITH_EXCEPTION = "create {} failed with exception:";
  97     private static final Logger log = Logger.getLogger(TypesUploadServlet.class);
  98     private final CapabilityTypeImportManager capabilityTypeImportManager;
  99     private final InterfaceLifecycleTypeImportManager interfaceLifecycleTypeImportManager;
 100     private final CategoriesImportManager categoriesImportManager;
 101     private final DataTypeImportManager dataTypeImportManager;
 102     private final GroupTypeImportManager groupTypeImportManager;
 103     private final PolicyTypeImportManager policyTypeImportManager;
 104     private final RelationshipTypeImportManager relationshipTypeImportManager;
 105
 106     @Inject
 107     public TypesUploadServlet(UserBusinessLogic userBusinessLogic, ComponentInstanceBusinessLogic componentInstanceBL,
 108                               ComponentsUtils componentsUtils, ServletUtils servletUtils, ResourceImportManager resourceImportManager,
 109                               CapabilityTypeImportManager capabilityTypeImportManager,
 110                               InterfaceLifecycleTypeImportManager interfaceLifecycleTypeImportManager,
 111                               CategoriesImportManager categoriesImportManager, DataTypeImportManager dataTypeImportManager,
 112                               GroupTypeImportManager groupTypeImportManager, PolicyTypeImportManager policyTypeImportManager,
 113                               RelationshipTypeImportManager relationshipTypeImportManager) {
 114         super(userBusinessLogic, componentInstanceBL, componentsUtils, servletUtils, resourceImportManager);
 115         this.capabilityTypeImportManager = capabilityTypeImportManager;
 116         this.interfaceLifecycleTypeImportManager = interfaceLifecycleTypeImportManager;
 117         this.categoriesImportManager = categoriesImportManager;
 118         this.dataTypeImportManager = dataTypeImportManager;
 119         this.groupTypeImportManager = groupTypeImportManager;
 120         this.policyTypeImportManager = policyTypeImportManager;
 121         this.relationshipTypeImportManager = relationshipTypeImportManager;
 122     }
 123
 124     @POST
 125     @Path("/capability")
 126     @Operation(description = "Create Capability Type from yaml", method = "POST", summary = "Returns created Capability Type", responses = {
 127         @ApiResponse(content = @Content(array = @ArraySchema(schema = @Schema(implementation = Response.class)))),
 128         @ApiResponse(responseCode = "201", description = "Capability Type created"),
 129         @ApiResponse(responseCode = "403", description = "Restricted operation"),
 130         @ApiResponse(responseCode = "400", description = "Invalid content / Missing content"),
 131         @ApiResponse(responseCode = "409", description = "Capability Type already exist")})
 132     @PermissionAllowed(AafPermission.PermNames.INTERNAL_ALL_VALUE)
 133     public Response uploadCapabilityType(@Parameter(description = "FileInputStream") @FormDataParam("capabilityTypeZip") File file,
 134                                          @Context final HttpServletRequest request, @HeaderParam("USER_ID") String creator,
 135                                          @Parameter(description = "model") @FormDataParam("model") String modelName,
 136                                          @Parameter(description = "includeToModelImport") @FormDataParam("includeToModelImport") boolean includeToModelDefaultImports) {
 137         ConsumerFourParam<Wrapper<Response>, String, String, Boolean> createElementsMethod = (responseWrapper, ymlPayload, model, includeToModelImport) ->
 138             createElementsType(responseWrapper, () -> capabilityTypeImportManager.createCapabilityTypes(ymlPayload, modelName,
 139                 includeToModelDefaultImports));
 140         return uploadElementTypeServletLogic(createElementsMethod, file, request, creator, NodeTypeEnum.CapabilityType.name(), modelName,
 141             includeToModelDefaultImports);
 142     }
 143
 144     @POST
 145     @Path("/relationship")
 146     @Operation(description = "Create Relationship Type from yaml", method = "POST", summary = "Returns created Relationship Type", responses = {
 147         @ApiResponse(content = @Content(array = @ArraySchema(schema = @Schema(implementation = Response.class)))),
 148         @ApiResponse(responseCode = "201", description = "Relationship Type created"),
 149         @ApiResponse(responseCode = "403", description = "Restricted operation"),
 150         @ApiResponse(responseCode = "400", description = "Invalid content / Missing content"),
 151         @ApiResponse(responseCode = "409", description = "Relationship Type already exist")})
 152     @PermissionAllowed(AafPermission.PermNames.INTERNAL_ALL_VALUE)
 153     public Response uploadRelationshipType(@Parameter(description = "FileInputStream") @FormDataParam("relationshipTypeZip") File file,
 154                                            @Context final HttpServletRequest request, @HeaderParam("USER_ID") String creator,
 155                                            @Parameter(description = "model") @FormDataParam("model") String modelName,
 156                                            @Parameter(description = "includeToModelImport") @FormDataParam("includeToModelImport") boolean includeToModelDefaultImports) {
 157         return uploadElementTypeServletLogic(
 158             this::createRelationshipTypes, file, request, creator, NodeTypeEnum.RelationshipType.getName(), modelName, includeToModelDefaultImports);
 159     }
 160
 161     @POST
 162     @Path("/interfaceLifecycle")
 163     @Operation(description = "Create Interface Lyfecycle Type from yaml", method = "POST", summary = "Returns created Interface Lifecycle Type", responses = {
 164         @ApiResponse(content = @Content(array = @ArraySchema(schema = @Schema(implementation = Response.class)))),
 165         @ApiResponse(responseCode = "201", description = "Interface Lifecycle Type created"),
 166         @ApiResponse(responseCode = "403", description = "Restricted operation"),
 167         @ApiResponse(responseCode = "400", description = "Invalid content / Missing content"),
 168         @ApiResponse(responseCode = "409", description = "Interface Lifecycle Type already exist")})
 169     @PermissionAllowed(AafPermission.PermNames.INTERNAL_ALL_VALUE)
 170     public Response uploadInterfaceLifecycleType(@Parameter(description = "FileInputStream") @FormDataParam("interfaceLifecycleTypeZip") File file,
 171                                                  @Context final HttpServletRequest request, @HeaderParam("USER_ID") String creator,
 172                                                  @Parameter(description = "model") @FormDataParam("model") String modelName,
 173                                                  @Parameter(description = "includeToModelImport") @FormDataParam("includeToModelImport") boolean includeToModelDefaultImports) {
 174         ConsumerTwoParam<Wrapper<Response>, String> createElementsMethod = (responseWrapper, ymlPayload) ->
 175             createElementsType(responseWrapper, () -> interfaceLifecycleTypeImportManager.createLifecycleTypes(ymlPayload, modelName,
 176                 includeToModelDefaultImports));
 177         return uploadElementTypeServletLogic(createElementsMethod, file, request, creator, "Interface Types");
 178     }
 179
 180     @POST
 181     @Path("/categories")
 182     @Operation(description = "Create Categories from yaml", method = "POST", summary = "Returns created categories", responses = {
 183         @ApiResponse(content = @Content(array = @ArraySchema(schema = @Schema(implementation = Response.class)))),
 184         @ApiResponse(responseCode = "201", description = "Categories created"),
 185         @ApiResponse(responseCode = "403", description = "Restricted operation"),
 186         @ApiResponse(responseCode = "400", description = "Invalid content / Missing content"),
 187         @ApiResponse(responseCode = "409", description = "Category already exist")})
 188     @PermissionAllowed(AafPermission.PermNames.INTERNAL_ALL_VALUE)
 189     public Response uploadCategories(@Parameter(description = "FileInputStream") @FormDataParam("categoriesZip") File file,
 190                                      @Context final HttpServletRequest request, @HeaderParam("USER_ID") String creator) {
 191         ConsumerTwoParam<Wrapper<Response>, String> createElementsMethod = (responseWrapper, ymlPayload) ->
 192             createElementsType(responseWrapper, () -> categoriesImportManager.createCategories(ymlPayload));
 193         return uploadElementTypeServletLogic(createElementsMethod, file, request, creator, "categories");
 194     }
 195
 196     @POST
 197     @Path("/datatypes")
 198     @Operation(description = "Create Categories from yaml", method = "POST", summary = "Returns created data types", responses = {
 199         @ApiResponse(content = @Content(array = @ArraySchema(schema = @Schema(implementation = Response.class)))),
 200         @ApiResponse(responseCode = "201", description = "Data types created"),
 201         @ApiResponse(responseCode = "403", description = "Restricted operation"),
 202         @ApiResponse(responseCode = "400", description = "Invalid content / Missing content"),
 203         @ApiResponse(responseCode = "409", description = "Data types already exist")})
 204     @PermissionAllowed(AafPermission.PermNames.INTERNAL_ALL_VALUE)
 205     public Response uploadDataTypes(@Parameter(description = "FileInputStream") @FormDataParam("dataTypesZip") File file,
 206                                     @Context final HttpServletRequest request, @HeaderParam("USER_ID") String creator,
 207                                     @Parameter(description = "model") @FormDataParam("model") String modelName,
 208                                     @Parameter(description = "includeToModelImport") @FormDataParam("includeToModelImport") boolean includeToModelDefaultImports) {
 209         return uploadElementTypeServletLogic(this::createDataTypes, file, request, creator, NodeTypeEnum.DataType.getName(), modelName,
 210             includeToModelDefaultImports);
 211     }
 212
 213     @POST
 214     @Path("/grouptypes")
 215     @Operation(description = "Create GroupTypes from yaml", method = "POST", summary = "Returns created group types", responses = {
 216         @ApiResponse(content = @Content(array = @ArraySchema(schema = @Schema(implementation = Response.class)))),
 217         @ApiResponse(responseCode = "201", description = "group types created"),
 218         @ApiResponse(responseCode = "403", description = "Restricted operation"),
 219         @ApiResponse(responseCode = "400", description = "Invalid content / Missing content"),
 220         @ApiResponse(responseCode = "409", description = "group types already exist")})
 221     @PermissionAllowed(AafPermission.PermNames.INTERNAL_ALL_VALUE)
 222     public Response uploadGroupTypes(@Parameter(description = "toscaTypeMetadata") @FormDataParam("toscaTypeMetadata") String toscaTypesMetaData,
 223                                      @Parameter(description = "model") @FormDataParam("model") String modelName,
 224                                      @Parameter(description = "FileInputStream") @FormDataParam("groupTypesZip") File file,
 225                                      @Context final HttpServletRequest request, @HeaderParam("USER_ID") String creator,
 226                                      @Parameter(description = "includeToModelImport") @FormDataParam("includeToModelImport") boolean includeToModelDefaultImports) {
 227         Map<String, ToscaTypeMetadata> typesMetadata = getTypesMetadata(toscaTypesMetaData);
 228         return uploadTypesWithMetaData(this::createGroupTypes, typesMetadata, file, request, creator, NodeTypeEnum.GroupType.getName(), modelName,
 229             includeToModelDefaultImports);
 230     }
 231
 232     @POST
 233     @Path("/policytypes")
 234     @Operation(description = "Create PolicyTypes from yaml", method = "POST", summary = "Returns created policy types", responses = {
 235         @ApiResponse(content = @Content(array = @ArraySchema(schema = @Schema(implementation = Response.class)))),
 236         @ApiResponse(responseCode = "201", description = "policy types created"),
 237         @ApiResponse(responseCode = "403", description = "Restricted operation"),
 238         @ApiResponse(responseCode = "400", description = "Invalid content / Missing content"),
 239         @ApiResponse(responseCode = "409", description = "policy types already exist")})
 240     @PermissionAllowed(AafPermission.PermNames.INTERNAL_ALL_VALUE)
 241     public Response uploadPolicyTypes(@Parameter(description = "toscaTypeMetadata") @FormDataParam("toscaTypeMetadata") String toscaTypesMetaData,
 242                                       @Parameter(description = "model") @FormDataParam("model") String modelName,
 243                                       @Parameter(description = "FileInputStream") @FormDataParam("policyTypesZip") File file,
 244                                       @Context final HttpServletRequest request, @HeaderParam("USER_ID") String creator,
 245                                       @Parameter(description = "includeToModelImport") @FormDataParam("includeToModelImport") boolean includeToModelDefaultImports) {
 246         Map<String, ToscaTypeMetadata> typesMetadata = getTypesMetadata(toscaTypesMetaData);
 247         return uploadTypesWithMetaData(this::createPolicyTypes, typesMetadata, file, request, creator, NodeTypeEnum.PolicyType.getName(), modelName,
 248             includeToModelDefaultImports);
 249     }
 250
 251     private Map<String, ToscaTypeMetadata> getTypesMetadata(String toscaTypesMetaData) {
 252         return gson.fromJson(toscaTypesMetaData, new TypeToken<Map<String, ToscaTypeMetadata>>() {
 253         }.getType());
 254     }
 255
 256     private Response uploadElementTypeServletLogic(ConsumerTwoParam<Wrapper<Response>, String> createElementsMethod, File file,
 257                                                    final HttpServletRequest request, String creator, String elementTypeName) {
 258         init();
 259         String userId = initHeaderParam(creator, request, Constants.USER_ID_HEADER);
 260         try {
 261             Wrapper<String> yamlStringWrapper = new Wrapper<>();
 262             String url = request.getMethod() + " " + request.getRequestURI();
 263             log.debug(START_HANDLE_REQUEST_OF, url);
 264             Wrapper<Response> responseWrapper = doUploadTypeValidations(request, userId, file);
 265             if (responseWrapper.isEmpty()) {
 266                 fillZipContents(yamlStringWrapper, file);
 267             }
 268             if (responseWrapper.isEmpty()) {
 269                 createElementsMethod.accept(responseWrapper, yamlStringWrapper.getInnerElement());
 270             }
 271             return responseWrapper.getInnerElement();
 272         } catch (Exception e) {
 273             log.debug(CREATE_FAILED_WITH_EXCEPTION, elementTypeName, e);
 274             BeEcompErrorManager.getInstance().logBeRestApiGeneralError(CREATE + elementTypeName);
 275             return buildErrorResponse(getComponentsUtils().getResponseFormat(ActionStatus.GENERAL_ERROR));
 276         }
 277     }
 278
 279     private Response uploadElementTypeServletLogic(final ConsumerFourParam<Wrapper<Response>, String, String, Boolean> createElementsMethod,
 280                                                    final File file, final HttpServletRequest request, final String creator,
 281                                                    final String elementTypeName, final String modelName, final boolean includeToModelDefaultImports) {
 282         init();
 283         final String userId = initHeaderParam(creator, request, Constants.USER_ID_HEADER);
 284         try {
 285             final Wrapper<String> yamlStringWrapper = new Wrapper<>();
 286             final String url = request.getMethod() + " " + request.getRequestURI();
 287             log.debug(START_HANDLE_REQUEST_OF, url);
 288             final Wrapper<Response> responseWrapper = doUploadTypeValidations(request, userId, file);
 289             if (responseWrapper.isEmpty()) {
 290                 fillZipContents(yamlStringWrapper, file);
 291             }
 292             if (responseWrapper.isEmpty()) {
 293                 createElementsMethod.accept(responseWrapper, yamlStringWrapper.getInnerElement(), modelName, includeToModelDefaultImports);
 294             }
 295             return responseWrapper.getInnerElement();
 296         } catch (final Exception e) {
 297             log.debug(CREATE_FAILED_WITH_EXCEPTION, elementTypeName, e);
 298             BeEcompErrorManager.getInstance().logBeRestApiGeneralError(CREATE + elementTypeName);
 299             return buildErrorResponse(getComponentsUtils().getResponseFormat(ActionStatus.GENERAL_ERROR));
 300         }
 301     }
 302
 303     private Wrapper<Response> doUploadTypeValidations(final HttpServletRequest request, String userId, File file) {
 304         Wrapper<Response> responseWrapper = new Wrapper<>();
 305         Wrapper<User> userWrapper = new Wrapper<>();
 306         String url = request.getMethod() + " " + request.getRequestURI();
 307         log.debug(START_HANDLE_REQUEST_OF, url);
 308         validateUserExist(responseWrapper, userWrapper, userId);
 309         if (responseWrapper.isEmpty()) {
 310             validateUserRole(responseWrapper, userWrapper.getInnerElement());
 311         }
 312         if (responseWrapper.isEmpty()) {
 313             validateDataNotNull(responseWrapper, file);
 314         }
 315         return responseWrapper;
 316     }
 317
 318     private Response uploadTypesWithMetaData(ConsumerFourParam<Wrapper<Response>, ToscaTypeImportData, String, Boolean> createElementsMethod,
 319                                              Map<String, ToscaTypeMetadata> typesMetaData, File file, final HttpServletRequest request,
 320                                              String creator, String elementTypeName, String modelName, final boolean includeToModelDefaultImports) {
 321         init();
 322         String userId = initHeaderParam(creator, request, Constants.USER_ID_HEADER);
 323         Wrapper<String> yamlStringWrapper = new Wrapper<>();
 324         try {
 325             Wrapper<Response> responseWrapper = doUploadTypeValidations(request, userId, file);
 326             if (responseWrapper.isEmpty()) {
 327                 fillZipContents(yamlStringWrapper, file);
 328             }
 329             if (responseWrapper.isEmpty()) {
 330                 ToscaTypeImportData toscaTypeImportData = new ToscaTypeImportData(yamlStringWrapper.getInnerElement(), typesMetaData);
 331                 createElementsMethod.accept(responseWrapper, toscaTypeImportData, modelName, includeToModelDefaultImports);
 332             }
 333             return responseWrapper.getInnerElement();
 334         } catch (Exception e) {
 335             log.debug(CREATE_FAILED_WITH_EXCEPTION, elementTypeName, e);
 336             BeEcompErrorManager.getInstance().logBeRestApiGeneralError(CREATE + elementTypeName);
 337             return buildErrorResponse(getComponentsUtils().getResponseFormat(ActionStatus.GENERAL_ERROR));
 338         }
 339     }
 340
 341     private <T> void createElementsType(Wrapper<Response> responseWrapper, Supplier<Either<T, ResponseFormat>> elementsCreater) {
 342         Either<T, ResponseFormat> eitherResult = elementsCreater.get();
 343         if (eitherResult.isRight()) {
 344             responseWrapper.setInnerElement(buildErrorResponse(eitherResult.right().value()));
 345         } else {
 346             try {
 347                 Response response = buildOkResponse(getComponentsUtils().getResponseFormat(ActionStatus.CREATED),
 348                     RepresentationUtils.toRepresentation(eitherResult.left().value()));
 349                 responseWrapper.setInnerElement(response);
 350             } catch (Exception e) {
 351                 responseWrapper.setInnerElement(buildErrorResponse(getComponentsUtils().getResponseFormat(ActionStatus.GENERAL_ERROR)));
 352                 log.error("#createElementsType - json serialization failed with error: ", e);
 353             }
 354         }
 355     }
 356
 357     // data types
 358     private void createDataTypes(Wrapper<Response> responseWrapper, String dataTypesYml, final String modelName,
 359                                  final boolean includeToModelDefaultImports) {
 360         final Supplier<Either<List<ImmutablePair<DataTypeDefinition, Boolean>>, ResponseFormat>> generateElementTypeFromYml = () ->
 361             dataTypeImportManager.createDataTypes(dataTypesYml, modelName, includeToModelDefaultImports);
 362         buildStatusForElementTypeCreate(responseWrapper, generateElementTypeFromYml, ActionStatus.DATA_TYPE_ALREADY_EXIST,
 363             NodeTypeEnum.DataType.name());
 364     }
 365
 366     // group types
 367     private void createGroupTypes(Wrapper<Response> responseWrapper, ToscaTypeImportData toscaTypeImportData, String modelName,
 368                                   final boolean includeToModelDefaultImports) {
 369         final Supplier<Either<List<ImmutablePair<GroupTypeDefinition, Boolean>>, ResponseFormat>> generateElementTypeFromYml = () ->
 370             groupTypeImportManager.createGroupTypes(toscaTypeImportData, modelName, includeToModelDefaultImports);
 371         buildStatusForElementTypeCreate(responseWrapper, generateElementTypeFromYml, ActionStatus.GROUP_TYPE_ALREADY_EXIST,
 372             NodeTypeEnum.GroupType.name());
 373     }
 374
 375     // policy types
 376     private void createPolicyTypes(Wrapper<Response> responseWrapper, ToscaTypeImportData toscaTypeImportData, String modelName,
 377                                    final boolean includeToModelDefaultImports) {
 378         final Supplier<Either<List<ImmutablePair<PolicyTypeDefinition, Boolean>>, ResponseFormat>> generateElementTypeFromYml = () ->
 379             policyTypeImportManager.createPolicyTypes(toscaTypeImportData, modelName, includeToModelDefaultImports);
 380         buildStatusForElementTypeCreate(responseWrapper, generateElementTypeFromYml, ActionStatus.POLICY_TYPE_ALREADY_EXIST,
 381             NodeTypeEnum.PolicyType.name());
 382     }
 383
 384     // data types
 385     private <T extends ToscaDataDefinition> void buildStatusForElementTypeCreate(Wrapper<Response> responseWrapper,
 386                                                                                  Supplier<Either<List<ImmutablePair<T, Boolean>>, ResponseFormat>> generateElementTypeFromYml,
 387                                                                                  ActionStatus alreadyExistStatus, String elementTypeName) {
 388         Either<List<ImmutablePair<T, Boolean>>, ResponseFormat> eitherResult = generateElementTypeFromYml.get();
 389         if (eitherResult.isRight()) {
 390             responseWrapper.setInnerElement(buildErrorResponse(eitherResult.right().value()));
 391         } else {
 392
 393             try {
 394                 final List<ImmutablePair<T, Boolean>> list = eitherResult.left().value();
 395                 ActionStatus status = ActionStatus.OK;
 396                 if (list != null) {
 397                     // Group result by the right value - true or false.
 398                     // I.e., get the number of data types which are new and which are old.
 399                     final Map<Boolean, List<ImmutablePair<T, Boolean>>> collect =
 400                         list.stream().collect(Collectors.groupingBy(ImmutablePair<T, Boolean>::getRight));
 401                     if (collect != null) {
 402                         Set<Boolean> keySet = collect.keySet();
 403                         if (keySet.size() == 1) {
 404                             Boolean isNew = keySet.iterator().next();
 405                             if (Boolean.TRUE.equals(isNew)) {
 406                                 // all data types created at the first time
 407                                 status = ActionStatus.CREATED;
 408                             } else {
 409                                 // All data types already exists
 410                                 status = alreadyExistStatus;
 411                             }
 412                         }
 413                     }
 414                 }
 415                 final Object representation = RepresentationUtils.toRepresentation(eitherResult.left().value());
 416                 responseWrapper.setInnerElement(buildOkResponse(getComponentsUtils().getResponseFormat(status), representation));
 417             } catch (IOException e) {
 418                 BeEcompErrorManager.getInstance().logBeRestApiGeneralError(CREATE + elementTypeName);
 419                 log.debug("failed to convert {} to json", elementTypeName, e);
 420                 responseWrapper.setInnerElement(buildErrorResponse(getComponentsUtils().getResponseFormat(ActionStatus.GENERAL_ERROR)));
 421             }
 422         }
 423     }
 424
 425     // relationship types
 426     private void createRelationshipTypes(final Wrapper<Response> responseWrapper,
 427                                          final String relationshipTypesYml,
 428                                          final String modelName,
 429                                          final boolean includeToModelDefaultImports) {
 430         final Supplier<Either<List<ImmutablePair<RelationshipTypeDefinition, Boolean>>, ResponseFormat>> generateElementTypeFromYml = () -> relationshipTypeImportManager
 431             .createRelationshipTypes(relationshipTypesYml, modelName, includeToModelDefaultImports);
 432         buildStatusForElementTypeCreate(responseWrapper, generateElementTypeFromYml, ActionStatus.RELATIONSHIP_TYPE_ALREADY_EXIST,
 433             NodeTypeEnum.RelationshipType.name());
 434     }
 435 }