private void updateDiffItem(string value1, string value2, string propertyName, string objectName, object parent, bool itemIsMissing)
{
_diffItemDTO.Value1 = value1;
_diffItemDTO.Value2 = value2;
_diffItemDTO.Property = propertyName;
_diffItemDTO.ObjectName = objectName;
_diffItemDTO.ItemIsMissing = itemIsMissing;
var entity = parent as IEntity;
_diffItemDTO.PathElements = entity == null ? new PathElements() : _pathElementsMapper.MapFrom(entity);
}
protected override void Context()
{
_pathToPathElementMapper = A.Fake <IPathToPathElementsMapper>();
_displayNameProvider = A.Fake <IDisplayNameProvider>();
_container = new Container().WithName("ROOT");
_pathElements = new PathElements();
sut = new DiffItemToDiffItemDTOMapper(_pathToPathElementMapper, _displayNameProvider);
A.CallTo(() => _pathToPathElementMapper.MapFrom(_container)).Returns(_pathElements);
A.CallTo(() => _displayNameProvider.DisplayNameFor(A <object> ._)).ReturnsLazily(x =>
{
var obj = x.GetArgument <object>(0);
return(obj != null ? obj.ToString() : string.Empty);
});
}
private void updateParameterDTOFromParameter(ParameterDTO parameterDTO, IParameter parameter)
{
var parameterPath = _entityPathResolver.ObjectPathFor(parameter);
var representationInfo = _representationInfoRepository.InfoFor(parameter);
parameterDTO.DisplayName = representationInfo.DisplayName;
parameterDTO.Description = representationInfo.Description;
parameterDTO.AllUnits = allUnitsFor(parameter);
parameterDTO.FormulaType = _formulaTypeMapper.MapFrom(parameter.Formula);
parameterDTO.IsFavorite = _favoriteRepository.Contains(parameterPath);
parameterDTO.Sequence = parameter.Sequence;
parameterDTO.PathElements = _parameterDisplayPathMapper.MapFrom(parameter);
//now create special list of values for parameter for our discrete parameters
updateListOfValues(parameterDTO, parameter);
}
public PathElements MapFrom(DataColumn dataColumn, IContainer rootContainer)
{
var quantityPath = dataColumn.QuantityInfo.Path.ToList();
if (isCalculationColumn(dataColumn, rootContainer, quantityPath))
{
return(_pathToPathElementsMapper.MapFrom(rootContainer, quantityPath));
}
if (dataColumn.IsObservedData())
{
return(ObservedDataPathElementsFor(dataColumn, quantityPath));
}
if (dataColumn.IsBaseGrid())
{
return(pathElementsForBaseGrid(dataColumn));
}
return(pathElementsForUnknownColumns(dataColumn, quantityPath));
}
public virtual QuantitySelectionDTO MapFrom(IQuantity quantity, int sequence)
{
if (quantity == null)
{
return(null);
}
var quantityPath = _entityPathResolver.ObjectPathFor(quantity);
var pathElements = _pathToPathElementsMapper.MapFrom(quantity);
return(new QuantitySelectionDTO
{
QuantityPath = quantityPath.PathAsString,
QuantityName = quantity.Name,
QuantityType = quantity.QuantityType,
Dimension = quantity.Dimension,
Quantity = quantity,
Sequence = sequence,
PathElements = pathElements
});
}
public IParameterDTO MapFrom(IParameter parameter)
{
var dto = new ParameterDTO(parameter);
MapProperties(parameter, dto);
dto.Formula = _formulaToDTOFormulaBuilderMapper.MapFrom(parameter.Formula);
dto.RHSFormula = _formulaToDTOFormulaBuilderMapper.MapFrom(parameter.RHSFormula);
dto.BuildMode = parameter.BuildMode;
dto.Dimension = parameter.Dimension;
dto.HasRHS = (parameter.RHSFormula != null);
dto.DisplayUnit = parameter.Dimension.BaseUnit;
dto.Group = _groupRepository.GroupByName(parameter.GroupName);
dto.IsAdvancedParameter = !parameter.Visible;
dto.CanBeVariedInPopulation = parameter.CanBeVariedInPopulation;
dto.PathElements = _pathToPathElementsMapper.MapFrom(parameter);
var parameterPath = _entityPathResolver.ObjectPathFor(parameter);
dto.IsFavorite = _favoriteRepository.Contains(parameterPath);
return(dto);
}
private PathElements displayPathForQuantity(IContainer rootContainer, IObjectPath objectPath)
{
return(_pathToPathElementsMapper.MapFrom(rootContainer, objectPath.ToList()));
}
