public Task <List <ILink> > GetAsync(INode node, INodeType nodeType)
{
var tsc = new TaskCompletionSource <List <ILink> >();
tsc.SetResult(Get(node, nodeType).ToList());
return(tsc.Task);
}
public IEnumerable <ILink> Get(INode node, INodeType nodeType)
{
return(from row in dbContext.Link
where (row.NodeARef == node.Id && row.NodeAType == node.NodeType.Id && row.NodeBType == nodeType.Id) ||
(row.NodeBRef == node.Id && row.NodeBType == node.NodeType.Id && row.NodeAType == nodeType.Id)
select MapRow(row));
}
/// <summary>
/// Creates a node of given type
/// </summary>
/// <param name="nodeType">Type of node to create</param>
public static NodeModel CreateNode(this INodeType nodeType)
{
var ret = new NodeModel(nodeType);
nodeType.PostLoad(ret);
return(ret);
}
/// <summary>
/// Simplest representation of a node
/// </summary>
/// <param name="nameof(id)">Node Id</param>
/// <param name="nameof(nodeType)">Node Type</param>
public Node(int id, INodeType nodeType)
{
Id = id;
if (nodeType == null)
throw new ArgumentNullException(nameof(nodeType));
NodeType = nodeType;
SetHashCode();
}
public async Task <List <ILink> > GetAsync(INode node, INodeType nodeType)
{
var rows = await(from row in dbContext.Link
where (row.NodeARef == node.Id && row.NodeAType == node.NodeType.Id && row.NodeBType == nodeType.Id) ||
(row.NodeBRef == node.Id && row.NodeBType == node.NodeType.Id && row.NodeAType == nodeType.Id)
select row).ToListAsync();
return(rows.Select(MapRow).ToList <ILink>());
}
/// <summary>
/// Gets All nodes of selected INodeType connected to source node
/// </summary>
/// <param name="nameof(node)">Source node</param>
/// <param name="nameof(nodeType)">Node type to filter nodes on</param>
/// <returns>Nodes connected source node</returns>
public async Task <List <T> > Get <T>(INode node, INodeType <T> nodeType) where T : INode
{
CheckParameters(node, nodeType);
var linksForNode = await linkRepository.GetAsync(node);
var requiredIds = GetIdsForNodeType(nodeType, linksForNode);
return(await GetNodesFromRepository(nodeType, requiredIds));
}
private static IEnumerable <int> GetIdsForNodeType(INodeType nodeType, List <ILink> linksForNode)
{
var requiredIds = linksForNode
.Flatten()
.Where(n => n.NodeType.Equals(nodeType))
.Distinct(equalityComparer)
.Select(n => n.Id);
return(requiredIds);
}
/// <summary>
/// Simplest representation of a node
/// </summary>
/// <param name="nameof(id)">Node Id</param>
/// <param name="nameof(nodeType)">Node Type</param>
public Node(int id, INodeType nodeType)
{
Id = id;
if (nodeType == null)
{
throw new ArgumentNullException(nameof(nodeType));
}
NodeType = nodeType;
SetHashCode();
}
void AddNodeType(INodeType nodeType, int indent)
{
foreach (var n in nodeType.Nodes)
{
AddNode(n, indent);
}
foreach (INodeType t in nodeType.ChildTypes)
{
AddNodeType(t, indent + 1);
}
}
private static void CheckParameters(INode node, INodeType nodeType)
{
if (node == null)
{
throw new ArgumentNullException(nameof(node));
}
if (nodeType == null)
{
throw new ArgumentNullException(nameof(nodeType));
}
}
public IAsyncNodeRepository CreateRepository(INodeType nodeType)
{
if (nodeType.Id == MockNodeTypes.Actor.Id)
{
return(new ActorRepository());
}
if (nodeType.Id == MockNodeTypes.Story.Id)
{
return(new StoryRepository());
}
throw new ArgumentOutOfRangeException();
}
/// <summary>
/// Creates a node of given type
/// </summary>
/// <param name="nodeType">Type of node to create</param>
public static SNode CreateSNode(this INodeType nodeType)
{
var ret = new SNode
{
NodeType = nodeType
};
nodeType.Init(ret);
nodeType.PostLoad(ret);
return(ret);
}
private InterfaceMethod GenerateInterfaceMethod(INodeType inputType, INodeType outputType)
{
var name = $"{interfaceMethodName}{++count}";
var parameterTypes = GetParameterTypesFromReturnType(inputType);
if (parameterTypes.Count == 0)
{
return(null);
}
return(new InterfaceMethod(outputType, name, parameterTypes));
}
public IAsyncNodeRepository CreateRepository(INodeType nodeType)
{
if (nodeType == StoryboardNodeTypes.Actor)
{
return(serviceProvider.GetService <ActorRepository>());
}
if (nodeType == StoryboardNodeTypes.Story)
{
return(serviceProvider.GetService <StoryRepository>());
}
throw new ArgumentOutOfRangeException(nameof(nodeType), "Could not find repository for nodeType");
}
private static IReadOnlyList <INodeType> GetParameterTypesFromReturnType(INodeType funcReturnType)
{
if (funcReturnType == EmptyNodeType.Instance)
{
return(new INodeType[0]);
}
else if (funcReturnType is TupleNodeType tupleNodeType)
{
return(tupleNodeType.Types);
}
else
{
return(new[] { funcReturnType });
}
}
private void AddNodeMenuItem(MenuAction <ConversationNode> menu, INodeType node, IGraphEditorControl <ConversationNode> control)
{
foreach (var n in node.Nodes.OrderBy(n => n.Name))
{
var nn = n;
var name = nn.Name;
menu.Add(new MenuAction <ConversationNode>(name, (nnn, p) => null, null, null, p => { control.AddNode(nn, p); }));
}
foreach (var n in node.ChildTypes)
{
var nn = n;
var a = menu.Add(new MenuAction <ConversationNode>(nn.Name, (nnn, p) => null, null, null, p => { }));
AddNodeMenuItem(a, nn, control);
}
}
/// <summary>
/// Gets All nodes of selected INodeType connected to source node
/// </summary>
/// <param name="node">Source node</param>
/// <param name="nodeType">Node type to filter nodes on</param>
/// <returns>Nodes connected source node</returns>
public IEnumerable <T> Get <T>(INode node, INodeType <T> nodeType) where T : INode
{
if (node == null)
{
throw new ArgumentNullException(nameof(node));
}
if (nodeType == null)
{
throw new ArgumentNullException(nameof(nodeType));
}
var linksForNode = linkRepository.Get(node);
var equalityComparer = new BaseNodeEqualityComparator();
var requiredIds = linksForNode
.Flatten()
.Where(n => n.NodeType.Equals(nodeType))
.Distinct(equalityComparer)
.Select(n => n.Id);
var repo = repositoryFactory.CreateRepository(nodeType);
return(repo.Get(requiredIds));
}
public (IParseFunction, IReadOnlyList <InterfaceMethod>) Visit(Selection target, INodeType input)
{
var interfaceMethods = new List <InterfaceMethod>();
var newSteps = new List <SelectionStep>();
foreach (var step in target.Steps)
{
IParseFunction func = step.Function;
INodeType funcReturnType = func.ReturnType;
InterfaceMethod interfaceMethod = null;
if (input != EmptyNodeType.Instance)
{
var name = $"{interfaceMethodName}{++count}";
interfaceMethod = new InterfaceMethod(input, name, GetParameterTypesFromReturnType(funcReturnType));
interfaceMethods.Add(interfaceMethod);
}
var newStep = new SelectionStep(func, interfaceMethod);
newSteps.Add(newStep);
}
return(new Selection(newSteps), interfaceMethods);
}
private static String GetReturnExpression(INodeType returnType, IReadOnlyList <Decl> nodes, String inputPositionReference, String factoryName, InterfaceMethod interfaceMethod)
{
String nodeString;
if (returnType == EmptyNodeType.Instance)
{
nodeString = "EmptyNode.Instance";
}
else if (interfaceMethod != null)
{
String param;
if (nodes.Count == 1 && nodes[0].Type == EmptyNodeType.Instance)
{
param = String.Empty;
}
else
{
param = String.Join(", ", nodes.Select(i => i.Name));
}
nodeString = $"{factoryName}.{interfaceMethod.Name}({param})";
}
else if (nodes.Count == 1)
{
nodeString = nodes[0].Name;
}
else
{
// Make a tuple
nodeString = $"({String.Join(", ", nodes.Select(i => i.Name))})";
}
var returnTypeString = returnType.GetParseResultTypeString();
return($"new {returnTypeString}({nodeString}, {inputPositionReference})");
}
public void ConsumeNodeXml(XmlReader xml)
{
if (xml != null && xml.NodeType == XmlNodeType.Element && xml.Name == "node")
{
#region Attribute Values
#region Id
if (xml.MoveToAttribute("id"))
{
Id = xml.Value;
}
#endregion
#region NodeType
if (xml.MoveToAttribute("type"))
{
switch (xml.Value)
{
case ConNodeTypeId:
_nodeType = IoCContainer.GetInjectionInstance().GetInstance<ConNode>();
break;
case DecisionNodeTypeId:
_nodeType = IoCContainer.GetInjectionInstance().GetInstance<DecisionNode>();
break;
case IdeaNodeTypeId:
_nodeType = IoCContainer.GetInjectionInstance().GetInstance<IdeaNode>();
break;
case MapNodeTypeId:
_nodeType = IoCContainer.GetInjectionInstance().GetInstance<MapNode>();
break;
case ProNodeTypeId:
_nodeType = IoCContainer.GetInjectionInstance().GetInstance<ProNode>();
break;
case QuestionNodeTypeId:
_nodeType = IoCContainer.GetInjectionInstance().GetInstance<QuestionNode>();
break;
default:
break;
}
}
#endregion
#region CreatedBy
if (xml.MoveToAttribute("author"))
{
CreatedBy = xml.Value;
}
#endregion
#region Created
if (xml.MoveToAttribute("created"))
{
string createdMillisecondsXmlValue = xml.Value;
long createdMilliseconds;
if (long.TryParse(createdMillisecondsXmlValue, out createdMilliseconds))
{
Created = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
Created = Created.AddMilliseconds(createdMilliseconds);
}
}
#endregion
#region LastModified
if (xml.MoveToAttribute("lastModified"))
{
string lastModifiedMillisecondsXmlValue = xml.Value;
long lastModifiedMilliseconds;
if (long.TryParse(lastModifiedMillisecondsXmlValue, out lastModifiedMilliseconds))
{
LastModified = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
LastModified = LastModified.AddMilliseconds(lastModifiedMilliseconds);
}
}
#endregion
#region Name
if (xml.MoveToAttribute("label"))
{
Name = xml.Value;
}
#endregion
#region LastModifiedBy
if (xml.MoveToAttribute("lastModificationAuthor"))
{
LastModifiedBy = xml.Value;
}
#endregion
#endregion
while (xml.Read())
{
if (xml.NodeType == XmlNodeType.Element)
{
}
else if (xml.NodeType == XmlNodeType.EndElement && xml.Name == "node")
{
break;
}
}
}
}
public IEnumerable<ILink> Get(INode node, INodeType nodeType)
{
return Get(node).Where(w => (INodeEqual(w.NodeA, node) || w.NodeA.NodeType.Id == nodeType.Id) && (INodeEqual(w.NodeB, node) || w.NodeA.NodeType.Id == nodeType.Id));
}
private Task <List <INode> > GetNodesFromRepository(INodeType nodeType, IEnumerable <int> ids)
{
var repo = repositoryFactory.CreateRepository(nodeType);
return(repo.GetAsync(ids));
}
public XmlCompendiumNode(INodeType nodeType)
: this()
{
_nodeType = nodeType;
}
public IPublishedContent GetNode(INodeType nodeType)
{
return(nodeType.FindNode(_umbracoWrapper.TypedContentAtRoot()));
}
public void ConsumeNodeXml(XmlReader xml, string domainNodeId, string documentLibraryUrl)
{
if (xml != null && xml.NodeType == XmlNodeType.Element && xml.Name == "node")
{
#region Attribute Values
#region Id
if (xml.MoveToAttribute("id"))
{
Id = xml.Value;
}
#endregion
#region NodeType
if (Id == domainNodeId)
{
_nodeType = IoCContainer.GetInjectionInstance().GetInstance<DomainNode>();
}
else
{
if (xml.MoveToAttribute("type"))
{
switch (xml.Value)
{
case CON_NODE_TYPE_ID:
_nodeType = IoCContainer.GetInjectionInstance().GetInstance<ConNode>();
break;
case DECISION_NODE_TYPE_ID:
_nodeType = IoCContainer.GetInjectionInstance().GetInstance<DecisionNode>();
break;
case IDEA_NODE_TYPE_ID:
_nodeType = IoCContainer.GetInjectionInstance().GetInstance<IdeaNode>();
break;
case MAP_NODE_TYPE_ID:
_nodeType = IoCContainer.GetInjectionInstance().GetInstance<MapNode>();
break;
case PRO_NODE_TYPE_ID:
_nodeType = IoCContainer.GetInjectionInstance().GetInstance<ProNode>();
break;
case QUESTION_NODE_TYPE_ID:
_nodeType = IoCContainer.GetInjectionInstance().GetInstance<QuestionNode>();
break;
case REFERENCE_NODE_TYPE_ID:
_nodeType = IoCContainer.GetInjectionInstance().GetInstance<ReferenceNode>();
break;
case ARGUMENT_NODE_TYPE_ID:
_nodeType = IoCContainer.GetInjectionInstance().GetInstance<ArgumentNode>();
break;
case NOTE_NODE_TYPE_ID:
_nodeType = IoCContainer.GetInjectionInstance().GetInstance<NoteNode>();
break;
case LIST_NODE_TYPE_ID:
_nodeType = IoCContainer.GetInjectionInstance().GetInstance<ListNode>();
break;
default:
break;
}
}
}
#endregion
#region CreatedBy
if (xml.MoveToAttribute("author"))
{
CreatedBy = xml.Value;
}
#endregion
#region Created
if (xml.MoveToAttribute("created"))
{
string createdMillisecondsXmlValue = xml.Value;
long createdMilliseconds;
if (long.TryParse(createdMillisecondsXmlValue, out createdMilliseconds))
{
Created = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
Created = Created.AddMilliseconds(createdMilliseconds);
}
}
#endregion
#region LastModified
if (xml.MoveToAttribute("lastModified"))
{
string lastModifiedMillisecondsXmlValue = xml.Value;
long lastModifiedMilliseconds;
if (long.TryParse(lastModifiedMillisecondsXmlValue, out lastModifiedMilliseconds))
{
LastModified = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
LastModified = LastModified.AddMilliseconds(lastModifiedMilliseconds);
}
}
#endregion
#region Name
if (xml.MoveToAttribute("label"))
{
Name = xml.Value;
}
#endregion
#region LastModifiedBy
if (xml.MoveToAttribute("lastModificationAuthor"))
{
LastModifiedBy = xml.Value;
}
#endregion
#endregion
while (xml.Read())
{
if (xml.NodeType == XmlNodeType.Element)
{
if (_nodeType.Name == "CompendiumReferenceNode")
{
if (xml.Name.ToLower() == "source")
{
string fullFilePath = xml.ReadInnerXml();
if (!string.IsNullOrEmpty(fullFilePath))
{
if (fullFilePath.ToLower().StartsWith("http://") || fullFilePath.ToLower().StartsWith("https://")
|| fullFilePath.ToLower().StartsWith("ftp://") || fullFilePath.ToLower().StartsWith("ftps://"))
{
Attachment = fullFilePath;
}
else
{
string linkedFileName = string.Empty;
if (fullFilePath.LastIndexOf("/") < 0 && fullFilePath.LastIndexOf("\\") > 0)
{
linkedFileName = fullFilePath.Substring(fullFilePath.LastIndexOf("\\") + 1);
}
else
{
linkedFileName = fullFilePath.Substring(fullFilePath.LastIndexOf("/") + 1);
}
Attachment = documentLibraryUrl + linkedFileName; //set the file name, the node name is can change independently
}
}
}
}
}
else if (xml.NodeType == XmlNodeType.EndElement && xml.Name == "node")
{
break;
}
}
}
}
public (IParseFunction, IReadOnlyList <InterfaceMethod>) Visit(Sequence target, INodeType input)
{
var interfaceMethods = new List <InterfaceMethod>();
InterfaceMethod interfaceMethod = null;
var types = target.Steps.Where(i => i.IsReturned).Select(i => i.Function.ReturnType).ToList();
if (types.Count > 0)
{
var name = $"{interfaceMethodName}{++count}";
interfaceMethod = new InterfaceMethod(input, name, types);
interfaceMethods.Add(interfaceMethod);
}
return(new Sequence(target.Steps, interfaceMethod), interfaceMethods);
}
public (IParseFunction, IReadOnlyList <InterfaceMethod>) Visit(Intrinsic target, INodeType input)
{
var interfaceMethod = GenerateInterfaceMethod(target.ReturnType, input);
if (interfaceMethod == null)
{
return(target, new InterfaceMethod[0]);
public void ConsumeNodeXml(XmlReader xml, string domainNodeId, string documentLibraryUrl)
{
if (xml != null && xml.NodeType == XmlNodeType.Element && xml.Name == "node")
{
#region Attribute Values
#region Id
if (xml.MoveToAttribute("id"))
{
Id = xml.Value;
}
#endregion
#region NodeType
if (Id == domainNodeId)
{
_nodeType = IoCContainer.GetInjectionInstance().GetInstance <DomainNode>();
}
else
{
if (xml.MoveToAttribute("type"))
{
switch (xml.Value)
{
case CON_NODE_TYPE_ID:
_nodeType = IoCContainer.GetInjectionInstance().GetInstance <ConNode>();
break;
case DECISION_NODE_TYPE_ID:
_nodeType = IoCContainer.GetInjectionInstance().GetInstance <DecisionNode>();
break;
case IDEA_NODE_TYPE_ID:
_nodeType = IoCContainer.GetInjectionInstance().GetInstance <IdeaNode>();
break;
case MAP_NODE_TYPE_ID:
_nodeType = IoCContainer.GetInjectionInstance().GetInstance <MapNode>();
break;
case PRO_NODE_TYPE_ID:
_nodeType = IoCContainer.GetInjectionInstance().GetInstance <ProNode>();
break;
case QUESTION_NODE_TYPE_ID:
_nodeType = IoCContainer.GetInjectionInstance().GetInstance <QuestionNode>();
break;
case REFERENCE_NODE_TYPE_ID:
_nodeType = IoCContainer.GetInjectionInstance().GetInstance <ReferenceNode>();
break;
case ARGUMENT_NODE_TYPE_ID:
_nodeType = IoCContainer.GetInjectionInstance().GetInstance <ArgumentNode>();
break;
case NOTE_NODE_TYPE_ID:
_nodeType = IoCContainer.GetInjectionInstance().GetInstance <NoteNode>();
break;
case LIST_NODE_TYPE_ID:
_nodeType = IoCContainer.GetInjectionInstance().GetInstance <ListNode>();
break;
default:
break;
}
}
}
#endregion
#region CreatedBy
if (xml.MoveToAttribute("author"))
{
CreatedBy = xml.Value;
}
#endregion
#region Created
if (xml.MoveToAttribute("created"))
{
string createdMillisecondsXmlValue = xml.Value;
long createdMilliseconds;
if (long.TryParse(createdMillisecondsXmlValue, out createdMilliseconds))
{
Created = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
Created = Created.AddMilliseconds(createdMilliseconds);
}
}
#endregion
#region LastModified
if (xml.MoveToAttribute("lastModified"))
{
string lastModifiedMillisecondsXmlValue = xml.Value;
long lastModifiedMilliseconds;
if (long.TryParse(lastModifiedMillisecondsXmlValue, out lastModifiedMilliseconds))
{
LastModified = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
LastModified = LastModified.AddMilliseconds(lastModifiedMilliseconds);
}
}
#endregion
#region Name
if (xml.MoveToAttribute("label"))
{
Name = xml.Value;
}
#endregion
#region LastModifiedBy
if (xml.MoveToAttribute("lastModificationAuthor"))
{
LastModifiedBy = xml.Value;
}
#endregion
#endregion
while (xml.Read())
{
if (xml.NodeType == XmlNodeType.Element)
{
if (_nodeType.Name == "CompendiumReferenceNode")
{
if (xml.Name.ToLower() == "source")
{
string fullFilePath = xml.ReadInnerXml();
if (!string.IsNullOrEmpty(fullFilePath))
{
if (fullFilePath.ToLower().StartsWith("http://") || fullFilePath.ToLower().StartsWith("https://") ||
fullFilePath.ToLower().StartsWith("ftp://") || fullFilePath.ToLower().StartsWith("ftps://"))
{
Attachment = fullFilePath;
}
else
{
string linkedFileName = string.Empty;
if (fullFilePath.LastIndexOf("/") < 0 && fullFilePath.LastIndexOf("\\") > 0)
{
linkedFileName = fullFilePath.Substring(fullFilePath.LastIndexOf("\\") + 1);
}
else
{
linkedFileName = fullFilePath.Substring(fullFilePath.LastIndexOf("/") + 1);
}
Attachment = documentLibraryUrl + linkedFileName; //set the file name, the node name is can change independently
}
}
}
}
}
else if (xml.NodeType == XmlNodeType.EndElement && xml.Name == "node")
{
break;
}
}
}
}
public XmlCompendiumNode(INodeType nodeType)
: this()
{
_nodeType = nodeType;
}
public ReferencedRule(String identifier, INodeType ruleNodeType, InterfaceMethod interfaceMethod)
{
this.Identifier = identifier;
this.RuleNodeType = ruleNodeType ?? new SingleNodeType("UNRESOLVED_RULE");
this.InterfaceMethod = interfaceMethod;
}
public Node(string path, INodeType nodeType)
{
mFilename = path;
mNodetype = nodeType;
}
public Task<List<ILink>> GetAsync(INode node, INodeType nodeType)
{
var tsc = new TaskCompletionSource<List<ILink>>();
tsc.SetResult(Get(node, nodeType).ToList());
return tsc.Task;
}
public static CreateLinkCommand ToCreateLinkCommand(this CreateLinkForNewNodeCommand command, int newNodeId, INodeType newNodeType)
{
return(new CreateLinkCommand
{
NodeA = new Node(newNodeId, newNodeType),
NodeB = new Node(command.NodeBId, StoryboardNodeTypes.GetFromValue(command.NodeBType)),
Strength = command.Strength,
Direction = (LinkFlow)command.Direction,
Type = new LinkType {
Id = command.Type
}
});
}
private Task <List <T> > GetNodesFromRepository <T>(INodeType <T> nodeType, IEnumerable <int> ids) where T : INode
{
var repo = repositoryFactory.CreateRepository(nodeType);
return(repo.GetAsync(ids));
}
public IAsyncNodeRepository <T> CreateRepository <T>(INodeType <T> nodeType) where T : INode
{
return(serviceProvider.GetService <IAsyncNodeRepository <T> >());
}
public InterfaceMethod(INodeType returnType, String name, IReadOnlyList <INodeType> parameterTypes)
{
this.ReturnType = returnType;
this.Name = name;
this.ParameterTypes = parameterTypes;
}
