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