private void adjustDisplayNameForMoleculeObserver(PathElements pathElements, IObserver observer)
{
//For all fraction observers, the name should remain as is except for liver zone observers that need to be rename explicitly
if (observerIsFractionOfDoseLiver(observer))
{
updateNameElementForFractionOfDose(pathElements, observer);
}
// These observers should be renamed to their dimension (concentration).
else if (observer.Name.StartsWith(CONCENTRATION_IN_CONTAINER))
{
updateNameElementToQuantityDimensionName(pathElements, observer);
}
}
protected override void Context()
{
base.Context();
_pathElements = new PathElements();
_pathElements[PathElementId.Simulation] = new PathElement {
DisplayName = "Sim"
};
_pathElements[PathElementId.TopContainer] = new PathElement {
DisplayName = "Organism"
};
_pathElements[PathElementId.Name] = new PathElement {
DisplayName = "OBS"
};
A.CallTo(() => _dataColumnToPathElementsMapper.MapFrom(_column, _individualSimulation.Model.Root)).Returns(_pathElements);
}
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);
});
}
protected override void Context()
{
base.Context();
_pathElements = new PathElements
{
[PathElement.Simulation] = new PathElementDTO {DisplayName = "Sim"},
[PathElement.TopContainer] = new PathElementDTO {DisplayName = "Organism"},
[PathElement.Container] = new PathElementDTO {DisplayName = "Liver"},
[PathElement.Molecule] = new PathElementDTO {DisplayName = "Drug"},
[PathElement.BottomCompartment] = new PathElementDTO {DisplayName = "Plasma"},
[PathElement.Name] = new PathElementDTO {DisplayName = "OBS"}
};
_column.DataInfo.Origin = ColumnOrigins.Observation;
A.CallTo(() => _dataColumnToPathElementsMapper.MapFrom(_column, _individualSimulation.Model.Root)).Returns(_pathElements);
}
private void updateMoleculeIcon(PathElements pathElements)
{
if (!pathElements.Contains(PathElement.Molecule))
{
return;
}
var moleculePathElement = pathElements[PathElement.Molecule];
if (ApplicationIcons.HasIconNamed(moleculePathElement.IconName))
{
return;
}
moleculePathElement.IconName = ApplicationIcons.Drug.IconName;
}
public PatternDetails(SourceFileContext ctx, ResourceDetails.Definition def, ResourceDetails.Definition.Pattern pattern)
{
PatternString = pattern.PatternString;
PathSegments = pattern.Template.Segments.Select(x => new PathSegment(ctx, def, x)).ToList();
if (pattern.Template.ParameterNames.Count() == 0)
{
// Path-template contains no parameters, special naming required.
UpperName = PatternString.ToUpperCamelCase();
LowerName = PatternString.ToLowerCamelCase();
}
else
{
// Standard naming, concat all parameter names.
UpperName = string.Join("", PathElements.Select(x => x.UpperCamel));
LowerName = string.Join("", PathElements.Take(1).Select(x => x.LowerCamel).Concat(PathElements.Skip(1).Select(x => x.UpperCamel)));
}
PathTemplateField = Field(Private | Static, ctx.Type <PathTemplate>(), $"s_{LowerName}").WithInitializer(New(ctx.Type <PathTemplate>())(pattern.Template.PathTemplateString));
}
private PathElements pathElementsForUnknownColumns(DataColumn dataColumn, List <string> quantityPath)
{
var pathColumnValues = new PathElements();
// extract first pathElement to TopContainer, remaining pathElements to Container
if (quantityPath.Count > 0)
{
pathColumnValues[PathElement.TopContainer] = new PathElementDTO {
DisplayName = quantityPath[0]
};
quantityPath.RemoveAt(0);
}
pathColumnValues[PathElement.Container] = new PathElementDTO {
DisplayName = quantityPath.ToString(Constants.DISPLAY_PATH_SEPARATOR)
};
return(pathColumnValues);
}
private void adjustDisplayPathForQuantity(PathElements pathElements, IQuantity quantity)
{
if (quantity.HasAncestorNamed(CoreConstants.Organ.Gallbladder))
adjustDisplayPathForGallBladder(pathElements, quantity);
else if (quantity.HasAncestorNamed(CoreConstants.Organ.Lumen))
adjustDisplayPathForLumen(pathElements, quantity);
else if (quantity.IsNamed(CoreConstants.Observer.PLASMA_UNBOUND))
adjustDisplayPathForContainerObserver(pathElements, quantity);
else if (quantity.Name.StartsWith(CoreConstants.Observer.TOTAL_FRACTION_OF_DOSE))
adjustDisplayPathForTotalFractionOfDose(pathElements, quantity);
//Container observers directly in a container located under organism
else if (!pathElements.Contains(PathElementId.BottomCompartment))
adjustDisplayPathForContainerObserver(pathElements, quantity);
else if (quantity.IsAnImplementationOf<IObserver>())
adjustDisplayNameForMoleculeObserver(pathElements, quantity.DowncastTo<IObserver>());
}
protected override void Context()
{
base.Context();
_pathElements = new PathElements();
_simulation = A.Fake <ISimulation>().WithName("Sim");
var baseGrid = new BaseGrid("Time", DomainHelperForSpecs.TimeDimensionForSpecs());
_column = new DataColumn("A", DomainHelperForSpecs.ConcentrationDimensionForSpecs(), baseGrid);
_repository = new DataRepository().WithName("Rep");
A.CallTo(() => _dataColumnToPathElementsMapper.MapFrom(_column, A <IContainer> ._)).Returns(_pathElements);
_pathElements[PathElement.Simulation] = new PathElementDTO {
DisplayName = "Sim"
};
_pathElements[PathElement.Container] = new PathElementDTO {
DisplayName = "Cont"
};
_pathElements[PathElement.Molecule] = new PathElementDTO {
DisplayName = "Drug"
};
}
protected override void Context()
{
base.Context();
_parameter = A.Fake <IParameter>();
_formula = A.Fake <IFormula>();
_dimension = A.Fake <IDimension>();
_group = A.Fake <IGroup>();
_parameter.Formula = _formula;
_parameter.RHSFormula = null;
_name = "Para";
_parameter.Name = _name;
_parameter.GroupName = "TOTO";
_parameter.Persistable = true;
_parameter.Visible = true;
_parameter.Dimension = _dimension;
_parameterBuildMode = ParameterBuildMode.Global;
_parameter.BuildMode = _parameterBuildMode;
_parameter.CanBeVariedInPopulation = true;
_pathElements = new PathElements();
A.CallTo(() => _pathToPathElementsMapper.MapFrom(_parameter)).Returns(_pathElements);
A.CallTo(() => _groupRepository.GroupByName(_parameter.GroupName)).Returns(_group);
}
private void adjustDisplayPathForParameterInSubSegment(PathElements pathElements, IParameter parameter, Func<IContainer, bool> containerCondition, string groupingName)
{
pathElements.Category = groupingName;
if (containerCondition(parameter.ParentContainer))
swapCompartmentWithContainer(pathElements);
}
protected override IEnumerable <PathElementId> DefaultPathElementsToUse(bool addSimulationName, PathElements pathElements)
{
if (addSimulationName)
{
yield return(PathElementId.Simulation);
}
yield return(PathElementId.Molecule);
if (shouldDisplayTopContainer(pathElements))
{
yield return(PathElementId.TopContainer);
}
yield return(PathElementId.Container);
yield return(PathElementId.BottomCompartment);
yield return(PathElementId.Name);
}
public NullParameterDTO() : base(null)
{
PathElements = new PathElements();
AllUnits = new List <Unit>();
}
private void adjustDisplayPathForContainerObserver(PathElements pathElements, IQuantity quantity)
{
updateCompartmentElementToQuantityDisplayName(pathElements, quantity);
updateNameElementToQuantityDimensionName(pathElements, quantity);
}
private void adjustDisplayPathForNeighborhood(PathElements pathElements, IQuantity quantity)
{
var neighborhood = quantity.NeighborhoodAncestor();
pathElements[PathElementId.Container] = CreatePathElement(neighborhood.FirstNeighbor.ParentContainer);
}
private void updateNameElementToQuantityDimensionName(PathElements pathElements, IQuantity quantity)
{
pathElements[PathElementId.Name] = CreatePathElement(dimensionDisplayNameFor(quantity));
}
private PathElement pathElementAt(PathElements pathElements, PathElementId pathElementId)
{
var dto = pathElements[pathElementId];
return(string.IsNullOrEmpty(dto.DisplayName) ? null : dto);
}
private void addParameterNode(ITreeNode node, PathElements pathElements, Cache <PathElements, IParameter> allPathElementByParameters)
{
var parameter = allPathElementByParameters[pathElements];
addParameterNode(node, parameter, parameterDisplayElementDTOFor(pathElements));
}
private bool shouldAddPathElementToNodeHierarchy(PathElement pathElementDTO, PathElements pathElements)
{
return(!string.IsNullOrEmpty(pathElementDTO.DisplayName) &&
!pathElementDTO.DisplayName.IsOneOf(Constants.ORGANISM, Constants.NEIGHBORHOODS, CoreConstants.Organ.LUMEN, Constants.APPLICATIONS, Constants.EVENTS) &&
!Equals(parameterDisplayElementDTOFor(pathElements), pathElementDTO)); //means that the parameter won't have the same display name as the parent node
}
protected override void Because()
{
_result = sut.MapFrom(_rootContainer, _path);
}
protected override IEnumerable <PathElementId> DefaultPathElementsToUse(bool addSimulationName, PathElements pathElements)
{
if (addSimulationName)
{
yield return(PathElementId.Simulation);
}
yield return(PathElementId.Molecule);
//Container is defined? no need to use TopContainer
if (!pathElements.Contains(PathElementId.Container))
{
yield return(PathElementId.TopContainer);
}
yield return(PathElementId.Container);
yield return(PathElementId.BottomCompartment);
yield return(PathElementId.Name);
}
private void adjustDisplayPathForTotalFractionOfDose(PathElements pathElements, IQuantity quantity)
{
pathElements[PathElementId.Container] = pathElements[PathElementId.TopContainer];
pathElements[PathElementId.TopContainer] = new PathElement();
}
private void updateNameElementForFractionOfDose(PathElements pathElements, IObserver observer)
{
var observerName = _fractionOfDoseLiverRegex.Matches(observer.Name)[0].Groups[OBSERVER_NAME].Value;
pathElements[PathElementId.Name] = CreatePathElement(observerName);
}
protected override void Because()
{
_pathElements = sut.MapFrom(_entity);
}
private void adjustDisplayPathForLumen(PathElements pathElements, IQuantity quantity)
{
if (quantityIsConcentration(quantity))
updateNameElementToQuantityDimensionName(pathElements, quantity);
}
protected override void Context()
{
base.Context();
_pathElements = new PathElements {{PathElement.Container, new PathElementDTO {DisplayName = "Toto"}}};
A.CallTo(() => _dataColumnToPathElementsMapper.MapFrom(_column, _individualSimulation.Model.Root)).Returns(_pathElements);
}
private void updateCompartmentElementToQuantityDisplayName(PathElements pathElements, IQuantity quantity)
{
pathElements[PathElementId.BottomCompartment] = CreatePathElement(_representationInfoRepository.DisplayNameFor(quantity));
}
protected virtual IEnumerable <PathElement> DefaultPathElementsToUse(bool addSimulationName, PathElements pathElements)
{
if (addSimulationName)
{
yield return(PathElement.Simulation);
}
yield return(PathElement.Molecule);
yield return(PathElement.TopContainer);
yield return(PathElement.Container);
yield return(PathElement.BottomCompartment);
yield return(PathElement.Name);
}
/// <summary>
/// Returns the <see cref="PathElements" /> corresponding to the container hiearchy represented by the
/// <paramref name="containers" />.
/// </summary>
/// <param name="containers">Containers hiearchy</param>
/// <param name="name">name of the entity for which the <see cref="PathElements" /> should be created</param>
protected virtual PathElements CreatePathElementsFrom(IReadOnlyList <IContainer> containers, string name)
{
var pathElements = new PathElements();
var containerList = containers.ToList();
if (!string.IsNullOrEmpty(name))
{
pathElements[PathElement.Name] = CreatePathElementDTO(name);
}
if (!containerList.Any())
{
return(pathElements);
}
// add Simulation entry
if (isRootContainer(containerList[0]))
{
var rootPathElement = CreatePathElementDTO(containerList[0]);
pathElements[PathElement.Simulation] = rootPathElement;
if (string.IsNullOrEmpty(rootPathElement.IconName))
{
rootPathElement.IconName = ApplicationIcons.Simulation.IconName;
}
containerList.RemoveAt(0);
}
// add Molecule entry first as top container might also be molecule container
var moleculeContainer = containerList.LastOrDefault(item => item.ContainerType == ContainerType.Molecule);
if (moleculeContainer != null)
{
pathElements[PathElement.Molecule] = CreatePathElementDTO(moleculeContainer);
if (containerList.Last() == moleculeContainer)
{
containerList.Remove(moleculeContainer);
}
// same name in molecule and in name, this is the amount for the molecule
if (string.Equals(pathElements[PathElement.Molecule].DisplayName, name))
{
pathElements[PathElement.Name].DisplayName = Captions.AmountInContainer;
}
}
// add TopContainer entry
if (containerList.Any())
{
pathElements[PathElement.TopContainer] = CreatePathElementDTO(containerList[0]);
containerList.RemoveAt(0);
}
// add BottomCompartment entry
// Problem: restrict to ContainerType == Compartment, to avoid Organ in BottomCompartment column e.g. for Organ Observers/Parameters
var compartmentContainer = containerList.LastOrDefault(item => item.ContainerType == ContainerType.Compartment);
if (compartmentContainer != null)
{
pathElements[PathElement.BottomCompartment] = CreatePathElementDTO(compartmentContainer);
if (containerList.Last() == compartmentContainer)
{
containerList.Remove(compartmentContainer);
}
}
if (containerList.Any())
{
pathElements[PathElement.Container] = CreateContainerPath(containerList);
}
return(pathElements);
}
protected override IEnumerable <PathElement> DefaultPathElementsToUse(bool addTopContainerName, PathElements pathElements)
{
if (addTopContainerName || chartOptions.SimulationInCurveName)
{
yield return(PathElement.Simulation);
}
//Observed data repository name is stored in PathElement.TopContainer. So if the top container name is to be displayed, we need to add it as well
if (addTopContainerName || chartOptions.TopContainerInCurveName)
{
yield return(PathElement.TopContainer);
}
yield return(PathElement.Container);
yield return(PathElement.BottomCompartment);
yield return(PathElement.Molecule);
yield return(PathElement.Name);
}
