protected override void Context()
{
base.Context();
_metaDataCategories = new List<MetaDataCategory>();
_dataImporterSettings = new DataImporterSettings();
_dataImporterSettings.AddNamingPatternMetaData("File");
}
public async Task Run_FileFormatError1()
{
// ARRANGE
this.fixture.MoqElementRepository.Invocations.Clear();
DataImporterSettings settings = new DataImporterSettings()
{
BlockSize = 100,
FileURI = nameof(FileResources.FileFormatError1),
};
int contador = 0;
this.fixture.MoqElementRepository
.Setup(a => a.SaveCollection(It.IsAny <List <Element> >()))
.Callback((List <Element> lst) => contador += lst.Count);
DataImporter sut = new DataImporter(
new Mock <ILogger <DataImporter> >().Object,
this.fixture.ServiceProvider.GetRequiredService <IFileImporterRepository>(),
this.fixture.ServiceProvider.GetRequiredService <IElementRepository>(),
settings);
// ACT
Func <Task> actTodo = () => sut.Run();
// ASSERT
await Assert.ThrowsAsync <FormatException>(actTodo);
this.fixture.MoqElementRepository.Verify(a => a.Initialize(), Times.Once());
}
protected override void Context()
{
base.Context();
_dialogCreator = A.Fake <IDialogCreator>();
_importer = IoC.Container.Resolve <IImporter>();
_applicationController = A.Fake <ApplicationController>();
sut = new DataImporter(_dialogCreator, _importer, _applicationController, _dimensionFactory);
_importerConfiguration = new ImporterConfiguration {
FileName = "IntegrationSample1.xlsx", NamingConventions = "{Source}.{Sheet}.{Organ}.{Molecule}"
};
_importerConfiguration.AddToLoadedSheets("Sheet1");
_importerConfigurationMW = new ImporterConfiguration {
FileName = "IntegrationSample1.xlsx", NamingConventions = "{Source}.{Sheet}.{Organ}.{Molecule}"
};
_importerConfigurationMW.AddToLoadedSheets("Sheet1");
_metaDataCategories = (IReadOnlyList <MetaDataCategory>)sut.DefaultMetaDataCategoriesForObservedData();
_dataImporterSettings = new DataImporterSettings();
_dataImporterSettings.NameOfMetaDataHoldingMoleculeInformation = "Molecule";
_dataImporterSettings.NameOfMetaDataHoldingMolecularWeightInformation = "Molecular Weight";
_dataImporterSettings.IgnoreSheetNamesAtImport = true;
_dataImporterSettings.CheckMolWeightAgainstMolecule = false;
_columnInfos = getDefaultColumnInfos();
_metaDataCategories.First(md => md.Name == _dataImporterSettings.NameOfMetaDataHoldingMoleculeInformation).ListOfValues.Add("TestInputMolecule", "233");
}
public void ReloadWithPKSimSettings()
{
var dataImporterSettings = new DataImporterSettings();
dataImporterSettings.AddNamingPatternMetaData(Constants.FILE, Constants.SHEET);
dataImporterSettings.AddNamingPatternMetaData(Constants.FILE, Constants.SHEET, "Species");
using (var serializationContext = SerializationTransaction.Create(_container))
{
var serializer = _modelingXmlSerializerRepository.SerializerFor <ImporterConfiguration>();
var fileName = _dialogCreator.AskForFileToOpen("Save configuration", "xml files (*.xml)|*.xml|All files (*.*)|*.*",
Constants.DirectoryKey.PROJECT);
if (fileName.IsNullOrEmpty())
{
return;
}
var xel = XElement.Load(fileName); // We have to correctly handle the case of cancellation
var configuration = serializer.Deserialize <ImporterConfiguration>(xel, serializationContext);
dataImporterSettings.NameOfMetaDataHoldingMoleculeInformation = "Molecule";
dataImporterSettings.NameOfMetaDataHoldingMolecularWeightInformation = "Molecular Weight";
_dialogCreator.MessageBoxInfo(_dataImporter.ImportFromConfiguration
(
configuration,
_dataImporter.DefaultMetaDataCategoriesForObservedData(),
_dataImporter.ColumnInfosForObservedData(),
dataImporterSettings,
_dialogCreator.AskForFileToOpen(Captions.Importer.OpenFile, Captions.Importer.ImportFileFilter, Constants.DirectoryKey.OBSERVED_DATA)
)?.Count() + " data sets successfully imported");
}
}
public async Task Run_FileOK1_BlockSize100()
{
await Task.Yield();
// ARRANGE
this.fixture.MoqElementRepository.Invocations.Clear();
DataImporterSettings settings = new DataImporterSettings()
{
BlockSize = 100,
FileURI = nameof(FileResources.FileOk1),
};
int contador = 0;
this.fixture.MoqElementRepository
.Setup(a => a.SaveCollection(It.IsAny <List <Element> >()))
.Callback((List <Element> lst) => contador += lst.Count);
DataImporter sut = new DataImporter(
new Mock <ILogger <DataImporter> >().Object,
this.fixture.ServiceProvider.GetRequiredService <IFileImporterRepository>(),
this.fixture.ServiceProvider.GetRequiredService <IElementRepository>(),
settings);
// ACT
await sut.Run();
// ASSERT
Assert.Equal(28793, contador);
this.fixture.MoqElementRepository.Verify(a => a.Initialize(), Times.Once());
}
private void addNamingPatterns(DataImporterSettings dataImporterSettings)
{
dataImporterSettings.AddNamingPatternMetaData(
Constants.FILE
);
dataImporterSettings.AddNamingPatternMetaData(
Constants.FILE,
Constants.SHEET
);
dataImporterSettings.AddNamingPatternMetaData(
Constants.ObservedData.MOLECULE,
Constants.ObservedData.SPECIES,
Constants.ObservedData.ORGAN,
Constants.ObservedData.COMPARTMENT
);
dataImporterSettings.AddNamingPatternMetaData(
Constants.ObservedData.MOLECULE,
Constants.ObservedData.SPECIES,
Constants.ObservedData.ORGAN,
Constants.ObservedData.COMPARTMENT,
Constants.ObservedData.STUDY_ID,
Constants.ObservedData.GENDER,
Constants.ObservedData.DOSE,
Constants.ObservedData.ROUTE,
Constants.ObservedData.SUBJECT_ID
);
}
private void addNamingPatterns(DataImporterSettings dataImporterSettings)
{
dataImporterSettings.AddNamingPatternMetaData(
FILE
);
dataImporterSettings.AddNamingPatternMetaData(
FILE,
SHEET
);
dataImporterSettings.AddNamingPatternMetaData(
MOLECULE,
SPECIES,
ORGAN,
COMPARTMENT
);
dataImporterSettings.AddNamingPatternMetaData(
MOLECULE,
SPECIES,
ORGAN,
COMPARTMENT,
STUDY_ID,
GENDER,
DOSE,
ROUTE,
SUBJECT_ID
);
}
public ICommand LoadOntogenyForMolecule(IndividualMolecule molecule, TSimulationSubject simulationSubject)
{
var dataImporterSettings = new DataImporterSettings
{
Caption = $"{CoreConstants.ProductDisplayName} - {PKSimConstants.UI.ImportOntogeny}",
Icon = ApplicationIcons.Excel
};
var data = _dataImporter.ImportDataSet(new List <MetaDataCategory>(), getColumnInfos(), dataImporterSettings);
if (data == null)
{
return(null);
}
var ontogeny = new UserDefinedOntogeny {
Table = formulaFrom(data), Name = data.Name
};
//only first formulation will be imported
if (_ontogenyRepository.AllNames().Contains(ontogeny.Name))
{
var name = _entityTask.NewNameFor(ontogeny, _ontogenyRepository.AllNames());
if (string.IsNullOrEmpty(name))
{
return(null);
}
ontogeny.Name = name;
}
return(SetOntogenyForMolecule(molecule, ontogeny, simulationSubject));
}
private static void registerImport(IContainer container)
{
var mobiDataImprterSettings = new DataImporterSettings {
Icon = ApplicationIcons.MoBi, Caption = "MoBi Data Import"
};
container.RegisterImplementationOf(mobiDataImprterSettings);
}
public override (IReadOnlyList <DataRepository> DataRepositories, ImporterConfiguration Configuration) ImportDataSets(
IReadOnlyList <MetaDataCategory> metaDataCategories,
IReadOnlyList <ColumnInfo> columnInfos,
DataImporterSettings dataImporterSettings,
string dataFileName)
{
throw new NotImplementedException();
}
public void SetSettings(IReadOnlyList <MetaDataCategory> metaDataCategories, ColumnInfoCache columnInfos,
DataImporterSettings dataImporterSettings)
{
_columnInfos = columnInfos;
_columnMappingPresenter.SetSettings(metaDataCategories, columnInfos);
_importerDataPresenter.SetSettings(metaDataCategories, columnInfos);
_dataImporterSettings = dataImporterSettings;
_metaDataCategories = metaDataCategories;
}
private static void registerImport(IContainer container)
{
var mobiDataImprterSettings = new DataImporterSettings {
Icon = ApplicationIcons.MoBi, Caption = "MoBi Data Import"
};
container.RegisterImplementationOf(mobiDataImprterSettings);
container.AddRegister(x => x.FromType <SBMLImportRegister>());
}
protected override void Context()
{
base.Context();
_metaDataCategories = new List<MetaDataCategory>
{
new MetaDataCategory {Name = "Species", IsMandatory = true},
new MetaDataCategory {Name = "StudyId", IsMandatory = false}
};
_dataImporterSettings = new DataImporterSettings();
}
public void StartWithOntogenySettings()
{
var dataImporterSettings = new DataImporterSettings
{
Caption = "PK-Sim - Import Ontogeny"
};
var dataSets = _importer.ImportDataSets(new List <MetaDataCategory>(), _dataGenerator.GetOntogenyColumnInfo(), dataImporterSettings);
promptForImports(dataSets.ToList());
}
public TableFormula ImportTableFormula()
{
var dataImporterSettings = new DataImporterSettings
{
Caption = $"{CoreConstants.ProductDisplayName} - {PKSimConstants.UI.ImportFormulation}",
IconName = ApplicationIcons.Formulation.IconName
};
var importedFormula = _dataImporter.ImportDataSet(new List <MetaDataCategory>(), getColumnInfos(), dataImporterSettings);
return(importedFormula == null ? null : formulaFrom(importedFormula));
}
public void StartWithOntogenySettings()
{
var dataImporterSettings = new DataImporterSettings
{
Caption = "PK-Sim - LoadCurrentSheet Ontogeny"
};
StartImporterExcelView(
new List <MetaDataCategory>(),
_dataGenerator.GetOntogenyColumnInfo(),
dataImporterSettings
);
}
public DataRepository ImportObservedData()
{
var dataImporterSettings = new DataImporterSettings();
dataImporterSettings.AddNamingPatternMetaData(Constants.FILE, Constants.SHEET);
dataImporterSettings.AddNamingPatternMetaData(Constants.FILE, Constants.SHEET, "Species");
var dataSet = _dataImporter.ImportDataSet(
_dataGenerator.DefaultMoBiMetaDataCategories(),
_dataGenerator.DefaultMoBiConcentrationImportConfiguration(),
dataImporterSettings);
return(dataSet);
}
public void StartWithPKSimSettings()
{
var dataImporterSettings = new DataImporterSettings();
dataImporterSettings.AddNamingPatternMetaData(Constants.FILE, Constants.SHEET);
dataImporterSettings.AddNamingPatternMetaData(Constants.FILE, Constants.SHEET, "Species");
var dataSets = _importer.ImportDataSets(
_dataGenerator.DefaultPKSimMetaDataCategories(),
_dataGenerator.DefaultPKSimConcentrationImportConfiguration(),
dataImporterSettings).ToList();
promptForImports(dataSets);
}
public void StartWithMoBiSettings()
{
var dataImporterSettings = new DataImporterSettings();
dataImporterSettings.AddNamingPatternMetaData(Constants.FILE);
StartImporterExcelView(
_dataGenerator.DefaultMoBiMetaDataCategories(),
_dataImporter.ColumnInfosForObservedData(),
dataImporterSettings
);
//promptForImports(dataSets);
}
/// <summary>
/// Initializes a new instance of the <see cref="DataImporter"/> class.
/// </summary>
/// <param name="logger">The logger.</param>
/// <param name="fileImporterRepository">The file importer repository.</param>
/// <param name="elementRepository">The element repository.</param>
/// <param name="dataImporterSettings">The data importer settings.</param>
public DataImporter(
ILogger <DataImporter> logger,
IFileImporterRepository fileImporterRepository,
IElementRepository elementRepository,
DataImporterSettings dataImporterSettings)
{
this.logger = logger;
this.fileImporterRepository = fileImporterRepository;
this.elementRepository = elementRepository;
this.dataImporterSettings = dataImporterSettings;
this.contents = new List <string>();
this.contentsLocker = new object();
}
public void StartPKSimSingleMode()
{
var dataImporterSettings = new DataImporterSettings();
dataImporterSettings.AddNamingPatternMetaData(Constants.FILE, Constants.SHEET);
dataImporterSettings.AddNamingPatternMetaData(Constants.FILE, Constants.SHEET, "Species");
var metaDataCategories = _dataImporter.DefaultMetaDataCategoriesForObservedData().ToList();
_dataGenerator.AddMoleculeValuesToMetaDataList(metaDataCategories);
StartImporterExcelView(
metaDataCategories,
_dataImporter.ColumnInfosForObservedData(),
dataImporterSettings
);
}
public void StartPKSimSingleMode()
{
var dataImporterSettings = new DataImporterSettings();
dataImporterSettings.AddNamingPatternMetaData(Constants.FILE, Constants.SHEET);
dataImporterSettings.AddNamingPatternMetaData(Constants.FILE, Constants.SHEET, "Species");
var dataSet = _importer.ImportDataSet(
_dataGenerator.DefaultPKSimMetaDataCategories(),
_dataGenerator.DefaultPKSimConcentrationImportConfiguration(),
dataImporterSettings);
promptForImports(new List <DataRepository> {
dataSet
});
}
protected override void Context()
{
_settings = new DataImporterSettings();
var repository = new DataRepository {
Name = "OldName"
};
repository.ExtendedProperties.Add(new ExtendedProperty <string> {
Name = "Species", Value = "Pig"
});
repository.ExtendedProperties.Add(new ExtendedProperty <string> {
Name = "Organ", Value = "Liver"
});
_repositories = new List <DataRepository> {
repository
};
repository = new DataRepository {
Name = "OldName"
};
repository.ExtendedProperties.Add(new ExtendedProperty <string> {
Name = "DefaultConvention", Value = "DefaultName"
});
repository.ExtendedProperties.Add(new ExtendedProperty <string> {
Name = "StudyID", Value = "99"
});
_repositories.Add(repository);
repository = new DataRepository {
Name = "OldName"
};
repository.ExtendedProperties.Add(new ExtendedProperty <string> {
Name = "Species", Value = "Pig"
});
repository.ExtendedProperties.Add(new ExtendedProperty <string> {
Name = "StudyID", Value = "99"
});
_repositories.Add(repository);
repository = new DataRepository {
Name = "OldName"
};
_repositories.Add(repository);
sut = new NamingPatternToRepositoryNameMapper();
}
private (IReadOnlyList <MetaDataCategory>, DataImporterSettings) initializeSettings(Compound compound = null, bool allowCompoundNameEdit = false)
{
var dataImporterSettings = new DataImporterSettings
{
Caption = $"{CoreConstants.ProductDisplayName} - {PKSimConstants.UI.ImportObservedData}",
IconName = ApplicationIcons.ObservedData.IconName,
// CheckMolWeightAgainstMolecule = true
};
addNamingPatterns(dataImporterSettings);
dataImporterSettings.NameOfMetaDataHoldingMoleculeInformation = Constants.ObservedData.MOLECULE;
dataImporterSettings.NameOfMetaDataHoldingMolecularWeightInformation = Constants.ObservedData.MOLECULAR_WEIGHT;
var metaDataCategories = _dataImporter.DefaultMetaDataCategoriesForObservedData().ToList();
populateMetaDataLists(metaDataCategories, compound, allowCompoundNameEdit);
return(metaDataCategories, dataImporterSettings);
}
private (IReadOnlyList <MetaDataCategory>, DataImporterSettings) initializeSettings()
{
var dataImporterSettings = new DataImporterSettings
{
IconName = ApplicationIcons.MoBi.IconName,
Caption = $"{AppConstants.PRODUCT_NAME} - {AppConstants.Captions.ImportObservedData}",
CheckMolWeightAgainstMolecule = false
};
addNamingPatterns(dataImporterSettings);
dataImporterSettings.NameOfMetaDataHoldingMoleculeInformation = MOLECULE;
dataImporterSettings.NameOfMetaDataHoldingMolecularWeightInformation = MOLECULAR_WEIGHT;
var metaDataCategories = _dataImporter.DefaultMetaDataCategoriesForObservedData().ToList();
populateMetaDataLists(metaDataCategories);
return(metaDataCategories, dataImporterSettings);
}
public TableFormula ImportSolubilityTableFormula()
{
var dataImporterSettings = new DataImporterSettings
{
Caption = $"{CoreConstants.ProductDisplayName} - {PKSimConstants.UI.ImportSolubilityTable}",
IconName = ApplicationIcons.Compound.IconName
};
dataImporterSettings.AddNamingPatternMetaData(Constants.FILE);
var importedFormula = _dataImporter.ImportDataSets(
new List <MetaDataCategory>(),
getColumnInfos(),
dataImporterSettings,
_dialogCreator.AskForFileToOpen(Captions.Importer.OpenFile, Captions.Importer.ImportFileFilter, Constants.DirectoryKey.OBSERVED_DATA)
).DataRepositories.FirstOrDefault();
return(importedFormula == null ? null : formulaFrom(importedFormula));
}
public override (IReadOnlyList <DataRepository> DataRepositories, ImporterConfiguration Configuration) ImportDataSets(
IReadOnlyList <MetaDataCategory> metaDataCategories,
IReadOnlyList <ColumnInfo> columnInfos,
DataImporterSettings dataImporterSettings,
string dataFileName
)
{
if (string.IsNullOrEmpty(dataFileName) || !System.IO.File.Exists(dataFileName))
{
return(Array.Empty <DataRepository>(), null);
}
var columnInfoCache = new ColumnInfoCache(columnInfos);
using (var importerModalPresenter = _applicationController.Start <IModalImporterPresenter>())
{
importerModalPresenter.SetCaption(dataImporterSettings.Caption);
return(importerModalPresenter.ImportDataSets(metaDataCategories, columnInfoCache, dataImporterSettings, dataFileName));
}
}
public DataImporterTask(
IDataImporter dataImporter,
ICsvDynamicSeparatorSelector csvSeparatorSelector,
IDimensionFactory dimensionFactory,
IPKMLPersistor pkmlPersistor
)
{
_dataImporter = dataImporter;
_dimensionFactory = dimensionFactory;
_pkmlPersistor = pkmlPersistor;
_metaDataCategories = _dataImporter.DefaultMetaDataCategoriesForObservedData();
_dataImporterSettings = new DataImporterSettings
{
NameOfMetaDataHoldingMoleculeInformation = Constants.ObservedData.MOLECULE,
NameOfMetaDataHoldingMolecularWeightInformation = Constants.ObservedData.MOLECULAR_WEIGHT,
IgnoreSheetNamesAtImport = true
};
_columnInfos = _dataImporter.ColumnInfosForObservedData();
_columnInfoCache = new ColumnInfoCache(_columnInfos);
_csvSeparatorSelector = csvSeparatorSelector;
}
public override IReadOnlyList <DataRepository> ImportFromConfiguration(
ImporterConfiguration configuration,
IReadOnlyList <MetaDataCategory> metaDataCategories,
IReadOnlyList <ColumnInfo> columnInfos,
DataImporterSettings dataImporterSettings,
string dataFileName)
{
if (string.IsNullOrEmpty(dataFileName) || !File.Exists(dataFileName))
{
throw new OSPSuiteException(Error.InvalidFile);
}
var columnInfoCache = new ColumnInfoCache(columnInfos);
var importedData = _importer.ImportFromConfiguration(configuration, columnInfoCache, dataFileName, metaDataCategories, dataImporterSettings);
if (importedData.MissingSheets.Count != 0)
{
_logger.AddWarning(Captions.Importer.SheetsNotFound(importedData.MissingSheets));
}
return(importedData.DataRepositories.Select(drm => drm.DataRepository).ToList());
}
private void addObservedData(Func <IReadOnlyList <ColumnInfo> > importConfiguration, Compound compound = null, bool allowCompoundNameEdit = false)
{
var dataImporterSettings = new DataImporterSettings {
Caption = $"{CoreConstants.ProductDisplayName} - {PKSimConstants.UI.ImportObservedData}", Icon = ApplicationIcons.ObservedData
};
dataImporterSettings.AddNamingPatternMetaData(Constants.FILE);
var metaDataCategories = defaultMetaDataCategories().ToList();
metaDataCategories.Insert(0, compoundNameCategory(compound, allowCompoundNameEdit));
var importedObservedData = _dataImporter.ImportDataSets(metaDataCategories, importConfiguration(), dataImporterSettings);
foreach (var observedData in importedObservedData)
{
adjustMolWeight(observedData);
_observedDataTask.AddObservedDataToProject(observedData);
updateQuantityInfoInImportedColumns(observedData);
}
}
