public IPKSimProject MapFrom(ProjectMetaData projectMetaData)
{
var project = new PKSimProject
{
Name = projectMetaData.Name,
Description = projectMetaData.Description
};
//Observed data needs to be loaded first into project
projectMetaData.AllObservedData.Each(x => project.AddObservedData(mapFrom(x)));
projectMetaData.BuildingBlocks.Each(x => project.AddBuildingBlock(mapFrom(x)));
//we need a shared context for all object referencing observed data and simulations
using (var context = _serializationContextFactory.Create(project.AllObservedData, project.All <ISimulation>()))
{
var localContext = context;
projectMetaData.ParameterIdentifications.Each(x => project.AddParameterIdentification(mapFrom(x, localContext)));
projectMetaData.SensitivityAnalyses.Each(x => project.AddSensitivityAnalysis(mapFrom(x, localContext)));
}
projectMetaData.SimulationComparisons.Each(x => project.AddSimulationComparison(mapFrom(x)));
//Once reference to dynamic meta data was added, deserialize the project itself
_serializationManager.Deserialize(project, projectMetaData.Content.Data);
//if the project DB Version is the same as the current project, the project did not change
if (projectMetaData.Version == ProjectVersions.Current)
{
project.HasChanged = false;
}
return(project);
}
protected override Task Context()
{
_classificationMapper = A.Fake <ClassificationMapper>();
_snapshotMapper = A.Fake <ISnapshotMapper>();
_executionContext = A.Fake <IExecutionContext>();
_lazyLoadTask = A.Fake <ILazyLoadTask>();
_simulationMapper = A.Fake <SimulationMapper>();
_simulationComparisonMapper = A.Fake <SimulationComparisonMapper>();
_parameterIdentificationMapper = A.Fake <ParameterIdentificationMapper>();
_classificationSnapshotTask = A.Fake <IClassificationSnapshotTask>();
_qualificationPlanMapper = A.Fake <QualificationPlanMapper>();
_creationMetaDataFactory = A.Fake <ICreationMetaDataFactory>();
_logger = A.Fake <ILogger>();
sut = new ProjectMapper(
_simulationMapper,
_simulationComparisonMapper,
_parameterIdentificationMapper,
_qualificationPlanMapper,
_executionContext,
_classificationSnapshotTask,
_lazyLoadTask,
_creationMetaDataFactory,
_logger);
A.CallTo(() => _executionContext.Resolve <ISnapshotMapper>()).Returns(_snapshotMapper);
_individual = new Individual().WithName("IND");
_compound = new Compound().WithName("COMP");
_event = new PKSimEvent().WithName("EVENT");
_formulation = new Formulation().WithName("FORM");
_protocol = new SimpleProtocol().WithName("PROTO");
_population = new RandomPopulation().WithName("POP");
_observedData = new DataRepository().WithName("OD");
_parameterIdentification = new OSPSuite.Core.Domain.ParameterIdentifications.ParameterIdentification().WithName("PI").WithId("PI_ID");
_classifiableObservedData = new ClassifiableObservedData {
Subject = _observedData
};
_classification = new Classification {
ClassificationType = ClassificationType.ObservedData
}.WithName("OD Classification");
_simulationComparison = new IndividualSimulationComparison().WithName("COMP").WithId("SimComp");
_simulation = new IndividualSimulation().WithName("IND_SIM").WithId("IndSim");
_qualificationPlan = new QualificationPlan().WithName("QP").WithId("QP_ID");
_project = new PKSimProject();
_project.AddBuildingBlock(_individual);
_project.AddBuildingBlock(_compound);
_project.AddBuildingBlock(_event);
_project.AddBuildingBlock(_formulation);
_project.AddBuildingBlock(_protocol);
_project.AddBuildingBlock(_population);
_project.AddObservedData(_observedData);
_project.AddBuildingBlock(_simulation);
_project.AddClassifiable(_classifiableObservedData);
_project.AddClassification(_classification);
_project.AddSimulationComparison(_simulationComparison);
_project.AddParameterIdentification(_parameterIdentification);
_project.AddQualificationPlan(_qualificationPlan);
_compoundSnapshot = new Snapshots.Compound();
_individualSnapshot = new Snapshots.Individual();
_eventSnapshot = new Event();
_formulationSnapshot = new Snapshots.Formulation();
_protocolSnapshot = new Snapshots.Protocol();
_populationSnapshot = new Snapshots.Population();
_observedDataSnapshot = new Snapshots.DataRepository();
_parameterIdentificationSnapshot = new ParameterIdentification();
_observedDataClassificationSnapshot = new Snapshots.Classification();
_simulationComparisonSnapshot = new SimulationComparison();
_simulationClassificationSnapshot = new Snapshots.Classification();
_comparisonClassificationSnapshot = new Snapshots.Classification();
_parameterIdentificationClassificationSnapshot = new Snapshots.Classification();
_qualificationPlanClassificationSnapshot = new Snapshots.Classification();
_qualificationPlanSnapshot = new Snapshots.QualificationPlan();
_simulationSnapshot = new Simulation();
A.CallTo(() => _snapshotMapper.MapToSnapshot(_compound)).Returns(_compoundSnapshot);
A.CallTo(() => _snapshotMapper.MapToSnapshot(_individual)).Returns(_individualSnapshot);
A.CallTo(() => _snapshotMapper.MapToSnapshot(_event)).Returns(_eventSnapshot);
A.CallTo(() => _snapshotMapper.MapToSnapshot(_formulation)).Returns(_formulationSnapshot);
A.CallTo(() => _snapshotMapper.MapToSnapshot(_protocol)).Returns(_protocolSnapshot);
A.CallTo(() => _snapshotMapper.MapToSnapshot(_population)).Returns(_populationSnapshot);
A.CallTo(() => _snapshotMapper.MapToSnapshot(_observedData)).Returns(_observedDataSnapshot);
A.CallTo(() => _simulationMapper.MapToSnapshot(_simulation, _project)).Returns(_simulationSnapshot);
A.CallTo(() => _simulationComparisonMapper.MapToSnapshot(_simulationComparison)).Returns(_simulationComparisonSnapshot);
A.CallTo(() => _parameterIdentificationMapper.MapToSnapshot(_parameterIdentification, _project)).Returns(_parameterIdentificationSnapshot);
A.CallTo(() => _qualificationPlanMapper.MapToSnapshot(_qualificationPlan)).Returns(_qualificationPlanSnapshot);
A.CallTo(() => _classificationSnapshotTask.MapClassificationsToSnapshots <ClassifiableObservedData>(_project)).Returns(new[] { _observedDataClassificationSnapshot });
A.CallTo(() => _classificationSnapshotTask.MapClassificationsToSnapshots <ClassifiableSimulation>(_project)).Returns(new[] { _simulationClassificationSnapshot });
A.CallTo(() => _classificationSnapshotTask.MapClassificationsToSnapshots <ClassifiableComparison>(_project)).Returns(new[] { _comparisonClassificationSnapshot });
A.CallTo(() => _classificationSnapshotTask.MapClassificationsToSnapshots <ClassifiableParameterIdentification>(_project)).Returns(new[] { _parameterIdentificationClassificationSnapshot });
A.CallTo(() => _classificationSnapshotTask.MapClassificationsToSnapshots <ClassifiableQualificationPlan>(_project)).Returns(new[] { _qualificationPlanClassificationSnapshot });
return(_completed);
}
protected override void Context()
{
_buildingBlockIconRetriever = A.Fake <IBuildingBlockIconRetriever>();
_view = A.Fake <ISimulationExplorerView>();
A.CallTo(() => _view.TreeView).Returns(A.Fake <IUxTreeView>());
_treeNodeFactory = A.Fake <ITreeNodeFactory>();
_contextMenuFactory = A.Fake <ITreeNodeContextMenuFactory>();
_regionResolver = A.Fake <IRegionResolver>();
_buildingBlockInSimulationManager = A.Fake <IBuildingBlockInSimulationManager>();
_buildingBlockTask = A.Fake <IBuildingBlockTask>();
_toolTipNodeCreator = A.Fake <IToolTipPartCreator>();
_projectRetriever = A.Fake <IProjectRetriever>();
_multipleTreeNodeContextMenuFactory = A.Fake <IMultipleTreeNodeContextMenuFactory>();
_parameterAnalysablesInExplorerPresenter = A.Fake <IParameterAnalysablesInExplorerPresenter>();
_simulationComparisonTask = A.Fake <ISimulationComparisonTask>();
_simulationFolderNode = new RootNode(RootNodeTypes.SimulationFolder);
_comparisonFolderNode = new RootNode(RootNodeTypes.ComparisonFolder);
_project = new PKSimProject();
_usedObservedData = new UsedObservedData {
Id = "UsedData"
};
_simulation = new IndividualSimulation().WithName("individualSimulation").WithId("individualSimulation");
_populationSimulation = new PopulationSimulation().WithName("populationSimulation").WithId("populationSimulation");
_importedSimulaton = A.Fake <Simulation>().WithName("ImportedSimulation").WithId("ImportedSimulation");
A.CallTo(() => _importedSimulaton.IsImported).Returns(true);
_simulation.Properties = new SimulationProperties();
_simulation.ModelProperties = new ModelProperties();
_simulation.ModelConfiguration = A.Fake <ModelConfiguration>();
_populationSimulation.Properties = new SimulationProperties();
_populationSimulation.ModelProperties = new ModelProperties();
_populationSimulation.ModelConfiguration = A.Fake <ModelConfiguration>();
_classificationPresenter = A.Fake <IClassificationPresenter>();
_project.AddBuildingBlock(_simulation);
_project.AddBuildingBlock(_populationSimulation);
var classifiableIndividualSimulation = new ClassifiableSimulation {
Subject = _simulation
};
var classfiablePopulationSimulation = new ClassifiableSimulation {
Subject = _populationSimulation
};
var classifiableImportSimulation = new ClassifiableSimulation {
Subject = _importedSimulaton
};
_project.AddClassifiable(classifiableIndividualSimulation);
_project.AddClassifiable(classfiablePopulationSimulation);
_individualSimulationNode = new SimulationNode(classifiableIndividualSimulation);
_populationSimulationNode = new SimulationNode(classfiablePopulationSimulation);
_importedSimulationNode = new SimulationNode(classifiableImportSimulation);
_usedObservedDataNode = A.Fake <ITreeNode>();
A.CallTo(() => _treeNodeFactory.CreateFor(classifiableIndividualSimulation)).Returns(_individualSimulationNode);
A.CallTo(() => _treeNodeFactory.CreateFor(classfiablePopulationSimulation)).Returns(_populationSimulationNode);
A.CallTo(() => _treeNodeFactory.CreateFor(classifiableImportSimulation)).Returns(_importedSimulationNode);
A.CallTo(() => _treeNodeFactory.CreateFor(_usedObservedData)).Returns(_usedObservedDataNode);
_project.AddBuildingBlock(_importedSimulaton);
var simulationComparison = A.Fake <ISimulationComparison>().WithId("SimComp_Id");
var classifiableComparison = new ClassifiableComparison {
Subject = simulationComparison
};
_comparisonNode = new ComparisonNode(classifiableComparison);
_project.AddSimulationComparison(simulationComparison);
A.CallTo(() => _treeNodeFactory.CreateFor(classifiableComparison)).Returns(_comparisonNode);
_usedCompoundBuildingBlock = new UsedBuildingBlock("toto", PKSimBuildingBlockType.Compound)
{
Id = "usedBB"
};
_simulation.AddUsedBuildingBlock(_usedCompoundBuildingBlock);
_simulation.AddUsedObservedData(_usedObservedData);
_project.AddClassifiable(classifiableComparison);
_templageCompoundBuildingBlock = A.Fake <IPKSimBuildingBlock>();
_usedBuildingBlockNode = new UsedBuildingBlockInSimulationNode(_simulation, _usedCompoundBuildingBlock, _templageCompoundBuildingBlock);
A.CallTo(() => _treeNodeFactory.CreateFor(_simulation, _usedCompoundBuildingBlock)).Returns(_usedBuildingBlockNode);
A.CallTo(() => _buildingBlockIconRetriever.IconFor(_simulation)).Returns(ApplicationIcons.SimulationGreen);
A.CallTo(() => _buildingBlockIconRetriever.IconFor(_populationSimulation)).Returns(ApplicationIcons.SimulationGreen);
A.CallTo(() => _buildingBlockIconRetriever.IconFor(_usedCompoundBuildingBlock)).Returns(ApplicationIcons.CompoundRed);
A.CallTo(() => _view.TreeView.NodeById(_simulation.Id)).Returns(_individualSimulationNode);
A.CallTo(() => _view.TreeView.NodeById(_usedCompoundBuildingBlock.Id)).Returns(_usedBuildingBlockNode);
A.CallTo(() => _view.TreeView.NodeById(RootNodeTypes.SimulationFolder.Id)).Returns(_simulationFolderNode);
A.CallTo(() => _view.TreeView.NodeById(RootNodeTypes.ComparisonFolder.Id)).Returns(_comparisonFolderNode);
_observedDataInSimulationManager = A.Fake <IObservedDataInSimulationManager>();
sut = new SimulationExplorerPresenter(
_view, _treeNodeFactory, _contextMenuFactory,
_multipleTreeNodeContextMenuFactory, _buildingBlockIconRetriever,
_regionResolver, _buildingBlockTask, _buildingBlockInSimulationManager,
_toolTipNodeCreator, _projectRetriever, _classificationPresenter,
_parameterAnalysablesInExplorerPresenter, _observedDataInSimulationManager, _simulationComparisonTask);
A.CallTo(() => _projectRetriever.CurrentProject).Returns(_project);
}
