2 * ============LICENSE_START=======================================================
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
11 * http://www.apache.org/licenses/LICENSE-2.0
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=========================================================
20 package org.openecomp.sdc.be.servlets;
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;
34 import java.io.IOException;
35 import java.util.List;
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;
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")
92 public class TypesUploadServlet extends AbstractValidationsServlet {
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;
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;
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);
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);
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");
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");
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);
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);
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);
251 private Map<String, ToscaTypeMetadata> getTypesMetadata(String toscaTypesMetaData) {
252 return gson.fromJson(toscaTypesMetaData, new TypeToken<Map<String, ToscaTypeMetadata>>() {
256 private Response uploadElementTypeServletLogic(ConsumerTwoParam<Wrapper<Response>, String> createElementsMethod, File file,
257 final HttpServletRequest request, String creator, String elementTypeName) {
259 String userId = initHeaderParam(creator, request, Constants.USER_ID_HEADER);
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);
268 if (responseWrapper.isEmpty()) {
269 createElementsMethod.accept(responseWrapper, yamlStringWrapper.getInnerElement());
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));
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) {
283 final String userId = initHeaderParam(creator, request, Constants.USER_ID_HEADER);
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);
292 if (responseWrapper.isEmpty()) {
293 createElementsMethod.accept(responseWrapper, yamlStringWrapper.getInnerElement(), modelName, includeToModelDefaultImports);
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));
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());
312 if (responseWrapper.isEmpty()) {
313 validateDataNotNull(responseWrapper, file);
315 return responseWrapper;
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) {
322 String userId = initHeaderParam(creator, request, Constants.USER_ID_HEADER);
323 Wrapper<String> yamlStringWrapper = new Wrapper<>();
325 Wrapper<Response> responseWrapper = doUploadTypeValidations(request, userId, file);
326 if (responseWrapper.isEmpty()) {
327 fillZipContents(yamlStringWrapper, file);
329 if (responseWrapper.isEmpty()) {
330 ToscaTypeImportData toscaTypeImportData = new ToscaTypeImportData(yamlStringWrapper.getInnerElement(), typesMetaData);
331 createElementsMethod.accept(responseWrapper, toscaTypeImportData, modelName, includeToModelDefaultImports);
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));
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()));
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);
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());
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());
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());
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()));
394 final List<ImmutablePair<T, Boolean>> list = eitherResult.left().value();
395 ActionStatus status = ActionStatus.OK;
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;
409 // All data types already exists
410 status = alreadyExistStatus;
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)));
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());