public void ClearRow(ColumnMappingDTO model)
{
if (model.Source == null)
{
return;
}
if (model.Source is GroupByDataFormatParameter)
{
_mappings.Remove(model);
_format.Parameters.Remove(model.Source);
}
else
{
if (ShouldManualInputOnMetaDataBeEnabled(model))
{
var source = model.Source as MetaDataFormatParameter;
_mappings.First(m => m.MappingName == source.MetaDataId).ExcelColumn = null;
source.ColumnName = null;
source.IsColumn = false;
}
else
{
var index = _format.Parameters.IndexOf(model.Source);
model.ExcelColumn = Captions.Importer.NoneEditorNullText;
model.Source = null;
_format.Parameters.RemoveAt(index);
}
}
ValidateMapping();
}
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();
}
}
private void Mapping_Click(object sender, EventArgs e)
{
try
{
bool doMapping = sender.Equals(this.buttonMap) ? true : false;
if (this.fastColumnMapping.SelectedObject != null)
{
ColumnMappingDTO columnMappingDTO = this.fastColumnMapping.SelectedObject as ColumnMappingDTO;
if (columnMappingDTO != null)//Check for a valid selected row
{
ColumnAvailableDTO columnAvailableDTO = null;
if (doMapping)
{
if (this.fastColumnAvailable.SelectedObject == null)
{
return;
}
columnAvailableDTO = this.fastColumnAvailable.SelectedObject as ColumnAvailableDTO;
if (columnAvailableDTO == null)
{
return; //Check for a valid selected row
}
List <ColumnMappingDTO> foundColumnMappingDTOs = this.ColumnMappingDTOs.Where(w => w.ColumnMappingName == columnAvailableDTO.ColumnAvailableName).ToList();
foreach (ColumnMappingDTO foundColumnMappingDTO in foundColumnMappingDTOs) //Clear current mapping foundColumnMappingDTOs
{
foundColumnMappingDTO.ColumnMappingName = "";
fastColumnMapping.RefreshObject(foundColumnMappingDTO);
}
}
List <ColumnAvailableDTO> foundColumnAvailableDTOs = this.ColumnAvailableDTOs.Where(w => w.ColumnMappingName == columnMappingDTO.ColumnDisplayName).ToList();
foreach (ColumnAvailableDTO foundColumnAvailableDTO in foundColumnAvailableDTOs)//Clear current mapping foundColumnAvailableDTOs
{
foundColumnAvailableDTO.ColumnMappingName = "";
fastColumnAvailable.RefreshObject(foundColumnAvailableDTO);
}
if (doMapping)
{//Make a collumn mapping: columnMappingDTO => columnAvailableDTO
columnMappingDTO.ColumnMappingName = columnAvailableDTO.ColumnAvailableName;
columnAvailableDTO.ColumnMappingName = columnMappingDTO.ColumnDisplayName;
fastColumnMapping.RefreshObject(columnMappingDTO);
fastColumnAvailable.RefreshObject(columnAvailableDTO);
}
else//Clear current mapping columnMappingDTO
{
columnMappingDTO.ColumnMappingName = "";
fastColumnMapping.RefreshObject(columnMappingDTO);
}
}
}
}
catch (Exception exception)
{
ExceptionHandlers.ShowExceptionMessageBox(this, exception);
}
}
private void updateErrorDescriptionAfterMeasurementDimensionChanged(ColumnMappingDTO model, Column column)
{
updateErrorAfterMeasurementChanges(model, column, relatedParameter =>
{
relatedParameter.MappedColumn.Dimension = column.Dimension;
relatedParameter.MappedColumn.Unit = new UnitDescription(column.Unit.SelectedUnit);
});
}
private RepositoryItem editButtonRepository(ColumnMappingDTO model)
{
var repo = new UxRepositoryItemComboBox(columnMappingGridView)
{
AllowNullInput = DefaultBoolean.True
};
repo.Items.Clear();
return(repo);
}
protected override void Because()
{
_model = new ColumnMappingDTO
(
ColumnMappingDTO.ColumnType.MetaData,
"Molecule",
new MetaDataFormatParameter("Col1", "Molecule"),
0
);
sut.ClearRow(_model);
}
private RepositoryItem descriptionRepository(ColumnMappingDTO model)
{
var descriptionRepository = new UxRepositoryItemImageComboBox(columnMappingGridView, _imageListRetriever)
{
AutoComplete = true,
AllowNullInput = DefaultBoolean.True,
NullText = Captions.Importer.NoneEditorNullText,
CloseUpKey = new KeyShortcut(Keys.Enter)
};
fillComboBoxItems(descriptionRepository, _presenter.GetAvailableRowsFor(model));
return(descriptionRepository);
}
protected override void Context()
{
base.Context();
UpdateSettings();
GroupByDataFormatParameter groupBySource = null;
groupBySource = _parameters[3] as GroupByDataFormatParameter;
_model = new ColumnMappingDTO(ColumnMappingDTO.ColumnType.GroupBy, "Study id", groupBySource, 0)
{
ExcelColumn = "Study id"
};
}
protected override void Context()
{
base.Context();
UpdateSettings();
MetaDataFormatParameter metaDataSource = null;
metaDataSource = _parameters[3] as MetaDataFormatParameter;
_model = new ColumnMappingDTO(ColumnMappingDTO.ColumnType.MetaData, "Study id", metaDataSource, 0)
{
ExcelColumn = "Study id"
};
}
private void updateErrorDescriptionAfterMeasurementUnitIsSetFromColumn(ColumnMappingDTO model, Column column)
{
updateErrorAfterMeasurementChanges(model, column, relatedParameter =>
{
if (!relatedParameter.MappedColumn.Unit.ColumnName.IsNullOrEmpty())
{
//already a column, nothing to do here
return;
}
relatedParameter.MappedColumn.Dimension = null;
relatedParameter.MappedColumn.Unit = new UnitDescription(column.Unit.SelectedUnit, column.Unit.ColumnName);
});
}
private void setUnitAndDimension(ColumnMappingDTO model)
{
var supportedDimensions = _columnInfos[model.MappingName].SupportedDimensions;
var unit = _format.ExtractUnitDescriptions(model.ExcelColumn, supportedDimensions);
if (unit.SelectedUnit == UnitDescription.InvalidUnit)
{
return;
}
var mappingDataFormatParameter = (model.Source as MappingDataFormatParameter);
mappingDataFormatParameter.MappedColumn.Unit = unit;
mappingDataFormatParameter.MappedColumn.Dimension = supportedDimensions.FirstOrDefault(x => x.HasUnit(unit.SelectedUnit));
}
private void updateErrorAfterMeasurementChanges(ColumnMappingDTO model, Column column, Action <MappingDataFormatParameter> updateAction)
{
if (!model.ColumnInfo.IsMeasurement)
{
return;
}
foreach (var relatedColumn in _columnInfos.RelatedColumnsFrom(column.Name))
{
var relatedParameter = _mappings.Select(x => x.Source).OfType <MappingDataFormatParameter>()
.FirstOrDefault(x => x.MappedColumn.Name == relatedColumn.Name);
if (relatedParameter == null)
{
continue;
}
updateAction(relatedParameter);
}
}
private RepositoryItem repositoryItemPopupContainerEdit(ColumnMappingDTO model)
{
if (_presenter.ShouldManualInputOnMetaDataBeEnabled(model))
{
return(_repositoryMetaDataPopupContainerEdit);
}
switch (model.Source)
{
case MappingDataFormatParameter _:
_presenter.SetSubEditorSettingsForMapping(model);
return(_repositoryMappingPopupContainerEdit);
case MetaDataFormatParameter md:
return(_disabledPopupContainerEdit);
}
return(_disabledPopupContainerEdit);
}
private RepositoryItemComboBox nameRepository(ColumnMappingDTO model)
{
var entry = new ColumnMappingOption()
{
Label = model.MappingName,
IconIndex = model.Icon,
Description = model.MappingName
};
var repo = new UxRepositoryItemComboBox(columnMappingGridView)
{
AllowNullInput = DefaultBoolean.True
};
fillComboBoxItem
(
repo,
entry
);
return(repo);
}
private bool columnNameHasManualInput(ColumnMappingDTO model, MetaDataCategory metaDataCategory)
{
if (model.Source == null)
{
return(false);
}
var source = model.Source as MetaDataFormatParameter;
if (source.ColumnName == null)
{
return(false);
}
if (source.IsColumn)
{
return(false);
}
return(!metaDataCategory.ListOfValues.Keys.Union(availableColumns()).Contains(model.ExcelColumn));
}
protected override void Context()
{
base.Context();
UpdateSettings();
MetaDataFormatParameter metaDataSource = null;
metaDataSource = _parameters[3] as MetaDataFormatParameter;
_firstModel = new ColumnMappingDTO(ColumnMappingDTO.ColumnType.MetaData, "Study id", metaDataSource, 0)
{
ExcelColumn = "Study id"
};
MetaDataFormatParameter secondMetaDataSource = null;
secondMetaDataSource = _parameters[4] as MetaDataFormatParameter;
_secondModel = new ColumnMappingDTO(ColumnMappingDTO.ColumnType.MetaData, "Patient id", secondMetaDataSource, 0)
{
ExcelColumn = "Patient id"
};
sut.SetDescriptionForRow(_firstModel);
}
public void SetDescriptionForRow(ColumnMappingDTO model)
{
var values = _metaDataCategories.FirstOrDefault(md => md.Name == model.MappingName)?.ListOfValues.Keys;
setDescriptionForRow(model, values != null && values.All(v => v != model.ExcelColumn));
}
public bool ShouldManualInputOnMetaDataBeEnabled(ColumnMappingDTO model)
{
var metaDataCategory = _metaDataCategories.FindByName(model.MappingName);
return(metaDataCategory != null && metaDataCategory.AllowsManualInput);
}
public void SetSubEditorSettingsForMapping(ColumnMappingDTO model)
{
_mappingParameterEditorPresenter.HideAll();
if (!(model.Source is MappingDataFormatParameter))
{
return;
}
var source = (MappingDataFormatParameter)model.Source;
var column = source.MappedColumn;
_mappingParameterEditorPresenter.InitView();
var columns = new List <string>()
{
column.Unit.ColumnName
};
var dimensions = new List <IDimension>();
string measurementUnit = null;
if (model.ColumnInfo.RelatedColumnOf != null) //if there is a measurement column
{
var relatedColumnDTO = _mappings.FirstOrDefault(c => c.MappingName == model.ColumnInfo.RelatedColumnOf);
var relatedColumn = ((MappingDataFormatParameter)relatedColumnDTO?.Source)?.MappedColumn;
measurementUnit = relatedColumn?.Unit?.SelectedUnit;
if (relatedColumn != null && !relatedColumn.Unit.ColumnName.IsNullOrEmpty())
{
_mappingParameterEditorPresenter.SetUnitColumnSelection();
columns.Add(relatedColumn.Unit.ColumnName);
}
else
{
_mappingParameterEditorPresenter.SetUnitsManualSelection();
}
if (relatedColumn != null)
{
dimensions.Add(relatedColumn.Dimension);
}
}
else
{
var errorColumnDTO = _mappings.FirstOrDefault(c => c.ColumnInfo?.RelatedColumnOf == model.MappingName);
var errorColumn = ((MappingDataFormatParameter)errorColumnDTO?.Source)?.MappedColumn;
if (errorColumn?.Unit != null && !errorColumn.Unit.ColumnName.IsNullOrEmpty())
{
columns.Add(errorColumn.Unit.ColumnName);
}
dimensions.AddRange(_columnInfos
.First(i => i.DisplayName == model.MappingName)
.SupportedDimensions);
}
_mappingParameterEditorPresenter.SetUnitOptions(column, dimensions, columns.Union(availableColumns()));
if (model.ColumnInfo.IsBase)
{
return;
}
if (model.ColumnInfo.IsAuxiliary)
{
_mappingParameterEditorPresenter.SetErrorTypeOptions
(
new List <string>()
{
Constants.STD_DEV_ARITHMETIC, Constants.STD_DEV_GEOMETRIC
},
source.MappedColumn.ErrorStdDev,
type => type == Constants.STD_DEV_ARITHMETIC ? measurementUnit : null
);
}
else
{
var lloqColumnSelection = column.LloqColumn != null;
columns = new List <string>();
if (column.LloqColumn != null)
{
columns.Add(column.LloqColumn);
}
if (column.LloqColumn != "")
{
columns.Add("");
}
columns.AddRange(availableColumns());
_mappingParameterEditorPresenter.SetLloqOptions(columns, column.LloqColumn, lloqColumnSelection);
}
}
public IEnumerable <RowOptionDTO> GetAvailableRowsFor(ColumnMappingDTO model)
{
var options = new List <RowOptionDTO>();
if (model == null)
{
return(options);
}
var excelColumns = availableColumns();
var topNames = new List <string>();
if (model.CurrentColumnType == ColumnMappingDTO.ColumnType.MetaData)
{
var metaDataCategory = _metaDataCategories.FirstOrDefault(md => md.Name == model.MappingName);
if (columnNameHasManualInput(model, metaDataCategory))
{
options.Add(new RowOptionDTO()
{
Description = model.ExcelColumn, ImageIndex = ApplicationIcons.IconIndex(ApplicationIcons.MetaData)
});
}
if (metaDataCategory != null && metaDataCategory.ShouldListOfValuesBeIncluded)
{
options.AddRange(metaDataCategory.ListOfValues.Keys.Select(v =>
{
metaDataCategory.ListOfImages.TryGetValue(v, out var value);
if (value != null)
{
return new RowOptionDTO()
{
Description = v, ImageIndex = ApplicationIcons.IconIndex(value)
}
}
;
var iconIndex = ApplicationIcons.IconIndex(v);
if (iconIndex == -1)
{
iconIndex = ApplicationIcons.IconIndex(ApplicationIcons.MetaData);
}
return(new RowOptionDTO()
{
Description = v, ImageIndex = iconIndex
});
}));
}
topNames = metaDataCategory.TopNames;
}
if (model.Source != null && (model.CurrentColumnType == ColumnMappingDTO.ColumnType.MetaData &&
(model.Source as MetaDataFormatParameter).IsColumn))
{
options.Add(new RowOptionDTO()
{
Description = model.Source.ColumnName, ImageIndex = ApplicationIcons.IconIndex(ApplicationIcons.ObservedDataForMolecule)
});
}
else if (model.Source != null && !(model.Source is AddGroupByFormatParameter) && !(model.Source is MetaDataFormatParameter))
{
options.Add(new RowOptionDTO()
{
Description = model.Source.ColumnName, ImageIndex = ApplicationIcons.IconIndex(ApplicationIcons.ObservedDataForMolecule)
});
}
if (model.CurrentColumnType == ColumnMappingDTO.ColumnType.AddGroupBy)
{
options.Add(new RowOptionDTO()
{
Description = model.ExcelColumn, ImageIndex = ApplicationIcons.IconIndex(ApplicationIcons.Add)
});
}
options.AddRange(excelColumns.Select(c => new RowOptionDTO()
{
Description = c, ImageIndex = ApplicationIcons.IconIndex(ApplicationIcons.ObservedDataForMolecule)
}));
var metaDataIconIndex = ApplicationIcons.IconIndex(ApplicationIcons.ObservedDataForMolecule);
return(options.OrderByDescending(o => topNames.Contains(o.Description)).ThenBy(o => o.ImageIndex == metaDataIconIndex)
.ThenBy(o => o.Description));
}
private RepositoryItem removeRepository(ColumnMappingDTO model)
{
return(model.Source == null || model.Source is AddGroupByFormatParameter
? _disabledRemoveButtonRepository
: _removeButtonRepository);
}
private void onValueChanged(ColumnMappingDTO model)
{
_presenter.SetDescriptionForRow(model);
}
public IEnumerable <ColumnMappingOption> GetAvailableOptionsFor(ColumnMappingDTO model)
{
var options = new List <ColumnMappingOption>();
if (model == null)
{
return(new List <ColumnMappingOption>());
}
if (model.Source != null)
{
switch (model.Source)
{
case GroupByDataFormatParameter _:
options.Add(generateGroupByColumnMappingOption(model.Source.ColumnName));
break;
case MappingDataFormatParameter tm:
options.Add(generateMappingColumnMappingOption(model.Source.ColumnName,
tm.MappedColumn.Unit.SelectedUnit));
break;
case MetaDataFormatParameter tm:
options.Add(generateMetaDataColumnMappingOption(model.Source.ColumnName));
break;
case AddGroupByFormatParameter _:
break;
default:
throw new Exception(Error.TypeNotSupported(model.Source.GetType().Name));
}
}
var availableColumns = this.availableColumns();
switch (model.CurrentColumnType)
{
case ColumnMappingDTO.ColumnType.Mapping:
foreach (var column in availableColumns)
{
options.Add(generateMappingColumnMappingOption(column));
}
break;
case ColumnMappingDTO.ColumnType.MetaData:
foreach (var column in availableColumns)
{
options.Add(
generateMetaDataColumnMappingOption(
column
)
);
}
break;
case ColumnMappingDTO.ColumnType.GroupBy:
//GroupBy only for missing columns
foreach (var column in availableColumns)
{
options.Add(
generateGroupByColumnMappingOption(
column
)
);
}
break;
case ColumnMappingDTO.ColumnType.AddGroupBy:
//GroupBy only for missing columns
foreach (var column in availableColumns)
{
options.Add(
generateAddGroupByColumnMappingOption(
column
)
);
}
break;
}
return(options);
}
//ToDo: this big switch statement here underneath should be refactored, probably broken to more than one functions.
//ToDo: also the part of the switch(model.Source) that also then in the cases changes the model.Source is kind of murky.
private void setDescriptionForRow(ColumnMappingDTO model, bool isColumn)
{
switch (model.Source)
{
//this is the case for the first setting of Mapping or MetaData. GroupBy and AddGroupBy are never null.
case null:
switch (model.CurrentColumnType)
{
case ColumnMappingDTO.ColumnType.MetaData:
model.Source = new MetaDataFormatParameter(model.ExcelColumn, model.MappingName, isColumn);
break;
case ColumnMappingDTO.ColumnType.Mapping:
model.Source = new MappingDataFormatParameter(model.ExcelColumn,
new Column()
{
Name = model.MappingName, Unit = new UnitDescription(UnitDescription.InvalidUnit)
});
setUnitAndDimension(model);
break;
default:
throw new NotImplementedException($"Setting description for unhandled column type: {model.CurrentColumnType}");
}
_format.Parameters.Add(model.Source);
break;
//this is the case for setting a new GroupBy parameter. The AddGroupByFormatParameter corresponds to the line in the ColumnMapping Grid
//that has the "+" button for adding the GroupBy, that's why in this case we are introducing a new Parameter, instead of changing the existing.
//The AddGroupByFormatParameter, should never be changed, as the "+" button line should always present in the Grid
case AddGroupByFormatParameter _:
model.Source = new GroupByDataFormatParameter(model.ExcelColumn);
_format.Parameters.Add(model.Source);
setDataFormat(_format.Parameters);
break;
//this is the case that corresponds to the changing of the mapping for a Parameter.
//The Parameter in this case can be Mapping, MetaData or GroupBy
default:
{
model.Source.ColumnName = model.ExcelColumn;
switch (model.CurrentColumnType)
{
case ColumnMappingDTO.ColumnType.MetaData:
(model.Source as MetaDataFormatParameter).IsColumn = isColumn;
break;
case ColumnMappingDTO.ColumnType.Mapping:
setUnitAndDimension(model);
break;
case ColumnMappingDTO.ColumnType.GroupBy:
break;
default:
throw new NotImplementedException($"Setting description for unhandled column type: {model.CurrentColumnType}");
}
break;
}
}
}
