message: "Error: Could not fetch data types from data base with model %1",
messageId: "SVC4153"
}
+
+ #-----------SVC4154---------------------------
+ # %1 - "Model name"
+ UNKNOWN_MODEL_TYPE: {
+ code: 400,
+ message: "Error: Model type %1 not known in the system",
+ messageId: "SVC4154"
+ }
#-----------SVC4154---------------------------
CSAR_TOSCA_IMPORTS_ERROR: {
}
}
- public Either<List<Component>, ResponseFormat> getLatestVersionNotAbstractComponentsMetadata(boolean isAbstractAbstract,
- HighestFilterEnum highestFilter,
- ComponentTypeEnum componentTypeEnum,
- String internalComponentType, String userId,
- String modelName) {
+ public Either<List<Component>, ResponseFormat> getLatestVersionNotAbstractComponentsMetadata(final boolean isAbstractAbstract,
+ final HighestFilterEnum highestFilter,
+ final ComponentTypeEnum componentTypeEnum,
+ final String internalComponentType, String userId,
+ final String modelName,
+ final boolean includeNormativeExtensionModels) {
Either<List<Component>, StorageOperationStatus> nonCheckoutCompResponse = null;
try {
validateUserExists(userId);
nonCheckoutCompResponse = toscaOperationFacade
- .getLatestVersionNotAbstractMetadataOnly(isAbstractAbstract, componentTypeEnum, internalComponentType, modelName);
+ .getLatestVersionNotAbstractMetadataOnly(isAbstractAbstract, componentTypeEnum, internalComponentType, modelName, includeNormativeExtensionModels);
if (nonCheckoutCompResponse.isLeft()) {
log.debug("Retrieved Resource successfully.");
return Either.left(nonCheckoutCompResponse.left().value());
import java.util.Map;
import java.util.Optional;
import org.apache.commons.lang3.StringUtils;
+import org.openecomp.sdc.be.datatypes.enums.ModelTypeEnum;
import org.openecomp.sdc.be.model.Model;
import org.openecomp.sdc.be.model.jsonjanusgraph.operations.exception.ModelOperationExceptionSupplier;
import org.openecomp.sdc.be.model.operations.impl.ModelOperation;
public List<Model> listModels() {
return modelOperation.findAllModels();
}
+
+ public List<Model> listModels(final ModelTypeEnum modelType) {
+ return modelOperation.findModels(modelType);
+ }
public void createModelImports(final String modelName, final InputStream modelImportsZip) {
if (StringUtils.isEmpty(modelName)) {
import org.openecomp.sdc.be.datatypes.enums.ComponentFieldsEnum;
import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
import org.openecomp.sdc.be.datatypes.enums.CreatedFrom;
+import org.openecomp.sdc.be.datatypes.enums.ModelTypeEnum;
import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum;
import org.openecomp.sdc.be.impl.ComponentsUtils;
}
if (MapUtils.isNotEmpty(dataTypesToCreate)) {
final String nameForGeneratedModel = resource.getModel() + "_" + csarInfo.getVfResourceName() + resource.getCsarVersion();
- final Model model = new Model(nameForGeneratedModel, resource.getModel());
+ final Model model = new Model(nameForGeneratedModel, resource.getModel(), ModelTypeEnum.NORMATIVE_EXTENSION);
modelBusinessLogic.createModel(model, new Yaml().dump(dataTypesToCreate));
resource.setModel(nameForGeneratedModel);
}
@Context final HttpServletRequest request,
@QueryParam("internalComponentType") String internalComponentType,
@QueryParam("componentModel") String internalComponentModel,
+ @QueryParam("includeNormativeExtensionModels") boolean includeNormativeExtensionModels,
@HeaderParam(value = Constants.USER_ID_HEADER) String userId,
@Parameter(description = "uid list", required = true) String data)
throws IOException {
}
Either<List<Component>, ResponseFormat> actionResponse = businessLogic
.getLatestVersionNotAbstractComponentsMetadata(false, HighestFilterEnum.HIGHEST_ONLY, componentTypeEnum,
- internalComponentType, userId, internalComponentModel);
+ internalComponentType, userId, internalComponentModel, includeNormativeExtensionModels);
if (actionResponse.isRight()) {
log.debug(FAILED_TO_GET_ALL_NON_ABSTRACT, componentType);
return buildErrorResponse(actionResponse.right().value());
import javax.ws.rs.PUT;
import javax.ws.rs.Path;
import javax.ws.rs.Produces;
+import javax.ws.rs.QueryParam;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Response;
import javax.ws.rs.core.Response.Status;
+import org.apache.commons.lang3.StringUtils;
import org.glassfish.jersey.media.multipart.FormDataParam;
import org.openecomp.sdc.be.components.impl.ComponentInstanceBusinessLogic;
import org.openecomp.sdc.be.components.impl.ModelBusinessLogic;
import org.openecomp.sdc.be.components.validation.UserValidations;
import org.openecomp.sdc.be.config.BeEcompErrorManager;
import org.openecomp.sdc.be.dao.api.ActionStatus;
+import org.openecomp.sdc.be.datatypes.enums.ModelTypeEnum;
import org.openecomp.sdc.be.exception.BusinessException;
import org.openecomp.sdc.be.impl.ComponentsUtils;
import org.openecomp.sdc.be.impl.ServletUtils;
import org.openecomp.sdc.be.model.Model;
+import org.openecomp.sdc.be.model.jsonjanusgraph.operations.exception.ModelOperationExceptionSupplier;
import org.openecomp.sdc.be.ui.model.ModelCreateRequest;
import org.openecomp.sdc.be.user.Role;
import org.openecomp.sdc.be.user.UserBusinessLogic;
validateUser(ValidationUtils.sanitizeInputString(userId));
final var modelName = ValidationUtils.sanitizeInputString(modelCreateRequest.getName().trim());
try {
+ if (modelCreateRequest.getModelType() == null){
+ modelCreateRequest.setModelType(ModelTypeEnum.NORMATIVE);
+ }
final Model createdModel = modelBusinessLogic
.createModel(new JMapper<>(Model.class, ModelCreateRequest.class).getDestination(modelCreateRequest));
modelBusinessLogic.createModelImports(modelName, modelImportsZip);
@ApiResponse(responseCode = "403", description = "Restricted operation")
}
)
- public Response listModels(@HeaderParam(value = Constants.USER_ID_HEADER) final String userId) {
+ public Response listModels(@HeaderParam(value = Constants.USER_ID_HEADER) final String userId, @QueryParam("modelType") final String modelType) {
validateUser(ValidationUtils.sanitizeInputString(userId));
try {
- final List<Model> modelList = modelBusinessLogic.listModels();
+ final List<Model> modelList = StringUtils.isEmpty(modelType)? modelBusinessLogic.listModels() : modelBusinessLogic.listModels(getModelTypeEnum(modelType));
return buildOkResponse(getComponentsUtils().getResponseFormat(ActionStatus.OK), RepresentationUtils.toRepresentation(modelList));
} catch (final BusinessException e) {
throw e;
return buildErrorResponse(getComponentsUtils().getResponseFormat(ActionStatus.GENERAL_ERROR));
}
}
+
+ private ModelTypeEnum getModelTypeEnum(final String modelType) {
+ final ModelTypeEnum modelTypeEnum = ModelTypeEnum.valueOf(modelType.toUpperCase());
+ if (modelTypeEnum == null) {
+ throw ModelOperationExceptionSupplier.unknownModelType(modelType).get();
+ }
+ return modelTypeEnum;
+ }
@PUT
@Path("/model/imports")
List<Component> componentList;
actionResponse = resourceBL
.getLatestVersionNotAbstractComponentsMetadata(isAbstract, HighestFilterEnum.HIGHEST_ONLY, ComponentTypeEnum.RESOURCE, null, userId,
- null);
+ null, false);
if (actionResponse.isRight()) {
log.debug(FAILED_TO_GET_ALL_NON_ABSTRACT, ComponentTypeEnum.RESOURCE.getValue());
return Either.right(buildErrorResponse(actionResponse.right().value()));
vduCp.getProperties().add(roleProp);
when(toscaOperationFacade.getLatestByToscaResourceNameAndModel("tosca.nodes.nfv.VduCp", "testModel_myVnf1.0")).thenReturn(Either.left(vduCp));
-
when(yamlTemplateParsingHandler.parseResourceInfoFromYAML(any(), any(), any(), any(), any(), any())).thenReturn(parsedToscaYamlInfo);
UploadComponentInstanceInfo uploadComponentInstanceInfo = new UploadComponentInstanceInfo();
// Model related
MODEL_ALREADY_EXISTS, INVALID_MODEL, MODEL_IMPORTS_IS_EMPTY, COULD_NOT_READ_MODEL_IMPORTS, MODEL_NOT_FOUND, MODEL_NAME_CANNOT_BE_EMPTY,
COMPONENT_WITH_MODEL_ALREADY_EXIST, COMPONENT_WITH_VENDOR_RELEASE_ALREADY_EXISTS, COMPONENT_WITH_VENDOR_RELEASE_ALREADY_EXISTS_IN_MODEL,
+ UNKNOWN_MODEL_TYPE,
// Service API URL
INVALID_SERVICE_API_URL,
// Property related
import org.openecomp.sdc.be.dao.neo4j.GraphEdgeLabels;
import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
import org.openecomp.sdc.be.datatypes.enums.GraphPropertyEnum;
+import org.openecomp.sdc.be.datatypes.enums.ModelTypeEnum;
import org.openecomp.sdc.be.datatypes.tosca.ToscaDataDefinition;
import org.openecomp.sdc.common.jsongraph.util.CommonUtility;
import org.openecomp.sdc.common.jsongraph.util.CommonUtility.LogLevelEnum;
return Either.right(graph.right().value());
}
}
+
+ public Either<List<GraphVertex>, JanusGraphOperationStatus> getByCriteria(final VertexTypeEnum type, final Map<GraphPropertyEnum, Object> props,
+ final Map<GraphPropertyEnum, Object> hasNotProps,
+ final JsonParseFlagEnum parseFlag,
+ final String model) {
+ return getByCriteria(type, props, hasNotProps, null, parseFlag, model, false);
+ }
- public Either<List<GraphVertex>, JanusGraphOperationStatus> getByCriteria(VertexTypeEnum type, Map<GraphPropertyEnum, Object> props,
- Map<GraphPropertyEnum, Object> hasNotProps,
- JsonParseFlagEnum parseFlag,
- String model) {
- return getByCriteria(type, props, hasNotProps, null, parseFlag, model);
+ public Either<List<GraphVertex>, JanusGraphOperationStatus> getByCriteria(final VertexTypeEnum type, final Map<GraphPropertyEnum, Object> props,
+ final Map<GraphPropertyEnum, Object> hasNotProps,
+ final JsonParseFlagEnum parseFlag,
+ final String model,
+ final boolean includeNormativeExtensionModels) {
+ return getByCriteria(type, props, hasNotProps, null, parseFlag, model, includeNormativeExtensionModels);
+ }
+
+ public Either<List<GraphVertex>, JanusGraphOperationStatus> getByCriteria(final VertexTypeEnum type,
+ final Map<GraphPropertyEnum, Object> hasProps,
+ final Map<GraphPropertyEnum, Object> hasNotProps,
+ final Map<String, Entry<JanusGraphPredicate, Object>> predicates,
+ final JsonParseFlagEnum parseFlag,
+ final String model) {
+ return getByCriteria(type, hasProps, hasNotProps, predicates, parseFlag, model, false);
}
public Either<List<GraphVertex>, JanusGraphOperationStatus> getByCriteria(final VertexTypeEnum type,
final Map<GraphPropertyEnum, Object> hasNotProps,
final Map<String, Entry<JanusGraphPredicate, Object>> predicates,
final JsonParseFlagEnum parseFlag,
- final String model) {
+ final String model,
+ final boolean includeNormativeExtensionModels) {
Either<JanusGraph, JanusGraphOperationStatus> graph = janusGraphClient.getGraph();
if (graph.isLeft()) {
try {
}
List<GraphVertex> result = new ArrayList<>();
- final Predicate<? super JanusGraphVertex> filterPredicate = StringUtils.isEmpty(model) ? this::vertexNotConnectedToAnyModel : vertex -> vertexValidForModel(vertex, model);
+ final Predicate<? super JanusGraphVertex> filterPredicate = StringUtils.isEmpty(model) ? this::vertexNotConnectedToAnyModel : vertex -> vertexValidForModel(vertex, model, includeNormativeExtensionModels);
final List<JanusGraphVertex> verticesForModel = StreamSupport.stream(vertices.spliterator(), false).filter(filterPredicate).collect(Collectors.toList());
if (verticesForModel == null || verticesForModel.size() == 0) {
return Either.right(JanusGraphOperationStatus.NOT_FOUND);
}
}
- private boolean vertexValidForModel(final JanusGraphVertex vertex, final String model) {
+ private boolean vertexValidForModel(final JanusGraphVertex vertex, final String model, final boolean includeNormativeExtensions) {
final String vertexLabel = (String)vertex.property(GraphPropertyEnum.LABEL.getProperty()).value();
final VertexTypeEnum vertexType = VertexTypeEnum.getByName(vertexLabel);
final GraphEdgeLabels edgeLabel = vertexType.equals(VertexTypeEnum.TOPOLOGY_TEMPLATE) ? GraphEdgeLabels.MODEL : GraphEdgeLabels.MODEL_ELEMENT;
final Either<List<ImmutablePair<JanusGraphVertex, Edge>>, JanusGraphOperationStatus> modelVertices = getParentVerticies(vertex, edgeLabel);
- return modelVertices.isLeft() && modelVertices.left().value().stream().anyMatch(vertexPair -> modelVertexMatchesModel(vertexPair.getLeft(), model));
+ return modelVertices.isLeft() && modelVertices.left().value().stream().anyMatch(vertexPair -> modelVertexMatchesModel(vertexPair.getLeft(), model, includeNormativeExtensions));
}
- private boolean modelVertexMatchesModel(final JanusGraphVertex modelVertex, final String model) {
+ private boolean modelVertexMatchesModel(final JanusGraphVertex modelVertex, final String model, final boolean includeNormativeExtensions) {
if (model.equals((String)modelVertex.property("name").value())) {
return true;
}
final Either<List<ImmutablePair<JanusGraphVertex, Edge>>, JanusGraphOperationStatus> derivedModels =
getParentVerticies(modelVertex, GraphEdgeLabels.DERIVED_FROM);
- return derivedModels.isLeft() && derivedModels.left().value().stream().anyMatch(derivedModel ->modelVertexMatchesModel(derivedModel.left, model));
+ if (derivedModels.isLeft() && derivedModels.left().value().stream().anyMatch(derivedModel ->modelVertexMatchesModel(derivedModel.left, model, includeNormativeExtensions))) {
+ return true;
+ }
+
+ if (includeNormativeExtensions && isANormativeExtension(modelVertex)) {
+ final Either<List<Vertex>,JanusGraphOperationStatus> derivedFromModels =
+ getChildrenVertices(modelVertex, EdgeLabelEnum.DERIVED_FROM, JsonParseFlagEnum.ParseAll);
+ return derivedFromModels.isLeft() && derivedFromModels.left().value().stream().anyMatch(derivedFromModel -> model.equals((String)derivedFromModel.property("name").value()));
+ }
+ return false;
+ }
+
+ private boolean isANormativeExtension(final JanusGraphVertex modelVertex) {
+ return ModelTypeEnum.NORMATIVE_EXTENSION.getValue().equals((String)modelVertex.property(GraphPropertyEnum.MODEL_TYPE.getProperty()).value());
}
private Either<List<ImmutablePair<JanusGraphVertex, Edge>>, JanusGraphOperationStatus> getParentVerticies(
CONTACT_ID ("contactId", String.class, false, false),
VENDOR_NAME ("vendorName", String.class, false, false),
VENDOR_RELEASE ("vendorRelease", String.class, false, false),
- MODEL ("model", String.class, false, false),
+ MODEL ("model", String.class, false, false),
+ MODEL_TYPE ("modelType", String.class, false, false),
CONFORMANCE_LEVEL ("conformanceLevel", String.class, false, false),
ICON ("icon", String.class, false, false),
TAGS ("tags", String.class, false, false),
import lombok.Getter;
import org.openecomp.sdc.be.dao.graph.datatype.GraphNode;
import org.openecomp.sdc.be.dao.neo4j.GraphPropertiesDictionary;
+import org.openecomp.sdc.be.datatypes.enums.ModelTypeEnum;
import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
@Getter
private final String name;
private final String uniqueId;
+ private final String modelType;
- public ModelData(final String name, final String uniqueId) {
+ public ModelData(final String name, final String uniqueId, final ModelTypeEnum modelType) {
super(NodeTypeEnum.Model);
this.name = name;
this.uniqueId = uniqueId;
+ this.modelType = modelType.getValue();
}
public ModelData(final Map<String, Object> properties) {
super(NodeTypeEnum.Model);
name = (String) properties.get(GraphPropertiesDictionary.NAME.getProperty());
uniqueId = (String) properties.get(GraphPropertiesDictionary.UNIQUE_ID.getProperty());
+ modelType = (String) properties.get(GraphPropertiesDictionary.MODEL_TYPE.getProperty());
}
@Override
final Map<String, Object> map = new HashMap<>();
addIfExists(map, GraphPropertiesDictionary.NAME, name);
addIfExists(map, GraphPropertiesDictionary.UNIQUE_ID, uniqueId);
+ addIfExists(map, GraphPropertiesDictionary.MODEL_TYPE, modelType);
return map;
}
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.TestInstance;
import org.junit.jupiter.api.TestInstance.Lifecycle;
+import org.openecomp.sdc.be.datatypes.enums.ModelTypeEnum;
@TestInstance(Lifecycle.PER_CLASS)
class ModelDataTest {
private final String modelName = "ETSI-SDC-MODEL-TEST";
private final String modelId = UUID.randomUUID().toString();
+ private final ModelTypeEnum modelType = ModelTypeEnum.NORMATIVE;
ModelData modelData;
@BeforeAll
void initTestData() {
- modelData = new ModelData(modelName, modelId);
+ modelData = new ModelData(modelName, modelId, modelType);
}
@Test
assertThat(modelData).isNotNull();
assertThat(modelData.getUniqueId()).isEqualTo(modelId);
assertThat(modelData.getName()).isEqualTo(modelName);
+ assertThat(modelData.getModelType()).isEqualTo(modelType.getValue());
}
@Test
void modelDataFromPropertiesMapTest() {
- final Map<String, Object> properties = new HashMap();
+ final Map<String, Object> properties = new HashMap<>();
properties.put("name", modelData.getName());
properties.put("uid", modelData.getUniqueId());
+ properties.put("modelType", modelData.getModelType());
final ModelData modelDataFromPropertiesMap = new ModelData(properties);
assertThat(modelDataFromPropertiesMap).isNotNull();
assertThat(modelDataFromPropertiesMap.getUniqueId()).isEqualTo(modelId);
assertThat(modelDataFromPropertiesMap.getName()).isEqualTo(modelName);
+ assertThat(modelDataFromPropertiesMap.getModelType()).isEqualTo(modelType.getValue());
}
@Test
assertThat(result).isNotEmpty();
assertThat(result.values()).contains(modelId);
assertThat(result.values()).contains(modelName);
+ assertThat(result.values()).contains(modelType.getValue());
}
}
*/
package org.openecomp.sdc.be.model;
+import org.openecomp.sdc.be.datatypes.enums.ModelTypeEnum;
import com.googlecode.jmapper.annotations.JGlobalMap;
import lombok.AllArgsConstructor;
import lombok.Data;
private String name;
private String derivedFrom;
+ private ModelTypeEnum modelType;
public Model(final String name) {
this.name = name;
}
+
+ public Model(final String name, final ModelTypeEnum modelType) {
+ this.name = name;
+ this.modelType = modelType;
+ }
}
return fetchServicesByCriteria(services, hasProps, hasNotProps, modelName);
}
- private Either<List<Component>, StorageOperationStatus> getLatestVersionNotAbstractToscaElementsMetadataOnly(boolean isAbstract,
- ComponentTypeEnum componentTypeEnum,
- String internalComponentType,
- VertexTypeEnum vertexType,
- String modelName) {
+ private Either<List<Component>, StorageOperationStatus> getLatestVersionNotAbstractToscaElementsMetadataOnly(final boolean isAbstract,
+ final ComponentTypeEnum componentTypeEnum,
+ final String internalComponentType,
+ final VertexTypeEnum vertexType,
+ final String modelName,
+ final boolean includeNormativeExtensionModels) {
List<Service> services = null;
Map<GraphPropertyEnum, Object> hasProps = new EnumMap<>(GraphPropertyEnum.class);
Map<GraphPropertyEnum, Object> hasNotProps = new EnumMap<>(GraphPropertyEnum.class);
fillPropsMap(hasProps, hasNotProps, internalComponentType, componentTypeEnum, isAbstract, vertexType, modelName);
Either<List<GraphVertex>, JanusGraphOperationStatus> getRes = janusGraphDao
- .getByCriteria(vertexType, hasProps, hasNotProps, JsonParseFlagEnum.ParseMetadata, modelName);
+ .getByCriteria(vertexType, hasProps, hasNotProps, JsonParseFlagEnum.ParseMetadata, modelName, includeNormativeExtensionModels);
if (getRes.isRight() && !JanusGraphOperationStatus.NOT_FOUND.equals(getRes.right().value())) {
return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(getRes.right().value()));
}
private Either<List<String>, StorageOperationStatus> getComponentUids(boolean isAbstract, ComponentTypeEnum componentTypeEnum,
String internalComponentType) {
Either<List<Component>, StorageOperationStatus> getToscaElementsRes = getLatestVersionNotAbstractMetadataOnly(isAbstract, componentTypeEnum,
- internalComponentType, null);
+ internalComponentType, null, false);
if (getToscaElementsRes.isRight()) {
return Either.right(getToscaElementsRes.right().value());
}
}
public Either<List<Component>, StorageOperationStatus> getLatestVersionNotAbstractMetadataOnly(boolean isAbstract,
- ComponentTypeEnum componentTypeEnum,
- String internalComponentType,
- String modelName) {
+ final ComponentTypeEnum componentTypeEnum,
+ final String internalComponentType,
+ final String modelName,
+ final boolean includeNormativeExtensionModels) {
List<VertexTypeEnum> internalVertexTypes = getInternalVertexTypes(componentTypeEnum, internalComponentType);
List<Component> result = new ArrayList<>();
for (VertexTypeEnum vertexType : internalVertexTypes) {
Either<List<Component>, StorageOperationStatus> listByVertexType = getLatestVersionNotAbstractToscaElementsMetadataOnly(isAbstract,
- componentTypeEnum, internalComponentType, vertexType, modelName);
+ componentTypeEnum, internalComponentType, vertexType, modelName, includeNormativeExtensionModels);
if (listByVertexType.isRight()) {
return listByVertexType;
}
var errorMsg = String.format("Failed to retrieve models. Status '%s'", janusGraphOperationStatus);
return () -> new OperationException(ActionStatus.GENERAL_ERROR, errorMsg);
}
+
+ public static Supplier<OperationException> unknownModelType(final String modelType) {
+ return () -> new OperationException(ActionStatus.UNKNOWN_MODEL_TYPE, modelType);
+ }
}
import org.openecomp.sdc.be.dao.neo4j.GraphEdgeLabels;
import org.openecomp.sdc.be.data.model.ToscaImportByModel;
import org.openecomp.sdc.be.datatypes.enums.GraphPropertyEnum;
+import org.openecomp.sdc.be.datatypes.enums.ModelTypeEnum;
import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
import org.openecomp.sdc.be.model.Model;
import org.openecomp.sdc.be.model.jsonjanusgraph.operations.exception.ModelOperationExceptionSupplier;
public Model createModel(final Model model, final boolean inTransaction) {
Model result = null;
- final var modelData = new ModelData(model.getName(), UniqueIdBuilder.buildModelUid(model.getName()));
+ final var modelData = new ModelData(model.getName(), UniqueIdBuilder.buildModelUid(model.getName()), model.getModelType());
try {
final Either<ModelData, JanusGraphOperationStatus> createNode = janusGraphGenericDao.createNode(modelData, ModelData.class);
if (createNode.isRight()) {
String.format("Failed to create model %s on JanusGraph with %s error", model, janusGraphOperationStatus));
}
addDerivedFromRelation(model);
- result = new Model(createNode.left().value().getName(), model.getDerivedFrom());
+ result = new Model(createNode.left().value().getName(), model.getDerivedFrom(), model.getModelType());
return result;
} finally {
if (!inTransaction) {
public List<Model> findAllModels() {
return findModelsByCriteria(Collections.emptyMap());
}
+
+ public List<Model> findModels(final ModelTypeEnum modelType) {
+ final Map<GraphPropertyEnum, Object> propertyCriteria = new EnumMap<>(GraphPropertyEnum.class);
+ propertyCriteria.put(GraphPropertyEnum.MODEL_TYPE, modelType.getValue());
+
+ return findModelsByCriteria(propertyCriteria);
+ }
private List<Model> findModelsByCriteria(final Map<GraphPropertyEnum, Object> propertyCriteria) {
final List<GraphVertex> modelVerticesByCriteria = findModelVerticesByCriteria(propertyCriteria);
private Model convertToModel(final GraphVertex modelGraphVertex) {
final String modelName = (String) modelGraphVertex.getMetadataProperty(GraphPropertyEnum.NAME);
-
+ final String modelTypeProperty = (String) modelGraphVertex.getMetadataProperty(GraphPropertyEnum.MODEL_TYPE);
+ final ModelTypeEnum modelType = StringUtils.isEmpty(modelTypeProperty) ? ModelTypeEnum.NORMATIVE : ModelTypeEnum.findByValue(modelTypeProperty).get();
+
final Either<ImmutablePair<ModelData, GraphEdge>, JanusGraphOperationStatus> parentNode =
janusGraphGenericDao.getChild(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.Model), UniqueIdBuilder.buildModelUid(modelName),
GraphEdgeLabels.DERIVED_FROM, NodeTypeEnum.Model, ModelData.class);
log.error(EcompLoggerErrorCode.DATA_ERROR, this.getClass().getName(), operationException.getMessage());
throw operationException;
}
- return new Model((String) modelGraphVertex.getMetadataProperty(GraphPropertyEnum.NAME));
+ return new Model((String) modelGraphVertex.getMetadataProperty(GraphPropertyEnum.NAME), modelType);
} else {
final ModelData parentModel = parentNode.left().value().getKey();
- return new Model((String) modelGraphVertex.getMetadataProperty(GraphPropertyEnum.NAME), parentModel.getName());
+ return new Model((String) modelGraphVertex.getMetadataProperty(GraphPropertyEnum.NAME), parentModel.getName(), modelType);
}
}
import javax.validation.constraints.NotNull;
import javax.validation.constraints.Size;
+import org.openecomp.sdc.be.datatypes.enums.ModelTypeEnum;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
private String name;
private String derivedFrom;
+
+ private ModelTypeEnum modelType;
+
}
import org.openecomp.sdc.be.dao.janusgraph.HealingJanusGraphGenericDao;
import org.openecomp.sdc.be.dao.neo4j.GraphEdgeLabels;
import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus;
+import org.openecomp.sdc.be.datatypes.enums.ModelTypeEnum;
import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
import org.openecomp.sdc.be.model.CapabilityTypeDefinition;
import org.openecomp.sdc.be.model.Model;
capabilityTypeDefinition.setType("tosca.capabilities.Container1");
capabilityTypeDefinition.setModel("testModel");
- Model model = new Model("testModel");
+ Model model = new Model("testModel", ModelTypeEnum.NORMATIVE);
modelOperation.createModel(model , true);
Either<CapabilityTypeDefinition, StorageOperationStatus> addCapabilityType1 = capabilityTypeOperation.addCapabilityType(capabilityTypeDefinition, true);
import org.mockito.MockitoAnnotations;
import org.openecomp.sdc.be.dao.janusgraph.HealingJanusGraphGenericDao;
import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus;
+import org.openecomp.sdc.be.datatypes.enums.ModelTypeEnum;
import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
import org.openecomp.sdc.be.model.DataTypeDefinition;
import org.openecomp.sdc.be.model.Model;
private void initTestData() {
- model = new Model(modelName);
+ model = new Model(modelName, ModelTypeEnum.NORMATIVE);
final String TEST_DATA_TYPE_001 = "test.data.type001";
final String TEST_DATA_TYPE_002 = "test.data.type002";
final String TEST_DATA_TYPE_003 = "test.data.type003";
import org.openecomp.sdc.be.dao.neo4j.GraphEdgeLabels;
import org.openecomp.sdc.be.dao.neo4j.GraphPropertiesDictionary;
import org.openecomp.sdc.be.datatypes.elements.GroupTypeDataDefinition;
+import org.openecomp.sdc.be.datatypes.enums.ModelTypeEnum;
import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
import org.openecomp.sdc.be.model.CapabilityDefinition;
import org.openecomp.sdc.be.model.CapabilityTypeDefinition;
public void testAddGroupTypeWithModel() {
GroupTypeDefinition groupTypeDefinition = createGroupTypeDef();
groupTypeDefinition.setModel("testModel");
- Model model = new Model("testModel");
+ Model model = new Model("testModel", ModelTypeEnum.NORMATIVE);
modelOperation.createModel(model , true);
Either<GroupTypeDefinition, StorageOperationStatus> addGroupType = groupTypeOperation.addGroupType(groupTypeDefinition);
import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus;
import org.openecomp.sdc.be.dao.neo4j.GraphEdgeLabels;
import org.openecomp.sdc.be.datatypes.components.ComponentMetadataDataDefinition;
+import org.openecomp.sdc.be.datatypes.enums.ModelTypeEnum;
import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
import org.openecomp.sdc.be.model.InterfaceDefinition;
import org.openecomp.sdc.be.model.ModelTestBase;
@Test
public void testGetAllInterfaceLifecycleTypesWithModel() {
final var uid = UniqueIdBuilder.buildInterfaceTypeUid(MODEL_NAME, INTERFACE_TYPE);
- final var modelData = new ModelData(MODEL_NAME, uid);
+ final var modelData = new ModelData(MODEL_NAME, uid, ModelTypeEnum.NORMATIVE);
final ImmutablePair<GraphNode, GraphEdge> modelNode = new ImmutablePair<>(modelData, Mockito.mock(GraphEdge.class));
final InterfaceData interfaceData = new InterfaceData();
import org.openecomp.sdc.be.dao.neo4j.GraphEdgeLabels;
import org.openecomp.sdc.be.data.model.ToscaImportByModel;
import org.openecomp.sdc.be.datatypes.enums.GraphPropertyEnum;
+import org.openecomp.sdc.be.datatypes.enums.ModelTypeEnum;
import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
import org.openecomp.sdc.be.model.Model;
import org.openecomp.sdc.be.model.ModelTestBase;
@Test
void createModelSuccessTest() {
- final ModelData modelData = new ModelData(modelName, UniqueIdBuilder.buildModelUid(modelName));
+ final ModelData modelData = new ModelData(modelName, UniqueIdBuilder.buildModelUid(modelName), ModelTypeEnum.NORMATIVE);
when(janusGraphGenericDao.createNode(any(),any())).thenReturn(Either.left(modelData));
- final Model createdModel = modelOperation.createModel(new Model(modelName), false);
+ final Model createdModel = modelOperation.createModel(new Model(modelName, ModelTypeEnum.NORMATIVE), false);
assertThat(createdModel).isNotNull();
assertThat(createdModel.getName()).isEqualTo(modelName);
}
@Test
void createDerivedModelSuccessTest() {
final String derivedModelName = "derivedModel";
- final ModelData modelData = new ModelData(derivedModelName, UniqueIdBuilder.buildModelUid(derivedModelName));
+ final ModelData modelData = new ModelData(derivedModelName, UniqueIdBuilder.buildModelUid(derivedModelName), ModelTypeEnum.NORMATIVE);
when(janusGraphGenericDao.createNode(any(),any())).thenReturn(Either.left(modelData));
final GraphVertex modelVertex = new GraphVertex();
modelVertex.addMetadataProperty(GraphPropertyEnum.NAME, "baseModel");
+ modelVertex.addMetadataProperty(GraphPropertyEnum.MODEL_TYPE, ModelTypeEnum.NORMATIVE.getValue());
when(janusGraphDao.getByCriteria(eq(VertexTypeEnum.MODEL), anyMap())).thenReturn(Either.left(Collections.singletonList(modelVertex)));
when(janusGraphGenericDao.getChild(eq("uid"), anyString(), eq(GraphEdgeLabels.DERIVED_FROM), eq(NodeTypeEnum.Model), eq(ModelData.class))).thenReturn(Either.right(JanusGraphOperationStatus.NOT_FOUND));
when(derivedFromOperation.addDerivedFromRelation("model.derivedModel", "model.baseModel", NodeTypeEnum.Model)).thenReturn(Either.left(new GraphRelation()));
- final Model createdModel = modelOperation.createModel(new Model(derivedModelName, modelName), false);
+ final Model createdModel = modelOperation.createModel(new Model(derivedModelName, modelName, ModelTypeEnum.NORMATIVE), false);
assertThat(createdModel).isNotNull();
assertThat(createdModel.getName()).isEqualTo(derivedModelName);
}
@Test
void createModelFailWithModelAlreadyExistTest() {
when(janusGraphGenericDao.createNode(any(),any())).thenReturn(Either.right(JanusGraphOperationStatus.JANUSGRAPH_SCHEMA_VIOLATION));
- final var model = new Model(modelName);
+ final var model = new Model(modelName, ModelTypeEnum.NORMATIVE);
assertThrows(OperationException.class, () -> modelOperation.createModel(model, false));
}
@Test
void createModelFailTest() {
when(janusGraphGenericDao.createNode(any(),any())).thenReturn(Either.right(JanusGraphOperationStatus.GRAPH_IS_NOT_AVAILABLE));
- final var model = new Model(modelName);
+ final var model = new Model(modelName, ModelTypeEnum.NORMATIVE);
assertThrows(OperationException.class, () -> modelOperation.createModel(model, false));
}
var modelName = "modelName";
final GraphVertex expectedVertex = mock(GraphVertex.class);
when(expectedVertex.getMetadataProperty(GraphPropertyEnum.NAME)).thenReturn(modelName);
+ when(expectedVertex.getMetadataProperty(GraphPropertyEnum.MODEL_TYPE)).thenReturn(ModelTypeEnum.NORMATIVE.getValue());
when(janusGraphDao.getByCriteria(eq(VertexTypeEnum.MODEL), mapArgumentCaptor.capture())).thenReturn(Either.left(List.of(expectedVertex)));
when(janusGraphGenericDao.getChild("uid", UniqueIdBuilder.buildModelUid(modelName), GraphEdgeLabels.DERIVED_FROM, NodeTypeEnum.Model,
ModelData.class)).thenReturn(Either.right(JanusGraphOperationStatus.NOT_FOUND));
assertEquals(modelName, value.get(GraphPropertyEnum.NAME));
assertEquals(UniqueIdBuilder.buildModelUid(modelName), value.get(GraphPropertyEnum.UNIQUE_ID));
- final Model expectedModel = new Model(modelName);
+ final Model expectedModel = new Model(modelName, ModelTypeEnum.NORMATIVE);
assertTrue(modelByNameOpt.isPresent());
assertEquals(expectedModel, modelByNameOpt.get());
}
void findAllModelsSuccessTest() {
final GraphVertex expectedVertex = mock(GraphVertex.class);
when(expectedVertex.getMetadataProperty(GraphPropertyEnum.NAME)).thenReturn(modelName);
+ when(expectedVertex.getMetadataProperty(GraphPropertyEnum.MODEL_TYPE)).thenReturn(ModelTypeEnum.NORMATIVE.getValue());
when(janusGraphDao.getByCriteria(VertexTypeEnum.MODEL, Collections.emptyMap())).thenReturn(Either.left(List.of(expectedVertex)));
when(janusGraphGenericDao.getChild("uid", UniqueIdBuilder.buildModelUid(modelName), GraphEdgeLabels.DERIVED_FROM, NodeTypeEnum.Model,
ModelData.class)).thenReturn(Either.right(JanusGraphOperationStatus.NOT_FOUND));
import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
-
-import fj.data.Either;
import java.util.Iterator;
import java.util.List;
import java.util.stream.Stream;
import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus;
import org.openecomp.sdc.be.dao.neo4j.GraphEdgeLabels;
import org.openecomp.sdc.be.datatypes.elements.PolicyTypeDataDefinition;
+import org.openecomp.sdc.be.datatypes.enums.ModelTypeEnum;
import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
import org.openecomp.sdc.be.model.Model;
import org.openecomp.sdc.be.model.ModelTestBase;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+import fj.data.Either;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:application-context-test.xml")
public void testAddPolicyTypeWithModel() {
PolicyTypeDefinition policyTypeDefinition = createPolicyTypeDef();
policyTypeDefinition.setModel("testModel");
- Model model = new Model("testModel");
+ Model model = new Model("testModel", ModelTypeEnum.NORMATIVE);
modelOperation.createModel(model , true);
Either<PolicyTypeDefinition, StorageOperationStatus> addPolicyType = policyTypeOperation.addPolicyType(policyTypeDefinition);
import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus;
import org.openecomp.sdc.be.dao.neo4j.GraphEdgeLabels;
import org.openecomp.sdc.be.datatypes.elements.RelationshipInstDataDefinition;
+import org.openecomp.sdc.be.datatypes.enums.ModelTypeEnum;
import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
import org.openecomp.sdc.be.model.ModelTestBase;
import org.openecomp.sdc.be.model.PropertyConstraint;
.when(janusGraphGenericDao).getNode(Mockito.anyString(), Mockito.any(), Mockito.eq(RelationshipTypeData.class), Mockito.any());
- ModelData modelData = new ModelData("modelA", "modelA");
+ ModelData modelData = new ModelData("modelA", "modelA", ModelTypeEnum.NORMATIVE);
ImmutablePair<ModelData, GraphEdge> pair = new ImmutablePair<>(modelData, new GraphEdge());
Mockito.doReturn(Either.left(pair))
.when(janusGraphGenericDao).getParentNode("uid", relationshipInstDataDefinition1.getUniqueId(), GraphEdgeLabels.MODEL_ELEMENT, NodeTypeEnum.Model, ModelData.class);
Mockito.doReturn(Either.left(new GraphRelation())).when(derivedFromOperation)
.addDerivedFromRelation(relationshipTypeDefinition.getUniqueId(), derivedFromRelationshipTypeData.getUniqueId(), NodeTypeEnum.RelationshipType);
- ModelData modelData = new ModelData("modelA", "modelA");
+ ModelData modelData = new ModelData("modelA", "modelA", ModelTypeEnum.NORMATIVE);
ImmutablePair<ModelData, GraphEdge> pair = new ImmutablePair<>(modelData, new GraphEdge());
Mockito.doReturn(Either.left(pair))
.when(janusGraphGenericDao).getParentNode("uid", dervideFromRelationshipInstDataDefinition.getUniqueId(), GraphEdgeLabels.MODEL_ELEMENT, NodeTypeEnum.Model, ModelData.class);
Mockito.doReturn(Either.right(JanusGraphOperationStatus.NOT_FOUND)).when(janusGraphGenericDao)
.getChild(Mockito.any(), Mockito.anyString(), Mockito.any(), Mockito.any(), Mockito.eq(RelationshipTypeData.class));
- ModelData modelData = new ModelData("modelA", "modelA");
+ ModelData modelData = new ModelData("modelA", "modelA", ModelTypeEnum.NORMATIVE);
ImmutablePair<ModelData, GraphEdge> pair = new ImmutablePair<>(modelData, new GraphEdge());
Mockito.doReturn(Either.left(pair))
.when(janusGraphGenericDao).getParentNode("uid", newRelationshipTypeDefinition.getUniqueId(), GraphEdgeLabels.MODEL_ELEMENT, NodeTypeEnum.Model, ModelData.class);
.getChild(Mockito.anyString(), Mockito.anyString(), Mockito.any(), Mockito.any(),
Mockito.eq(RelationshipTypeData.class));
- ModelData modelData = new ModelData("modelA", "modelA");
+ ModelData modelData = new ModelData("modelA", "modelA", ModelTypeEnum.NORMATIVE);
ImmutablePair<ModelData, GraphEdge> pair = new ImmutablePair<>(modelData, new GraphEdge());
Mockito.doReturn(Either.left(pair))
.when(janusGraphGenericDao).getParentNode("uid", relationshipTypeDefinition.getUniqueId(), GraphEdgeLabels.MODEL_ELEMENT, NodeTypeEnum.Model, ModelData.class);
let model = this.workspaceService.metadata.model
if (model) {
params = params.append('componentModel', model);
+ if (this.workspaceService.getMetadataType() === 'SERVICE'){
+ params = params.append('includeNormativeExtensionModels', 'true');
+ }
}
const loadInstances = this.http.get(this.facadeUrl, {params});
const loadGroups = this.http.get(this.baseUrl + 'groupTypes', {params});
return this.http.get<Model[]>(this.baseUrl + "/v1/catalog/model");
}
+ getModelsOfType(type: string):Observable<Model[]> {
+ return this.http.get<Model[]>(this.baseUrl + "/v1/catalog/model?modelType=" + type);
+ }
+
}
return;
}
- this.modelService.getModels().subscribe((modelsFound: Model[]) => {
- modelsFound.forEach(model => {this.$scope.models.push({id: model.name, name: model.name})});
- });
+ if (!this.$scope.isCreateMode() && this.$scope.isVspImport()){
+ this.modelService.getModels().subscribe((modelsFound: Model[]) => {
+ modelsFound.forEach(model => {this.$scope.models.push({id: model.name, name: model.name})});
+ });
+ } else {
+ this.modelService.getModelsOfType("normative").subscribe((modelsFound: Model[]) => {
+ modelsFound.forEach(model => {this.$scope.models.push({id: model.name, name: model.name})});
+ });
+ }
this.$scope.models.sort(function (model1, model2) {
if (model1.id > model2.id) {
CURRENT_CATALOG_UPDATE_TIME("currentUpdateTime", Long.class, false, true),
//Healing
HEALING_VERSION("healVersion", Integer.class, false, true),
- MODEL("model", String.class, false, false);
+ MODEL("model", String.class, false, false),
+ MODEL_TYPE("modelType", String.class, false, false);
// @formatter:on
private final String property;
--- /dev/null
+/*
+ * ============LICENSE_START=======================================================
+ * Copyright (C) 2021 Nordix Foundation
+ * ================================================================================
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ * ============LICENSE_END=========================================================
+ */
+package org.openecomp.sdc.be.datatypes.enums;
+
+import java.util.Arrays;
+import java.util.Optional;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+@Getter
+@AllArgsConstructor
+public enum ModelTypeEnum {
+ NORMATIVE("normative"),
+ NORMATIVE_EXTENSION("normative-extension");
+
+ private final String value;
+
+ public static Optional<ModelTypeEnum> findByValue(String value) {
+ return Arrays.stream(ModelTypeEnum.values()).filter(modelTypeEnum -> modelTypeEnum.getValue().equals(value)).findAny();
+ }
+}
function getModelUrl() {
const restCatalogPrefix = Configuration.get('restCatalogPrefix');
- return `${restCatalogPrefix}/v1/catalog/model/`;
+ return `${restCatalogPrefix}/v1/catalog/model?modelType=normative`;
}
function uploadFile(vspId, formData, version) {
});
mockRest.addHandler('fetch', ({options, data, baseUrl}) => {
- expect(baseUrl).toEqual('/sdc1/feProxy/rest/v1/catalog/model/');
+ expect(baseUrl).toEqual('/sdc1/feProxy/rest/v1/catalog/model?modelType=normative');
expect(data).toEqual(undefined);
expect(options).toEqual(undefined);
return [];
Code Review / sdc.git / commitdiff