//// Objects
//
/// <summary>
/// Helper to create an Object-Node. Note: __NO__ NodeId is created by the default! Must be done by outer
/// functionality!!
/// </summary>
/// <param name="parent">Parent node</param>
/// <param name="mode">Type or instance</param>
/// <param name="browseDisplayName">Name displayed in the node tree</param>
/// <param name="referenceTypeFromParentId"></param>
/// <param name="typeDefinitionId">Type of the Object</param>
/// <param name="modellingRule">Modeling Rule, if not None</param>
/// <param name="extraName"></param>
/// <returns>The node</returns>
public BaseObjectState CreateAddObject(
NodeState parent, AasUaBaseEntity.CreateMode mode,
string browseDisplayName,
NodeId referenceTypeFromParentId = null,
NodeId typeDefinitionId = null,
AasUaNodeHelper.ModellingRule modellingRule = AasUaNodeHelper.ModellingRule.None,
string extraName = null)
{
var x = AasUaNodeHelper.CreateObject(parent, browseDisplayName, typeDefinitionId: typeDefinitionId,
modellingRule: modellingRule, extraName: extraName);
x.NodeId = nodeMgr.NewFromParent(nodeMgr.SystemContext, mode, x, parent);
nodeMgr.AddPredefinedNode(nodeMgr.SystemContext, x);
if (parent != null)
{
parent.AddChild(x);
}
if (referenceTypeFromParentId != null)
{
if (parent != null)
{
if (!parent.ReferenceExists(referenceTypeFromParentId, false, x.NodeId))
{
parent.AddReference(referenceTypeFromParentId, false, x.NodeId);
}
if (referenceTypeFromParentId == ReferenceTypeIds.HasComponent)
{
x.AddReference(referenceTypeFromParentId, true, parent.NodeId);
}
if (referenceTypeFromParentId == ReferenceTypeIds.HasProperty)
{
x.AddReference(referenceTypeFromParentId, true, parent.NodeId);
}
}
//// nodeMgr.AddReference(parentNodeId, new AasReference(referenceTypeId, false, x.NodeId));
}
//// if (typeDefinitionId != null)
//// {
//// x.TypeDefinitionId = typeDefinitionId;
//// x.AddReference(ReferenceTypeIds.HasTypeDefinition, false, typeDefinitionId);
//// // nodeMgr.AddReference(x.NodeId, new AasReference(ReferenceTypeIds.HasTypeDefinition, false,
//// // typeDefinitionId));
//// }
return(x);
}
/// <summary>
/// Adds a root notifier.
/// </summary>
/// <param name="notifier">The notifier.</param>
/// <remarks>
/// A root notifier is a notifier owned by the NodeManager that is not the target of a
/// HasNotifier reference. These nodes need to be linked directly to the Server object.
/// </remarks>
protected override void AddRootNotifier(NodeState notifier)
{
if (_rootNotifiers == null)
{
_rootNotifiers = new List <NodeState>();
}
for (int ii = 0; ii < _rootNotifiers.Count; ii++)
{
if (Object.ReferenceEquals(notifier, _rootNotifiers[ii]))
{
return;
}
}
_rootNotifiers.Add(notifier);
// need to prevent recursion with the server object.
if (notifier.NodeId != ObjectIds.Server)
{
notifier.OnReportEvent = OnReportEvent;
if (!notifier.ReferenceExists(ReferenceTypeIds.HasNotifier, true, ObjectIds.Server))
{
notifier.AddReference(ReferenceTypeIds.HasNotifier, true, ObjectIds.Server);
}
}
// subscribe to existing events.
if (_server.EventManager != null)
{
IList <IEventMonitoredItem> monitoredItems = _server.EventManager.GetMonitoredItems();
for (int ii = 0; ii < monitoredItems.Count; ii++)
{
if (monitoredItems[ii].MonitoringAllEvents)
{
SubscribeToEvents(
SystemContext,
notifier,
monitoredItems[ii],
true);
}
}
}
}
/// <summary>
/// Adds a root notifier.
/// </summary>
/// <param name="notifier">The notifier.</param>
/// <remarks>
/// A root notifier is a notifier owned by the NodeManager that is not the target of a
/// HasNotifier reference. These nodes need to be linked directly to the Server object.
/// </remarks>
protected virtual void AddRootNotifier(NodeState notifier)
{
if (m_rootNotifiers == null)
{
m_rootNotifiers = new List<NodeState>();
}
for (int ii = 0; ii < m_rootNotifiers.Count; ii++)
{
if (Object.ReferenceEquals(notifier, m_rootNotifiers[ii]))
{
return;
}
}
m_rootNotifiers.Add(notifier);
// need to prevent recursion with the server object.
if (notifier.NodeId != ObjectIds.Server)
{
notifier.OnReportEvent = OnReportEvent;
if (!notifier.ReferenceExists(ReferenceTypeIds.HasNotifier, true, ObjectIds.Server))
{
notifier.AddReference(ReferenceTypeIds.HasNotifier, true, ObjectIds.Server);
}
}
// subscribe to existing events.
if (m_server.EventManager != null)
{
IList<IEventMonitoredItem> monitoredItems = m_server.EventManager.GetMonitoredItems();
for (int ii = 0; ii < monitoredItems.Count; ii++)
{
if (monitoredItems[ii].MonitoringAllEvents)
{
SubscribeToEvents(
SystemContext,
notifier,
monitoredItems[ii],
true);
}
}
}
}
/// <summary>
/// Calls a method on the specified nodes.
/// </summary>
public override void Call(
OperationContext context,
IList <CallMethodRequest> methodsToCall,
IList <CallMethodResult> results,
IList <ServiceResult> errors)
{
ServerSystemContext systemContext = SystemContext.Copy(context);
IDictionary <NodeId, NodeState> operationCache = new NodeIdDictionary <NodeState>();
bool didRefresh = false;
for (int ii = 0; ii < methodsToCall.Count; ii++)
{
CallMethodRequest methodToCall = methodsToCall[ii];
bool refreshMethod = methodToCall.MethodId.Equals(Opc.Ua.MethodIds.ConditionType_ConditionRefresh) ||
methodToCall.MethodId.Equals(Opc.Ua.MethodIds.ConditionType_ConditionRefresh2);
if (refreshMethod)
{
if (didRefresh)
{
errors[ii] = StatusCodes.BadRefreshInProgress;
methodToCall.Processed = true;
continue;
}
else
{
didRefresh = true;
}
}
bool ackMethod = methodToCall.MethodId.Equals(Opc.Ua.MethodIds.AcknowledgeableConditionType_Acknowledge);
bool confirmMethod = methodToCall.MethodId.Equals(Opc.Ua.MethodIds.AcknowledgeableConditionType_Confirm);
bool commentMethod = methodToCall.MethodId.Equals(Opc.Ua.MethodIds.ConditionType_AddComment);
bool ackConfirmMethod = ackMethod || confirmMethod || commentMethod;
// Need to try to capture any calls to ConditionType::Acknowledge
if (methodToCall.ObjectId.Equals(Opc.Ua.ObjectTypeIds.ConditionType) && (ackConfirmMethod))
{
// Mantis Issue 6944 which is a duplicate of 5544 - result is Confirm should be Bad_NodeIdInvalid
// Override any other errors that may be there, even if this is 'Processed'
errors[ii] = StatusCodes.BadNodeIdInvalid;
methodToCall.Processed = true;
continue;
}
// skip items that have already been processed.
if (methodToCall.Processed)
{
continue;
}
MethodState method = null;
lock (Lock)
{
// check for valid handle.
NodeHandle initialHandle = GetManagerHandle(systemContext, methodToCall.ObjectId, operationCache);
if (initialHandle == null)
{
if (ackConfirmMethod)
{
// Mantis 6944
errors[ii] = StatusCodes.BadNodeIdUnknown;
methodToCall.Processed = true;
}
continue;
}
// owned by this node manager.
methodToCall.Processed = true;
// Look for an alarm branchId to operate on.
NodeHandle handle = FindBranchNodeHandle(systemContext, initialHandle, methodToCall);
// validate the source node.
NodeState source = ValidateNode(systemContext, handle, operationCache);
if (source == null)
{
errors[ii] = StatusCodes.BadNodeIdUnknown;
continue;
}
// find the method.
method = source.FindMethod(systemContext, methodToCall.MethodId);
if (method == null)
{
// check for loose coupling.
if (source.ReferenceExists(ReferenceTypeIds.HasComponent, false, methodToCall.MethodId))
{
method = (MethodState)FindPredefinedNode(methodToCall.MethodId, typeof(MethodState));
}
if (method == null)
{
errors[ii] = StatusCodes.BadMethodInvalid;
continue;
}
}
}
// call the method.
CallMethodResult result = results[ii] = new CallMethodResult();
errors[ii] = Call(
systemContext,
methodToCall,
method,
result);
}
}
