private void reflectMetaDataChangesForColumn(ImportDataColumn column)
{
_gridPresenter.ReflectMetaDataChangesForColumn(column);
UnitChanged?.Invoke(this, new EventArgs());
}
public void should_fill_data_table_with_skipping_rows_sheet3()
{
ImportDataTable testTable = _importDataTable.Clone();
ImportDataColumn col = testTable.Columns.ItemByIndex(1);
col.SkipNullValueRows = true;
col.Dimensions = new List <Dimension>
{
new Dimension
{
DisplayName = "Time",
IsDefault = true,
Name = "Time",
Units = new List <Unit>
{
new Unit
{
IsDefault = false, Name = "h", DisplayName = "in Stunden"
},
new Unit {
IsDefault = true, Name = "d", DisplayName = "in Tagen"
}
}
}
};
var tables = sut.ImportDataTables(testTable, _excelFile, _sheetNames[2], 0, 1, 2, -1, _cms);
tables[0].Rows.Count.ShouldBeEqualTo(46);
}
public void should_throw_exception_MultipleDefaultDimensionsFound()
{
IList <Dimension> dimensions = new List <Dimension>(2)
{
new Dimension
{
DisplayName = "DimA",
IsDefault = true,
Name = "A",
Units =
new List <Unit>
{
new Unit {
DisplayName = "UnitA", IsDefault = true, Name = "A"
}
}
},
new Dimension
{
DisplayName = "DimB",
IsDefault = true,
Name = "B",
Units =
new List <Unit>
{
new Unit {
DisplayName = "UnitA", IsDefault = true, Name = "A"
}
}
}
};
var importDataColumn = new ImportDataColumn();
The.Action(() => importDataColumn.Dimensions = dimensions).ShouldThrowAn <MultipleDefaultDimensionsFound>();
}
public string GetLowerLimitOfQuantificationToolTipTextForRow(int dataTableRow)
{
if (!sourceRowHasValueBelowLowerLimitOfQuantification(dataTableRow))
{
return(string.Empty);
}
ImportDataColumn lloqColumn = null;
foreach (ImportDataColumn column in _table.Columns)
{
double columnValue;
if (!double.TryParse(getValueForRowAndColumn(dataTableRow, column), out columnValue))
{
continue;
}
if (hasValueBelowLimitOfQuantification(column, columnValue))
{
lloqColumn = column;
}
}
if (lloqColumn == null)
{
return(string.Empty);
}
return(ToolTips.LLOQTooltip(lloqColumn.ColumnName, getValueForRowAndColumn(dataTableRow, lloqColumn), lloqColumn.ActiveUnit.DisplayName, getLowerLimitFromColumnExtendedProperties(lloqColumn)));
}
public void when_attaching_the_property_to_the_column()
{
var importDataColumn = new ImportDataColumn();
sut.AttachLLOQ(importDataColumn, 1.0F);
importDataColumn.ColumnContainsValidLLOQ().ShouldBeTrue();
importDataColumn.LLOQProperty().ShouldBeEqualTo(1.0F);
}
public void should_find_the_column_value_if_string_value_is_not_valid()
{
var stringValue = $">{99}";
var column = new ImportDataColumn();
column.ExtendedProperties[Constants.LLOQ] = 1.0F;
sut.GetInterpretationOfLLOQ(stringValue, column).ShouldBeEqualTo(0.5F);
}
public void should_find_the_higher_of_the_two_values_when_two_limits_are_encountered_in_a_column()
{
var stringValue = $"<{0.5}";
var column = new ImportDataColumn();
column.ExtendedProperties[Constants.LLOQ] = 1.0F;
sut.GetInterpretationOfLLOQ(stringValue, column).ShouldBeEqualTo(0.5F);
}
public void ReflectMetaDataChangesForColumn(ImportDataColumn column)
{
//maybe the unit must be changed according to new metadata entered
column.SetColumnUnitDependingOnMetaData();
_view.ReflectMetaDataChangesForColumn(column);
RaiseMetaDataChangedEvent();
}
public float GetInterpretationOfLLOQ(string stringValue, ImportDataColumn importDataColumn)
{
if (float.IsNaN(ParseLLOQ(stringValue)) && float.IsNaN(importDataColumn.LLOQProperty()))
{
return(float.NaN);
}
return(DetermineBestLLOQ(ParseLLOQ(stringValue), importDataColumn.LLOQProperty()) / 2);
}
public void easy_case_should_indicate_a_match_can_be_found_should_match()
{
var stringValue = $"<{0.5}";
sut.IsLLOQ(stringValue).ShouldBeTrue();
sut.ParseLLOQ(stringValue).ShouldBeEqualTo(0.5F);
var column = new ImportDataColumn();
sut.GetInterpretationOfLLOQ(stringValue, column).ShouldBeEqualTo(0.25F);
}
public void should_throw_exception_DublicatedInputParameterFoundForDimension_For_DisplayName()
{
IList <Dimension> dimensions = new List <Dimension>
{
new Dimension
{
Name = "DimA",
IsDefault = true,
Units = new List <Unit>(2)
{
new Unit
{
DisplayName = "UnitA",
IsDefault = false,
Name = "A"
},
new Unit
{
DisplayName = "UnitB",
IsDefault = true,
Name = "B"
}
},
InputParameters = new List <InputParameter>(2)
{
new InputParameter
{
DisplayName = "Molecular Weight",
Name = "MolWeight",
Unit = new Unit
{
DisplayName =
"Gram per Mol",
Name = "g/mol"
}
},
new InputParameter
{
DisplayName = "Molecular Weight",
Name = "Velocity",
Unit =
new Unit
{
DisplayName = "Gram per Litre",
Name = "g/l"
}
}
}
}
};
var importDataColumn = new ImportDataColumn();
The.Action(() => importDataColumn.Dimensions = dimensions).ShouldThrowAn
<DublicatedInputParameterForDimension>();
}
public SetUnitView(ImportDataColumn importDataColumn, IImporterTask importerTask)
{
_importDataColumn = importDataColumn;
getUnits();
InitializeComponent();
Shown += (s, e) => enableButtons();
Text = Captions.Importer.PleaseEnterDimensionAndUnitInformation;
btnOK.Click += (o, e) => this.DoWithinExceptionHandler(onOkClick);
btnCopy.Click += (o, e) => this.DoWithinExceptionHandler(onCopyClick);
if (useDimensionSelector)
{
_dimensionComboBox = createComboBox("Dimension", onDimensionComboBoxTextChanged);
}
_unitComboBox = createComboBox("Unit", onUnitComboBoxTextChanged);
if (useDimensionSelector)
{
fillDimensionComboBox();
}
fillUnitComboBox();
if (useDimensionSelector)
{
var dimItem = _dimensionComboBox.Properties.Items.GetItem(_importDataColumn.ActiveDimension.Name);
if (_dimensionComboBox.Properties.Items.Contains(dimItem))
{
_dimensionComboBox.EditValue = _importDataColumn.ActiveDimension.Name;
}
else
{
importerTask.SetColumnUnit(_importDataColumn, selectedUnit.Name, true);
}
}
var unitItem = _unitComboBox.Properties.Items.GetItem(_importDataColumn.ActiveUnit.Name);
if (_unitComboBox.Properties.Items.Contains(unitItem))
{
_unitComboBox.EditValue = _importDataColumn.ActiveUnit.Name;
}
arrangeControls();
enableButtons();
if (ParentForm != null)
{
Icon = ParentForm.Icon;
}
}
protected override void Context()
{
base.Context();
_table.Columns.Add(new ImportDataColumn());
var dataColumn = new ImportDataColumn();
_table.Columns.Add(dataColumn);
_table.LoadDataRow(new object[] { 1, 1 }, fAcceptChanges: true);
sut.Edit(_table);
}
public void should_throw_exception_MissingUnitsForDimension()
{
IList <Dimension> dimensions = new List <Dimension>(1)
{
new Dimension {
DisplayName = "DimA", IsDefault = true, Name = "A"
}
};
var importDataColumn = new ImportDataColumn();
The.Action(() => importDataColumn.Dimensions = dimensions).ShouldThrowAn <MissingUnitsForDimension>();
}
public void ReflectMetaDataChangesForColumn(ImportDataColumn column)
{
foreach (GridColumn gc in gridView.Columns)
{
if (_presenter.TableColumnByName(gc.FieldName) == null)
{
continue;
}
setColumnImage(gc);
gc.Caption = _presenter.GetCaptionForColumnByName(gc.FieldName);
gc.BestFit();
}
}
protected override void Context()
{
base.Context();
_table.Columns.Add(new ImportDataColumn());
var dataColumn = new ImportDataColumn();
_table.Columns.Add(dataColumn);
dataColumn.ExtendedProperties.Add(Constants.LLOQ, 10);
_table.LoadDataRow(new object[] { 1, 1 }, fAcceptChanges: true);
sut.Edit(_table);
}
private SplitContainerControl createColumnMetaDataControl(ImportDataColumn col, bool swapPanels)
{
if (col.MetaData == null)
{
return(null);
}
if (string.IsNullOrEmpty(col.Source))
{
return(null);
}
var colMetaDataControl = new MetaDataEditControl(col.MetaData)
{
Tag = col, AutoAcceptChanges = true
};
Controls.Add(colMetaDataControl);
colMetaDataControl.OnCopyMetaData += onCopyMetaDataColumnControlPanel;
colMetaDataControl.OnIsDataValidChanged += onIsValidChangedColumnControlPanel;
colMetaDataControl.OnMetaDataChanged += onMetaDataChangedColumnControlPanel;
if (col.MetaData.Rows.Count > 0)
{
col.SetColumnUnitDependingOnMetaData();
reflectMetaDataChangesForColumn(col);
}
var newSplitter = new SplitContainerControl();
Controls.Add(newSplitter);
newSplitter.BeginInit();
newSplitter.Horizontal = false;
newSplitter.FixedPanel = SplitFixedPanel.Panel1;
newSplitter.AlwaysScrollActiveControlIntoView = true;
newSplitter.Panel2.Controls.Add(colMetaDataControl);
colMetaDataControl.Dock = DockStyle.Fill;
newSplitter.Panel2.Name = col.ColumnName;
newSplitter.Panel2.Text = col.GetCaptionForColumn();
newSplitter.Panel2.ShowCaption = true;
newSplitter.Panel2.BorderStyle = BorderStyles.Simple;
newSplitter.Panel2.MinSize = PANEL_MIN_SIZE;
newSplitter.Panel2.Height = (col.MetaData.Columns.Count + 2) * PANEL_ROW_HEIGHT;
newSplitter.CollapsePanel = SplitCollapsePanel.Panel2;
if (swapPanels)
{
newSplitter.SwapPanels();
}
newSplitter.SplitterPosition = PANEL_ROW_HEIGHT;
newSplitter.EndInit();
return(newSplitter);
}
public void should_throw_invalid_unit_sheet3()
{
ImportDataTable testTable = _importDataTable.Clone();
ImportDataColumn col = testTable.Columns.ItemByIndex(1);
col.Dimensions = new List <Dimension>
{
new Dimension
{
DisplayName = "Time",
IsDefault = true,
Name = "Time",
Units = new List <Unit>
{
new Unit
{
IsDefault = false, Name = "hour", DisplayName = "in Stunden"
},
new Unit {
IsDefault = true, Name = "d", DisplayName = "in Tagen"
}
}
}
};
var cms = new List <ColumnMapping>(_cms.Count);
foreach (ColumnMapping ocm in _cms)
{
var cm = new ColumnMapping {
SourceColumn = ocm.SourceColumn, Target = ocm.Target
};
if (cm.SourceColumn == _columnNames[1])
{
cm.SelectedUnit = new Unit {
Name = "h"
}
}
;
cms.Add(cm);
}
The.Action(() => sut.ImportDataTables(testTable, _excelFile, _sheetNames[2], 0, 1, 2, -1, cms)).ShouldThrowAn
<InvalidUnitForExcelColumnException>();
}
public void should_not_fill_data_table_with_more_rows_sheet2()
{
ImportDataTable testTable = _importDataTable.Clone();
ImportDataColumn col = testTable.Columns.ItemByIndex(1);
col.Dimensions = new List <Dimension>
{
new Dimension
{
DisplayName = "Time",
IsDefault = true,
Name = "Time",
Units = new List <Unit>
{
new Unit
{
IsDefault = false, Name = "h", DisplayName = "in Stunden"
},
new Unit {
IsDefault = true, Name = "d", DisplayName = "in Tagen"
}
}
}
};
var cms = new List <ColumnMapping>(_cms.Count);
foreach (ColumnMapping ocm in _cms)
{
var cm = new ColumnMapping {
SourceColumn = ocm.SourceColumn, Target = ocm.Target
};
if (cm.SourceColumn == _columnNames[1])
{
cm.SourceColumn += " [h]";
}
cms.Add(cm);
}
var tables = sut.ImportDataTables(testTable, _excelFile, _sheetNames[1], 0, 0, 1, 99, cms);
tables[0].Rows.Count.ShouldBeEqualTo(49);
}
public void should_throw_exception_DublicatedUnitFoundForDimension_For_DisplayName()
{
var units = new List <Unit>(2)
{
new Unit {
DisplayName = "UnitA", IsDefault = false, Name = "A"
},
new Unit {
DisplayName = "UnitA", IsDefault = true, Name = "B"
}
};
var dim = new Dimension {
Name = "DimA", IsDefault = true, Units = units
};
IList <Dimension> dimensions = new List <Dimension> {
dim
};
var importDataColumn = new ImportDataColumn();
The.Action(() => importDataColumn.Dimensions = dimensions).ShouldThrowAn <DublicatedUnitForDimension>();
}
public void AttachLLOQ(ImportDataColumn column, float lloq)
{
column.AttachLLOQ(DetermineBestLLOQ(lloq, column.LLOQProperty()));
}
/// <summary>
/// This method converts an <see cref="ImportDataColumn" /> object and adds it to the data repository.
/// </summary>
/// <param name="dataRepository"></param>
/// <param name="importDataColumn">Import data column to be converted.</param>
/// <param name="columnInfos">Specification of columns including specification of meta data.</param>
/// <param name="errorNaN">
/// This is a flag informing the caller about whether error have been changed to NaN because they
/// are out of definition.
/// </param>
private void convertImportDataColumn(DataRepository dataRepository, ImportDataColumn importDataColumn, IEnumerable <ColumnInfo> columnInfos, out bool errorNaN)
{
errorNaN = false;
if (containsColumnByName(dataRepository.Columns, importDataColumn.ColumnName))
{
return;
}
if (string.IsNullOrEmpty(importDataColumn.Source))
{
return; //not mapped and this means not used.
}
var importDataTable = importDataColumn.Table;
var enumerable = columnInfos as IList <ColumnInfo> ?? columnInfos.ToList();
var colInfo = enumerable.FirstOrDefault(col => col.Name == importDataColumn.ColumnName);
if (colInfo == null)
{
return;
}
if (importDataColumn.Dimensions == null)
{
throw new OSPSuiteException(string.Format("Column {0} has no dimension.", importDataColumn.ColumnName));
}
var dimension = _dimensionFactory.Dimension(importDataColumn.ActiveDimension.Name);
DataColumn dataColumn;
if (string.IsNullOrEmpty(colInfo.BaseGridName) || (colInfo.BaseGridName == colInfo.Name))
{
dataColumn = new BaseGrid(importDataColumn.ColumnName, dimension);
}
else
{
if (!containsColumnByName(dataRepository.Columns, colInfo.BaseGridName))
{
bool columnErrorNaN;
convertImportDataColumn(dataRepository, importDataTable.Columns.ItemByName(colInfo.BaseGridName),
enumerable, out columnErrorNaN);
errorNaN |= columnErrorNaN;
}
var baseGrid = findColumnByName(dataRepository.Columns, colInfo.BaseGridName) as BaseGrid;
dataColumn = new DataColumn(importDataColumn.ColumnName, dimension, baseGrid);
}
var dataInfo = new DataInfo(ColumnOrigins.Undefined);
dataColumn.DataInfo = dataInfo;
if (!string.IsNullOrEmpty(importDataColumn.Source))
{
dataInfo.Source = importDataColumn.Source;
}
var unit = dimension.Unit(importDataColumn.ActiveUnit.Name);
var values = new float[importDataTable.Rows.Count];
var i = 0;
//loop over view rows to get the sorted values.
foreach (DataRowView row in importDataTable.DefaultView)
{
var value = row[importDataColumn.ColumnName];
if (value == null || value == DBNull.Value)
{
values[i++] = float.NaN;
}
else
{
values[i++] = (float)dataColumn.Dimension.UnitValueToBaseUnitValue(unit, (double)value);
}
}
dataInfo.DisplayUnitName = unit.Name;
dataColumn.Values = values;
//transfer input parameters
if (importDataColumn.ActiveDimension.InputParameters != null)
{
//transfer input parameters to extended properties
foreach (var inputParameter in importDataColumn.ActiveDimension.InputParameters)
{
if (inputParameter.Value == null)
{
continue;
}
//create an extended property
var extendedProperty =
Activator.CreateInstance(typeof(ExtendedProperty <>).MakeGenericType(typeof(double)))
as IExtendedProperty;
if (extendedProperty == null)
{
continue;
}
extendedProperty.Name = inputParameter.Name;
extendedProperty.ValueAsObject = (double)inputParameter.Value;
dataInfo.ExtendedProperties.Add(extendedProperty);
}
}
//transfer meta data information to data info fields or extended properties
if (importDataColumn.MetaData != null && importDataColumn.MetaData.Rows.Count > 0)
{
foreach (MetaDataColumn metaData in importDataColumn.MetaData.Columns)
{
var value = importDataColumn.MetaData.Rows.ItemByIndex(0)[metaData];
if (value == DBNull.Value && !metaData.Required)
{
continue;
}
var propInfo = dataInfo.GetType().GetProperty(metaData.ColumnName);
if (propInfo != null)
{
if (metaData.ColumnName == Constants.AUXILIARY_TYPE)
{
switch (value.ToString())
{
case Constants.STD_DEV_ARITHMETIC:
value = AuxiliaryType.ArithmeticStdDev;
for (i = 0; i < dataColumn.Values.Count; i++)
{
if (dataColumn.Values[i] < 0F)
{
dataColumn[i] = float.NaN;
errorNaN = true;
}
}
break;
case Constants.STD_DEV_GEOMETRIC:
value = AuxiliaryType.GeometricStdDev;
for (i = 0; i < dataColumn.Values.Count; i++)
{
if (dataColumn.Values[i] < 1F)
{
dataColumn[i] = float.NaN;
errorNaN = true;
}
}
break;
}
}
else
{
// set explicitly defined property
if (propInfo.PropertyType.IsEnum)
{
value = Enum.Parse(propInfo.PropertyType, value.ToString(), true);
}
}
propInfo.SetValue(dataColumn.DataInfo, value, null);
}
else
{
// add extended property
var extendedProperty =
Activator.CreateInstance(typeof(ExtendedProperty <>).MakeGenericType(metaData.DataType))
as IExtendedProperty;
if (extendedProperty == null)
{
continue;
}
extendedProperty.Name = metaData.ColumnName;
extendedProperty.ValueAsObject = value;
dataInfo.ExtendedProperties.Add(extendedProperty);
}
}
}
//special case: Origin
//if AuxiliaryType is set, set Origin to ObservationAuxiliary else to Observation for standard columns
//type is set to BaseGrid for baseGrid column
if (dataColumn.IsBaseGrid())
{
dataInfo.Origin = ColumnOrigins.BaseGrid;
}
else
{
dataInfo.Origin = (dataColumn.DataInfo.AuxiliaryType == AuxiliaryType.Undefined)
? ColumnOrigins.Observation
: ColumnOrigins.ObservationAuxiliary;
}
if (dataInfo.Origin == ColumnOrigins.Observation)
{
addLowerLimitOfQuantification(importDataColumn, dataColumn);
}
dataRepository.Add(dataColumn);
}
public ImportDataTable ConvertToImportDataTable(IReadOnlyList <MetaDataCategory> metaDataCategories, IEnumerable <ColumnInfo> columnInfos)
{
var retVal = new ImportDataTable();
if (metaDataCategories != null && metaDataCategories.Count > 0)
{
retVal.MetaData = convertToMetaDataTable(metaDataCategories);
}
foreach (var columnInfo in columnInfos)
{
var column = new ImportDataColumn
{
ColumnName = columnInfo.Name,
DisplayName = columnInfo.DisplayName,
Description = columnInfo.Description,
DataType = columnInfo.DataType,
Required = (columnInfo.IsMandatory || columnInfo.NullValuesHandling == NullValuesHandlingType.NotAllowed),
SkipNullValueRows = (columnInfo.NullValuesHandling == NullValuesHandlingType.DeleteRow),
};
if (columnInfo.MetaDataCategories != null && columnInfo.MetaDataCategories.Count > 0)
{
column.MetaData = convertToMetaDataTable(columnInfo.MetaDataCategories);
}
if (columnInfo.DimensionInfos != null && columnInfo.DimensionInfos.Count > 0)
{
column.Dimensions = columnInfo.DimensionInfos.Select(dimensioninfo => dimensioninfo.ConvertToDimensions()).ToList();
column.ActiveDimension = DimensionHelper.FindDimension(column.Dimensions,
columnInfo.DefaultDimension.Name);
}
if (!string.IsNullOrEmpty(columnInfo.RelatedColumnOf)) //column is error column, so we need auxiliary type as metadata
{
column.ColumnNameOfRelatedColumn = columnInfo.RelatedColumnOf;
//Add AuxiliaryType meta data category
if (column.MetaData == null)
{
column.MetaData = new MetaDataTable();
}
var listOfValues = new Dictionary <string, string>
{
{ Constants.STD_DEV_ARITHMETIC, Constants.STD_DEV_ARITHMETIC },
{ Constants.STD_DEV_GEOMETRIC, Constants.STD_DEV_GEOMETRIC }
};
//if there is only the dimensionless dimension defined only geometric error make sense
if (column.Dimensions.Count == 1)
{
if (column.Dimensions[0].IsDimensionless())
{
listOfValues.Remove(Constants.STD_DEV_ARITHMETIC);
}
}
var auxiliaryTypeColumn = new MetaDataColumn
{
ColumnName = Constants.AUXILIARY_TYPE,
DisplayName = "Error Type",
DataType = typeof(string),
Description = "What is the type of error?",
ListOfValues = new Dictionary <string, string>(listOfValues),
IsListOfValuesFixed = true,
Required = true
};
column.MetaData.Columns.Add(auxiliaryTypeColumn);
// add special condition to the dimensions
// for geometric error the unit must be dimensionless
// for arithmetic the unit must be a concrete dimension
foreach (var dim in column.Dimensions)
{
if (dim.MetaDataConditions == null)
{
dim.MetaDataConditions = new Dictionary <string, string>();
}
if (dim.IsDimensionless())
{
dim.MetaDataConditions.Add(Constants.AUXILIARY_TYPE, Constants.STD_DEV_GEOMETRIC);
if (dim.IsDefault)
{
auxiliaryTypeColumn.DefaultValue = Constants.STD_DEV_GEOMETRIC;
}
}
else
{
dim.MetaDataConditions.Add(Constants.AUXILIARY_TYPE, Constants.STD_DEV_ARITHMETIC);
if (dim.IsDefault)
{
auxiliaryTypeColumn.DefaultValue = Constants.STD_DEV_ARITHMETIC;
}
}
}
}
retVal.Columns.Add(column);
}
return(retVal);
}
public SuperToolTip GetToolTipForImportDataColumn(ImportDataColumn importDataColumn)
{
return(_importerTask.GetToolTipForImportDataColumn(importDataColumn));
}
