public override ReferenceDTO CreateMoleculePath(DummyMoleculeContainerDTO dtoObjectBase, bool shouldCreateAbsolutePaths, IEntity refObject)
{
var moleculeProperties = _context.Get <IContainer>(dtoObjectBase.MoleculePropertiesContainer.Id);
var parentContainer = moleculeProperties.ParentContainer;
var firstPathElemnt = getPathKeywordForContainer(parentContainer);
if (firstPathElemnt.IsNullOrEmpty())
{
return(base.CreateMoleculePath(dtoObjectBase, shouldCreateAbsolutePaths, refObject));
}
string moleculeElement = shouldCreateAbsolutePaths ? dtoObjectBase.Name : ObjectPathKeywords.MOLECULE;
return(new ReferenceDTO
{
Path = CreateFormulaUsablePathFrom(new[] { firstPathElemnt, moleculeElement }, AppConstants.AmountAlias, Constants.Dimension.AMOUNT)
});
}
public virtual ReferenceDTO CreateMoleculePath(DummyMoleculeContainerDTO dtoObjectBase, bool shouldCreateAbsolutePaths, IEntity refObject)
{
var moleculeProperties = _context.Get <IContainer>(dtoObjectBase.MoleculePropertiesContainer.Id);
var parentContainer = moleculeProperties.ParentContainer;
if (parentContainer == null)
{
return(null);
}
IEnumerable <string> elements;
IFormulaUsablePath path;
if (shouldCreateAbsolutePaths)
{
elements = _objectPathFactory.CreateAbsoluteObjectPath(parentContainer);
path = _objectPathFactory.CreateFormulaUsablePathFrom(elements);
}
else
{
if (refObject == parentContainer)
{
path = new FormulaUsablePath();
}
else
{
elements = _objectPathFactory.CreateRelativeObjectPath(refObject, parentContainer);
path = _objectPathFactory.CreateFormulaUsablePathFrom(elements);
}
AdjustReferences(parentContainer, path);
}
path.Alias = _aliasCreator.CreateAliasFrom(dtoObjectBase.Name);
path.Dimension = _context.DimensionFactory.Dimension(Constants.Dimension.AMOUNT);
path.Add(dtoObjectBase.Name);
return(new ReferenceDTO {
Path = path
});
}
protected virtual void AddChildrenFromDummyMolecule(List <IObjectBaseDTO> children, DummyMoleculeContainerDTO dummyMolecule)
{
var parameterDTOs = new List <IObjectBaseDTO>();
var moleculePropertiesContainer = _context.Get <IContainer>(dummyMolecule.MoleculePropertiesContainer.Id);
parameterDTOs.AddRange(moleculePropertiesContainer.GetChildren <IParameter>()
.Where(selectionPredicate)
.Select(x => _dummyParameterDTOMapper.MapFrom(x, moleculePropertiesContainer, dummyMolecule)));
if (isGlobalMoleculePropertiesContainer(moleculePropertiesContainer))
{
//add Child Container
children.AddRange(getAllMoleculeChildren <TransporterMoleculeContainer>(_context.CurrentProject, dummyMolecule)
.MapAllUsing(_objectBaseDTOMapper));
children.AddRange(getAllMoleculeChildren <InteractionContainer>(_context.CurrentProject, dummyMolecule)
.MapAllUsing(_objectBaseDTOMapper));
//add global Molecule Properties defined in Molecules BB because the molecule represents a global molecule container
parameterDTOs.AddRange(getAllMoleculeChildren <IParameter>(_context.CurrentProject, dummyMolecule)
.Where(para => para.BuildMode != ParameterBuildMode.Local)
.Select(x => _dummyParameterDTOMapper.MapFrom(x, moleculePropertiesContainer, dummyMolecule)));
}
else
{
//This is a local molecule container . We add local Molecules Properties defined in Molecule BB only if container is defined in a physical cotnainer
if (moleculePropertiesContainer.ParentContainer.Mode == ContainerMode.Physical)
{
parameterDTOs.AddRange(getAllMoleculeChildren <IParameter>(_context.CurrentProject, dummyMolecule)
.Where(para => para.BuildMode == ParameterBuildMode.Local)
.Select(x => _dummyParameterDTOMapper.MapFrom(x, moleculePropertiesContainer, dummyMolecule)));
}
}
children.AddRange(parameterDTOs.OrderBy(x => x.Name));
}
private IEnumerable <T> getAllMoleculeChildren <T>(IMoBiProject currentProject, DummyMoleculeContainerDTO dummyMolecule) where T : class, IEntity
{
IEnumerable <T> children = new List <T>();
foreach (var moleculeBuildingBlock in currentProject.MoleculeBlockCollection)
{
var moleculeBuilder = moleculeBuildingBlock.FindByName(dummyMolecule.Name);
if (moleculeBuilder == null)
{
continue;
}
children = moleculeBuilder.GetChildren <T>().Union(children);
children = children.Distinct(new NameComparer <T>()).Where(selectionPredicate);
}
return(children.OrderBy(x => x.Name));
}
protected override void AddChildrenFromDummyMolecule(List <IObjectBaseDTO> children, DummyMoleculeContainerDTO dummyMolecule)
{
IEnumerable <TransporterMoleculeContainer> allTransporterMoleculeContainers = new List <TransporterMoleculeContainer>();
IMoleculeBuildingBlock editedMoleculeBuildingBlock = null;
var allMoleculeBuildingBlocks = editedMoleculeBuildingBlock != null ? new[] { editedMoleculeBuildingBlock } : _context.CurrentProject.MoleculeBlockCollection;
foreach (var moleculeBuildingBlock in allMoleculeBuildingBlocks)
{
if (moleculeBuildingBlock.Any(builder => builder.Name.Equals(dummyMolecule.Name)))
{
allTransporterMoleculeContainers = moleculeBuildingBlock[dummyMolecule.Name].TransporterMoleculeContainerCollection.Union(allTransporterMoleculeContainers);
allTransporterMoleculeContainers = allTransporterMoleculeContainers.Distinct(new NameComparer <TransporterMoleculeContainer>());
}
}
children.AddRange(allTransporterMoleculeContainers.MapAllUsing(_transporterMoleculeContainerMapper));
base.AddChildrenFromDummyMolecule(children, dummyMolecule);
}
