protected override void Context()
{
_globalPKAnalysisPresenter = A.Fake <IGlobalPKAnalysisPresenter>();
_concentrationDim = A.Fake <IDimension>();
_timeDim = A.Fake <IDimension>();
_view = A.Fake <IIndividualPKAnalysisView>();
_pkaAnalysisTask = A.Fake <IPKAnalysisTask>();
_simulation = A.Fake <IndividualSimulation>();
_simulations = new List <Simulation>();
_simulations.Add(_simulation);
_exportTask = A.Fake <IPKAnalysisExportTask>();
_individualPKAnalysisToDTOMapper = A.Fake <IIndividualPKAnalysisToPKAnalysisDTOMapper>();
_pkParameterRepository = A.Fake <IPKParameterRepository>();
;
var dataRepository = new DataRepository();
_baseGrid = new BaseGrid("Base", _timeDim);
_col1 = new DataColumn {
DataInfo = new DataInfo(ColumnOrigins.Calculation, AuxiliaryType.Undefined, "mg", DateTime.Now, string.Empty, string.Empty, 5), Dimension = _concentrationDim
};
_col2 = new DataColumn {
Dimension = _concentrationDim, DataInfo = new DataInfo(ColumnOrigins.Calculation, AuxiliaryType.Undefined, "mg", DateTime.Now, string.Empty, string.Empty, 5)
};
_col3 = new DataColumn {
Dimension = _concentrationDim, DataInfo = new DataInfo(ColumnOrigins.Calculation, AuxiliaryType.Undefined, "mg", DateTime.Now, string.Empty, string.Empty, 5)
};
dataRepository.Add(_col1);
dataRepository.Add(_col2);
_simulation.DataRepository = dataRepository;
var curve1 = A.Fake <Curve>();
A.CallTo(() => curve1.yData).Returns(_col1);
A.CallTo(() => curve1.xData).Returns(_baseGrid);
var curve2 = A.Fake <Curve>();
A.CallTo(() => curve2.yData).Returns(_col2);
A.CallTo(() => curve2.xData).Returns(_baseGrid);
var curve3 = A.Fake <Curve>();
A.CallTo(() => curve3.yData).Returns(_col3);
A.CallTo(() => curve3.xData).Returns(_col1);
_curves = new List <Curve> {
curve1, curve2, curve3
};
_allPKAnalysis = new List <Tuple <DataColumn, PKAnalysis> >();
_pkAnalysis1 = createPKAnalysis();
_pkAnalysis2 = createPKAnalysis();
_allPKAnalysis.Add(new Tuple <DataColumn, PKAnalysis>(_col1, _pkAnalysis1));
_allPKAnalysis.Add(new Tuple <DataColumn, PKAnalysis>(_col2, _pkAnalysis2));
_allGlobalPKParameters = new List <IParameter>();
A.CallTo(_pkaAnalysisTask).WithReturnType <IEnumerable <Tuple <DataColumn, PKAnalysis> > >().Returns(_allPKAnalysis);
A.CallTo(_pkaAnalysisTask).WithReturnType <IEnumerable <IParameter> >().Returns(_allGlobalPKParameters);
_presenterSettingsTask = A.Fake <IPresentationSettingsTask>();
sut = new IndividualPKAnalysisPresenter(_view, _pkaAnalysisTask, _exportTask, _globalPKAnalysisPresenter,
_individualPKAnalysisToDTOMapper, _pkParameterRepository, _presenterSettingsTask);
}
protected override void Context()
{
_editObservedDataTask = A.Fake <IEditObservedDataTask>();
_view = A.Fake <IDataRepositoryDataView>();
_dataRepositoryTask = A.Fake <IDataRepositoryExportTask>();
_commandCollector = A.Fake <ICommandCollector>();
sut = new DataRepositoryDataPresenter(_view, _dataRepositoryTask, _editObservedDataTask);
sut.InitializeWith(_commandCollector);
//common setup
_dataRepository = new DataRepository();
_dataTable = new DataTable();
A.CallTo(() => _dataRepositoryTask.ToDataTable(_dataRepository, A <DataColumnExportOptions> ._)).Returns(new[] { _dataTable });
var col = _dataTable.AddColumn <float>("test");
col.ExtendedProperties.Add(Constants.DATA_REPOSITORY_COLUMN_ID, "col");
_baseGrid = new BaseGrid("base", "base", Constants.Dimension.NO_DIMENSION)
{
Values = new ArraySegment <float>()
};
_dim = A.Fake <IDimension>();
_col = new DataColumn("col", "col", _dim, _baseGrid)
{
Values = new ArraySegment <float>()
};
_dataRepository.Add(_baseGrid);
_dataRepository.Add(_col);
}
protected override Task Context()
{
_dataColumnMapper = A.Fake <DataColumnMapper>();
_extendedPropertyMapper = A.Fake <ExtendedPropertyMapper>();
sut = new DataRepositoryMapper(_extendedPropertyMapper, _dataColumnMapper);
_dataRepository = DomainHelperForSpecs.ObservedData();
_dataColumn = _dataRepository.ObservationColumns().First();
_relatedColumn = new DataColumn("related", DomainHelperForSpecs.NoDimension(), _dataRepository.BaseGrid)
{
Values = new[] { 0f, 0f, 0f },
DataInfo = { Origin = ColumnOrigins.ObservationAuxiliary }
};
_dataColumn.AddRelatedColumn(_relatedColumn);
_dataRepository.Add(_relatedColumn);
_dataRepository.Description = "description";
_dataRepository.Name = "thename";
_extendedProperty = new ExtendedProperty <string> {
Name = "Name"
};
_dataRepository.ExtendedProperties.Add(_extendedProperty);
_dataColumnSnapshot = new Snapshots.DataColumn();
_extendedPropertySnapshot = new Snapshots.ExtendedProperty();
_baseGridSnapshot = new Snapshots.DataColumn();
A.CallTo(() => _dataColumnMapper.MapToSnapshot(_dataColumn)).Returns(_dataColumnSnapshot);
A.CallTo(() => _extendedPropertyMapper.MapToSnapshot(_extendedProperty)).Returns(_extendedPropertySnapshot);
A.CallTo(() => _extendedPropertyMapper.MapToModel(_extendedPropertySnapshot, A <SnapshotContext> ._)).Returns(_extendedProperty);
A.CallTo(() => _dataColumnMapper.MapToSnapshot(_dataRepository.BaseGrid)).Returns(_baseGridSnapshot);
return(Task.FromResult(true));
}
private void updateColumnProperties(DataColumn sourceColumn, DataColumn targetColumn)
{
targetColumn.QuantityInfo = sourceColumn.QuantityInfo?.Clone();
targetColumn.DataInfo = sourceColumn.DataInfo?.Clone();
targetColumn.Values = sourceColumn.Values;
targetColumn.IsInternal = sourceColumn.IsInternal;
}
private void addBaseGridToRepository(DataRepository dataRepository, DataColumn baseGrid)
{
if (isAlreadyCloned(baseGrid))
{
return;
}
dataRepository.Add(cloneBaseGrid(baseGrid));
}
private BaseGrid cloneBaseGrid(DataColumn baseGridToClone)
{
var newBaseGrid = new BaseGrid(baseGridToClone.Name, baseGridToClone.Dimension);
updateColumnProperties(baseGridToClone, newBaseGrid);
_idMap.Add(baseGridToClone.Id, newBaseGrid.Id);
return(newBaseGrid);
}
public DataColumn CloneColumn(DataColumn sourceColumn, BaseGrid clonedBaseGrid)
{
var newColumn = new DataColumn(sourceColumn.Name, sourceColumn.Dimension, clonedBaseGrid);
updateColumnProperties(sourceColumn, newColumn);
_idMap.Add(sourceColumn.Id, newColumn.Id);
return(newColumn);
}
private DataTable createTableFor(string tableName, DataColumn baseGridColumn, IEnumerable <DataColumn> columnsToExport, Func <DataColumn, string> columnNameRetriever, Func <DataColumn, IDimension> dimensionRetriever, bool formatOutput, bool useDisplayUnit)
{
var dataTable = new DataTable(tableName);
//user string because we want to export the unit
var allColumns = columnsToExport.Where(col => !col.IsBaseGrid())
.Where(x => x.BaseGrid == baseGridColumn).ToList();
moveDrugColumnsFirst(allColumns);
allColumns.Insert(0, baseGridColumn);
var cacheName = retrieveUniqueNameForColumns(allColumns, columnNameRetriever);
var cacheDimensions = retrieveDimensionsFor(allColumns, dimensionRetriever);
allColumns.Each(x =>
{
var column = dataTable.Columns.Add(cacheName[x], formatOutput ? typeof(string) : typeof(float));
column.ExtendedProperties.Add(Constants.DATA_REPOSITORY_COLUMN_ID, x.Id);
});
//add units information
for (int i = 0; i < dataTable.Columns.Count; i++)
{
var col = dataTable.Columns[i];
var dataColumn = allColumns[i];
var dimension = cacheDimensions[dataColumn];
var unit = unitFor(dimension, dataColumn, useDisplayUnit);
if (!string.IsNullOrWhiteSpace(unit.Name))
{
col.ColumnName = $"{col.ColumnName} [{unit.Name}]";
}
}
for (int i = 0; i < baseGridColumn.Values.Count; i++)
{
var row = dataTable.NewRow();
for (int j = 0; j < allColumns.Count; j++)
{
var columnToExport = allColumns[j];
var dimension = cacheDimensions[columnToExport];
var unit = unitFor(dimension, columnToExport, useDisplayUnit);
double value = dimension.BaseUnitValueToUnitValue(unit, columnToExport.Values[i]);
if (formatOutput)
{
row[j] = _numericFormatter.Format(value);
}
else
{
row[j] = value;
}
}
dataTable.Rows.Add(row);
}
return(dataTable);
}
private Unit unitFor(IDimension dimension, DataColumn column, bool useDisplayUnit)
{
if (useDisplayUnit)
{
return(dimension.UnitOrDefault(column.DataInfo.DisplayUnitName));
}
return(dimension.BaseUnit);
}
public void UpdateMolWeight(DataColumn column, IQuantity quantity, IModel model)
{
var molWeight = model.MolWeightFor(quantity);
if (molWeight != null)
{
column.DataInfo.MolWeight = molWeight;
}
}
private DataTable createTableFor(
string tableName,
DataColumn baseGridColumn,
IEnumerable <DataColumn> columnsToExport,
Func <DataColumn, string> columnNameRetriever,
Func <DataColumn, IDimension> dimensionRetriever,
bool useDisplayUnit,
Type columnType,
Func <double, object> valueFunc)
{
var dataTable = new DataTable(tableName);
var allColumns = sortColumnsForExport(columnsToExport.Where(x => !x.IsBaseGrid() && x.BaseGrid == baseGridColumn));
allColumns.Insert(0, baseGridColumn);
var cacheName = retrieveUniqueNameForColumns(allColumns, columnNameRetriever);
var cacheDimensions = retrieveDimensionsFor(allColumns, dimensionRetriever);
allColumns.Each(x =>
{
var column = dataTable.Columns.Add(cacheName[x], columnType);
column.ExtendedProperties.Add(Constants.DATA_REPOSITORY_COLUMN_ID, x.Id);
});
//add units information
for (int i = 0; i < dataTable.Columns.Count; i++)
{
var col = dataTable.Columns[i];
var dataColumn = allColumns[i];
var dimension = cacheDimensions[dataColumn];
var unit = unitFor(dimension, dataColumn, useDisplayUnit);
if (!string.IsNullOrWhiteSpace(unit.Name))
{
col.ColumnName = $"{col.ColumnName} [{unit.Name}]";
}
}
for (int i = 0; i < baseGridColumn.Values.Count; i++)
{
var row = dataTable.NewRow();
for (int j = 0; j < allColumns.Count; j++)
{
var columnToExport = allColumns[j];
var dimension = cacheDimensions[columnToExport];
var unit = unitFor(dimension, columnToExport, useDisplayUnit);
var value = dimension.BaseUnitValueToUnitValue(unit, columnToExport.Values[i]);
row[j] = valueFunc(value);
}
dataTable.Rows.Add(row);
}
return(dataTable);
}
protected override void Context()
{
base.Context();
_col1 = new DataColumn("col2", _mass, _baseGrid1)
{
Values = new float[] { 10, 20, 30 }
};
_dataRepository.Name = "aaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbb";
_dataRepository.Add(_col1);
}
protected override void Context()
{
base.Context();
NumericFormatterOptions.Instance.DecimalPlace = 2;
_col1 = new DataColumn("col1", _mass, _baseGrid1)
{
Values = new float[] { 0.11111f, 0.222222f, 0.33333333f }
};
_dataRepository.Add(_col1);
}
private void updateRelateColumnValue(DataRow row, DataColumn dataColumn, int index)
{
if (dataColumn == null)
{
return;
}
var dimension = _dimensionFactory.MergedDimensionFor(dataColumn);
row[dataColumn.Name] = _reportingHelper.ConvertToDisplayUnit(dimension.Unit(dataColumn.DataInfo.DisplayUnitName), dimension, dataColumn.Values[index]);
}
private static string tableNameFrom(DataColumn baseGrid)
{
const string defaultTableName = "Table";
var tableName = baseGrid.Repository != null ? baseGrid.Repository.Name : defaultTableName;
if (string.IsNullOrEmpty(tableName))
{
tableName = defaultTableName;
}
return(new string(FileHelper.RemoveIllegalCharactersFrom(tableName).Take(Constants.MAX_NUMBER_OF_CHAR_IN_TABLE_NAME).ToArray()));
}
private BaseGrid activeBaseGrid(DataColumn xData, DataColumn yData)
{
if (Curve.InterpolationMode == InterpolationModes.xLinear)
{
return(xData.BaseGrid);
}
if (Curve.InterpolationMode == InterpolationModes.yLinear)
{
return(yData.BaseGrid);
}
throw new ArgumentException("InterpolationMode = " + Curve.InterpolationMode);
}
protected override void Context()
{
base.Context();
_baseGrid1.DisplayUnit = _time.Unit("h");
_baseGrid1.Values = new List <float> {
4.98f
}; //0.083 h
_col1 = new DataColumn("col1", _mass, _baseGrid1)
{
Values = new[] { 12.487f }
};
_dataRepository.Add(_col1);
}
protected override async Task Context()
{
await base.Context();
_snapshot = await sut.MapToSnapshot(_dataRepository);
_baseGrid = new BaseGrid("baseGrid", DomainHelperForSpecs.TimeDimensionForSpecs());
_mappedDataColumn = new DataColumn("DataColumn", DomainHelperForSpecs.ConcentrationDimensionForSpecs(), _baseGrid);
_mappedRelatedColumn = new DataColumn("RelatedColumn", DomainHelperForSpecs.ConcentrationDimensionForSpecs(), _baseGrid);
_mappedDataColumn.AddRelatedColumn(_mappedRelatedColumn);
A.CallTo(() => _dataColumnMapper.MapToModel(_snapshot.BaseGrid, A <SnapshotContextWithDataRepository> ._)).Returns(_baseGrid);
A.CallTo(() => _dataColumnMapper.MapToModel(_snapshot.Columns.First(), A <SnapshotContextWithDataRepository> ._)).Returns(_mappedDataColumn);
}
private void addMolWeight(DataColumn col, System.Data.DataColumn column)
{
if (col.DataInfo.MolWeight == null)
{
return;
}
var dimension = _dimensionFactory.Dimension(AppConstants.Parameters.MOLECULAR_WEIGHT);
var displayUnit = _reportingHelper.GetDisplayUnitFor(dimension);
column.SetNotes(new[]
{
string.Format(Constants.PROPERTY_PROMPT_FORMAT, Constants.MOLECULE_WEIGHT,
$"{_reportingHelper.ConvertToDisplayUnit(displayUnit, dimension, (float) col.DataInfo.MolWeight)} {_reportingHelper.GetDisplayUnitFor(displayUnit, dimension)}")
});
}
protected override void Context()
{
base.Context();
_col1 = new DataColumn("col1", _mass, _baseGrid1)
{
Values = new float[] { 10, 20, 30 },
DataInfo = { Origin = ColumnOrigins.Observation }
};
_col2 = new DataColumn("col2", _mass, _baseGrid1)
{
Values = new float[] { 100, 200, 300 },
DataInfo = { AuxiliaryType = AuxiliaryType.ArithmeticStdDev, Origin = ColumnOrigins.ObservationAuxiliary }
};
_col1.AddRelatedColumn(_col2);
_dataRepository.Add(_col2);
_dataRepository.Add(_col1);
}
protected override bool AddRelatedValuesToRow(DataRow row, DataColumn yData, IDimension yDimension, Unit yUnit, double y, float baseValue)
{
var stdDev = Curve.yData.GetValue(baseValue);
if (!IsValidValue(stdDev) || stdDev == 0)
{
stdDev = 1;
}
if (!IsValidValue(y / stdDev))
{
return(false);
}
row[LOW] = y / stdDev;
row[HIGH] = y * stdDev;
return(true);
}
protected override void Context()
{
base.Context();
_fileName = "file";
_dataTable1 = new DataTable();
_dataTable2 = new DataTable();
var baseGrid = new BaseGrid("time", A.Fake <IDimension>());
_col1 = new DataColumnn("col1", A.Fake <IDimension>(), baseGrid);
_col2 = new DataColumnn("col2", A.Fake <IDimension>(), baseGrid);
_global = new GlobalPKAnalysis();
_sim1 = A.Fake <Simulation>().WithName("Sim");
A.CallTo(_dialogCreator).WithReturnType <string>().Returns(_fileName);
A.CallTo(() => _dataRepositoryTask.ToDataTable(A <IEnumerable <DataColumnn> > ._, A <Func <DataColumnn, string> > ._, false)).Returns(new[] { _dataTable1, _dataTable2 });
A.CallTo(() => _dataRepositoryTask.ExportToExcel(A <IEnumerable <DataTable> > ._, _fileName, true))
.Invokes(x => _dataTables = x.GetArgument <IEnumerable <DataTable> >(0));
}
protected override bool AddRelatedValuesToRow(DataRow row, DataColumn yData, IDimension yDimension, Unit yUnit, double y, float baseValue)
{
var stdDev = yDimension.BaseUnitValueToUnitValue(yUnit, Curve.yData.GetValue(baseValue));
if (!IsValidValue(stdDev))
{
stdDev = 0;
}
if (!IsValidYValue(y - stdDev))
{
return(false);
}
row[LOW] = y - stdDev;
row[HIGH] = y + stdDev;
return(true);
}
private DataColumn addColumnToRepository(DataRepository dataRepository, DataColumn sourceColumn)
{
if (isAlreadyCloned(sourceColumn))
{
return(dataRepository[idOfCloneFor(sourceColumn)]);
}
var baseGridColumn = dataRepository[idOfCloneFor(sourceColumn.BaseGrid)].DowncastTo <BaseGrid>();
var newColumn = CloneColumn(sourceColumn, baseGridColumn);
dataRepository.Add(newColumn);
foreach (var relatedColumn in sourceColumn.RelatedColumns)
{
newColumn.AddRelatedColumn(addColumnToRepository(dataRepository, relatedColumn));
}
return(newColumn);
}
private DataColumn createRelatedColumnFor(DataTable dataTable, DataColumn dataColumn, AuxiliaryType auxiliaryType, string caption)
{
if (!dataColumn.ContainsRelatedColumn(auxiliaryType))
{
return(null);
}
var realatedColumn = dataColumn.GetRelatedColumn(AuxiliaryType.ArithmeticStdDev);
if (realatedColumn == null)
{
return(null);
}
var errCol = dataTable.AddColumn <float>(realatedColumn.Name);
errCol.SetUnit(realatedColumn.DataInfo.DisplayUnitName);
errCol.SetNotes(new[] { caption });
return(realatedColumn);
}
protected override bool AddRelatedValuesToRow(DataRow row, DataColumn yData, IDimension yDimension, Unit yUnit, double y, float baseValue)
{
var relatedColumn = yData.GetRelatedColumn(AuxiliaryType.GeometricStdDev);
var stdDev = relatedColumn.GetValue(baseValue);
if (!IsValidValue(stdDev) || stdDev == 0)
{
stdDev = 1;
}
if (!IsValidYValue(y / stdDev))
{
return(false);
}
row[LOW] = y / stdDev;
row[HIGH] = y * stdDev;
row[Y2] = y;
return(true);
}
protected override bool AddRelatedValuesToRow(DataRow row, DataColumn yData, IDimension yDimension, Unit yUnit, double y, float baseValue)
{
var relatedColumn = yData.GetRelatedColumn(AuxiliaryType.ArithmeticStdDev);
var stdDev = yDimension.BaseUnitValueToUnitValue(yUnit, relatedColumn.GetValue(baseValue));
if (!IsValidValue(stdDev))
{
stdDev = 0;
}
row[HIGH] = y + stdDev;
row[LOW] = y - stdDev;
row[Y2] = y;
if (!IsValidYValue(y - stdDev))
{
row[LOW] = y;
}
return(true);
}
protected override void Context()
{
_dataRepositoryTask = A.Fake <IDataRepositoryTask>();
_dimensionFactory = A.Fake <IDimensionFactory>();
sut = new WeightedDataRepositoryToDataTableMapper(_dataRepositoryTask, _dimensionFactory);
var baseGrid = new BaseGrid("name", _dimensionFactory.NoDimension)
{
Values = new[] { 0.0f }
};
var dataColumn = new DataColumn {
Values = new[] { 0.0f }
};
_dataRepository = new DataRepository {
baseGrid, dataColumn
};
_weightedObservedData = new WeightedObservedData(_dataRepository);
A.CallTo(() => _dataRepositoryTask.ToDataTable(A <IEnumerable <DataColumn> > ._, A <bool> ._, A <bool> ._, A <bool> ._)).Returns(new[] { new DataTable() });
}
protected override void Context()
{
_view = A.Fake <IWeightedDataRepositoryDataView>();
_dimensionFactory = A.Fake <IDimensionFactory>();
_weightedDataRepositoryToDataTableMapper = A.Fake <IWeightedDataRepositoryToDataTableMapper>();
var baseGrid = new BaseGrid("name", _dimensionFactory.NoDimension)
{
Values = new[] { 0.0f }
};
var dataColumn = new DataColumn {
Values = new[] { 0.0f }
};
_dataRepository = new DataRepository {
baseGrid, dataColumn
};
_weightedObservedData = new WeightedObservedData(_dataRepository);
A.CallTo(() => _weightedDataRepositoryToDataTableMapper.MapFrom(_weightedObservedData)).Returns(new DataTable());
sut = new WeightedDataRepositoryDataPresenter(_view, _weightedDataRepositoryToDataTableMapper);
}
private float convertCellToFloat(int sourceRow, DataColumn observationColumn)
{
return(observationColumn.Values[sourceRow]);
}
