public void Drop(ReferenceDTO droppedReferenceDTO)
{
if (droppedReferenceDTO == null)
{
return;
}
addPathToFormula(droppedReferenceDTO.Path);
}
public ActionResult Update(ReferenceDTO ReferenceDTO)
{
Reference Reference = _ReferenceService.GetByID(ReferenceDTO.ID);
Reference.Name = ReferenceDTO.Name;
Reference.Explanation = ReferenceDTO.Explanation;
Reference.Link = ReferenceDTO.Link;
Reference.LogoPath = ReferenceDTO.LogoPath;
_ReferenceService.Update(Reference);
return(Redirect("/SysAdmin/Reference/List"));
}
private void updateReferenceForTransportMoleculeContainer(ReferenceDTO dto, IParameter parameter, bool shouldCreateAbsolutePaths)
{
var transporterMoleculeContainer = parameter.ParentContainer as TransporterMoleculeContainer;
if (transporterMoleculeContainer == null)
{
return;
}
dto.Path.Replace(transporterMoleculeContainer.Name, shouldCreateAbsolutePaths ? transporterMoleculeContainer.TransportName : ObjectPathKeywords.TRANSPORTER);
}
public ActionResult Update(int id)
{
Reference Reference = _ReferenceService.GetByID(id);
ReferenceDTO ReferenceDTO = new ReferenceDTO()
{
ID = Reference.ID,
Explanation = Reference.Explanation,
Name = Reference.Name,
Link = Reference.Link,
LogoPath = Reference.LogoPath,
};
return(View(ReferenceDTO));
}
public override ReferenceDTO CreatePathsFromEntity(IObjectBase objectBase, bool shouldCreateAbsolutePaths, IEntity refObject, IUsingFormula editedObject)
{
var parameter = objectBase as IParameter;
// we need a special treatment for parameters defined at the molecule
if (parameter != null && parameter.IsAtMolecule())
{
var dto = new ReferenceDTO();
dto.Path = cratePathToMoleculeProperty(parameter, shouldCreateAbsolutePaths, refObject);
dto.BuildMode = parameter.BuildMode;
return(dto);
}
return(base.CreatePathsFromEntity(objectBase, shouldCreateAbsolutePaths, refObject, editedObject));
}
// POST api/<controller>
public void SaveReference(ReferenceDTO value)
{
if (value.ReferenceContent != null)
{
string test = value.ReferenceContent;
string refno = "0";
if (value.Number.Length > 1)
{
refno = value.Number;
}
new Reference().saveReferences(decimal.Parse(value.ProtocolVersionCKey), decimal.Parse(value.NoteCKey),
decimal.Parse(value.ReferenceCKey), int.Parse(value.Number),
value.ReferenceContent, decimal.Parse(value.UserCKey));
}
}
/// <summary>
/// Creates the path from parameter dummy.
/// </summary>
/// <param name="objectBaseDTO">The dummy parameter dto.</param>
/// <param name="shouldCreateAbsolutePaths">if set to <c>true</c> creates absolute paths otherwise creates reltive paths.</param>
/// <param name="refObject">
/// The reference object the user chosen (may the concrete object that uses the reference or a
/// existing parent of it).
/// </param>
/// <param name="editedObject"></param>
/// <returns> The path that could be uses in the model to reference the object</returns>
public virtual ReferenceDTO CreatePathFromParameterDummy(IObjectBaseDTO objectBaseDTO, bool shouldCreateAbsolutePaths, IEntity refObject, IUsingFormula editedObject)
{
if (IsMoleculeReference(objectBaseDTO))
{
return(createMoleculeReference());
}
var dtoDummyParameter = (DummyParameterDTO)objectBaseDTO;
var parameterToUse = _context.Get <IParameter>(dtoDummyParameter.ParameterToUse.Id);
ReferenceDTO dtoReference;
if (parameterToUse.IsAtMolecule())
{
dtoReference = new ReferenceDTO();
IObjectPath tmpPath;
//global molecule parameters we always reference absolute
if (shouldCreateAbsolutePaths || !parameterToUse.BuildMode.Equals(ParameterBuildMode.Local))
{
tmpPath = _objectPathFactory.CreateAbsoluteObjectPath(dtoDummyParameter.Parent);
}
else
{
if (refObject != dtoDummyParameter.Parent)
{
tmpPath = _objectPathFactory.CreateRelativeObjectPath(refObject, dtoDummyParameter.Parent);
}
else
{
tmpPath = new ObjectPath();
}
tmpPath = AdjustReferences(parameterToUse, tmpPath);
}
dtoReference.Path = _objectPathFactory.CreateFormulaUsablePathFrom(tmpPath)
.WithAlias(_aliasCreator.CreateAliasFrom(parameterToUse.Name))
.WithDimension(parameterToUse.Dimension);
dtoReference.Path.Add(parameterToUse.Name);
}
else
{
dtoReference = CreatePathsFromEntity(parameterToUse, shouldCreateAbsolutePaths, refObject, editedObject);
}
dtoReference.Path.Replace(Constants.MOLECULE_PROPERTIES, dtoDummyParameter.ModelParentName);
dtoReference.BuildMode = parameterToUse.BuildMode;
return(dtoReference);
}
public bool DragDropAllowedFor(ReferenceDTO droppedReferenceDTO)
{
if (ReadOnly)
{
return(false);
}
if (droppedReferenceDTO?.Path == null)
{
return(false);
}
if (droppedReferenceDTO.Path.IsAnImplementationOf <TimePath>())
{
return(true);
}
return(true);
}
public bool DragDropAllowedFor(ReferenceDTO droppedReferenceDTO)
{
if (ReadOnly)
{
return(false);
}
if (droppedReferenceDTO == null || droppedReferenceDTO.Path == null)
{
return(false);
}
if (droppedReferenceDTO.Path.IsAnImplementationOf <TimePath>())
{
return(true);
}
if (droppedReferenceDTO.BuildMode.Equals(ParameterBuildMode.Local) && referencesToLocalForbidden)
{
return(false);
}
return(true);
}
public override ReferenceDTO CreatePathsFromEntity(IObjectBase objectBase, bool shouldCreateAbsolutePaths, IEntity refObject, IUsingFormula editedObject)
{
var entity = objectBase as IFormulaUsable;
var dtoReference = new ReferenceDTO();
if (entity == null)
{
return(dtoReference);
}
// relative paths are only used for parameter in the same event group
if (refObject != null && refObject != null && entity.RootContainer.Equals(refObject.RootContainer))
{
dtoReference.Path = CreateRelativePath(entity, refObject, editedObject);
}
else
{
dtoReference.Path = CreateAbsolutePath(entity);
}
return(dtoReference);
}
/// <summary>
/// Creates the path from entity.
/// </summary>
/// <param name="objectBase">The object base that should be referenced</param>
/// <param name="shouldCreateAbsolutePaths">if set to <c>true</c> should create absolute paths otherwise relative paths are created.</param>
/// <param name="refObject">The object from which the path is created.</param>
/// <param name="editedObject"></param>
/// <returns> the dto Object for the reference</returns>
public virtual ReferenceDTO CreatePathsFromEntity(IObjectBase objectBase, bool shouldCreateAbsolutePaths, IEntity refObject, IUsingFormula editedObject)
{
var dto = new ReferenceDTO();
if (!objectBase.IsAnImplementationOf <IFormulaUsable>())
{
return(null);
}
var formulaUseable = objectBase.DowncastTo <IFormulaUsable>();
if (isGlobal(objectBase))
{
// This a global parameters that we always use as absolute paths
dto.Path = CreateAlwaysAbsolutePaths(objectBase, formulaUseable);
}
else
{
// local reaction and molecule properties are always referenced local.
if (formulaUseable.IsAtReaction() || formulaUseable.IsAtMolecule())
{
shouldCreateAbsolutePaths = false;
}
dto.Path = shouldCreateAbsolutePaths
? CreateAbsolutePath(formulaUseable)
: CreateRelativePath(formulaUseable, refObject, editedObject);
}
var parameter = formulaUseable as IParameter;
if (parameter == null)
{
return(dto);
}
dto.BuildMode = parameter.BuildMode;
updateReferenceForTransportMoleculeContainer(dto, parameter, shouldCreateAbsolutePaths);
return(dto);
}
protected override void Because()
{
_referenceDTO = sut.CreatePathFromParameterDummy(_concentrationDTO, shouldCreateAbsolutePaths: false, refObject: _localCompartment, editedObject: A.Fake <IUsingFormula>());
}
protected override void Because()
{
_result = sut.CreatePathsFromEntity(_reacPara2, false, A.Fake <IContainer>(), _reacPara1);
}
protected override void Because()
{
_result = sut.CreatePathFromParameterDummy(_dtoMoleculeParameter, false, _container, A.Fake <IUsingFormula>());
}
protected override void Because()
{
_result = sut.CreatePathsFromEntity(_parameter, true, _refContainer, _parameter);
}
