catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/ResourceImportManager.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  * Modifications copyright (c) 2019 Nokia
  20  * ================================================================================
  21  */
  22 package org.openecomp.sdc.be.components.impl;
  23
  24 import static org.openecomp.sdc.be.model.jsonjanusgraph.operations.ToscaElementOperation.createDataType;
  25 import static org.openecomp.sdc.be.model.jsonjanusgraph.operations.ToscaElementOperation.createDataTypeDefinitionWithName;
  26
  27 import fj.data.Either;
  28 import java.util.ArrayList;
  29 import java.util.Arrays;
  30 import java.util.Collections;
  31 import java.util.Comparator;
  32 import java.util.EnumMap;
  33 import java.util.HashMap;
  34 import java.util.HashSet;
  35 import java.util.Iterator;
  36 import java.util.List;
  37 import java.util.Map;
  38 import java.util.Map.Entry;
  39 import java.util.Optional;
  40 import java.util.Set;
  41 import java.util.function.Function;
  42 import java.util.regex.Pattern;
  43 import java.util.stream.Collectors;
  44 import javax.servlet.ServletContext;
  45 import org.apache.commons.codec.binary.Base64;
  46 import org.apache.commons.collections4.CollectionUtils;
  47 import org.apache.commons.collections4.MapUtils;
  48 import org.apache.commons.lang3.StringUtils;
  49 import org.apache.commons.lang3.tuple.ImmutablePair;
  50 import org.openecomp.sdc.be.auditing.api.AuditEventFactory;
  51 import org.openecomp.sdc.be.auditing.impl.AuditingManager;
  52 import org.openecomp.sdc.be.auditing.impl.resourceadmin.AuditImportResourceAdminEventFactory;
  53 import org.openecomp.sdc.be.components.csar.CsarInfo;
  54 import org.openecomp.sdc.be.components.impl.ArtifactsBusinessLogic.ArtifactOperationEnum;
  55 import org.openecomp.sdc.be.components.impl.ImportUtils.Constants;
  56 import org.openecomp.sdc.be.components.impl.ImportUtils.ResultStatusEnum;
  57 import org.openecomp.sdc.be.components.impl.ImportUtils.ToscaElementTypeEnum;
  58 import org.openecomp.sdc.be.components.impl.exceptions.ByActionStatusComponentException;
  59 import org.openecomp.sdc.be.components.impl.exceptions.ComponentException;
  60 import org.openecomp.sdc.be.components.lifecycle.LifecycleChangeInfoWithAction;
  61 import org.openecomp.sdc.be.config.BeEcompErrorManager;
  62 import org.openecomp.sdc.be.config.BeEcompErrorManager.ErrorSeverity;
  63 import org.openecomp.sdc.be.dao.api.ActionStatus;
  64 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphDao;
  65 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus;
  66 import org.openecomp.sdc.be.dao.jsongraph.GraphVertex;
  67 import org.openecomp.sdc.be.dao.jsongraph.types.JsonParseFlagEnum;
  68 import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum;
  69 import org.openecomp.sdc.be.datatypes.elements.OperationDataDefinition;
  70 import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition;
  71 import org.openecomp.sdc.be.datatypes.elements.SchemaDefinition;
  72 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
  73 import org.openecomp.sdc.be.datatypes.enums.GraphPropertyEnum;
  74 import org.openecomp.sdc.be.datatypes.enums.JsonPresentationFields;
  75 import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
  76 import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum;
  77 import org.openecomp.sdc.be.impl.ComponentsUtils;
  78 import org.openecomp.sdc.be.impl.WebAppContextWrapper;
  79 import org.openecomp.sdc.be.model.ArtifactDefinition;
  80 import org.openecomp.sdc.be.model.AttributeDefinition;
  81 import org.openecomp.sdc.be.model.CapabilityDefinition;
  82 import org.openecomp.sdc.be.model.ComponentInstanceProperty;
  83 import org.openecomp.sdc.be.model.DataTypeDefinition;
  84 import org.openecomp.sdc.be.model.DefaultUploadResourceInfo;
  85 import org.openecomp.sdc.be.model.InterfaceDefinition;
  86 import org.openecomp.sdc.be.model.LifecycleStateEnum;
  87 import org.openecomp.sdc.be.model.NodeTypesMetadataList;
  88 import org.openecomp.sdc.be.model.PropertyDefinition;
  89 import org.openecomp.sdc.be.model.RequirementDefinition;
  90 import org.openecomp.sdc.be.model.Resource;
  91 import org.openecomp.sdc.be.model.UploadComponentInstanceInfo;
  92 import org.openecomp.sdc.be.model.UploadInterfaceInfo;
  93 import org.openecomp.sdc.be.model.UploadResourceInfo;
  94 import org.openecomp.sdc.be.model.User;
  95 import org.openecomp.sdc.be.model.category.CategoryDefinition;
  96 import org.openecomp.sdc.be.model.category.SubCategoryDefinition;
  97 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ToscaOperationFacade;
  98 import org.openecomp.sdc.be.model.jsonjanusgraph.utils.ModelConverter;
  99 import org.openecomp.sdc.be.model.mapper.NodeTypeMetadataMapper;
 100 import org.openecomp.sdc.be.model.operations.api.IGraphLockOperation;
 101 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
 102 import org.openecomp.sdc.be.model.operations.impl.CapabilityTypeOperation;
 103 import org.openecomp.sdc.be.resources.data.auditing.AuditingActionEnum;
 104 import org.openecomp.sdc.be.resources.data.auditing.model.CommonAuditData;
 105 import org.openecomp.sdc.be.resources.data.auditing.model.ResourceCommonInfo;
 106 import org.openecomp.sdc.be.resources.data.auditing.model.ResourceVersionInfo;
 107 import org.openecomp.sdc.be.utils.TypeUtils;
 108 import org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum;
 109 import org.openecomp.sdc.common.log.enums.EcompLoggerErrorCode;
 110 import org.openecomp.sdc.common.log.wrappers.Logger;
 111 import org.openecomp.sdc.common.util.ThreadLocalsHolder;
 112 import org.openecomp.sdc.common.util.ValidationUtils;
 113 import org.openecomp.sdc.exception.ResponseFormat;
 114 import org.springframework.beans.factory.annotation.Autowired;
 115 import org.springframework.web.context.WebApplicationContext;
 116 import org.yaml.snakeyaml.Yaml;
 117
 118 @org.springframework.stereotype.Component("resourceImportManager")
 119 public class ResourceImportManager {
 120
 121     static final Pattern PROPERTY_NAME_PATTERN_IGNORE_LENGTH = Pattern.compile("['\\w\\s\\-\\.\\:]+");
 122     private static final Logger log = Logger.getLogger(ResourceImportManager.class);
 123     private final InterfaceDefinitionHandler interfaceDefinitionHandler;
 124     private final ComponentsUtils componentsUtils;
 125     private final CapabilityTypeOperation capabilityTypeOperation;
 126     private final JanusGraphDao janusGraphDao;
 127     private ServletContext servletContext;
 128     private AuditingManager auditingManager;
 129     private ResourceBusinessLogic resourceBusinessLogic;
 130     @Autowired
 131     private ServiceBusinessLogic serviceBusinessLogic;
 132     private IGraphLockOperation graphLockOperation;
 133     private ToscaOperationFacade toscaOperationFacade;
 134     private ResponseFormatManager responseFormatManager;
 135
 136     @Autowired
 137     public ResourceImportManager(final ComponentsUtils componentsUtils, final CapabilityTypeOperation capabilityTypeOperation,
 138                                  final InterfaceDefinitionHandler interfaceDefinitionHandler, final JanusGraphDao janusGraphDao) {
 139         this.componentsUtils = componentsUtils;
 140         this.capabilityTypeOperation = capabilityTypeOperation;
 141         this.interfaceDefinitionHandler = interfaceDefinitionHandler;
 142         this.janusGraphDao = janusGraphDao;
 143     }
 144
 145     public ServiceBusinessLogic getServiceBusinessLogic() {
 146         return serviceBusinessLogic;
 147     }
 148
 149     public void setServiceBusinessLogic(ServiceBusinessLogic serviceBusinessLogic) {
 150         this.serviceBusinessLogic = serviceBusinessLogic;
 151     }
 152
 153     @Autowired
 154     public void setToscaOperationFacade(ToscaOperationFacade toscaOperationFacade) {
 155         this.toscaOperationFacade = toscaOperationFacade;
 156     }
 157
 158     public ImmutablePair<Resource, ActionStatus> importNormativeResource(final String resourceYml, final UploadResourceInfo resourceMetaData,
 159                                                                          final Map<String, UploadComponentInstanceInfo> instancesFromCsar,
 160                                                                          final User creator, final boolean createNewVersion, final boolean needLock,
 161                                                                          final boolean isInTransaction) {
 162         LifecycleChangeInfoWithAction lifecycleChangeInfo = new LifecycleChangeInfoWithAction();
 163         lifecycleChangeInfo.setUserRemarks("certification on import");
 164         Function<Resource, Boolean> validator = resource -> resourceBusinessLogic.validatePropertiesDefaultValues(resource);
 165         return importCertifiedResource(resourceYml, resourceMetaData, creator, validator, lifecycleChangeInfo, isInTransaction, createNewVersion,
 166             needLock, null, null, false, null, null, false, instancesFromCsar);
 167     }
 168
 169     public void importAllNormativeResource(final String resourcesYaml, final NodeTypesMetadataList nodeTypesMetadataList, final User user,
 170                                            final boolean createNewVersion, final boolean needLock) {
 171         final Map<String, Object> nodeTypesYamlMap;
 172         try {
 173             nodeTypesYamlMap = new Yaml().load(resourcesYaml);
 174         } catch (final Exception e) {
 175             log.error(EcompLoggerErrorCode.BUSINESS_PROCESS_ERROR, ResourceImportManager.class.getName(), "Could not parse node types YAML", e);
 176             throw new ByActionStatusComponentException(ActionStatus.INVALID_NODE_TYPES_YAML);
 177         }
 178         if (!nodeTypesYamlMap.containsKey(ToscaTagNamesEnum.NODE_TYPES.getElementName())) {
 179             return;
 180         }
 181         final Map<String, Object> nodeTypesMap = (Map<String, Object>) nodeTypesYamlMap.get(ToscaTagNamesEnum.NODE_TYPES.getElementName());
 182         importAllNormativeResource(nodeTypesMap, nodeTypesMetadataList, null, user, "", createNewVersion,needLock);
 183     }
 184
 185     public void importAllNormativeResource(final  Map<String, Object> nodeTypesMap, final NodeTypesMetadataList nodeTypesMetadataList,
 186                                            Map<String, UploadComponentInstanceInfo> instancesFromCsar, final User user, String model, final boolean createNewVersion, final boolean needLock) {
 187         try {
 188             nodeTypesMetadataList.getNodeMetadataList().forEach(nodeTypeMetadata -> {
 189                 final String nodeTypeToscaName = nodeTypeMetadata.getToscaName();
 190                 final Map<String, Object> nodeTypeMap = (Map<String, Object>) nodeTypesMap.get(nodeTypeToscaName);
 191                 if (nodeTypeMap == null) {
 192                     log.warn(EcompLoggerErrorCode.BUSINESS_PROCESS_ERROR, ResourceImportManager.class.getName(),
 193                         "Could not find given node type '{}'. The node will not be created.", nodeTypeToscaName);
 194                 } else {
 195                     final Map<String, Map<String, Map<String, Object>>> nodeTypeDefinitionMap =
 196                         Map.of(ToscaTagNamesEnum.NODE_TYPES.getElementName(),
 197                             Map.of(nodeTypeToscaName, nodeTypeMap)
 198                         );
 199                     final String nodeTypeYaml = new Yaml().dump(nodeTypeDefinitionMap);
 200                     UploadResourceInfo uploadResourceInfo = NodeTypeMetadataMapper.mapTo(nodeTypeMetadata);
 201                     if (uploadResourceInfo instanceof DefaultUploadResourceInfo) {
 202                         uploadResourceInfo.setModel(model);
 203                         uploadResourceInfo.setContactId(user.getUserId());
 204                     }
 205                     importNormativeResource(nodeTypeYaml, uploadResourceInfo, instancesFromCsar, user, createNewVersion, needLock, true);
 206                 }
 207             });
 208             janusGraphDao.commit();
 209         } catch (final Exception e) {
 210             janusGraphDao.rollback();
 211             throw e;
 212         }
 213     }
 214
 215     public ImmutablePair<Resource, ActionStatus> importNormativeResourceFromCsar(String resourceYml, UploadResourceInfo resourceMetaData,
 216                                                                                  User creator, boolean createNewVersion, boolean needLock) {
 217         LifecycleChangeInfoWithAction lifecycleChangeInfo = new LifecycleChangeInfoWithAction();
 218         lifecycleChangeInfo.setUserRemarks("certification on import");
 219         Function<Resource, Boolean> validator = resource -> resourceBusinessLogic.validatePropertiesDefaultValues(resource);
 220         return importCertifiedResource(resourceYml, resourceMetaData, creator, validator, lifecycleChangeInfo, false, createNewVersion, needLock,
 221             null, null, false, null, null, false, null);
 222     }
 223
 224     public ImmutablePair<Resource, ActionStatus> importCertifiedResource(String resourceYml, UploadResourceInfo resourceMetaData, User creator,
 225                                                                          Function<Resource, Boolean> validationFunction,
 226                                                                          LifecycleChangeInfoWithAction lifecycleChangeInfo, boolean isInTransaction,
 227                                                                          boolean createNewVersion, boolean needLock,
 228                                                                          Map<ArtifactOperationEnum, List<ArtifactDefinition>> nodeTypeArtifactsToHandle,
 229                                                                          List<ArtifactDefinition> nodeTypesNewCreatedArtifacts,
 230                                                                          boolean forceCertificationAllowed, CsarInfo csarInfo, String nodeName,
 231                                                                          boolean isNested, Map<String, UploadComponentInstanceInfo> instancesFromCsar) {
 232         Resource resource = new Resource();
 233         ImmutablePair<Resource, ActionStatus> responsePair = new ImmutablePair<>(resource, ActionStatus.CREATED);
 234         Either<ImmutablePair<Resource, ActionStatus>, ResponseFormat> response = Either.left(responsePair);
 235         String latestCertifiedResourceId = null;
 236         try {
 237             boolean shouldBeCertified = nodeTypeArtifactsToHandle == null || nodeTypeArtifactsToHandle.isEmpty();
 238             setConstantMetaData(resource, shouldBeCertified);
 239             setResourceMetaData(resource, resourceYml, resourceMetaData);
 240             populateResourceFromYaml(resourceYml, resource, instancesFromCsar);
 241             validationFunction.apply(resource);
 242             resource.getComponentMetadataDefinition().getMetadataDataDefinition().setNormative(resourceMetaData.isNormative());
 243             checkResourceExists(createNewVersion, csarInfo, resource);
 244             resource = resourceBusinessLogic
 245                 .createOrUpdateResourceByImport(resource, creator, true, isInTransaction, needLock, csarInfo, nodeName, isNested).left;
 246             Resource changeStateResponse;
 247             if (nodeTypeArtifactsToHandle != null && !nodeTypeArtifactsToHandle.isEmpty()) {
 248                 Either<List<ArtifactDefinition>, ResponseFormat> handleNodeTypeArtifactsRes = resourceBusinessLogic
 249                     .handleNodeTypeArtifacts(resource, nodeTypeArtifactsToHandle, nodeTypesNewCreatedArtifacts, creator, isInTransaction, false);
 250                 if (handleNodeTypeArtifactsRes.isRight()) {
 251                     //TODO: should be used more correct action
 252                     throw new ByActionStatusComponentException(ActionStatus.GENERAL_ERROR);
 253                 }
 254             }
 255             latestCertifiedResourceId = getLatestCertifiedResourceId(resource);
 256             changeStateResponse = resourceBusinessLogic
 257                 .propagateStateToCertified(creator, resource, lifecycleChangeInfo, isInTransaction, needLock, forceCertificationAllowed);
 258             responsePair = new ImmutablePair<>(changeStateResponse, response.left().value().right);
 259         } catch (RuntimeException e) {
 260             handleImportResourceException(resourceMetaData, creator, true, e);
 261         } finally {
 262             if (latestCertifiedResourceId != null && needLock) {
 263                 log.debug("unlock resource {}", latestCertifiedResourceId);
 264                 graphLockOperation.unlockComponent(latestCertifiedResourceId, NodeTypeEnum.Resource);
 265             }
 266         }
 267         return responsePair;
 268     }
 269
 270     private void checkResourceExists(final boolean isCreate, final CsarInfo csarInfo, final Resource resource) {
 271         if (isCreate) {
 272             checkResourceExistsOnCreate(resource, csarInfo);
 273         } else {
 274             checkResourceExistsOnUpdate(resource);
 275         }
 276     }
 277
 278     private void checkResourceExistsOnCreate(final Resource resource, final CsarInfo csarInfo) {
 279         if (isCsarPresent(csarInfo)) {
 280             return;
 281         }
 282         final Either<Resource, StorageOperationStatus> resourceEither =
 283             toscaOperationFacade.getComponentByNameAndVendorRelease(resource.getComponentType(), resource.getName(),
 284                 resource.getVendorRelease(), JsonParseFlagEnum.ParseAll, resource.getModel());
 285         if (resourceEither.isLeft() && toscaOperationFacade.isNodeAssociatedToModel(resource.getModel(), resource)) {
 286             if (resource.getModel() == null) {
 287                 throw new ByActionStatusComponentException(ActionStatus.COMPONENT_WITH_VENDOR_RELEASE_ALREADY_EXISTS,
 288                     resource.getName(), resource.getVendorRelease());
 289             }
 290             throw new ByActionStatusComponentException(ActionStatus.COMPONENT_WITH_VENDOR_RELEASE_ALREADY_EXISTS_IN_MODEL,
 291                 resource.getName(), resource.getVendorRelease(), resource.getModel());
 292         }
 293     }
 294
 295     private void checkResourceExistsOnUpdate(final Resource resource) {
 296         final String model = resource.getModel();
 297         final Either<Resource, StorageOperationStatus> latestByName = toscaOperationFacade.getLatestByName(resource.getName(), model);
 298         if (latestByName.isLeft() && toscaOperationFacade.isNodeAssociatedToModel(model, resource)) {
 299             if (model == null) {
 300                 throw new ByActionStatusComponentException(ActionStatus.COMPONENT_NAME_ALREADY_EXIST,
 301                     resource.getResourceType().name(), resource.getName());
 302             }
 303             throw new ByActionStatusComponentException(ActionStatus.COMPONENT_WITH_MODEL_ALREADY_EXIST, resource.getName(), model);
 304         }
 305     }
 306
 307     private boolean isCsarPresent(final CsarInfo csarInfo) {
 308         return csarInfo != null && StringUtils.isNotEmpty(csarInfo.getCsarUUID());
 309     }
 310
 311     private String getLatestCertifiedResourceId(Resource resource) {
 312         Map<String, String> allVersions = resource.getAllVersions();
 313         Double latestCertifiedVersion = 0.0;
 314         if (allVersions != null) {
 315             for (String version : allVersions.keySet()) {
 316                 Double dVersion = Double.valueOf(version);
 317                 if ((dVersion > latestCertifiedVersion) && (version.endsWith(".0"))) {
 318                     latestCertifiedVersion = dVersion;
 319                 }
 320             }
 321             return allVersions.get(String.valueOf(latestCertifiedVersion));
 322         } else {
 323             return null;
 324         }
 325     }
 326
 327     public void populateResourceMetadata(UploadResourceInfo resourceMetaData, Resource resource) {
 328         if (resource != null && resourceMetaData != null) {
 329             resource.setDescription(resourceMetaData.getDescription());
 330             resource.setTags(resourceMetaData.getTags());
 331             resource.setCategories(resourceMetaData.getCategories());
 332             resource.setContactId(resourceMetaData.getContactId());
 333             resource.setName(resourceMetaData.getName());
 334             resource.setIcon(resourceMetaData.getResourceIconPath());
 335             resource.setResourceVendorModelNumber(resourceMetaData.getResourceVendorModelNumber());
 336             resource.setResourceType(ResourceTypeEnum.valueOf(resourceMetaData.getResourceType()));
 337             resource.setTenant(resourceMetaData.getTenant());
 338             if (resourceMetaData.getVendorName() != null) {
 339                 resource.setVendorName(resourceMetaData.getVendorName());
 340             }
 341             if (resourceMetaData.getVendorRelease() != null) {
 342                 resource.setVendorRelease(resourceMetaData.getVendorRelease());
 343             }
 344             if (resourceMetaData.getModel() != null) {
 345                 resource.setModel(resourceMetaData.getModel());
 346             }
 347         }
 348     }
 349
 350     public ImmutablePair<Resource, ActionStatus> importUserDefinedResource(String resourceYml, UploadResourceInfo resourceMetaData, User creator,
 351                                                                            boolean isInTransaction) {
 352         Resource resource = new Resource();
 353         ImmutablePair<Resource, ActionStatus> responsePair = new ImmutablePair<>(resource, ActionStatus.CREATED);
 354         try {
 355             setMetaDataFromJson(resourceMetaData, resource);
 356             populateResourceFromYaml(resourceYml, resource, null);
 357             // currently import VF isn't supported. In future will be supported import VF only with CSAR file!!
 358             if (ResourceTypeEnum.VF == resource.getResourceType()) {
 359                 log.debug("Now import VF isn't supported. It will be supported in future with CSAR file only");
 360                 throw new ByActionStatusComponentException(ActionStatus.RESTRICTED_OPERATION);
 361             }
 362             resourceBusinessLogic.validateDerivedFromNotEmpty(creator, resource, AuditingActionEnum.CREATE_RESOURCE);
 363             resourceBusinessLogic.validatePropertiesDefaultValues(resource);
 364             responsePair = resourceBusinessLogic.createOrUpdateResourceByImport(resource, creator, false, isInTransaction, true, null, null, false);
 365         } catch (RuntimeException e) {
 366             handleImportResourceException(resourceMetaData, creator, false, e);
 367         }
 368         return responsePair;
 369     }
 370
 371     private void populateResourceFromYaml(final String resourceYml, Resource resource, Map<String, UploadComponentInstanceInfo> instancesFromCsar) {
 372         @SuppressWarnings("unchecked") Object ymlObj = new Yaml().load(resourceYml);
 373         if (ymlObj instanceof Map) {
 374             final Either<Resource, StorageOperationStatus> existingResource = getExistingResource(resource);
 375             final Map<String, Object> toscaJsonAll = (Map<String, Object>) ymlObj;
 376             Map<String, Object> toscaJson = toscaJsonAll;
 377             if (toscaJsonAll.containsKey(ToscaTagNamesEnum.NODE_TYPES.getElementName()) && resource.getResourceType() != ResourceTypeEnum.CVFC) {
 378                 toscaJson = new HashMap<>();
 379                 toscaJson.put(ToscaTagNamesEnum.NODE_TYPES.getElementName(), toscaJsonAll.get(ToscaTagNamesEnum.NODE_TYPES.getElementName()));
 380             }
 381             final List<Object> foundElements = new ArrayList<>();
 382             final Either<List<Object>, ResultStatusEnum> toscaElements = ImportUtils
 383                 .findToscaElements(toscaJsonAll, ToscaTagNamesEnum.DATA_TYPES.getElementName(), ToscaElementTypeEnum.MAP, foundElements);
 384             if (toscaElements.isLeft()) {
 385                 final Map<String, Object> toscaAttributes = (Map<String, Object>) foundElements.get(0);
 386                 if (MapUtils.isNotEmpty(toscaAttributes)) {
 387                     resource.setDataTypes(extractDataTypeFromJson(resourceBusinessLogic, toscaAttributes, resource.getModel()));
 388                 }
 389             }
 390             final Resource parentResource = setDerivedFrom(toscaJson, resource);
 391             if (StringUtils.isEmpty(resource.getToscaResourceName())) {
 392                 setToscaResourceName(toscaJson, resource);
 393             }
 394             setCapabilities(toscaJson, resource, parentResource);
 395             setProperties(toscaJson, resource, existingResource);
 396             setAttributes(toscaJson, resource);
 397             setRequirements(toscaJson, resource, parentResource);
 398             setInterfaceLifecycle(toscaJson, resource, existingResource, instancesFromCsar);
 399         } else {
 400             throw new ByActionStatusComponentException(ActionStatus.GENERAL_ERROR);
 401         }
 402     }
 403
 404     private Either<Resource, StorageOperationStatus> getExistingResource(final Resource resource) {
 405         final Either<List<GraphVertex>, JanusGraphOperationStatus> byCriteria = janusGraphDao.getByCriteria(
 406             getVertexTypeEnum(resource.getResourceType()), propertiesToMatch(resource), propertiesToNotMatch(),
 407             JsonParseFlagEnum.ParseAll, resource.getModel(), false);
 408         if (byCriteria.isLeft() && CollectionUtils.isNotEmpty(byCriteria.left().value())) {
 409             final List<GraphVertex> graphVertexList = byCriteria.left().value();
 410             if (graphVertexList.size() == 1) {
 411                 return toscaOperationFacade.getToscaElement(graphVertexList.get(0).getUniqueId());
 412             } else {
 413                 final Optional<GraphVertex> vertex = graphVertexList.stream()
 414                     .max(Comparator.comparing(graphVertex -> (String) graphVertex.getMetadataProperties().get(GraphPropertyEnum.VERSION)));
 415                 if (vertex.isPresent()) {
 416                     return toscaOperationFacade.getToscaElement(vertex.get().getUniqueId());
 417                 }
 418             }
 419         }
 420         return Either.right(StorageOperationStatus.NOT_FOUND);
 421     }
 422
 423     private VertexTypeEnum getVertexTypeEnum(final ResourceTypeEnum resourceType) {
 424         return ModelConverter.isAtomicComponent(resourceType) ? VertexTypeEnum.NODE_TYPE : VertexTypeEnum.TOPOLOGY_TEMPLATE;
 425     }
 426
 427     private Map<GraphPropertyEnum, Object> propertiesToMatch(final Resource resource) {
 428         final Map<GraphPropertyEnum, Object> graphProperties = new EnumMap<>(GraphPropertyEnum.class);
 429         graphProperties.put(GraphPropertyEnum.NORMALIZED_NAME, ValidationUtils.normaliseComponentName(resource.getName()));
 430         graphProperties.put(GraphPropertyEnum.COMPONENT_TYPE, resource.getComponentType().name());
 431         graphProperties.put(GraphPropertyEnum.RESOURCE_TYPE, resource.getResourceType().name());
 432         graphProperties.put(GraphPropertyEnum.IS_HIGHEST_VERSION, true);
 433         return graphProperties;
 434     }
 435
 436     private Map<GraphPropertyEnum, Object> propertiesToNotMatch() {
 437         final Map<GraphPropertyEnum, Object> graphProperties = new EnumMap<>(GraphPropertyEnum.class);
 438         graphProperties.put(GraphPropertyEnum.IS_DELETED, true);
 439         graphProperties.put(GraphPropertyEnum.IS_ARCHIVED, true);
 440         return graphProperties;
 441     }
 442
 443     private void setToscaResourceName(Map<String, Object> toscaJson, Resource resource) {
 444         resource.setToscaResourceName(getToscaResourceName(toscaJson));
 445     }
 446
 447     private String getToscaResourceName(Map<String, Object> toscaJson) {
 448         Either<Map<String, Object>, ResultStatusEnum> toscaElement = ImportUtils
 449                 .findFirstToscaMapElement(toscaJson, ToscaTagNamesEnum.NODE_TYPES);
 450         if (toscaElement.isLeft() && toscaElement.left().value().size() == 1) {
 451             return toscaElement.left().value().keySet().iterator().next();
 452         }
 453         return null;
 454     }
 455
 456     private void setInterfaceLifecycle(Map<String, Object> toscaJson, Resource resource, Either<Resource, StorageOperationStatus> existingResource,
 457                                        Map<String, UploadComponentInstanceInfo> instancesFromCsar) {
 458         final Either<Map<String, Object>, ResultStatusEnum> toscaInterfaces = ImportUtils
 459             .findFirstToscaMapElement(toscaJson, ToscaTagNamesEnum.INTERFACES);
 460         final Map<String, InterfaceDefinition> moduleInterfaces = new HashMap<>();
 461         final Map<String, Object> map;
 462         List<UploadInterfaceInfo> interfaceInfoList = null;
 463         if (MapUtils.isNotEmpty(instancesFromCsar)) {
 464             interfaceInfoList = instancesFromCsar.values().stream().filter(i -> MapUtils.isNotEmpty(i.getInterfaces()))
 465                 .flatMap(i -> i.getInterfaces().values().stream()).collect(Collectors.toList());
 466         }
 467         if (toscaInterfaces.isLeft()) {
 468             map = toscaInterfaces.left().value();
 469             for (final Entry<String, Object> interfaceNameValue : map.entrySet()) {
 470                 final Either<InterfaceDefinition, ResultStatusEnum> eitherInterface =
 471                     createModuleInterface(interfaceNameValue.getValue(), resource.getModel());
 472                 if (eitherInterface.isRight()) {
 473                     log.info("error when creating interface:{}, for resource:{}", interfaceNameValue.getKey(), resource.getName());
 474                 } else {
 475                     final InterfaceDefinition interfaceDefinition = eitherInterface.left().value();
 476                     if (CollectionUtils.isNotEmpty(interfaceInfoList)) {
 477                         updateInterfaceDefinition(interfaceDefinition, interfaceInfoList);
 478                     }
 479                     moduleInterfaces.put(interfaceDefinition.getType(), interfaceDefinition);
 480                 }
 481             }
 482         } else {
 483             map = Collections.emptyMap();
 484         }
 485         if (existingResource.isLeft()) {
 486             final Map<String, InterfaceDefinition> interfaces = existingResource.left().value().getInterfaces();
 487             if (MapUtils.isNotEmpty(interfaces)) {
 488                 final Map<String, InterfaceDefinition> userCreatedInterfaceDefinitions =
 489                     interfaces.entrySet().stream()
 490                         .filter(i -> i.getValue().isUserCreated())
 491                         .filter(i -> !map.containsKey(i.getValue().getType()))
 492                         .collect(Collectors.toMap(Entry::getKey, Entry::getValue));
 493                 if (MapUtils.isNotEmpty(userCreatedInterfaceDefinitions)) {
 494                     moduleInterfaces.putAll(userCreatedInterfaceDefinitions);
 495                 }
 496             }
 497         }
 498
 499         if (MapUtils.isNotEmpty(moduleInterfaces)) {
 500             resource.setInterfaces(moduleInterfaces);
 501         }
 502     }
 503
 504     private void updateInterfaceDefinition(InterfaceDefinition interfaceDefinition, List<UploadInterfaceInfo> interfaceInfoList) {
 505         Map<String, OperationDataDefinition> operations = new HashMap<>();
 506         interfaceInfoList.stream().filter(i -> interfaceDefinition.getType().endsWith(i.getKey())).forEach(i -> {
 507             i.getOperations().values().forEach(o -> {
 508                 o.setImplementation(null);
 509             });
 510             operations.putAll(i.getOperations());
 511         });
 512         interfaceDefinition.setOperations(operations);
 513     }
 514
 515     private Either<InterfaceDefinition, ResultStatusEnum> createModuleInterface(final Object interfaceJson, final String model) {
 516         try {
 517             if (interfaceJson instanceof String) {
 518                 final InterfaceDefinition interfaceDefinition = new InterfaceDefinition();
 519                 interfaceDefinition.setType((String) interfaceJson);
 520                 return Either.left(interfaceDefinition);
 521             }
 522             if (interfaceJson instanceof Map) {
 523                 final Map<String, Object> interfaceJsonMap = (Map<String, Object>) interfaceJson;
 524                 final InterfaceDefinition interfaceDefinition = interfaceDefinitionHandler.create(interfaceJsonMap, model);
 525                 return Either.left(interfaceDefinition);
 526             }
 527             return Either.right(ResultStatusEnum.GENERAL_ERROR);
 528         } catch (final Exception e) {
 529             BeEcompErrorManager.getInstance().logBeSystemError("Import Resource- create interface");
 530             log.debug("error when creating interface, message:{}", e.getMessage(), e);
 531             return Either.right(ResultStatusEnum.GENERAL_ERROR);
 532         }
 533     }
 534
 535     private void setRequirements(Map<String, Object> toscaJson, Resource resource,
 536                                  Resource parentResource) {// Note that parentResource can be null
 537         Either<List<Object>, ResultStatusEnum> toscaRequirements = ImportUtils
 538             .findFirstToscaListElement(toscaJson, ToscaTagNamesEnum.REQUIREMENTS);
 539         if (toscaRequirements.isLeft()) {
 540             List<Object> jsonRequirements = toscaRequirements.left().value();
 541             Map<String, List<RequirementDefinition>> moduleRequirements = new HashMap<>();
 542             // Checking for name duplication
 543             Set<String> reqNames = new HashSet<>();
 544             // Getting flattened list of capabilities of parent node - cap name to cap type
 545             Map<String, String> reqName2TypeMap = getReqName2Type(parentResource);
 546             for (Object jsonRequirementObj : jsonRequirements) {
 547                 // Requirement
 548                 Map<String, Object> requirementJsonWrapper = (Map<String, Object>) jsonRequirementObj;
 549                 String requirementName = requirementJsonWrapper.keySet().iterator().next();
 550                 String reqNameLowerCase = requirementName.toLowerCase();
 551                 if (reqNames.contains(reqNameLowerCase)) {
 552                     log.debug("More than one requirement with same name {} (case-insensitive) in imported TOSCA file is invalid", reqNameLowerCase);
 553                     throw new ByActionStatusComponentException(ActionStatus.IMPORT_DUPLICATE_REQ_CAP_NAME, "requirement", reqNameLowerCase);
 554                 }
 555                 reqNames.add(reqNameLowerCase);
 556                 RequirementDefinition requirementDef = createRequirementFromImportFile(requirementJsonWrapper.get(requirementName));
 557                 requirementDef.setName(requirementName);
 558                 if (moduleRequirements.containsKey(requirementDef.getCapability())) {
 559                     moduleRequirements.get(requirementDef.getCapability()).add(requirementDef);
 560                 } else {
 561                     List<RequirementDefinition> list = new ArrayList<>();
 562                     list.add(requirementDef);
 563                     moduleRequirements.put(requirementDef.getCapability(), list);
 564                 }
 565                 // Validating against req/cap of "derived from" node
 566                 Boolean validateVsParentCap = validateCapNameVsDerived(reqName2TypeMap, requirementDef.getCapability(), requirementDef.getName());
 567                 if (!validateVsParentCap) {
 568                     String parentResourceName = parentResource != null ? parentResource.getName() : "";
 569                     log.debug("Requirement with name {} already exists in parent {}", requirementDef.getName(), parentResourceName);
 570                     throw new ByActionStatusComponentException(ActionStatus.IMPORT_REQ_CAP_NAME_EXISTS_IN_DERIVED, "requirement",
 571                         requirementDef.getName().toLowerCase(), parentResourceName);
 572                 }
 573             }
 574             if (moduleRequirements.size() > 0) {
 575                 resource.setRequirements(moduleRequirements);
 576             }
 577         }
 578     }
 579
 580     private RequirementDefinition createRequirementFromImportFile(Object requirementJson) {
 581         RequirementDefinition requirement = new RequirementDefinition();
 582         if (requirementJson instanceof String) {
 583             String requirementJsonString = (String) requirementJson;
 584             requirement.setCapability(requirementJsonString);
 585         } else if (requirementJson instanceof Map) {
 586             Map<String, Object> requirementJsonMap = (Map<String, Object>) requirementJson;
 587             if (requirementJsonMap.containsKey(ToscaTagNamesEnum.CAPABILITY.getElementName())) {
 588                 requirement.setCapability((String) requirementJsonMap.get(ToscaTagNamesEnum.CAPABILITY.getElementName()));
 589             }
 590             if (requirementJsonMap.containsKey(ToscaTagNamesEnum.NODE.getElementName())) {
 591                 requirement.setNode((String) requirementJsonMap.get(ToscaTagNamesEnum.NODE.getElementName()));
 592             }
 593             if (requirementJsonMap.containsKey(ToscaTagNamesEnum.RELATIONSHIP.getElementName())) {
 594                 requirement.setRelationship((String) requirementJsonMap.get(ToscaTagNamesEnum.RELATIONSHIP.getElementName()));
 595             }
 596             if (requirementJsonMap.containsKey(ToscaTagNamesEnum.OCCURRENCES.getElementName())) {
 597                 List<Object> occurrencesList = (List) requirementJsonMap.get(ToscaTagNamesEnum.OCCURRENCES.getElementName());
 598                 validateOccurrences(occurrencesList);
 599                 requirement.setMinOccurrences(occurrencesList.get(0).toString());
 600                 requirement.setMaxOccurrences(occurrencesList.get(1).toString());
 601             }
 602         } else {
 603             throw new ByActionStatusComponentException(ActionStatus.INVALID_YAML);
 604         }
 605         return requirement;
 606     }
 607
 608     private void setProperties(final Map<String, Object> toscaJson, final Resource resource,
 609                                final Either<Resource, StorageOperationStatus> existingResource) {
 610         final Map<String, Object> reducedToscaJson = new HashMap<>(toscaJson);
 611         ImportUtils.removeElementFromJsonMap(reducedToscaJson, "capabilities");
 612         final Either<Map<String, PropertyDefinition>, ResultStatusEnum> properties = ImportUtils.getProperties(reducedToscaJson);
 613         if (properties.isLeft()) {
 614             final Map<String, PropertyDefinition> propertyDefinitionMap = properties.left().value();
 615             if (MapUtils.isNotEmpty(propertyDefinitionMap)) {
 616                 final List<PropertyDefinition> propertiesList = new ArrayList<>();
 617                 for (final Entry<String, PropertyDefinition> entry : propertyDefinitionMap.entrySet()) {
 618                     addPropertyToList(resource.getName(), propertiesList, entry);
 619                 }
 620                 if (existingResource.isLeft() && CollectionUtils.isNotEmpty(existingResource.left().value().getProperties())) {
 621                     final List<PropertyDefinition> userCreatedResourceProperties =
 622                         existingResource.left().value().getProperties().stream()
 623                             .filter(PropertyDataDefinition::isUserCreated)
 624                             .filter(propertyDefinition -> !propertyDefinitionMap.containsKey(propertyDefinition.getName()))
 625                             .collect(Collectors.toList());
 626                     if (CollectionUtils.isNotEmpty(userCreatedResourceProperties)) {
 627                         propertiesList.addAll(userCreatedResourceProperties);
 628                     }
 629                 }
 630
 631                 resource.setProperties(propertiesList);
 632             }
 633         } else if (properties.right().value() != ResultStatusEnum.ELEMENT_NOT_FOUND) {
 634             throw new ByActionStatusComponentException(
 635                 componentsUtils.convertFromResultStatusEnum(properties.right().value(), JsonPresentationFields.PROPERTY));
 636         }
 637     }
 638
 639     private void addPropertyToList(final String resourceName,
 640                                    final List<PropertyDefinition> propertiesList,
 641                                    final Entry<String, PropertyDefinition> entry) {
 642         final String propertyName = entry.getKey();
 643         if (!PROPERTY_NAME_PATTERN_IGNORE_LENGTH.matcher(propertyName).matches()) {
 644             log.debug("The property with invalid name {} occured upon import resource {}. ", propertyName, resourceName);
 645             throw new ByActionStatusComponentException(
 646                 componentsUtils.convertFromResultStatusEnum(ResultStatusEnum.INVALID_PROPERTY_NAME, JsonPresentationFields.PROPERTY));
 647         }
 648         final PropertyDefinition propertyDefinition = entry.getValue();
 649         propertyDefinition.setName(propertyName);
 650         propertiesList.add(propertyDefinition);
 651     }
 652
 653     private void setAttributes(final Map<String, Object> originalToscaJsonMap, final Resource resource) {
 654         final Map<String, Object> toscaJsonMap = new HashMap<>(originalToscaJsonMap);
 655         ImportUtils.removeElementFromJsonMap(toscaJsonMap, "capabilities");
 656         final Either<Map<String, AttributeDefinition>, ResultStatusEnum> getAttributeEither = ImportUtils.getAttributes(toscaJsonMap);
 657         if (getAttributeEither.isRight()) {
 658             final ResultStatusEnum resultStatus = getAttributeEither.right().value();
 659             if (resultStatus == ResultStatusEnum.ELEMENT_NOT_FOUND) {
 660                 return;
 661             }
 662             throw new ByActionStatusComponentException(componentsUtils.convertFromResultStatusEnum(resultStatus, JsonPresentationFields.ATTRIBUTES));
 663         }
 664         final List<AttributeDefinition> attributeDefinitionList = new ArrayList<>();
 665         final Map<String, AttributeDefinition> attributeMap = getAttributeEither.left().value();
 666         if (MapUtils.isEmpty(attributeMap)) {
 667             return;
 668         }
 669         for (final Entry<String, AttributeDefinition> entry : attributeMap.entrySet()) {
 670             final String name = entry.getKey();
 671             if (!PROPERTY_NAME_PATTERN_IGNORE_LENGTH.matcher(name).matches()) {
 672                 log.debug("Detected attribute with invalid name '{}' during resource '{}' import. ", name, resource.getName());
 673                 throw new ByActionStatusComponentException(
 674                     componentsUtils.convertFromResultStatusEnum(ResultStatusEnum.INVALID_ATTRIBUTE_NAME, JsonPresentationFields.ATTRIBUTES));
 675             }
 676             final AttributeDefinition attributeDefinition = entry.getValue();
 677             attributeDefinition.setName(name);
 678             if (attributeDefinition.getEntry_schema() != null && attributeDefinition.getEntry_schema().getType() != null) {
 679                 attributeDefinition.setSchema(new SchemaDefinition());
 680                 attributeDefinition.getSchema().setProperty(new PropertyDataDefinition());
 681                 attributeDefinition.getSchema().getProperty().setType(entry.getValue().getEntry_schema().getType());
 682             }
 683             attributeDefinitionList.add(attributeDefinition);
 684         }
 685         resource.setAttributes(attributeDefinitionList);
 686     }
 687
 688     private Resource setDerivedFrom(Map<String, Object> toscaJson, Resource resource) {
 689         Either<String, ResultStatusEnum> toscaDerivedFromElement = ImportUtils
 690             .findFirstToscaStringElement(toscaJson, ToscaTagNamesEnum.DERIVED_FROM);
 691         Resource derivedFromResource = null;
 692         if (toscaDerivedFromElement.isLeft()) {
 693             String derivedFrom = toscaDerivedFromElement.left().value();
 694             log.debug("Derived from TOSCA name is {}", derivedFrom);
 695             resource.setDerivedFrom(Arrays.asList(new String[]{derivedFrom}));
 696             Either<Resource, StorageOperationStatus> latestByToscaResourceName = toscaOperationFacade.getLatestByToscaResourceName(derivedFrom,
 697                 resource.getModel());
 698             if (latestByToscaResourceName.isRight()) {
 699                 StorageOperationStatus operationStatus = latestByToscaResourceName.right().value();
 700                 if (operationStatus == StorageOperationStatus.NOT_FOUND) {
 701                     operationStatus = StorageOperationStatus.PARENT_RESOURCE_NOT_FOUND;
 702                 }
 703                 log.debug("Error when fetching parent resource {}, error: {}", derivedFrom, operationStatus);
 704                 ActionStatus convertFromStorageResponse = componentsUtils.convertFromStorageResponse(operationStatus);
 705                 BeEcompErrorManager.getInstance().logBeComponentMissingError("Import TOSCA YAML", "resource", derivedFrom);
 706                 throw new ByActionStatusComponentException(convertFromStorageResponse, derivedFrom);
 707             }
 708             derivedFromResource = latestByToscaResourceName.left().value();
 709         }
 710         return derivedFromResource;
 711     }
 712
 713     private void setCapabilities(Map<String, Object> toscaJson, Resource resource,
 714                                  Resource parentResource) {// Note that parentResource can be null
 715         Either<Map<String, Object>, ResultStatusEnum> toscaCapabilities = ImportUtils
 716             .findFirstToscaMapElement(toscaJson, ToscaTagNamesEnum.CAPABILITIES);
 717         if (toscaCapabilities.isLeft()) {
 718             Map<String, Object> jsonCapabilities = toscaCapabilities.left().value();
 719             Map<String, List<CapabilityDefinition>> moduleCapabilities = new HashMap<>();
 720             Iterator<Entry<String, Object>> capabilitiesNameValue = jsonCapabilities.entrySet().iterator();
 721             Set<String> capNames = new HashSet<>();
 722             // Getting flattened list of capabilities of parent node - cap name
 723
 724             // to cap type
 725             Map<String, String> capName2TypeMap = getCapName2Type(parentResource);
 726             while (capabilitiesNameValue.hasNext()) {
 727                 Entry<String, Object> capabilityNameValue = capabilitiesNameValue.next();
 728                 // Validating that no req/cap duplicates exist in imported YAML
 729                 String capNameLowerCase = capabilityNameValue.getKey().toLowerCase();
 730                 if (capNames.contains(capNameLowerCase)) {
 731                     log.debug("More than one capability with same name {} (case-insensitive) in imported TOSCA file is invalid", capNameLowerCase);
 732                     throw new ByActionStatusComponentException(ActionStatus.IMPORT_DUPLICATE_REQ_CAP_NAME, "capability", capNameLowerCase);
 733                 }
 734                 capNames.add(capNameLowerCase);
 735                 CapabilityDefinition capabilityDef = createCapabilityFromImportFile(capabilityNameValue.getValue());
 736                 capabilityDef.setName(capabilityNameValue.getKey());
 737                 if (moduleCapabilities.containsKey(capabilityDef.getType())) {
 738                     moduleCapabilities.get(capabilityDef.getType()).add(capabilityDef);
 739                 } else {
 740                     List<CapabilityDefinition> list = new ArrayList<>();
 741                     list.add(capabilityDef);
 742                     moduleCapabilities.put(capabilityDef.getType(), list);
 743                 }
 744                 // Validating against req/cap of "derived from" node
 745                 Boolean validateVsParentCap = validateCapNameVsDerived(capName2TypeMap, capabilityDef.getType(), capabilityDef.getName());
 746                 if (!validateVsParentCap) {
 747                     // Here parentResource is for sure not null, so it's
 748
 749                     // null-safe
 750
 751                     // Check added to avoid sonar warning
 752                     String parentResourceName = parentResource != null ? parentResource.getName() : "";
 753                     log.debug("Capability with name {} already exists in parent {}", capabilityDef.getName(), parentResourceName);
 754                     throw new ByActionStatusComponentException(ActionStatus.IMPORT_REQ_CAP_NAME_EXISTS_IN_DERIVED, "capability",
 755                         capabilityDef.getName().toLowerCase(), parentResourceName);
 756                 }
 757             }
 758             if (moduleCapabilities.size() > 0) {
 759                 resource.setCapabilities(moduleCapabilities);
 760             }
 761         }
 762     }
 763
 764     private Map<String, String> getCapName2Type(Resource parentResource) {
 765         Map<String, String> capName2type = new HashMap<>();
 766         if (parentResource != null) {
 767             Map<String, List<CapabilityDefinition>> capabilities = parentResource.getCapabilities();
 768             if (capabilities != null) {
 769                 for (List<CapabilityDefinition> capDefinitions : capabilities.values()) {
 770                     for (CapabilityDefinition capDefinition : capDefinitions) {
 771                         String nameLowerCase = capDefinition.getName().toLowerCase();
 772                         if (capName2type.get(nameLowerCase) != null) {
 773                             String parentResourceName = parentResource.getName();
 774                             log.debug("Resource with name {} has more than one capability with name {}, ignoring case", parentResourceName,
 775                                 nameLowerCase);
 776                             BeEcompErrorManager.getInstance().logInternalDataError("Import resource",
 777                                 "Parent resource " + parentResourceName + " of imported resource has one or more capabilities with name "
 778                                     + nameLowerCase, ErrorSeverity.ERROR);
 779                             throw new ByActionStatusComponentException(ActionStatus.GENERAL_ERROR);
 780                         }
 781                         capName2type.put(nameLowerCase, capDefinition.getType());
 782                     }
 783                 }
 784             }
 785         }
 786         return capName2type;
 787     }
 788
 789     private Map<String, String> getReqName2Type(Resource parentResource) {
 790         Map<String, String> reqName2type = new HashMap<>();
 791         if (parentResource != null) {
 792             Map<String, List<RequirementDefinition>> requirements = parentResource.getRequirements();
 793             if (requirements != null) {
 794                 for (List<RequirementDefinition> reqDefinitions : requirements.values()) {
 795                     for (RequirementDefinition reqDefinition : reqDefinitions) {
 796                         String nameLowerCase = reqDefinition.getName().toLowerCase();
 797                         if (reqName2type.get(nameLowerCase) != null) {
 798                             String parentResourceName = parentResource.getName();
 799                             log.debug("Resource with name {} has more than one requirement with name {}, ignoring case", parentResourceName,
 800                                 nameLowerCase);
 801                             BeEcompErrorManager.getInstance().logInternalDataError("Import resource",
 802                                 "Parent resource " + parentResourceName + " of imported resource has one or more requirements with name "
 803                                     + nameLowerCase, ErrorSeverity.ERROR);
 804                             throw new ByActionStatusComponentException(ActionStatus.GENERAL_ERROR);
 805                         }
 806                         reqName2type.put(nameLowerCase, reqDefinition.getCapability());
 807                     }
 808                 }
 809             }
 810         }
 811         return reqName2type;
 812     }
 813
 814     private Boolean validateCapNameVsDerived(Map<String, String> parentCapName2Type, String childCapabilityType, String reqCapName) {
 815         String capNameLowerCase = reqCapName.toLowerCase();
 816         log.trace("Validating capability {} vs parent resource", capNameLowerCase);
 817         String parentCapType = parentCapName2Type.get(capNameLowerCase);
 818         if (parentCapType != null) {
 819             if (childCapabilityType.equals(parentCapType)) {
 820                 log.debug("Capability with name {} is of same type {} for imported resource and its parent - this is OK", capNameLowerCase,
 821                     childCapabilityType);
 822                 return true;
 823             }
 824             Either<Boolean, StorageOperationStatus> capabilityTypeDerivedFrom = capabilityTypeOperation
 825                 .isCapabilityTypeDerivedFrom(childCapabilityType, parentCapType);
 826             if (capabilityTypeDerivedFrom.isRight()) {
 827                 log.debug("Couldn't check whether imported resource capability derives from its parent's capability");
 828                 throw new ByActionStatusComponentException(componentsUtils.convertFromStorageResponse(capabilityTypeDerivedFrom.right().value()));
 829             }
 830             return capabilityTypeDerivedFrom.left().value();
 831         }
 832         return true;
 833     }
 834
 835     private CapabilityDefinition createCapabilityFromImportFile(Object capabilityJson) {
 836         CapabilityDefinition capabilityDefinition = new CapabilityDefinition();
 837         if (capabilityJson instanceof String) {
 838             String capabilityJsonString = (String) capabilityJson;
 839             capabilityDefinition.setType(capabilityJsonString);
 840         } else if (capabilityJson instanceof Map) {
 841             Map<String, Object> capabilityJsonMap = (Map<String, Object>) capabilityJson;
 842             // Type
 843             if (capabilityJsonMap.containsKey(ToscaTagNamesEnum.TYPE.getElementName())) {
 844                 capabilityDefinition.setType((String) capabilityJsonMap.get(ToscaTagNamesEnum.TYPE.getElementName()));
 845             }
 846             // ValidSourceTypes
 847             if (capabilityJsonMap.containsKey(ToscaTagNamesEnum.VALID_SOURCE_TYPES.getElementName())) {
 848                 capabilityDefinition
 849                     .setValidSourceTypes((List<String>) capabilityJsonMap.get(ToscaTagNamesEnum.VALID_SOURCE_TYPES.getElementName()));
 850             }
 851             // ValidSourceTypes
 852             if (capabilityJsonMap.containsKey(ToscaTagNamesEnum.DESCRIPTION.getElementName())) {
 853                 capabilityDefinition.setDescription((String) capabilityJsonMap.get(ToscaTagNamesEnum.DESCRIPTION.getElementName()));
 854             }
 855             if (capabilityJsonMap.containsKey(ToscaTagNamesEnum.OCCURRENCES.getElementName())) {
 856                 List<Object> occurrencesList = (List) capabilityJsonMap.get(ToscaTagNamesEnum.OCCURRENCES.getElementName());
 857                 validateOccurrences(occurrencesList);
 858                 capabilityDefinition.setMinOccurrences(occurrencesList.get(0).toString());
 859                 capabilityDefinition.setMaxOccurrences(occurrencesList.get(1).toString());
 860             }
 861             if (capabilityJsonMap.containsKey(ToscaTagNamesEnum.PROPERTIES.getElementName())) {
 862                 Either<Map<String, PropertyDefinition>, ResultStatusEnum> propertiesRes = ImportUtils.getProperties(capabilityJsonMap);
 863                 if (propertiesRes.isRight()) {
 864                     throw new ByActionStatusComponentException(ActionStatus.PROPERTY_NOT_FOUND);
 865                 } else {
 866                     propertiesRes.left().value().entrySet().stream().forEach(e -> e.getValue().setName(e.getKey().toLowerCase()));
 867                     List<ComponentInstanceProperty> capabilityProperties = propertiesRes.left().value().values().stream()
 868                         .map(p -> new ComponentInstanceProperty(p, p.getDefaultValue(), null)).collect(Collectors.toList());
 869                     capabilityDefinition.setProperties(capabilityProperties);
 870                 }
 871             }
 872         } else if (!(capabilityJson instanceof List)) {
 873             throw new ByActionStatusComponentException(ActionStatus.INVALID_YAML);
 874         }
 875         return capabilityDefinition;
 876     }
 877
 878     private void handleImportResourceException(UploadResourceInfo resourceMetaData, User user, boolean isNormative, RuntimeException e) {
 879         ResponseFormat responseFormat;
 880         ComponentException newException;
 881         if (e instanceof ComponentException) {
 882             ComponentException componentException = (ComponentException) e;
 883             responseFormat = componentException.getResponseFormat();
 884             if (responseFormat == null) {
 885                 responseFormat = getResponseFormatManager().getResponseFormat(componentException.getActionStatus(), componentException.getParams());
 886             }
 887             newException = componentException;
 888         } else {
 889             responseFormat = getResponseFormatManager().getResponseFormat(ActionStatus.GENERAL_ERROR);
 890             newException = new ByActionStatusComponentException(ActionStatus.GENERAL_ERROR);
 891         }
 892         String payloadName = (resourceMetaData != null) ? resourceMetaData.getPayloadName() : "";
 893         BeEcompErrorManager.getInstance().logBeSystemError("Import Resource " + payloadName);
 894         log.debug("Error when importing resource from payload:{} Exception text: {}", payloadName, e.getMessage(), e);
 895         auditErrorImport(resourceMetaData, user, responseFormat, isNormative);
 896         throw newException;
 897     }
 898
 899     private void auditErrorImport(UploadResourceInfo resourceMetaData, User user, ResponseFormat errorResponseWrapper, boolean isNormative) {
 900         String version, lifeCycleState;
 901         if (isNormative) {
 902             version = TypeUtils.getFirstCertifiedVersionVersion();
 903             lifeCycleState = LifecycleStateEnum.CERTIFIED.name();
 904         } else {
 905             version = "";
 906             lifeCycleState = LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT.name();
 907         }
 908         String message = "";
 909         if (errorResponseWrapper.getMessageId() != null) {
 910             message = errorResponseWrapper.getMessageId() + ": ";
 911         }
 912         message += errorResponseWrapper.getFormattedMessage();
 913         AuditEventFactory factory = new AuditImportResourceAdminEventFactory(
 914             CommonAuditData.newBuilder().status(errorResponseWrapper.getStatus()).description(message).requestId(ThreadLocalsHolder.getUuid())
 915                 .build(), new ResourceCommonInfo(resourceMetaData.getName(), ComponentTypeEnum.RESOURCE.getValue()),
 916             ResourceVersionInfo.newBuilder().state(lifeCycleState).version(version).build(),
 917             ResourceVersionInfo.newBuilder().state("").version("").build(), "", user, "");
 918         getAuditingManager().auditEvent(factory);
 919     }
 920
 921     private void setResourceMetaData(Resource resource, String resourceYml, UploadResourceInfo resourceMetaData) {
 922         Map<String, Object> ymlObj = new Yaml().load(resourceYml);
 923         String toscaName = getToscaResourceName(ymlObj);
 924         final Either<Resource, StorageOperationStatus> latestByToscaName = toscaOperationFacade
 925             .getLatestByToscaResourceName(toscaName, resourceMetaData.getModel());
 926         if (latestByToscaName.isLeft() && resourceMetaData instanceof DefaultUploadResourceInfo) {
 927             setMetaDataFromLatestResource(resource, latestByToscaName.left().value());
 928         } else {
 929             setMetaDataFromJson(resourceMetaData, resource);
 930         }
 931     }
 932
 933     private void setMetaDataFromJson(final UploadResourceInfo resourceMetaData, final Resource resource) {
 934         this.populateResourceMetadata(resourceMetaData, resource);
 935         resource.setCreatorUserId(resourceMetaData.getContactId());
 936         final String payloadData = resourceMetaData.getPayloadData();
 937         if (payloadData != null) {
 938             resource.setToscaVersion(getToscaVersion(payloadData));
 939         }
 940         final List<CategoryDefinition> categories = resourceMetaData.getCategories();
 941         calculateResourceIsAbstract(resource, categories);
 942     }
 943
 944     private void setMetaDataFromLatestResource(Resource resource, Resource latestResource) {
 945         if (resource != null && latestResource != null) {
 946             resource.setCreatorUserId(latestResource.getContactId());
 947             resource.setDescription(latestResource.getDescription());
 948             resource.setTags(latestResource.getTags());
 949             resource.setCategories(latestResource.getCategories());
 950             resource.setContactId(latestResource.getContactId());
 951             resource.setName(latestResource.getName());
 952             resource.setIcon(latestResource.getIcon());
 953             resource.setResourceVendorModelNumber(latestResource.getResourceVendorModelNumber());
 954             resource.setResourceType(latestResource.getResourceType());
 955             if (latestResource.getVendorName() != null) {
 956                 resource.setVendorName(latestResource.getVendorName());
 957             }
 958             if (latestResource.getVendorRelease() != null) {
 959                 resource.setVendorRelease(latestResource.getVendorRelease());
 960             }
 961             if (latestResource.getModel() != null) {
 962                 resource.setModel(latestResource.getModel());
 963             }
 964             if (latestResource.getToscaVersion() != null) {
 965                 resource.setToscaVersion(latestResource.getToscaVersion());
 966             }
 967             final List<CategoryDefinition> categories = latestResource.getCategories();
 968             calculateResourceIsAbstract(resource, categories);
 969         }
 970     }
 971
 972     private Map<String, Object> decodePayload(final String payloadData) {
 973         final String decodedPayload = new String(Base64.decodeBase64(payloadData));
 974         return (Map<String, Object>) new Yaml().load(decodedPayload);
 975     }
 976
 977     private String getToscaVersion(final String payloadData) {
 978         final Map<String, Object> mappedToscaTemplate = decodePayload(payloadData);
 979         final Either<String, ResultStatusEnum> findFirstToscaStringElement = ImportUtils
 980             .findFirstToscaStringElement(mappedToscaTemplate, ToscaTagNamesEnum.TOSCA_VERSION);
 981         if (findFirstToscaStringElement.isLeft()) {
 982             return findFirstToscaStringElement.left().value();
 983         } else {
 984             return null;
 985         }
 986     }
 987
 988     private void calculateResourceIsAbstract(Resource resource, List<CategoryDefinition> categories) {
 989         if (categories != null && !categories.isEmpty()) {
 990             CategoryDefinition categoryDef = categories.get(0);
 991             resource.setAbstract(false);
 992             if (categoryDef != null && categoryDef.getName() != null && categoryDef.getName().equals(Constants.ABSTRACT_CATEGORY_NAME)) {
 993                 SubCategoryDefinition subCategoryDef = categoryDef.getSubcategories().get(0);
 994                 if (subCategoryDef != null && subCategoryDef.getName().equals(Constants.ABSTRACT_SUBCATEGORY)) {
 995                     resource.setAbstract(true);
 996                 }
 997             }
 998         }
 999     }
1000
1001     private void setConstantMetaData(Resource resource, boolean shouldBeCertified) {
1002         String version;
1003         LifecycleStateEnum state;
1004         if (shouldBeCertified) {
1005             version = TypeUtils.getFirstCertifiedVersionVersion();
1006             state = ImportUtils.Constants.NORMATIVE_TYPE_LIFE_CYCLE;
1007         } else {
1008             version = ImportUtils.Constants.FIRST_NON_CERTIFIED_VERSION;
1009             state = ImportUtils.Constants.NORMATIVE_TYPE_LIFE_CYCLE_NOT_CERTIFIED_CHECKOUT;
1010         }
1011         resource.setVersion(version);
1012         resource.setLifecycleState(state);
1013         resource.setHighestVersion(ImportUtils.Constants.NORMATIVE_TYPE_HIGHEST_VERSION);
1014         resource.setVendorName(ImportUtils.Constants.VENDOR_NAME);
1015         resource.setVendorRelease(ImportUtils.Constants.VENDOR_RELEASE);
1016     }
1017
1018     private void validateOccurrences(List<Object> occurrensesList) {
1019         if (!ValidationUtils.validateListNotEmpty(occurrensesList)) {
1020             log.debug("Occurrenses list empty");
1021             throw new ByActionStatusComponentException(ActionStatus.INVALID_OCCURRENCES);
1022         }
1023         if (occurrensesList.size() < 2) {
1024             log.debug("Occurrenses list size not 2");
1025             throw new ByActionStatusComponentException(ActionStatus.INVALID_OCCURRENCES);
1026         }
1027         Object minObj = occurrensesList.get(0);
1028         Object maxObj = occurrensesList.get(1);
1029         Integer minOccurrences;
1030         Integer maxOccurrences;
1031         if (minObj instanceof Integer) {
1032             minOccurrences = (Integer) minObj;
1033         } else {
1034             log.debug("Invalid occurrenses format. low_bound occurrense must be Integer {}", minObj);
1035             throw new ByActionStatusComponentException(ActionStatus.INVALID_OCCURRENCES);
1036         }
1037         if (minOccurrences < 0) {
1038             log.debug("Invalid occurrenses format.low_bound occurrense negative {}", minOccurrences);
1039             throw new ByActionStatusComponentException(ActionStatus.INVALID_OCCURRENCES);
1040         }
1041         if (maxObj instanceof String) {
1042             if (!"UNBOUNDED".equals(maxObj)) {
1043                 log.debug("Invalid occurrenses format. Max occurrence is {}", maxObj);
1044                 throw new ByActionStatusComponentException(ActionStatus.INVALID_OCCURRENCES);
1045             }
1046         } else {
1047             if (maxObj instanceof Integer) {
1048                 maxOccurrences = (Integer) maxObj;
1049             } else {
1050                 log.debug("Invalid occurrenses format.  Max occurrence is {}", maxObj);
1051                 throw new ByActionStatusComponentException(ActionStatus.INVALID_OCCURRENCES);
1052             }
1053             if (maxOccurrences < 0 || maxOccurrences < minOccurrences) {
1054                 log.debug("Invalid occurrenses format.  min occurrence is {}, Max occurrence is {}", minOccurrences, maxOccurrences);
1055                 throw new ByActionStatusComponentException(ActionStatus.INVALID_OCCURRENCES);
1056             }
1057         }
1058     }
1059
1060     public synchronized void init(ServletContext servletContext) {
1061         if (this.servletContext == null) {
1062             this.servletContext = servletContext;
1063             responseFormatManager = ResponseFormatManager.getInstance();
1064             resourceBusinessLogic = getResourceBL(servletContext);
1065         }
1066     }
1067
1068     public boolean isResourceExist(String resourceName) {
1069         return resourceBusinessLogic.isResourceExist(resourceName);
1070     }
1071
1072     private ResourceBusinessLogic getResourceBL(ServletContext context) {
1073         WebAppContextWrapper webApplicationContextWrapper = (WebAppContextWrapper) context
1074             .getAttribute(org.openecomp.sdc.common.api.Constants.WEB_APPLICATION_CONTEXT_WRAPPER_ATTR);
1075         WebApplicationContext webApplicationContext = webApplicationContextWrapper.getWebAppContext(context);
1076         return webApplicationContext.getBean(ResourceBusinessLogic.class);
1077     }
1078
1079     public ServletContext getServletContext() {
1080         return servletContext;
1081     }
1082
1083     public void setServletContext(ServletContext servletContext) {
1084         this.servletContext = servletContext;
1085     }
1086
1087     public AuditingManager getAuditingManager() {
1088         return auditingManager;
1089     }
1090
1091     @Autowired
1092     public void setAuditingManager(AuditingManager auditingManager) {
1093         this.auditingManager = auditingManager;
1094     }
1095
1096     public ResponseFormatManager getResponseFormatManager() {
1097         return responseFormatManager;
1098     }
1099
1100     public void setResponseFormatManager(ResponseFormatManager responseFormatManager) {
1101         this.responseFormatManager = responseFormatManager;
1102     }
1103
1104     public ResourceBusinessLogic getResourceBusinessLogic() {
1105         return resourceBusinessLogic;
1106     }
1107
1108     @Autowired
1109     public void setResourceBusinessLogic(ResourceBusinessLogic resourceBusinessLogic) {
1110         this.resourceBusinessLogic = resourceBusinessLogic;
1111     }
1112
1113     public IGraphLockOperation getGraphLockOperation() {
1114         return graphLockOperation;
1115     }
1116
1117     @Autowired
1118     public void setGraphLockOperation(IGraphLockOperation graphLockOperation) {
1119         this.graphLockOperation = graphLockOperation;
1120     }
1121
1122     private List<DataTypeDefinition> extractDataTypeFromJson(final ResourceBusinessLogic resourceBusinessLogic,
1123                                                              final Map<String, Object> foundElements,
1124                                                              final String model) {
1125         final List<DataTypeDefinition> dataTypeDefinitionList = new ArrayList<>();
1126         if (MapUtils.isNotEmpty(foundElements)) {
1127             final Either<Map<String, DataTypeDefinition>, JanusGraphOperationStatus> dataTypeCacheAll =
1128                 resourceBusinessLogic.applicationDataTypeCache.getAll(model);
1129             if (dataTypeCacheAll.isLeft()) {
1130                 for (final Entry<String, Object> attributeNameValue : foundElements.entrySet()) {
1131                     final Object value = attributeNameValue.getValue();
1132                     if (value instanceof Map) {
1133                         final DataTypeDefinition dataTypeDefinition = createDataTypeDefinitionWithName(attributeNameValue);
1134                         final DataTypeDefinition dataTypeDefinitionParent = dataTypeCacheAll.left().value()
1135                             .get(dataTypeDefinition.getDerivedFromName());
1136                         dataTypeDefinition.setDerivedFrom(dataTypeDefinitionParent);
1137                         dataTypeDefinitionList.add(dataTypeDefinition);
1138                     } else {
1139                         dataTypeDefinitionList.add(createDataType(String.valueOf(value)));
1140                     }
1141                 }
1142             }
1143         }
1144         return dataTypeDefinitionList;
1145     }
1146 }