private void UpdateCodeBlockNodeContent(CodeBlockNodeModel cbn, string value)
{
var command = new DynCmd.UpdateModelValueCommand(Guid.Empty, cbn.GUID, "Code", value);
CurrentDynamoModel.ExecuteCommand(command);
}
/// <summary>
/// Forms new connections from the external nodes to the Node To Code Node,
/// based on the connectors passed as inputs.
/// </summary>
/// <param name="externalOutputConnections">List of connectors to remake, along with the port names of the new port</param>
/// <param name="codeBlockNode">The new Node To Code created Code Block Node</param>
private void ReConnectOutputConnections(Dictionary <ConnectorModel, string> externalOutputConnections, CodeBlockNodeModel codeBlockNode)
{
foreach (var kvp in externalOutputConnections)
{
var connector = kvp.Key;
string variableName = kvp.Value;
int startIndex = 0, endIndex = 0;
//Get the start and end idex for the ports for the connection
endIndex = connector.End.Owner.InPorts.IndexOf(connector.End);
int i = 0;
for (i = 0; i < codeBlockNode.OutPorts.Count; i++)
{
if (codeBlockNode.GetAstIdentifierForOutputIndex(i).Value == variableName)
{
break;
}
}
var portModel = codeBlockNode.OutPorts[i];
startIndex = codeBlockNode.OutPorts.IndexOf(portModel);
//Make the new connection and then record and add it
var newConnector = ConnectorModel.Make(codeBlockNode, connector.End.Owner,
startIndex, endIndex, PortType.INPUT);
this.Connectors.Add(newConnector);
UndoRecorder.RecordCreationForUndo(newConnector);
}
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
NodeModel node = null;
var obj = JObject.Load(reader);
var type = Type.GetType(obj["$type"].Value <string>());
//if we can't find this type - try to look in our load from assemblies,
//but only during testing - this is required during testing because some dlls are loaded
//using Assembly.LoadFrom using the assemblyHelper - which loads dlls into loadFrom context -
//dlls loaded with LoadFrom context cannot be found using Type.GetType() - this should
//not be an issue during normal dynamo use but if it is we can enable this code.
if (type == null && this.isTestMode == true)
{
List <Assembly> resultList;
var typeName = obj["$type"].Value <string>().Split(',').FirstOrDefault();
//this assemblyName does not usually contain version information...
var assemblyName = obj["$type"].Value <string>().Split(',').Skip(1).FirstOrDefault().Trim();
if (assemblyName != null)
{
if (this.loadedAssemblies.TryGetValue(assemblyName, out resultList))
{
var matchingTypes = resultList.Select(x => x.GetType(typeName)).ToList();
type = matchingTypes.FirstOrDefault();
}
}
}
// If the id is not a guid, makes a guid based on the id of the node
var guid = GuidUtility.tryParseOrCreateGuid(obj["Id"].Value <string>());
var replication = obj["Replication"].Value <string>();
var inPorts = obj["Inputs"].ToArray().Select(t => t.ToObject <PortModel>()).ToArray();
var outPorts = obj["Outputs"].ToArray().Select(t => t.ToObject <PortModel>()).ToArray();
var resolver = (IdReferenceResolver)serializer.ReferenceResolver;
string assemblyLocation = objectType.Assembly.Location;
bool remapPorts = true;
if (type == null)
{
node = CreateDummyNode(obj, assemblyLocation, inPorts, outPorts);
}
else if (type == typeof(Function))
{
var functionId = Guid.Parse(obj["FunctionSignature"].Value <string>());
CustomNodeDefinition def = null;
CustomNodeInfo info = null;
bool isUnresolved = !manager.TryGetCustomNodeData(functionId, null, false, out def, out info);
Function function = manager.CreateCustomNodeInstance(functionId, null, false, def, info);
node = function;
if (isUnresolved)
{
function.UpdatePortsForUnresolved(inPorts, outPorts);
}
}
else if (type == typeof(CodeBlockNodeModel))
{
var code = obj["Code"].Value <string>();
CodeBlockNodeModel codeBlockNode = new CodeBlockNodeModel(code, guid, 0.0, 0.0, libraryServices, ElementResolver);
node = codeBlockNode;
// If the code block node is in an error state read the extra port data
// and initialize the input and output ports
if (node.IsInErrorState)
{
List <string> inPortNames = new List <string>();
var inputs = obj["Inputs"];
foreach (var input in inputs)
{
inPortNames.Add(input["Name"].ToString());
}
// NOTE: This could be done in a simpler way, but is being implemented
// in this manner to allow for possible future port line number
// information being available in the file
List <int> outPortLineIndexes = new List <int>();
var outputs = obj["Outputs"];
int outputLineIndex = 0;
foreach (var output in outputs)
{
outPortLineIndexes.Add(outputLineIndex++);
}
codeBlockNode.SetErrorStatePortData(inPortNames, outPortLineIndexes);
}
}
else if (typeof(DSFunctionBase).IsAssignableFrom(type))
{
var mangledName = obj["FunctionSignature"].Value <string>();
var functionDescriptor = libraryServices.GetFunctionDescriptor(mangledName);
if (functionDescriptor == null)
{
node = CreateDummyNode(obj, assemblyLocation, inPorts, outPorts);
}
else
{
if (type == typeof(DSVarArgFunction))
{
node = new DSVarArgFunction(functionDescriptor);
// The node syncs with the function definition.
// Then we need to make the inport count correct
var varg = (DSVarArgFunction)node;
varg.VarInputController.SetNumInputs(inPorts.Count());
}
else if (type == typeof(DSFunction))
{
node = new DSFunction(functionDescriptor);
}
}
}
else if (type == typeof(DSVarArgFunction))
{
var functionId = Guid.Parse(obj["FunctionSignature"].Value <string>());
node = manager.CreateCustomNodeInstance(functionId);
}
else if (type.ToString() == "CoreNodeModels.Formula")
{
node = (NodeModel)obj.ToObject(type);
}
else
{
node = (NodeModel)obj.ToObject(type);
// We don't need to remap ports for any nodes with json constructors which pass ports
remapPorts = false;
}
if (remapPorts)
{
RemapPorts(node, inPorts, outPorts, resolver);
}
// Cannot set Lacing directly as property is protected
node.UpdateValue(new UpdateValueParams("ArgumentLacing", replication));
node.GUID = guid;
// Add references to the node and the ports to the reference resolver,
// so that they are available for entities which are deserialized later.
serializer.ReferenceResolver.AddReference(serializer.Context, node.GUID.ToString(), node);
foreach (var p in node.InPorts)
{
serializer.ReferenceResolver.AddReference(serializer.Context, p.GUID.ToString(), p);
}
foreach (var p in node.OutPorts)
{
serializer.ReferenceResolver.AddReference(serializer.Context, p.GUID.ToString(), p);
}
return(node);
}
