/// <summary>
/// Creates the destination node from connector.
/// </summary>
/// <param name="objectsCollection">The objects collection.</param>
/// <param name="connector">The connector.</param>
/// <returns>DestinationNode.</returns>
public DestinationNode CreateDestinationNodeFromConnector(ICollection<IExpressionObjectBase> objectsCollection, IConnectorIn connector)
{
RestoreConnections(objectsCollection);
Validate(objectsCollection);
_values = new Dictionary<string, object>();
if (connector.Connection != null && connector.Connection.Source != null)
{
var destinationNode = new DestinationNode();
destinationNode.ResultNodes.Add(
CreateResultNode(connector, connector.DataType, Constants.Result));
return destinationNode;
}
return null;
}
/// <summary>
/// Determines whether the specified connectors can be connected.
/// </summary>
/// <param name="source">The source connector.</param>
/// <param name="destination">The destination connector.</param>
/// <returns>ConnectivityState</returns>
public ConnectivityState CanConnect(IConnectorOut source, IConnectorIn destination)
{
var destinationField = FindDestinationField(destination);
if (destinationField == null)
return ConnectivityState.Allow();
if (!IsAccessible(destinationField))
return ConnectivityState.Refuse(
string.Format(CultureInfo.InvariantCulture, "Field {0} is not accessible", destinationField.Name));
if (destinationField.DataType == NodeDataType.List || destinationField.DataType == NodeDataType.Array
|| destinationField.DataType == NodeDataType.FixedArray || destinationField.DataType == NodeDataType.Checklist
|| destinationField.DataType == NodeDataType.Sample)
return ConnectivityState.Allow();
return IsValidMapping(source, GetSourceContext((DestinationField)destinationField.ParentField))
? ConnectivityState.Allow()
: ConnectivityState.Refuse();
}
/// <summary>
/// Determines whether the specified connectors can be connected.
/// </summary>
/// <param name="source">The source connector.</param>
/// <param name="destination">The destination connector.</param>
/// <returns>Returns <c>true</c> if the specified connectors can be connected; otherwise, <c>false</c>.</returns>
public ConnectivityState CanConnect(IConnectorOut source, IConnectorIn destination)
{
var sourceOwner = source.Owner as SourceFieldList;
var destinationOwner = destination.Owner as DestinationFieldList;
if (sourceOwner == null || destinationOwner == null)
return ConnectivityState.Allow();
var sourceField = sourceOwner.GetAllFields().FirstOrDefault(f => f.ConnectorOut.Id == source.Id);
var destinationField = destinationOwner.GetAllFields().FirstOrDefault(f => f.ConnectorIn.Id == destination.Id);
if (sourceField == null || destinationField == null)
return ConnectivityState.Allow();
var result = ConnectivityState.Allow();
if (sourceField.DataType == NodeDataType.CrossReference &&
destinationField.DataType == NodeDataType.CrossReference)
{
result &= CrossRefFieldsAreCompatible(sourceField, destinationField);
}
return result;
}
/// <summary>
/// Prepares the partial script beginning from the specified input connector.
/// </summary>
/// <param name="objectsCollection">A collection of designer built nodes.</param>
/// <param name="connectorIn">The input connector</param>
/// <param name="parametresToReplace">The parametres to replace.</param>
/// <returns>System.String.</returns>
public string PrepareScriptPart(ICollection<IExpressionObjectBase> objectsCollection, IConnectorIn connectorIn, Dictionary<string, string> parametresToReplace = null)
{
if (objectsCollection == null || objectsCollection.Count == 0)
return string.Empty;
lock (_lockobject)
{
var destinationNode = ExpressionNodeFactory.CreateDestinationNodeFromConnector(objectsCollection, connectorIn);
return ExpressionNodeExecuter.PrepareScript(destinationNode, parametresToReplace);
}
}
/// <summary>
/// Finds the destination field.
/// </summary>
/// <param name="fields">The fields.</param>
/// <param name="connector">The connector.</param>
/// <returns>DestinationField.</returns>
private DestinationField FindDestinationField(IEnumerable<DestinationField> fields, IConnectorIn connector)
{
foreach (var destinationField in fields)
{
if (destinationField.ConnectorIn == connector)
return destinationField;
var subfield = FindDestinationField(destinationField.Subfields.Cast<DestinationField>(), connector);
if (subfield != null)
return subfield;
}
return null;
}
/// <summary>
/// Finds the destination field.
/// </summary>
/// <param name="connector">The connector.</param>
/// <returns>DestinationField.</returns>
private DestinationField FindDestinationField(IConnectorIn connector)
{
var fieldList = connector.Owner as DestinationFieldList;
if (fieldList == null)
return null;
return FindDestinationField(fieldList.Fields, connector);
}
/// <summary>
/// Determines whether [is valid mapping] [the specified connector].
/// </summary>
/// <param name="connector">The connector.</param>
/// <param name="sourceContext">The source context.</param>
/// <returns><c>true</c> if [is valid mapping] [the specified connector]; otherwise, <c>false</c>.</returns>
private bool IsValidMapping(IConnectorIn connector, SourceField sourceContext)
{
return connector.Connection != null && connector.Connection.Source != null &&
IsValidMapping(connector.Connection.Source, sourceContext);
}
/// <summary>
/// Determines whether the specified connectors can be connected.
/// </summary>
/// <param name="sourceConnector">The source connector.</param>
/// <param name="destinationConnector">The destination connector.</param>
/// <returns>The ConnectivityState.</returns>
public ConnectivityState CanConnect(IConnectorOut sourceConnector, IConnectorIn destinationConnector)
{
var expressionItems = new List<IExpressionObjectBase>();
ExpressionTranslator.TranslateToExpressionObjects(expressionItems, Diagram);
ExpressionNodeFactory.RestoreConnections(expressionItems);
if (sourceConnector != null && destinationConnector != null)
return ExpressionValidator.CanConnect(sourceConnector, destinationConnector);
return ConnectivityState.Refuse();
}
private Connection CreateConnection(IConnectorOut source, IConnectorIn sink)
{
return new Connection { Source = source, Sink = sink };
}
/// <summary>
/// Deserializes the specified XML reader.
/// </summary>
/// <param name="xmlReader">The XML reader.</param>
public override void Deserialize(XmlReader xmlReader)
{
Id = Guid.Parse(xmlReader.GetAttribute("id"));
Source = new ConnectorOut(this) {Id = Guid.Parse(xmlReader.GetAttribute("sourceId")) };
Sink = new ConnectorIn(this) { Id = Guid.Parse(xmlReader.GetAttribute("destinationId")) };
}
/// <summary>
/// Creates the Result node
/// </summary>
/// <param name="connectorIn">The input connector</param>
/// <param name="dataType">The data type</param>
/// <param name="fieldName">The field name</param>
/// <returns>ResultNode</returns>
private ResultNode CreateResultNode(IConnectorIn connectorIn, NodeDataType dataType, string fieldName)
{
return
new ResultNode
{
FieldName = fieldName,
DataType = dataType,
Expression = ToExpressionNode(
connectorIn.Connection.Source.Connection.Source.Owner,
connectorIn.Connection.Source.Connection)
};
}
