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