/// <summary>
/// Updates the base event.
/// </summary>
private void UpdateBaseEvent(BaseEventState instance, EventType eventType, ONEVENTSTRUCT e)
{
BinaryEncoder encoder = new BinaryEncoder(ServiceMessageContext.GlobalContext);
encoder.WriteString(null, e.szSource);
encoder.WriteString(null, e.szConditionName);
encoder.WriteInt32(null, e.ftActiveTime.dwHighDateTime);
encoder.WriteInt32(null, e.ftActiveTime.dwLowDateTime);
encoder.WriteInt32(null, e.dwCookie);
byte[] eventId = encoder.CloseAndReturnBuffer();
NodeId eventTypeId = AeParsedNodeId.Construct(e.dwEventType, e.dwEventCategory, e.szConditionName, m_namespaceIndex);
NodeId sourceNode = AeModelUtils.ConstructIdForSource(e.szSource, null, m_namespaceIndex);
string sourceName = e.szSource;
DateTime time = ComUtils.GetDateTime(e.ftTime);
DateTime receiveTime = DateTime.UtcNow;
LocalizedText message = e.szMessage;
ushort severity = (ushort)e.dwSeverity;
instance.TypeDefinitionId = eventTypeId;
instance.SetChildValue(m_defaultContext, Opc.Ua.BrowseNames.EventId, eventId, false);
instance.SetChildValue(m_defaultContext, Opc.Ua.BrowseNames.EventType, eventTypeId, false);
instance.SetChildValue(m_defaultContext, Opc.Ua.BrowseNames.SourceNode, sourceNode, false);
instance.SetChildValue(m_defaultContext, Opc.Ua.BrowseNames.SourceName, sourceName, false);
instance.SetChildValue(m_defaultContext, Opc.Ua.BrowseNames.Time, time, false);
instance.SetChildValue(m_defaultContext, Opc.Ua.BrowseNames.ReceiveTime, receiveTime, false);
instance.SetChildValue(m_defaultContext, Opc.Ua.BrowseNames.Message, message, false);
instance.SetChildValue(m_defaultContext, Opc.Ua.BrowseNames.Severity, severity, false);
}
/// <summary>
/// Creates an instance of an event.
/// </summary>
public BaseEventState CreateInstance(ServerSystemContext context, AeEventTypeState eventType)
{
BaseEventState instance = null;
switch (eventType.EventType.EventTypeMapping)
{
case EventTypeMapping.AlarmConditionType: { instance = new AlarmConditionState(null); break; }
case EventTypeMapping.AuditEventType: { instance = new AuditEventState(null); break; }
case EventTypeMapping.BaseEventType: { instance = new BaseEventState(null); break; }
case EventTypeMapping.DeviceFailureEventType: { instance = new DeviceFailureEventState(null); break; }
case EventTypeMapping.DiscreteAlarmType: { instance = new DiscreteAlarmState(null); break; }
case EventTypeMapping.NonExclusiveDeviationAlarmType: { instance = new NonExclusiveDeviationAlarmState(null); break; }
case EventTypeMapping.ExclusiveLevelAlarmType: { instance = new ExclusiveLevelAlarmState(null); break; }
case EventTypeMapping.LimitAlarmType: { instance = new LimitAlarmState(null); break; }
case EventTypeMapping.NonExclusiveLevelAlarmType: { instance = new NonExclusiveLevelAlarmState(null); break; }
case EventTypeMapping.OffNormalAlarmType: { instance = new OffNormalAlarmState(null); break; }
case EventTypeMapping.SystemEventType: { instance = new SystemEventState(null); break; }
case EventTypeMapping.TripAlarmType: { instance = new TripAlarmState(null); break; }
}
return instance;
}
/// <summary>
/// Constructs an event object from a notification.
/// </summary>
/// <param name="session">The session.</param>
/// <param name="monitoredItem">The monitored item that produced the notification.</param>
/// <param name="notification">The notification.</param>
/// <param name="eventTypeMappings">Mapping between event types and known event types.</param>
/// <returns>
/// The event object. Null if the notification is not a valid event type.
/// </returns>
public static BaseEventState ConstructEvent(
Session session,
MonitoredItem monitoredItem,
EventFieldList notification,
Dictionary<NodeId,NodeId> eventTypeMappings)
{
// find the event type.
NodeId eventTypeId = FindEventType(monitoredItem, notification);
if (eventTypeId == null)
{
return null;
}
// look up the known event type.
NodeId knownTypeId = null;
if (!eventTypeMappings.TryGetValue(eventTypeId, out knownTypeId))
{
// check for a known type
for (int jj = 0; jj < KnownEventTypes.Length; jj++)
{
if (KnownEventTypes[jj] == eventTypeId)
{
knownTypeId = eventTypeId;
eventTypeMappings.Add(eventTypeId, eventTypeId);
break;
}
}
// browse for the supertypes of the event type.
if (knownTypeId == null)
{
ReferenceDescriptionCollection supertypes = FormUtils.BrowseSuperTypes(session, eventTypeId, false);
// can't do anything with unknown types.
if (supertypes == null)
{
return null;
}
// find the first supertype that matches a known event type.
for (int ii = 0; ii < supertypes.Count; ii++)
{
for (int jj = 0; jj < KnownEventTypes.Length; jj++)
{
if (KnownEventTypes[jj] == supertypes[ii].NodeId)
{
knownTypeId = KnownEventTypes[jj];
eventTypeMappings.Add(eventTypeId, knownTypeId);
break;
}
}
if (knownTypeId != null)
{
break;
}
}
}
}
if (knownTypeId == null)
{
return null;
}
// all of the known event types have a UInt32 as identifier.
uint? id = knownTypeId.Identifier as uint?;
if (id == null)
{
return null;
}
// construct the event based on the known event type.
BaseEventState e = null;
switch (id.Value)
{
case ObjectTypes.ConditionType: { e = new ConditionState(null); break; }
case ObjectTypes.DialogConditionType: { e = new DialogConditionState(null); break; }
case ObjectTypes.AlarmConditionType: { e = new AlarmConditionState(null); break; }
case ObjectTypes.ExclusiveLimitAlarmType: { e = new ExclusiveLimitAlarmState(null); break; }
case ObjectTypes.NonExclusiveLimitAlarmType: { e = new NonExclusiveLimitAlarmState(null); break; }
case ObjectTypes.AuditEventType: { e = new AuditEventState(null); break; }
case ObjectTypes.AuditUpdateMethodEventType: { e = new AuditUpdateMethodEventState(null); break; }
default:
{
e = new BaseEventState(null);
break;
}
}
// get the filter which defines the contents of the notification.
EventFilter filter = monitoredItem.Status.Filter as EventFilter;
// initialize the event with the values in the notification.
e.Update(session.SystemContext, filter.SelectClauses, notification);
// save the orginal notification.
e.Handle = notification;
return e;
}