Dont add to additional_types on import failure

[sdc.git] / catalog-be / src / main / java / org / openecomp / sdc / be / components / impl / GroupTypeImportManager.java

diff --git a/catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/GroupTypeImportManager.java b/catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/GroupTypeImportManager.java
index d3640a7..890647f 100644 (file)
--- a/catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/GroupTypeImportManager.java
+++ b/catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/GroupTypeImportManager.java
@@ -23,9 +23,13 @@ import fj.data.Either;
 import java.util.Collections;
 import java.util.List;
 import java.util.Map;
+import java.util.Optional;
 import java.util.stream.Collectors;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+import org.apache.commons.lang3.StringUtils;
 import org.apache.commons.lang3.tuple.ImmutablePair;
-import org.openecomp.sdc.be.components.impl.CommonImportManager.ElementTypeEnum;
 import org.openecomp.sdc.be.components.impl.model.ToscaTypeImportData;
 import org.openecomp.sdc.be.config.BeEcompErrorManager;
 import org.openecomp.sdc.be.dao.api.ActionStatus;
@@ -33,10 +37,14 @@ import org.openecomp.sdc.be.impl.ComponentsUtils;
 import org.openecomp.sdc.be.model.CapabilityDefinition;
 import org.openecomp.sdc.be.model.ComponentInstanceProperty;
 import org.openecomp.sdc.be.model.GroupTypeDefinition;
+import org.openecomp.sdc.be.model.Model;
 import org.openecomp.sdc.be.model.PropertyDefinition;
 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ToscaOperationFacade;
+import org.openecomp.sdc.be.model.normatives.ElementTypeEnum;
 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
 import org.openecomp.sdc.be.model.operations.impl.GroupTypeOperation;
+import org.openecomp.sdc.be.model.operations.impl.ModelOperation;
+import org.openecomp.sdc.be.model.operations.impl.UniqueIdBuilder;
 import org.openecomp.sdc.be.model.utils.TypeCompareUtils;
 import org.openecomp.sdc.be.utils.TypeUtils;
 import org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum;
@@ -52,28 +60,49 @@ public class GroupTypeImportManager {
     private final ComponentsUtils componentsUtils;
     private final ToscaOperationFacade toscaOperationFacade;
     private final CommonImportManager commonImportManager;
+    private final ModelOperation modelOperation;
 
     public GroupTypeImportManager(GroupTypeOperation groupTypeOperation, ComponentsUtils componentsUtils, ToscaOperationFacade toscaOperationFacade,
-                                  CommonImportManager commonImportManager) {
+                                  CommonImportManager commonImportManager, ModelOperation modelOperation) {
         this.groupTypeOperation = groupTypeOperation;
         this.componentsUtils = componentsUtils;
         this.toscaOperationFacade = toscaOperationFacade;
         this.commonImportManager = commonImportManager;
+        this.modelOperation = modelOperation;
     }
 
-    public Either<List<ImmutablePair<GroupTypeDefinition, Boolean>>, ResponseFormat> createGroupTypes(ToscaTypeImportData toscaTypeImportData) {
-        return commonImportManager.createElementTypes(toscaTypeImportData, this::createGroupTypesFromYml, this::upsertGroupTypesByDao);
+    public Either<List<ImmutablePair<GroupTypeDefinition, Boolean>>, ResponseFormat> createGroupTypes(ToscaTypeImportData toscaTypeImportData,
+                                                                                                      String modelName,
+                                                                                                      final boolean includeToModelDefaultImports) {
+        final Either<List<ImmutablePair<GroupTypeDefinition, Boolean>>, ResponseFormat> elementTypes = commonImportManager.createElementTypes(
+            toscaTypeImportData, this::createGroupTypesFromYml, this::upsertGroupTypesByDao, modelName);
+        if (elementTypes.isLeft() && includeToModelDefaultImports && StringUtils.isNotEmpty(modelName)) {
+            commonImportManager.addTypesToDefaultImports(ElementTypeEnum.GROUP_TYPE, toscaTypeImportData.getToscaTypesYml(), modelName);
+        }
+        return elementTypes;
     }
 
-    private Either<List<GroupTypeDefinition>, ActionStatus> createGroupTypesFromYml(String groupTypesYml) {
-        return commonImportManager.createElementTypesFromYml(groupTypesYml, this::createGroupType);
+    private Either<List<GroupTypeDefinition>, ActionStatus> createGroupTypesFromYml(String groupTypesYml, String modelName) {
+        Either<List<GroupTypeDefinition>, ActionStatus> groupTypes = commonImportManager.createElementTypesFromYml(groupTypesYml,
+            this::createGroupType);
+        if (groupTypes.isLeft() && StringUtils.isNotEmpty(modelName)) {
+            final Optional<Model> modelOptional = modelOperation.findModelByName(modelName);
+            if (modelOptional.isPresent()) {
+                groupTypes.left().value().forEach(groupType -> groupType.setModel(modelName));
+                return groupTypes;
+            }
+            return Either.right(ActionStatus.INVALID_MODEL);
+        }
+        return groupTypes;
     }
 
     private Either<List<ImmutablePair<GroupTypeDefinition, Boolean>>, ResponseFormat> upsertGroupTypesByDao(
-        List<GroupTypeDefinition> groupTypesToCreate) {
-        return commonImportManager.createElementTypesByDao(groupTypesToCreate, this::validateGroupType,
-            groupType -> new ImmutablePair<>(ElementTypeEnum.GROUP_TYPE, groupType.getType()), groupTypeOperation::getLatestGroupTypeByType,
-            groupTypeOperation::addGroupType, this::updateGroupType);
+        List<GroupTypeDefinition> groupTypesToCreate, String modelName) {
+        return commonImportManager.createElementTypesWithVersionByDao(groupTypesToCreate, this::validateGroupType,
+            groupType -> new ImmutablePair<>(ElementTypeEnum.GROUP_TYPE, UniqueIdBuilder.buildGroupTypeUid(groupType.getModel(),
+                groupType.getType(), groupType.getVersion())),
+            groupTypeOperation::getLatestGroupTypeByType,
+            groupTypeOperation::addGroupType, this::updateGroupType, modelName);
     }
 
     private Either<GroupTypeDefinition, StorageOperationStatus> updateGroupType(GroupTypeDefinition newGroupType, GroupTypeDefinition oldGroupType) {
@@ -90,28 +119,25 @@ public class GroupTypeImportManager {
     }
 
     private Either<ActionStatus, ResponseFormat> validateGroupType(GroupTypeDefinition groupType) {
-        Either<ActionStatus, ResponseFormat> result = Either.left(ActionStatus.OK);
         if (groupType.getMembers() != null) {
             if (groupType.getMembers().isEmpty()) {
-                ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.GROUP_MEMBER_EMPTY, groupType.getType());
-                result = Either.right(responseFormat);
+                return Either.right(componentsUtils.getResponseFormat(ActionStatus.GROUP_MEMBER_EMPTY, groupType.getType()));
             } else {
                 for (String member : groupType.getMembers()) {
                     // Verify that such Resource exist
                     Either<org.openecomp.sdc.be.model.Resource, StorageOperationStatus> eitherMemberExist = toscaOperationFacade
-                        .getLatestByToscaResourceName(member);
+                        .getLatestByToscaResourceName(member, groupType.getModel());
                     if (eitherMemberExist.isRight()) {
                         StorageOperationStatus operationStatus = eitherMemberExist.right().value();
                         log.debug("Error when fetching parent resource {}, error: {}", member, operationStatus);
                         ActionStatus convertFromStorageResponse = componentsUtils.convertFromStorageResponse(operationStatus);
                         BeEcompErrorManager.getInstance().logBeComponentMissingError("Import GroupType", "resource", member);
-                        result = Either.right(componentsUtils.getResponseFormat(convertFromStorageResponse, member));
-                        break;
+                        return Either.right(componentsUtils.getResponseFormat(convertFromStorageResponse, member));
                     }
                 }
             }
         }
-        return result;
+        return Either.left(ActionStatus.OK);
     }
 
     private GroupTypeDefinition createGroupType(String groupTypeName, Map<String, Object> toscaJson) {
@@ -126,8 +152,7 @@ public class GroupTypeImportManager {
             // Metadata
             commonImportManager.setField(toscaJson, TypeUtils.ToscaTagNamesEnum.METADATA.getElementName(), groupType::setMetadata);
             // Capabilities
-            Map<String, CapabilityDefinition> capabilities = createCapabilities(toscaJson);
-            groupType.setCapabilities(capabilities);
+            groupType.setCapabilities(createCapabilities(toscaJson));
             // Members
             commonImportManager.setField(toscaJson, TypeUtils.ToscaTagNamesEnum.MEMBERS.getElementName(), groupType::setMembers);
             groupType.setType(groupTypeName);
@@ -172,18 +197,13 @@ public class GroupTypeImportManager {
         return pl.stream().map(ComponentInstanceProperty::new).collect(Collectors.toList());
     }
 
+    @NoArgsConstructor
+    @Getter
+    @Setter
     private class CapabilityTypeToscaJsonHolder {
 
         private Map<String, Object> capabilityTypeToscaJson;
 
-        public Map<String, Object> getCapabilityTypeToscaJson() {
-            return capabilityTypeToscaJson;
-        }
-
-        public void setCapabilityTypeToscaJson(Map<String, Object> capabilityTypeToscaJson) {
-            this.capabilityTypeToscaJson = capabilityTypeToscaJson;
-        }
-
         public boolean isEmpty() {
             return capabilityTypeToscaJson == null;
         }