private SimulationPoint parseMappingOnSameGivenColumn(MappingDataFormatParameter currentParameter, DataSheet dataSheet, UnformattedRow row)
{
var lloqIndex = string.IsNullOrWhiteSpace(currentParameter.MappedColumn.LloqColumn)
? -1
: dataSheet.GetColumnDescription(currentParameter.MappedColumn.LloqColumn).Index;
var unit = currentParameter.MappedColumn.Unit.ExtractUnit(columnName => dataSheet.GetColumnDescription(columnName).Index, row.Data);
if (lloqIndex < 0 || !double.TryParse(row.Data.ElementAt(lloqIndex).Trim(), out var lloq))
{
lloq = double.NaN;
}
var columnDescription = dataSheet.GetColumnDescription(currentParameter.ColumnName);
var element = row.Data.ElementAt(columnDescription.Index).Trim();
if (double.TryParse(element, out var result))
{
return new SimulationPoint()
{
Measurement = result,
Lloq = lloq,
Unit = unit
}
}
;
return(new SimulationPoint()
{
Measurement = double.NaN,
Lloq = lloq,
Unit = unit
});
}
public void the_unit_and_dimension_are_set_properly(string oldUnitDescription, string newUnitDescription, bool haveOldSource, bool shouldUpdate)
{
//Set up
UpdateSettings();
MappingDataFormatParameter mappingSource = null;
if (haveOldSource)
{
mappingSource = _parameters[2] as MappingDataFormatParameter;
mappingSource.MappedColumn.Unit = new UnitDescription(oldUnitDescription);
}
_model = new ColumnMappingDTO(ColumnMappingDTO.ColumnType.Mapping, "Concentration", mappingSource, 0);
A.CallTo(() => _basicFormat.ExtractUnitDescriptions(A <string> .Ignored, A <IReadOnlyList <IDimension> > .Ignored))
.Returns(new UnitDescription(newUnitDescription));
//Act
_model.ExcelColumn = "Measurement";
sut.SetDescriptionForRow(_model);
//Assert
var mappingDataFormat = (_model.Source as MappingDataFormatParameter);
var mappedColumn = mappingDataFormat.MappedColumn;
mappedColumn.Unit.SelectedUnit.ShouldBeEqualTo(shouldUpdate ? newUnitDescription : oldUnitDescription);
if (shouldUpdate && newUnitDescription != UnitDescription.InvalidUnit)
{
mappedColumn.Dimension.HasUnit(mappedColumn.Unit.SelectedUnit).ShouldBeTrue();
}
}
protected override void Context()
{
base.Context();
_mappingSource = _parameters[1] as MappingDataFormatParameter;
A.CallTo(() => _mappingParameterEditorPresenter.Unit).Returns(new UnitDescription("µmol"));
UpdateSettings();
}
protected override void Context()
{
base.Context();
_mappingSource = _parameters[2] as MappingDataFormatParameter;
A.CallTo(() => _mappingParameterEditorPresenter.Unit).Returns(new UnitDescription("µmol/l"));
A.CallTo(() => _mappingParameterEditorPresenter.SelectedErrorType).Returns(ARITMETIC_ERROR);
UpdateSettings();
}
protected override void Context()
{
base.Context();
_mappingSource = _parameters[1] as MappingDataFormatParameter;
A.CallTo(() => _mappingParameterEditorPresenter.Unit).Returns(new UnitDescription("µmol", "Some Column"));
_rawDataSheet = A.Fake <DataSheet>();
A.CallTo(() => _rawDataSheet.GetColumn(A <string> .Ignored)).Returns(new[] { "µmol" });
sut.SetRawData(_rawDataSheet);
UpdateSettings();
}
protected override void Context()
{
base.Context();
var supportedDimensions = _columnInfos["Error"].SupportedDimensions;
supportedDimensions.Clear();
supportedDimensions.AddRange(DomainHelperForSpecs.ExtendedDimensionsForSpecs());
_mappingSource = _parameters[2] as MappingDataFormatParameter;
_mappingSource.MappedColumn.Dimension = supportedDimensions.First(x => x.Name == Constants.Dimension.FRACTION);
A.CallTo(() => _mappingParameterEditorPresenter.Unit).Returns(new UnitDescription(""));
A.CallTo(() => _mappingParameterEditorPresenter.SelectedErrorType).Returns(ARITMETIC_ERROR);
UpdateSettings();
}
protected List <DataFormatParameter> CreateParameters(MappingDataFormatParameter concentration, MappingDataFormatParameter error)
{
return(new List <DataFormatParameter>()
{
new MappingDataFormatParameter("Time", new Column()
{
Name = "Time", Unit = new UnitDescription("min")
}),
concentration,
error,
new GroupByDataFormatParameter("Study id"),
new GroupByDataFormatParameter("Patient id")
});
}
private SimulationPoint parseMappingOnSameColumn(MappingDataFormatParameter currentParameter, DataSheet dataSheet, UnformattedRow row)
{
var columnDescription = dataSheet.GetColumnDescription(currentParameter.ColumnName);
var element = row.Data.ElementAt(columnDescription.Index).Trim();
if (!currentParameter.MappedColumn.Unit.ColumnName.IsNullOrEmpty())
{
ColumnDescription unitColumnDescription = null;
if (!string.IsNullOrEmpty(currentParameter.MappedColumn.Unit.ColumnName))
{
unitColumnDescription = dataSheet.GetColumnDescription(currentParameter.MappedColumn.Unit.ColumnName);
}
if (unitColumnDescription == null)
{
throw new MissingColumnException(dataSheet.SheetName, currentParameter.MappedColumn.Unit.ColumnName);
}
}
var unit = currentParameter.MappedColumn.Unit.ExtractUnit(columnName => dataSheet.GetColumnDescription(columnName).Index, row.Data);
if (double.TryParse(element, out var result))
{
return new SimulationPoint()
{
Measurement = result,
Unit = unit,
Lloq = double.NaN
}
}
;
if (element.StartsWith("<"))
{
result = element.Substring(1).ConvertedTo <double>();
return(new SimulationPoint()
{
Lloq = result,
Unit = unit
});
}
return(new SimulationPoint()
{
Measurement = double.NaN,
Unit = unit
});
}
protected override void Context()
{
base.Context();
var concentration =
new MappingDataFormatParameter("Observation", new Column()
{
Name = "Concentration", Unit = new UnitDescription("mol/l")
});
var error = new MappingDataFormatParameter("Error",
new Column()
{
Name = "Error", Unit = new UnitDescription("g/l"), ErrorStdDev = Constants.STD_DEV_ARITHMETIC
});
_errorUnitParameters = CreateParameters(concentration, error);
A.CallTo(() => _basicFormat.Parameters).Returns(_errorUnitParameters);
UpdateSettings();
}
public void UpdateDescriptionForModel(MappingDataFormatParameter mappingSource)
{
if (mappingSource == null)
{
return;
}
var model = _mappings.FirstOrDefault(x => x.Source == mappingSource);
if (model == null)
{
return;
}
var column = ((MappingDataFormatParameter)model.Source).MappedColumn;
if (!string.IsNullOrEmpty(_mappingParameterEditorPresenter.Unit.ColumnName))
{
column.Unit = new UnitDescription(_rawData.GetColumn(_mappingParameterEditorPresenter.Unit.ColumnName).FirstOrDefault(), _mappingParameterEditorPresenter.Unit.ColumnName);
column.Dimension = null;
updateErrorDescriptionAfterMeasurementUnitIsSetFromColumn(model, column);
}
else
{
//When unit is set, the dimension has to be inferred from it.
//The dimension is the first from the supported dimension which
//has the selected unit.
column.Unit = _mappingParameterEditorPresenter.Unit;
if (column.Dimension == null || !column.Dimension.HasUnit(column.Unit.SelectedUnit))
{
column.Dimension = _columnInfos[model.MappingName]
.SupportedDimensions
.FirstOrDefault(x => x.HasUnit(column.Unit.SelectedUnit));
updateErrorDescriptionAfterMeasurementDimensionChanged(model, column);
}
}
if (model.ColumnInfo.IsBase)
{
ValidateMapping();
_view.CloseEditor();
return;
}
if (model.ColumnInfo.IsAuxiliary)
{
if (_mappingParameterEditorPresenter.SelectedErrorType == 0)
{
column.ErrorStdDev = Constants.STD_DEV_ARITHMETIC;
}
else
{
column.ErrorStdDev = Constants.STD_DEV_GEOMETRIC;
column.Dimension = Constants.Dimension.NO_DIMENSION;
column.Unit = new UnitDescription(column.Dimension.BaseUnit.Name);
}
}
else //in this case the column is a measurement column
{
column.LloqColumn = _mappingParameterEditorPresenter.LloqFromColumn() ? _mappingParameterEditorPresenter.LloqColumn : null;
}
ValidateMapping();
_view.CloseEditor();
}
