public static Pad CreateInstance(PadContract contract, ExecutionMode mode, IInstance instance)
{
Pad pad = new Pad(mode);
var nodes = new List <Nodes.NodeBase>();
foreach (var nodecontract in contract.Nodes)
{
nodes.Add(NodeFactory.CreateNode(nodecontract, instance.GetMappings()));
}
pad.Nodes = nodes;
// fill the in and out nodes
foreach (var nodecontract in contract.Nodes)
{
Nodes.NodeBase node = (from o in nodes where o.Id == nodecontract.NodeId select o).FirstOrDefault();
if (node != null)
{
if (nodecontract.InNodes != null)
{
node.InPorts = (from o in nodes where nodecontract.InNodes.Contains(o.Id) select o)?.ToList <NodeBase>();
}
if (nodecontract.OutNodes != null)
{
node.OutPorts = (from o in nodes where nodecontract.OutNodes.Contains(o.Id) select o)?.ToList <NodeBase>();
}
}
}
return(pad);
}
public static Pad ToModel(this PadContract pad)
{
var model = new Pad();
model.Id = pad.Id;
model.Description = pad.Description;
model.Name = pad.Name;
model.Identifier = pad.Identifier;
model.TriggerData = pad.TriggerData;
model.Nodes = pad.Nodes?.Select(n => n.ToModel()).ToList();
model.CurrentMaxSequenceId = pad.CurrentMaxSequenceId;
return(model);
}
public static PadContract ToContract(this Pad pad)
{
var contract = new PadContract()
{
Id = pad.Id,
Identifier = pad.Identifier,
Name = pad.Name,
Description = pad.Description,
TriggerData = pad.TriggerData,
};
var nodes = new List <NodeBaseContract>();
if (pad.Nodes != null)
{
foreach (var node in pad.Nodes)
{
nodes.Add(node.ToContract());
}
}
contract.Nodes = nodes;
return(contract);
}
public ExecutionCommand(PadContract contract, Instances instances, Guid userId)
{
this.UserId = userId;
this.Pad = contract;
this.Instances = instances;
}
public async void AddNodeConstantNumberTest()
{
var padContract = new PadContract()
{
Id = 1,
Name = "test"
};
var constant1 = new NodeBaseContract()
{
Id = 1,
NodeId = 1,
OutNodes = new List <long>()
{
3
},
Type = NodeType.Input,
MetaData = new NodeMetaData()
{
NodeData = new NodeMetaDataAttribute()
{
NodeClass = typeof(ConstantNode)
},
FieldsMetaData = new List <FieldMetaDataAttribute>()
{
new FieldMetaDataAttribute()
{
Name = "Value",
ValueType = typeof(int)
},
new FieldMetaDataAttribute()
{
Name = "ConstantType",
ValueType = typeof(ConstantType)
}
}
}
};
var constant2 = new NodeBaseContract()
{
Id = 2,
NodeId = 2,
OutNodes = new List <long>()
{
3
},
Type = NodeType.Input,
MetaData = new NodeMetaData()
{
NodeData = new Engine.NodeMetaDataAttribute()
{
NodeClass = typeof(ConstantNode)
},
FieldsMetaData = new List <FieldMetaDataAttribute>()
{
new FieldMetaDataAttribute()
{
Name = "Value",
ValueType = typeof(int)
},
new FieldMetaDataAttribute()
{
Name = "ConstantType",
ValueType = typeof(ConstantType)
}
}
}
};
var add = new NodeBaseContract()
{
Id = 3,
NodeId = 3,
InNodes = new List <long>()
{
1, 2
},
Type = NodeType.Output,
MetaData = new NodeMetaData()
{
NodeData = new Engine.NodeMetaDataAttribute()
{
NodeClass = typeof(AddNode)
},
FieldsMetaData = new List <FieldMetaDataAttribute>()
{
new FieldMetaDataAttribute()
{
Name = "Left",
Direction = FieldDirection.Input,
MappedNodeId = 1,
MappedFieldName = "Value"
},
new FieldMetaDataAttribute()
{
Name = "Right",
MappedNodeId = 2,
Direction = FieldDirection.Input,
}
}
}
};
padContract.Nodes = new List <NodeBaseContract>()
{
constant1, constant2, add
};
List <InstanceMapping> mappings = new List <InstanceMapping>()
{
new InstanceMapping()
{
NodeId = 1,
FieldMappings = new List <FieldMapping>()
{
new FieldMapping()
{
FieldName = "Value", Value = "1"
},
new FieldMapping()
{
FieldName = "ConstantType", Value = "Int"
},
}
},
new InstanceMapping()
{
NodeId = 2,
FieldMappings = new List <FieldMapping>()
{
new FieldMapping()
{
FieldName = "Value", Value = "1"
},
new FieldMapping()
{
FieldName = "ConstantType", Value = "Int"
},
}
}
};
var instance = new Instances(mappings);
var json = JsonConvert.SerializeObject(instance);
var pad = PadFactory.CreateInstance(padContract, ExecutionMode.Normal, instance);
await pad.Init();
await pad.Execute(pad.Context, instance);
Assert.Equal(ExecutionStatus.Success, pad.Context.Status);
Assert.Equal(2.0, pad.Context.Result);
}
