/// <summary>
/// Convert node to node vertex model
/// </summary>
/// <param name="node"></param>
/// <param name="context"></param>
/// <returns></returns>
private async Task WriteNodeAsync(BaseNodeModel node, ISystemContext context)
{
if (node == null)
{
return;
}
var vertex = node.ToVertex(_source.Id, _revision, _codec);
if (vertex == null)
{
return;
}
foreach (var reference in node.GetBrowseReferences(context))
{
// Get modelling rule?
await WriteReferenceAsync(vertex, reference);
}
await _loader.AddVertexAsync(vertex);
// Add source edge
await _loader.AddEdgeAsync(vertex,
new AddressSpaceSourceEdgeModel {
Id = _source.CreateEdgeId(vertex.NodeId, _source.Id),
Revision = _revision,
SourceId = _source.Id
}, _source);
}
/// <summary>
/// Load references
/// </summary>
/// <param name="nodeModel"></param>
/// <param name="ct"></param>
/// <returns></returns>
public async Task FetchReferencesAsync(BaseNodeModel nodeModel, CancellationToken ct)
{
try {
// Read node with value
var response = await _client.ExecuteServiceAsync(_endpoint, _elevation,
_priority, ct, session => {
_encoder.Context.UpdateFromSession(session);
return(session.BrowseAsync(_diagnostics.ToStackModel(), null,
nodeModel.NodeId, 0u, Opc.Ua.BrowseDirection.Both,
ReferenceTypeIds.References, true, 0u));
});
SessionClientEx.Validate(response.Results, response.DiagnosticInfos);
OperationResultEx.Validate("Browse_" + nodeModel.NodeId, Diagnostics,
response.Results.Select(r => r.StatusCode), null, false);
while (true)
{
foreach (var reference in response.Results[0].References)
{
nodeModel.AddReference(reference.ReferenceTypeId,
!reference.IsForward, reference.NodeId);
_references++;
}
if (response.Results[0].ContinuationPoint == null)
{
break;
}
response = await _client.ExecuteServiceAsync(_endpoint, _elevation,
_priority, ct, session => {
_encoder.Context.UpdateFromSession(session);
return(session.BrowseNextAsync(_diagnostics.ToStackModel(), false,
new ByteStringCollection {
response.Results[0].ContinuationPoint
}));
});
SessionClientEx.Validate(response.Results, response.DiagnosticInfos);
OperationResultEx.Validate("BrowseNext_" + nodeModel.NodeId, Diagnostics,
response.Results.Select(r => r.StatusCode), null, false);
}
}
catch (Exception ex) {
_logger.Error(ex, "Failed browsing node object for node {nodeId}.",
nodeModel.NodeId);
}
}
/// <summary>
/// Convert node model to vertex
/// </summary>
/// <param name="node"></param>
/// <param name="sourceId"></param>
/// <param name="revision"></param>
/// <param name="codec"></param>
/// <param name="context"></param>
/// <returns></returns>
public static BaseNodeVertexModel ToVertex(this BaseNodeModel node, string sourceId,
long revision, IVariantEncoder codec, ServiceMessageContext context)
{
if (node == null)
{
throw new ArgumentNullException(nameof(node));
}
if (NodeId.IsNull(node.NodeId))
{
throw new ArgumentException(nameof(node));
}
var builtInType = BuiltInType.Null;
BaseNodeVertexModel vertex;
switch (node)
{
case ObjectNodeModel oNode:
vertex = new ObjectNodeVertexModel {
EventNotifier = (NodeEventNotifier?)oNode.EventNotifier
};
break;
case PropertyNodeModel vNode:
vertex = new PropertyNodeVertexModel {
ValueRank = (NodeValueRank?)vNode.ValueRank,
ArrayDimensions = vNode.ArrayDimensions,
AccessLevel = (vNode.AccessLevel != null || vNode.AccessLevelEx != null) ?
(NodeAccessLevel?)((vNode.AccessLevel ?? 0) |
(vNode.AccessLevelEx ?? 0)) : null,
MinimumSamplingInterval = vNode.MinimumSamplingInterval,
Historizing = vNode.Historizing,
Value = vNode.Value == null ? null : codec.Encode(vNode.Value.Value,
out builtInType, context),
BuiltInType = builtInType
};
break;
case VariableNodeModel vNode:
vertex = new VariableNodeVertexModel {
ValueRank = (NodeValueRank?)vNode.ValueRank,
ArrayDimensions = vNode.ArrayDimensions,
AccessLevel = (vNode.AccessLevel != null || vNode.AccessLevelEx != null) ?
(NodeAccessLevel?)((vNode.AccessLevel ?? 0) |
(vNode.AccessLevelEx ?? 0)) : null,
MinimumSamplingInterval = vNode.MinimumSamplingInterval,
Historizing = vNode.Historizing,
Value = vNode.Value == null ? null : codec.Encode(vNode.Value.Value,
out builtInType, context),
BuiltInType = builtInType
};
break;
case MethodNodeModel mNode:
vertex = new MethodNodeVertexModel {
Executable = mNode.Executable.ToNullable(false),
UserExecutable = mNode.UserExecutable.ToNullable(false)
};
break;
case ViewNodeModel vNode:
vertex = new ViewNodeVertexModel {
ContainsNoLoops = vNode.ContainsNoLoops
};
break;
case ObjectTypeNodeModel otNode:
vertex = new ObjectTypeNodeVertexModel {
IsAbstract = otNode.IsAbstract
};
break;
case PropertyTypeNodeModel vtNode:
vertex = new PropertyTypeNodeVertexModel {
IsAbstract = vtNode.IsAbstract ?? false,
ValueRank = (NodeValueRank?)vtNode.ValueRank,
ArrayDimensions = vtNode.ArrayDimensions,
Value = vtNode.Value == null ? null : codec.Encode(vtNode.Value.Value,
out builtInType, context),
BuiltInType = builtInType
};
break;
case VariableTypeNodeModel vtNode:
vertex = new VariableTypeNodeVertexModel {
IsAbstract = vtNode.IsAbstract ?? false,
ValueRank = (NodeValueRank?)vtNode.ValueRank,
ArrayDimensions = vtNode.ArrayDimensions,
Value = vtNode.Value == null ? null : codec.Encode(vtNode.Value.Value,
out builtInType, context),
BuiltInType = builtInType
};
break;
case DataTypeNodeModel dtNode:
vertex = new DataTypeNodeVertexModel {
IsAbstract = dtNode.IsAbstract,
DataTypeDefinition = dtNode.Definition == null ? null :
codec.Encode(new Variant(new ExtensionObject(dtNode.Definition)),
out _, context)
};
break;
case ReferenceTypeNodeModel rtNode:
vertex = new ReferenceTypeNodeVertexModel {
IsAbstract = rtNode.IsAbstract,
Symmetric = rtNode.Symmetric,
InverseName = rtNode.InverseName.AsString()
};
break;
default:
return(null);
}
vertex.NodeId = node.NodeId.AsString(context);
vertex.BrowseName = node.BrowseName.AsString(context);
vertex.DisplayName = node.DisplayName.AsString();
vertex.Description = node.Description.AsString();
vertex.WriteMask = (uint?)node.WriteMask;
vertex.UserWriteMask = (uint?)node.UserWriteMask;
if (!string.IsNullOrEmpty(node.SymbolicName) && node.SymbolicName != node.BrowseName.Name)
{
vertex.SymbolicName = node.SymbolicName;
}
vertex.Revision = revision;
vertex.SourceId = sourceId;
vertex.Id = CreateAddressSpaceVertexId(sourceId, vertex.NodeId);
#if FALSE
if (node.RolePermissions != null && node.RolePermissions.Count > 0)
{
}
if (node.UserRolePermissions != null && node.UserRolePermissions.Count > 0)
{
}
// export references.
var exportedReferences = new List <Reference>();
foreach (var reference in node.GetAllReferences(context))
{
if (node.NodeClass == NodeClass.Method)
{
if (!reference.IsInverse &&
reference.ReferenceTypeId == ReferenceTypeIds.HasTypeDefinition)
{
continue;
}
}
exportedReferences.Add(new Reference {
ReferenceType = EncodeNodeId(reference.ReferenceTypeId, context),
IsForward = !reference.IsInverse,
Value = EncodeExpandedNodeId(reference.TargetId, context)
});
}
vertex.References = exportedReferences.ToArray();
#endif
return(vertex);
}
