import org.apache.commons.collections4.CollectionUtils;
+import org.openecomp.core.util.UniqueValueUtil;
+import org.openecomp.core.utilities.json.JsonSchemaDataGenerator;
import org.openecomp.sdc.common.errors.CoreException;
import org.openecomp.sdc.common.errors.ErrorCategory;
import org.openecomp.sdc.common.errors.ErrorCode;
import org.openecomp.sdc.logging.types.LoggerErrorCode;
import org.openecomp.sdc.logging.types.LoggerTragetServiceName;
import org.openecomp.sdc.vendorsoftwareproduct.ComputeManager;
-import org.openecomp.sdc.vendorsoftwareproduct.dao.ComponentDao;
+import org.openecomp.sdc.vendorsoftwareproduct.VendorSoftwareProductConstants;
import org.openecomp.sdc.vendorsoftwareproduct.dao.ComputeDao;
import org.openecomp.sdc.vendorsoftwareproduct.dao.DeploymentFlavorDao;
import org.openecomp.sdc.vendorsoftwareproduct.dao.VendorSoftwareProductInfoDao;
private CompositionEntityDataManager compositionEntityDataManager;
private VendorSoftwareProductInfoDao vspInfoDao;
private DeploymentFlavorDao deploymentFlavorDao;
- private ComponentDao componentDao;
- private static final String MANUAL = "Manual";
-
- public ComputeManagerImpl(
- VendorSoftwareProductInfoDao vspInfoDao,
- ComputeDao computeDao,
- CompositionEntityDataManager compositionEntityDataManager,
- DeploymentFlavorDao deploymentFlavorDao,
- ComponentDao componentDao
- ) {
+
+ public ComputeManagerImpl(VendorSoftwareProductInfoDao vspInfoDao,
+ ComputeDao computeDao,
+ CompositionEntityDataManager compositionEntityDataManager,
+ DeploymentFlavorDao deploymentFlavorDao) {
this.computeDao = computeDao;
this.compositionEntityDataManager = compositionEntityDataManager;
this.vspInfoDao = vspInfoDao;
this.deploymentFlavorDao = deploymentFlavorDao;
- this.componentDao = componentDao;
}
@Override
- public ComputeEntity createCompute(ComputeEntity compute, String user) {
- ComputeEntity createdCompute = null;
- mdcDataDebugMessage.debugEntryMessage("VSP id, component id", compute.getVspId(),
- compute.getComponentId());
-
- /*Version activeVersion =
- getVersionInfo(compute.getVspId(), VersionableEntityAction.Write, user).getActiveVersion();
- compute.setVersion(activeVersion);*/
- //if (!isManual(compute.getVspId(), activeVersion)) {
+ public ComputeEntity createCompute(ComputeEntity compute) {
+ mdcDataDebugMessage
+ .debugEntryMessage("VSP id, component id", compute.getVspId(), compute.getComponentId());
+
if (!vspInfoDao.isManual(compute.getVspId(), compute.getVersion())) {
ErrorCode onboardingMethodUpdateErrorCode = NotSupportedHeatOnboardMethodErrorBuilder
.getAddComputeNotSupportedHeatOnboardMethodErrorBuilder();
onboardingMethodUpdateErrorCode.message());
throw new CoreException(onboardingMethodUpdateErrorCode);
} else {
-
- //validateComponentId(compute.getVspId(),compute.getVersion(),compute.getComponentId());
- Collection<ComputeEntity> vfcComputeList = listCompute(compute.getVspId(),compute.getVersion
- (),compute.getComponentId());
-
- validateVfcCompute(compute, vfcComputeList, LoggerTragetServiceName.CREATE_COMPUTE);
- createdCompute = createCompute(compute);
+ validateUniqueName(compute.getVspId(), compute.getVersion(), compute.getComponentId(),
+ compute.getComputeCompositionData().getName());
+
+ compute.setQuestionnaireData(
+ new JsonSchemaDataGenerator(getComputeQuestionnaireSchema(null)).generateData());
+ computeDao.create(compute);
+ createUniqueName(compute.getVspId(), compute.getVersion(), compute.getComponentId(),
+ compute.getComputeCompositionData().getName());
}
mdcDataDebugMessage
.debugExitMessage("VSP id, component id", compute.getVspId(), compute.getComponentId());
- return createdCompute;
+ return compute;
}
- private ComputeEntity createCompute(ComputeEntity compute) {
-
- return compositionEntityDataManager.createCompute(compute);
- }
-
- /*private void validateCompute(ComputeEntity compute) {
- Collection<ComputeEntity> vfcComputeList = listCompute(compute.getVspId(),compute.getVersion
- (),compute.getComponentId());
-
- if (!isComputeNameUnique(vfcComputeList,compute.getComputeCompositionData().getName())) {
- final ErrorCode duplicateComputeInComponentErrorBuilder =
- new DuplicateComputeInComponentErrorBuilder(compute.getComputeCompositionData().getName(),
- compute.getComponentId()).build();
- MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
- LoggerTragetServiceName.CREATE_COMPUTE, ErrorLevel.ERROR.name(),
- LoggerErrorCode.DATA_ERROR.getErrorCode(),
- duplicateComputeInComponentErrorBuilder.message());
- throw new CoreException(duplicateComputeInComponentErrorBuilder);
- }
-
- }*/
-
- private void validateComputeUpdate(ComputeEntity compute) {
- Collection<ComputeEntity> vfcComputeList = listCompute(compute.getVspId(),compute.getVersion
- (),compute.getComponentId());
-
- for (ComputeEntity ce : vfcComputeList) {
- if (ce.getId().equals(compute.getId())) {
- vfcComputeList.remove(ce);
- break;
- }
- }
-
- if (!isComputeNameUnique(vfcComputeList,compute.getComputeCompositionData().getName())) {
- final ErrorCode duplicateComputeInComponentErrorBuilder =
- new DuplicateComputeInComponentErrorBuilder(compute.getComputeCompositionData().getName(),
- compute.getComponentId()).build();
- MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
- LoggerTragetServiceName.UPDATE_COMPUTE, ErrorLevel.ERROR.name(),
- LoggerErrorCode.DATA_ERROR.getErrorCode(),
- duplicateComputeInComponentErrorBuilder.message());
- throw new CoreException(duplicateComputeInComponentErrorBuilder);
- }
-
- }
@Override
- public Collection<ListComputeResponse> listCompute(String vspId, Version version,
- String componentId, String user) {
-
+ public Collection<ListComputeResponse> listComputes(String vspId, Version version,
+ String componentId) {
mdcDataDebugMessage.debugEntryMessage("VSP id, component id", vspId, componentId);
- //validateComponentId(vspId, version, componentId);
- ComputeEntity entity = new ComputeEntity(vspId, version, componentId, null);
- Collection<ComputeEntity> computes = computeDao.list(entity);
+ Collection<ComputeEntity> computes =
+ computeDao.list(new ComputeEntity(vspId, version, componentId, null));
Collection<ListComputeResponse> computeResponse =
- getListComputeResponse(vspId, version, user, computes);
+ getListComputeResponse(vspId, version, computes);
mdcDataDebugMessage.debugExitMessage("VSP id, component id", vspId, componentId);
return computeResponse;
}
private Collection<ListComputeResponse> getListComputeResponse(String vspId, Version version,
- String user,
Collection<ComputeEntity> computes) {
- Set<String> vspComputes = getComputeAssociatedWithDepFlavors(vspId, version, user);
- Collection<ListComputeResponse> computeResponse = new ArrayList<ListComputeResponse>();
- for(ComputeEntity computeEntity : computes) {
+ Set<String> vspComputes = getComputeAssociatedWithDepFlavors(vspId, version);
+ Collection<ListComputeResponse> computeResponse = new ArrayList<>();
+ for (ComputeEntity computeEntity : computes) {
ListComputeResponse response = new ListComputeResponse();
response.setComputeEntity(computeEntity);
- if(vspComputes.contains(computeEntity.getId())) {
+ if (vspComputes.contains(computeEntity.getId())) {
response.setAssociatedWithDeploymentFlavor(true);
} else {
response.setAssociatedWithDeploymentFlavor(false);
return computeResponse;
}
- private Set<String> getComputeAssociatedWithDepFlavors(String vspId, Version version,
- String user) {
+ private Set<String> getComputeAssociatedWithDepFlavors(String vspId, Version version) {
final Collection<DeploymentFlavorEntity> deploymentFlavorEntities =
deploymentFlavorDao.list(new DeploymentFlavorEntity(vspId, version, null));
- Set<String> vspComputes = new HashSet<String>();
- for(DeploymentFlavorEntity entity : deploymentFlavorEntities) {
+ Set<String> vspComputes = new HashSet<>();
+ for (DeploymentFlavorEntity entity : deploymentFlavorEntities) {
final List<ComponentComputeAssociation> componentComputeAssociations =
entity.getDeploymentFlavorCompositionData().getComponentComputeAssociations();
- if(componentComputeAssociations != null && !componentComputeAssociations.isEmpty()) {
- for(ComponentComputeAssociation association : componentComputeAssociations) {
+ if (componentComputeAssociations != null && !componentComputeAssociations.isEmpty()) {
+ for (ComponentComputeAssociation association : componentComputeAssociations) {
vspComputes.add(association.getComputeFlavorId());
}
}
return vspComputes;
}
- private boolean isComputeNameUnique(Collection<ComputeEntity> vfcComputeList, String name) {
- for (ComputeEntity compute : vfcComputeList) {
- if (compute.getComputeCompositionData().getName().equalsIgnoreCase(name)) {
- return false;
- }
- }
- return true;
- }
-
- private Collection<ComputeEntity> listCompute(String vspId, Version version,String componentId) {
- Collection<ComputeEntity> computeEntities =
- computeDao.list(new ComputeEntity(vspId, version, componentId, null));
-
- return computeEntities;
- }
-
@Override
public CompositionEntityResponse<ComputeData> getCompute(String vspId, Version version,
String componentId,
- String computeFlavorId, String user) {
+ String computeFlavorId) {
mdcDataDebugMessage.debugEntryMessage("VSP id, component id, compute id", vspId,
componentId, computeFlavorId);
- /*version = VersioningUtil
- .resolveVersion(version, getVersionInfo(vspId, VersionableEntityAction.Read, user));*/
- ComputeEntity computeEntity = getCompute(vspId, version, componentId, computeFlavorId);
+ ComputeEntity computeEntity = getValidatedCompute(vspId, version, componentId, computeFlavorId);
ComputeData compute = computeEntity.getComputeCompositionData();
ComputeCompositionSchemaInput schemaInput = new ComputeCompositionSchemaInput();
return response;
}
- private ComputeEntity getCompute(String vspId, Version version, String componentId, String
- computeFlavorId) {
- //validateComponentId(vspId,version,componentId);
+ private ComputeEntity getValidatedCompute(String vspId, Version version, String componentId,
+ String computeFlavorId) {
ComputeEntity retrieved = computeDao.get(new ComputeEntity(vspId, version, componentId,
computeFlavorId));
VersioningUtil
return retrieved;
}
- /*private void validateComponentId(String vspId, Version version, String componentId) {
- ComponentEntity retrivedComponent = componentDao.get(new ComponentEntity(vspId, version,
- componentId));
- VersioningUtil
- .validateEntityExistence(retrivedComponent, new ComponentEntity(vspId, version,
- componentId),VspDetails.ENTITY_TYPE);
- }*/
-
@Override
public QuestionnaireResponse getComputeQuestionnaire(String vspId, Version version, String
- componentId, String computeId, String user) {
+ componentId, String computeId) {
mdcDataDebugMessage.debugEntryMessage("VSP id, componentId", vspId, componentId, computeId);
- /*version = VersioningUtil
- .resolveVersion(version, getVersionInfo(vspId, VersionableEntityAction.Read, user));*/
- //validateComponentId(vspId,version,componentId);
QuestionnaireResponse questionnaireResponse = new QuestionnaireResponse();
- //validateComponentId(vspId,version,componentId);
- ComputeEntity computeQuestionnaire = computeDao.getQuestionnaireData(vspId, version, componentId, computeId);
+ ComputeEntity computeQuestionnaire =
+ computeDao.getQuestionnaireData(vspId, version, componentId, computeId);
VersioningUtil
- .validateEntityExistence(computeQuestionnaire, new ComputeEntity(vspId, version, componentId,
- computeId), VspDetails.ENTITY_TYPE);
+ .validateEntityExistence(computeQuestionnaire,
+ new ComputeEntity(vspId, version, componentId, computeId), VspDetails.ENTITY_TYPE);
questionnaireResponse.setData(computeQuestionnaire.getQuestionnaireData());
questionnaireResponse.setSchema(getComputeQuestionnaireSchema(null));
- mdcDataDebugMessage.debugExitMessage("VSP id, component id", vspId,
- componentId, computeId);
+ mdcDataDebugMessage.debugExitMessage("VSP id, component id", vspId, componentId, computeId);
return questionnaireResponse;
}
- protected String getComputeQuestionnaireSchema(SchemaTemplateInput schemaInput) {
- mdcDataDebugMessage.debugEntryMessage(null, null);
-
- mdcDataDebugMessage.debugExitMessage(null, null);
- return SchemaGenerator
- .generate(SchemaTemplateContext.questionnaire, CompositionEntityType.compute,
- schemaInput);
- }
-
-
@Override
- public void updateComputeQuestionnaire(String vspId, Version version, String componentId, String
- computeId,
- String questionnaireData, String user) {
- mdcDataDebugMessage.debugEntryMessage("VSP id, component id, compute id", vspId,
- componentId, computeId);
+ public void updateComputeQuestionnaire(String vspId, Version version, String componentId,
+ String computeId, String questionnaireData) {
+ mdcDataDebugMessage
+ .debugEntryMessage("VSP id, component id, compute id", vspId, componentId, computeId);
- /*Version activeVersion =
- getVersionInfo(vspId, VersionableEntityAction.Write, user).getActiveVersion();
- getComponent(vspId, activeVersion, componentId);*/
- ComputeEntity retrieved = computeDao.get(new ComputeEntity(vspId,version,componentId,
+ ComputeEntity retrieved = computeDao.get(new ComputeEntity(vspId, version, componentId,
computeId));
VersioningUtil.validateEntityExistence(retrieved, new ComputeEntity(vspId, version,
componentId, computeId), VspDetails.ENTITY_TYPE);
computeDao.updateQuestionnaireData(vspId, version, componentId, computeId, questionnaireData);
- mdcDataDebugMessage.debugExitMessage("VSP id, component id, compute id", vspId,
- componentId, computeId);
+ mdcDataDebugMessage
+ .debugExitMessage("VSP id, component id, compute id", vspId, componentId, computeId);
}
@Override
- public CompositionEntityValidationData updateCompute(ComputeEntity compute, String user) {
+ public CompositionEntityValidationData updateCompute(ComputeEntity compute) {
mdcDataDebugMessage
- .debugEntryMessage("VSP id, component id", compute.getVspId(), compute.getComponentId(),
- compute.getId());
-
- /*Version activeVersion =
- getVersionInfo(image.getVspId(), VersionableEntityAction.Write, user).getActiveVersion();
- image.setVersion(activeVersion);*/
+ .debugEntryMessage("VSP id, component id", compute.getVspId(), compute.getComponentId(),
+ compute.getId());
- ComputeEntity retrieved = getComputeEntity(compute.getVspId(), compute.getVersion(), compute.getComponentId(),
+ ComputeEntity retrieved =
+ getComputeEntity(compute.getVspId(), compute.getVersion(), compute.getComponentId(),
compute.getId());
- if(!vspInfoDao.isManual(compute.getVspId(), compute.getVersion())) {
- final ComputeData computeCompositionData = compute.getComputeCompositionData();
- final String name = computeCompositionData.getName();
- //final String format = computeCompositionData.getFormat();
- validateHeatVspComputeUpdate("Name", name, retrieved.getComputeCompositionData()
- .getName());
- /*validateHeatVspComputeUpdate("format", format, retrieved.getComputeCompositionData()
- .getFormat());*/
+ boolean manual = vspInfoDao.isManual(compute.getVspId(), compute.getVersion());
+ if (!manual) {
+ validateHeatVspComputeUpdate("Name",
+ compute.getComputeCompositionData().getName(),
+ retrieved.getComputeCompositionData().getName());
}
- Collection<ComputeEntity> vfcComputeList = listComputes(compute.getVspId() ,
- compute.getVersion(), compute.getComponentId());
-
- //Set to null so that retrieved object is equal to one in list and gets removed.
- retrieved.setQuestionnaireData(null);
- vfcComputeList.remove(retrieved);
- if(vspInfoDao.isManual(compute.getVspId(), compute.getVersion()))
- validateVfcCompute(compute, vfcComputeList, LoggerTragetServiceName.UPDATE_COMPUTE);
-
- //Set format to default value in order to handle FTL validation when compute format is null
- /*if(compute.getComputeCompositionData().getFormat() == null)
- compute.getComputeCompositionData().setFormat(ComputeFormat.qcow2.name());*/
-
ComputeCompositionSchemaInput schemaInput = new ComputeCompositionSchemaInput();
schemaInput.setCompute(compute.getComputeCompositionData());
CompositionEntityValidationData validationData = compositionEntityDataManager
- .validateEntity(compute, SchemaTemplateContext.composition, schemaInput);
+ .validateEntity(compute, SchemaTemplateContext.composition, schemaInput);
if (CollectionUtils.isEmpty(validationData.getErrors())) {
+ updateUniqueName(compute.getVspId(), compute.getVersion(), compute.getComponentId(),
+ retrieved.getComputeCompositionData().getName(),
+ compute.getComputeCompositionData().getName());
computeDao.update(compute);
}
mdcDataDebugMessage
- .debugExitMessage("VSP id, component id", compute.getVspId(), compute.getComponentId(),
- compute.getId());
+ .debugExitMessage("VSP id, component id", compute.getVspId(), compute.getComponentId(),
+ compute.getId());
return validationData;
}
private void validateHeatVspComputeUpdate(String name, String value, String retrivedValue) {
- if(value != null && !value.equals(retrivedValue)) {
+ if (value != null && !value.equals(retrivedValue)) {
final ErrorCode updateHeatComputeErrorBuilder =
- DuplicateComputeInComponentErrorBuilder.getComputeHeatReadOnlyErrorBuilder(name);
+ DuplicateComputeInComponentErrorBuilder.getComputeHeatReadOnlyErrorBuilder(name);
MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
- LoggerTragetServiceName.UPDATE_COMPUTE, ErrorLevel.ERROR.name(),
- LoggerErrorCode.PERMISSION_ERROR.getErrorCode(),
- updateHeatComputeErrorBuilder.message());
+ LoggerTragetServiceName.UPDATE_COMPUTE, ErrorLevel.ERROR.name(),
+ LoggerErrorCode.PERMISSION_ERROR.getErrorCode(),
+ updateHeatComputeErrorBuilder.message());
throw new CoreException(updateHeatComputeErrorBuilder);
}
}
- private void validateVfcCompute(ComputeEntity compute, Collection<ComputeEntity> vfcComputeList,
- String event) {
- if (isComputeNameDuplicate(vfcComputeList,compute.getComputeCompositionData().getName(),
- compute.getId())) {
- ErrorCode errorCode = DuplicateComputeInComponentErrorBuilder
- .getDuplicateComputeNameErrorBuilder(compute.getComputeCompositionData().getName(),
- compute.getComponentId());
-
- MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
- event, ErrorLevel.ERROR.name(),
- errorCode.id(),errorCode.message());
-
- throw new CoreException(errorCode);
- }
- }
-
- private boolean isComputeNameDuplicate(Collection<ComputeEntity> computes, String name, String computeId) {
- for (ComputeEntity compute : computes) {
- if (compute.getComputeCompositionData().getName().equalsIgnoreCase(name) && !compute.getId().equals(computeId)) {
- return true;
- }
- }
- return false;
- }
-
-
private ComputeEntity getComputeEntity(String vspId, Version version, String componentId,
- String computeId) {
- //validateComponentId(vspId,version,componentId);
- ComputeEntity computeEntity = computeDao.get(new ComputeEntity(vspId, version, componentId, computeId));
- VersioningUtil.validateEntityExistence(computeEntity, new ComputeEntity(vspId, version, componentId,
- computeId), VspDetails.ENTITY_TYPE);
- return computeEntity;
- }
-
- private Collection<ComputeEntity> listComputes(String vspId, Version version, String componentId) {
- return computeDao.list(new ComputeEntity(vspId, version, componentId, null));
+ String computeId) {
+ ComputeEntity computeEntity =
+ computeDao.get(new ComputeEntity(vspId, version, componentId, computeId));
+ VersioningUtil
+ .validateEntityExistence(computeEntity, new ComputeEntity(vspId, version, componentId,
+ computeId), VspDetails.ENTITY_TYPE);
+ return computeEntity;
}
@Override
- public void deleteCompute(String vspId, Version version, String componentId, String
- computeFlavorId, String user) {
+ public void deleteCompute(String vspId, Version version, String componentId,
+ String computeFlavorId) {
final String VSP_COMPOSITION_EDIT_NOT_ALLOWED_MSG =
"Composition entities may not be created / deleted for Vendor Software Product "
+ "whose entities were uploaded";
mdcDataDebugMessage.debugEntryMessage("VSP id, component id, compute id", vspId,
componentId, computeFlavorId);
- /*Version activeVersion =
- getVersionInfo(vspId, VersionableEntityAction.Write, user).getActiveVersion();*/
if (!vspInfoDao.isManual(vspId, version)) {
MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
LoggerTragetServiceName.DELETE_COMPUTE, ErrorLevel.ERROR.name(),
.withId(VendorSoftwareProductErrorCodes.VSP_COMPOSITION_EDIT_NOT_ALLOWED)
.withMessage(VSP_COMPOSITION_EDIT_NOT_ALLOWED_MSG).build());
}
- ComputeEntity retrived = getCompute(vspId,version,componentId,computeFlavorId);
- if (retrived != null){
- deleteComputeFromDeploymentFlavors(vspId,version,computeFlavorId);
+ ComputeEntity retrieved = getValidatedCompute(vspId, version, componentId, computeFlavorId);
+ if (retrieved != null) {
+ deleteComputeFromDeploymentFlavors(vspId, version, computeFlavorId);
computeDao.delete(new ComputeEntity(vspId, version, componentId, computeFlavorId));
+ deleteUniqueValue(retrieved.getVspId(), retrieved.getVersion(), retrieved.getComponentId(),
+ retrieved.getComputeCompositionData().getName());
}
mdcDataDebugMessage.debugExitMessage("VSP id, component id, compute id", vspId,
componentId, computeFlavorId);
}
- private void deleteComputeFromDeploymentFlavors(String vspId, Version activeVersion,
+ private void deleteComputeFromDeploymentFlavors(String vspId, Version version,
String computeFlavorId) {
- //Collection<DeploymentFlavorEntity> listDF = listDeploymentFlavors(vspId, activeVersion);
- Collection<DeploymentFlavorEntity> listDF = deploymentFlavorDao.list(new DeploymentFlavorEntity
- (vspId, activeVersion, null));
- for(DeploymentFlavorEntity df : listDF) {
- DeploymentFlavorEntity deploymentFlavorEntity=removeComputeFromDF(df, computeFlavorId);
- if(deploymentFlavorEntity!=null)
+ Collection<DeploymentFlavorEntity> listDF =
+ deploymentFlavorDao.list(new DeploymentFlavorEntity(vspId, version, null));
+ for (DeploymentFlavorEntity df : listDF) {
+ DeploymentFlavorEntity deploymentFlavorEntity = removeComputeFromDF(df, computeFlavorId);
+ if (deploymentFlavorEntity != null) {
deploymentFlavorDao.update(deploymentFlavorEntity);
+ }
}
}
- private DeploymentFlavorEntity removeComputeFromDF(DeploymentFlavorEntity df, String
- computeFlavorId) {
+ private DeploymentFlavorEntity removeComputeFromDF(DeploymentFlavorEntity df,
+ String computeFlavorId) {
DeploymentFlavor flavor = df.getDeploymentFlavorCompositionData();
List<ComponentComputeAssociation> associations = flavor.getComponentComputeAssociations();
if (associations != null) {
return null;
}
- protected String getComputeCompositionSchema(SchemaTemplateInput schemaInput){
- mdcDataDebugMessage.debugEntryMessage(null, null);
- mdcDataDebugMessage.debugExitMessage(null, null);
- return SchemaGenerator.generate(SchemaTemplateContext.composition, CompositionEntityType.compute, schemaInput);
+ protected String getComputeCompositionSchema(SchemaTemplateInput schemaInput) {
+ mdcDataDebugMessage.debugEntryMessage(null);
+ mdcDataDebugMessage.debugExitMessage(null);
+ return SchemaGenerator
+ .generate(SchemaTemplateContext.composition, CompositionEntityType.compute, schemaInput);
+ }
+
+ protected String getComputeQuestionnaireSchema(SchemaTemplateInput schemaInput) {
+ mdcDataDebugMessage.debugEntryMessage(null);
+ mdcDataDebugMessage.debugExitMessage(null);
+ return SchemaGenerator
+ .generate(SchemaTemplateContext.questionnaire, CompositionEntityType.compute, schemaInput);
}
- /*boolean isManual(String vspId, Version version) {
+ protected void validateUniqueName(String vspId, Version version, String componentId,
+ String name) {
+ UniqueValueUtil.validateUniqueValue(VendorSoftwareProductConstants.UniqueValues.COMPUTE_NAME,
+ vspId, version.getId(), componentId, name);
+ }
- VspDetails vsp = vspInfoDao.get(new VspDetails(vspId, version));
- String onboardingMethod = vsp.getOnboardingMethod();
- if (MANUAL.equals(onboardingMethod)) {
- return true;
- }
- return false;
- }*/
+ protected void createUniqueName(String vspId, Version version, String componentId, String name) {
+ UniqueValueUtil
+ .createUniqueValue(VendorSoftwareProductConstants.UniqueValues.COMPUTE_NAME, vspId,
+ version.getId(), componentId, name);
+ }
+
+ protected void updateUniqueName(String vspId, Version version, String componentId,
+ String oldName, String newName) {
+ UniqueValueUtil
+ .updateUniqueValue(VendorSoftwareProductConstants.UniqueValues.COMPUTE_NAME, oldName,
+ newName, vspId, version.getId(), componentId);
+ }
+ protected void deleteUniqueValue(String vspId, Version version, String componentId, String name) {
+ if (componentId == null) {
+ UniqueValueUtil
+ .deleteUniqueValue(VendorSoftwareProductConstants.UniqueValues.COMPUTE_NAME, vspId,
+ version.getId(), name);
+ }
+ UniqueValueUtil
+ .deleteUniqueValue(VendorSoftwareProductConstants.UniqueValues.COMPUTE_NAME, vspId,
+ version.getId(), componentId, name);
+ }
}
Code Review / sdc.git / blobdiff