public void Convert(IWithDimension withDimension)
{
if (withDimension == null)
{
return;
}
if (withDimension.Dimension == null)
{
return;
}
if (!ConverterConstants.DummyDimensions.ContainsKey(withDimension.Dimension.Name))
{
return;
}
Unit displayUnit = null;
var formulaUsable = withDimension as IFormulaUsable;
if (formulaUsable != null)
{
displayUnit = formulaUsable.DisplayUnit;
}
withDimension.Dimension = _dimensionFactory.Dimension(ConverterConstants.DummyDimensions[withDimension.Dimension.Name]);
if (formulaUsable == null)
{
return;
}
formulaUsable.DisplayUnit = withDimension.Dimension.UnitOrDefault(displayUnit.Name);
}
private void updateDimension(IWithDimension withDimension)
{
if (withDimension == null)
{
return;
}
withDimension.Dimension = _newObjectPath.Dimension;
}
private static void updateImportedQuantityWithQuantityDimension(IWithDimension originalWithDimension, ImportedQuantityDTO dto)
{
var valueInDisplayUnit = dto.ConvertToDisplayUnit(dto.QuantityInBaseUnit);
dto.Dimension = originalWithDimension.Dimension;
dto.DisplayUnit = originalWithDimension.Dimension.Unit(dto.DisplayUnit.Name);
dto.QuantityInBaseUnit = dto.ConvertToBaseUnit(valueInDisplayUnit);
}
public static ReactionDimensionMode ReactionDimension(this IWithDimension withDimension)
{
if (withDimension.Dimension.Name.IsOneOf(Constants.Dimension.MOLAR_CONCENTRATION, Constants.Dimension.MOLAR_CONCENTRATION_PER_TIME))
{
return(ReactionDimensionMode.ConcentrationBased);
}
return(ReactionDimensionMode.AmountBased);
}
private bool conversionRequired(IWithDimension withDimension, string amountDimension)
{
if (withDimension.IsConcentrationBased() && _reactionDimensionRetriever.SelectedDimensionMode == ReactionDimensionMode.AmountBased)
{
throw new CannotConvertConcentrationToAmountException(_objectTypeResolver.TypeFor(withDimension));
}
return(_reactionDimensionRetriever.SelectedDimensionMode == ReactionDimensionMode.ConcentrationBased &&
string.Equals(withDimension.Dimension.Name, amountDimension));
}
protected void ValidateDtoAgainstBuilderForUpdate(IWithDimension originalWithDimension, ImportedQuantityDTO dto, DataRow row, int rowIndex)
{
if (Equals(originalWithDimension.Dimension, dto.Dimension))
{
return;
}
//Different dimensions sharing a common unit. Make sure we import in the expected dimension
if (haveCommonUnits(originalWithDimension.Dimension, dto.DisplayUnit))
{
updateImportedQuantityWithQuantityDimension(originalWithDimension, dto);
return;
}
// +2 because there is a mandatory header row (+1) and this index is 0-based, while excel rows start at 1 (+1)
dto.SetWarning(row, rowIndex + 2, AppConstants.Warnings.TheImportedDimensionDoesNotMatchTheExistingQuantity(dto.Path.ToString(), originalWithDimension.Dimension, dto.Dimension));
}
protected static bool HasEquivalentDimension(IWithDimension subject, IWithDimension target)
{
return(target.Dimension == subject.Dimension);
}
public static bool IsFraction(this IWithDimension objectWithDimension)
{
return(objectWithDimension.Dimension != null && objectWithDimension.Dimension.Name.IsOneOf(Constants.Dimension.FRACTION));
}
public static bool IsAmount(this IWithDimension objectWithDimension)
{
return(objectWithDimension.Dimension != null &&
(string.Equals(objectWithDimension.Dimension.Name, Constants.Dimension.AMOUNT) ||
string.Equals(objectWithDimension.Dimension.Name, Constants.Dimension.MASS_AMOUNT)));
}
protected override void Context()
{
_dimensionFactory = A.Fake <IDimensionFactory>();
_withDimension = A.Fake <IWithDimension>();
sut = new UsingDimensionConverter(_dimensionFactory);
}
public static bool DimensionIsOneOf(this IWithDimension withDimension, params string[] dimensionNames) => withDimension.DimensionName().IsOneOf(dimensionNames);
public static float ConvertToBaseUnit(this IWithDimension withDimension, float value, Unit unit)
{
return(withDimension.Dimension?.UnitValueToBaseUnitValue(unit, value) ?? value);
}
public Unit DisplayUnitFor(IWithDimension withDimension)
{
return(DisplayUnitRetriever.PreferredUnitFor(withDimension));
}
public static bool IsConcentrationBased(this IWithDimension withDimension)
{
return(ReactionDimension(withDimension) == ReactionDimensionMode.ConcentrationBased);
}
public static bool IsAmountBased(this IWithDimension withDimension)
{
return(ReactionDimension(withDimension) == ReactionDimensionMode.AmountBased);
}
public static string[] AllUnitNames(this IWithDimension withDimension) => withDimension?.Dimension?.GetUnitNames().ToArray() ?? Array.Empty <string>();
public static Unit[] AllUnits(this IWithDimension withDimension) => withDimension?.Dimension?.Units.ToArray() ?? Array.Empty <Unit>();
public static bool HasUnit(this IWithDimension withDimension, string unit) => withDimension?.Dimension != null && withDimension.Dimension.HasUnit(unit);
public static string BaseUnitName(this IWithDimension withDimension) => withDimension?.Dimension?.BaseUnit.Name ?? string.Empty;
public static string DimensionName(this IWithDimension withDimension) => withDimension?.Dimension == null ? string.Empty : withDimension.Dimension.Name;
private IDimension rhsDimensionFor(IWithDimension withDimension)
{
return(_context.DimensionFactory.RHSDimensionFor(withDimension.Dimension));
}
public static bool IsConcentration(this IWithDimension withDimension) => withDimension.DimensionIsOneOf(Constants.Dimension.MOLAR_CONCENTRATION, Constants.Dimension.MASS_CONCENTRATION);
public static float ConvertToBaseUnit(this IWithDimension withDimension, float value, string unit)
{
return(HasUnit(withDimension, unit) ? ConvertToBaseUnit(withDimension, value, withDimension.Dimension.Unit(unit)) : value);
}
public static bool IsAmount(this IWithDimension withDimension) => withDimension.DimensionIsOneOf(Constants.Dimension.MOLAR_AMOUNT, Constants.Dimension.MASS_AMOUNT);
public Unit PreferredUnitFor(IWithDimension withDimension, Unit defaultUnit = null)
{
return(PreferredUnitFor(withDimension.Dimension));
}
public bool Matches(IDimension sourceDimension, IDimension targedDimension, IWithDimension withDimension)
{
return(SourceDimension.Equals(sourceDimension) &&
TargetDimension.Equals(targedDimension) &&
Converter.CanBeUsedFor(withDimension));
}
public static Unit GetDisplayUnit(this XElement element, IWithDimension withDimension)
{
return(GetDisplayUnit(element, withDimension.Dimension));
}
public static bool IsConcentration(this IWithDimension objectWithDimension)
{
return(objectWithDimension.Dimension != null &&
(string.Equals(objectWithDimension.Dimension.Name, Constants.Dimension.MOLAR_CONCENTRATION) ||
string.Equals(objectWithDimension.Dimension.Name, Constants.Dimension.MASS_CONCENTRATION)));
}
public IDimension MergedDimensionFor(IWithDimension objectWithDimension)
{
return(_dimensionFactory.MergedDimensionFor(objectWithDimension));
}
public static bool IsFraction(this IWithDimension withDimension) => withDimension.DimensionIsOneOf(Constants.Dimension.FRACTION);
