public Result <DataResponse> GetEventData(OpcUAQuery query, NodeId startNodeId, Opc.Ua.EventFilter eventFilter)
{
var nodeCache = _nodeCacheFactory.Create(_session);
eventFilter.AddSelectClause(ObjectTypeIds.BaseEventType, "SourceNode");
eventFilter.AddSelectClause(ObjectTypeIds.BaseEventType, "EventType");
var eventFilterValues = GetEventFilterValues(startNodeId, eventFilter);
if (eventFilterValues == null)
{
var monitorItem = AddMonitorItem(startNodeId, eventFilter);
eventFilterValues = new EventFilterValues(monitorItem, query, eventFilter);
if (!TryAddEventFilterValues(startNodeId, eventFilterValues))
{
RemoveMonitorItem(monitorItem);
eventFilterValues = null;
}
}
lock (_eventData)
{
if (eventFilterValues == null)
{
eventFilterValues = GetEventFilterValues(startNodeId, eventFilter);
}
if (eventFilterValues != null)
{
return(_eventDataResponse.CreateEventSubscriptionDataResponse(eventFilterValues.Values.Values, query, nodeCache));
}
}
return(new Result <DataResponse>(StatusCodes.BadUnexpectedError, ""));
}
internal static Opc.Ua.EventFilter GetEventFilter(OpcUAQuery query, NamespaceTable namespaceTable)
{
var eventFilter = new Opc.Ua.EventFilter();
if (query.eventQuery?.eventColumns != null)
{
foreach (var column in query.eventQuery.eventColumns)
{
var bp = Converter.GetBrowsePath(column.browsePath, namespaceTable);
var path = SimpleAttributeOperand.Format(bp);
eventFilter.AddSelectClause(ObjectTypes.BaseEventType, path, Attributes.Value);
}
}
if (query.eventQuery?.eventFilters != null)
{
for (int i = 0; i < query.eventQuery.eventFilters.Length; i++)
{
var filter = query.eventQuery.eventFilters[i];
eventFilter.WhereClause.Push(filter.oper, GetOperands(filter, namespaceTable));
}
}
return(eventFilter);
}
internal EventFilterValues(MonitoredItem monitoredItem, OpcUAQuery query, Opc.Ua.EventFilter filter)
{
MonitoredItem = monitoredItem;
Query = query;
Filter = filter;
Values = new Dictionary <SourceAndEventTypeKey, VariantCollection>();
LastRead = DateTimeOffset.UtcNow;
}
internal static Dictionary <int, Field> AddEventFields(DataFrame dataFrame, OpcUAQuery query)
{
var fields = new Dictionary <int, Field>();
for (int i = 0; i < query.eventQuery.eventColumns.Length; i++)
{
var col = query.eventQuery.eventColumns[i];
var type = GetTypeForField(col.browsePath);
var field = dataFrame.AddField(string.IsNullOrEmpty(col.alias) ? GetFieldName(col.browsePath) : col.alias, type);
field.Config.Filterable = true;
fields.Add(i, field);
}
return(fields);
}
private List <OpcUAQuery> ParseJSONQueries(DatasourceRequest request)
{
List <OpcUAQuery> ret = new List <OpcUAQuery>();
foreach (Query query in request.Queries)
{
try
{
log.Information("Handling {0}", query.ModelJson);
OpcUAQuery uaq = JsonSerializer.Deserialize <OpcUAQuery>(query.ModelJson);
ret.Add(uaq);
}
catch (Exception ex)
{
Log.Information("Caught exception {0}", ex);
}
}
return(ret);
}
private BrowsePath ResolveRelativePath(OpcUAQuery query, NamespaceTable namespaceTable)
{
var path = new BrowsePath();
var nodeId = Converter.GetNodeId(query.nodePath.node.nodeId, namespaceTable);
path.StartingNode = nodeId;
if (query.useTemplate && query.relativePath != null && query.relativePath.Length > 0)
{
var r = new RelativePath();
path.RelativePath = r;
for (int i = 0; i < query.relativePath.Length; i++)
{
r.Elements.Add(new RelativePathElement()
{
TargetName = Converter.GetQualifiedName(query.relativePath[i], namespaceTable), IncludeSubtypes = true, ReferenceTypeId = Opc.Ua.ReferenceTypes.References, IsInverse = false
});
}
}
return(path);
}
internal static string GetFieldName(OpcUAQuery query, BrowsePath relativePath)
{
string fieldName = query.alias;
if (string.IsNullOrEmpty(fieldName))
{
fieldName = String.Join(" / ", query.nodePath.browsePath.Select(a => a.name).ToArray());
if (relativePath?.RelativePath?.Elements?.Count > 0)
{
StringBuilder sb = new StringBuilder();
sb.Append(fieldName);
var pelemt = relativePath.RelativePath.Elements;
for (int i = 0; i < pelemt.Count; i++)
{
sb.Append(" / ");
sb.Append(pelemt[i].TargetName.Name);
}
fieldName = sb.ToString();
}
}
return(fieldName);
}
public OpcUAQuery(DataQuery dataQuery)
{
refId = dataQuery.RefId;
maxDataPoints = dataQuery.MaxDataPoints;
intervalMs = dataQuery.IntervalMS;
timeRange = dataQuery.TimeRange;
byte[] byDecoded = Convert.FromBase64String(dataQuery.Json.ToBase64());
OpcUAQuery query = JsonSerializer.Deserialize <OpcUAQuery>(byDecoded);
datasourceId = query.datasourceId;
nodePath = query.nodePath;
templateVariable = query.templateVariable;
useTemplate = query.useTemplate;
alias = query.alias;
readType = query.readType;
aggregate = query.aggregate;
maxValuesPerNode = query.maxValuesPerNode;
resampleInterval = query.resampleInterval;
eventQuery = query.eventQuery;
relativePath = query.relativePath;
}
internal static Result <DataResponse> GetDataResponseForDataValue(ILogger log, DataValue dataValue, NodeId nodeId, OpcUAQuery query, BrowsePath relativePath)
{
try
{
if (Opc.Ua.StatusCode.IsGood(dataValue.StatusCode))
{
DataResponse dataResponse = new DataResponse();
DataFrame dataFrame = new DataFrame(query.refId);
var timeField = dataFrame.AddField("Time", typeof(DateTime));
var fieldName = GetFieldName(query, relativePath);
Field valueField = dataFrame.AddField(fieldName, dataValue?.Value != null ? dataValue.Value.GetType() : typeof(string));
timeField.Append(LimitDateTime(dataValue.SourceTimestamp));
valueField.Append(dataValue?.Value != null ? dataValue?.Value : "");
dataResponse.Frames.Add(dataFrame.ToGprcArrowFrame());
return(new Result <DataResponse>(dataResponse));
}
else
{
return(new Result <DataResponse>(dataValue.StatusCode, string.Format("Error reading node with id {0}", nodeId.ToString())));
}
}
catch (Exception e)
{
log.LogError(e.Message);
return(new Result <DataResponse>(dataValue.StatusCode, string.Format("Error reading node with id {0}: {1}", nodeId.ToString(), e.Message)));
}
}
internal static Result <DataResponse> CreateHistoryDataResponse(Result <HistoryData> valuesResult, OpcUAQuery query, BrowsePath relativePath)
{
if (valuesResult.Success)
{
var dataResponse = new DataResponse();
var dataFrame = new DataFrame(query.refId);
var timeField = dataFrame.AddField("Time", typeof(DateTime));
Field valueField = null;
foreach (DataValue entry in valuesResult.Value.DataValues)
{
if (valueField == null && entry.Value != null)
{
var fieldName = GetFieldName(query, relativePath);
valueField = dataFrame.AddField(fieldName, entry.Value.GetType());
}
if (valueField != null)
{
valueField.Append(entry.Value);
timeField.Append(entry.SourceTimestamp);
}
}
dataResponse.Frames.Add(dataFrame.ToGprcArrowFrame());
return(new Result <DataResponse>(dataResponse));
}
else
{
return(new Result <DataResponse>(valuesResult.StatusCode, valuesResult.Error));
}
}
public Result <DataResponse> CreateEventDataResponse(Result <HistoryEvent> historyEventResult, OpcUAQuery query, INodeCache nodeCache)
{
if (historyEventResult.Success)
{
var historyEvent = historyEventResult.Value;
var dataResponse = new DataResponse();
var dataFrame = new DataFrame(query.refId);
var fields = AddEventFields(dataFrame, query);
if (historyEvent.Events.Count > 0)
{
foreach (var e in historyEvent.Events)
{
FillEventDataFrame(fields, e.EventFields, query, nodeCache);
}
}
dataResponse.Frames.Add(dataFrame.ToGprcArrowFrame());
return(new Result <DataResponse>(dataResponse));
}
else
{
return(new Result <DataResponse>(historyEventResult.StatusCode, historyEventResult.Error));
}
}
public Result <DataResponse> CreateEventSubscriptionDataResponse(ICollection <VariantCollection> events, OpcUAQuery query, INodeCache nodeCache)
{
var dataResponse = new DataResponse();
var dataFrame = new DataFrame(query.refId);
var fields = AddEventFields(dataFrame, query);
foreach (var ev in events)
{
FillEventDataFrame(fields, ev, query, nodeCache);
}
dataResponse.Frames.Add(dataFrame.ToGprcArrowFrame());
return(new Result <DataResponse>(dataResponse));
}
internal static void FillEventDataFrame(Dictionary <int, Field> fields, VariantCollection eventFields, OpcUAQuery query, INodeCache nodeCache)
{
for (int k = 0; k < eventFields.Count; k++)
{
var field = eventFields[k];
if (fields.TryGetValue(k, out Field dataField))
{
var path = query.eventQuery.eventColumns[k].browsePath;
dataField.Append(GetDataFieldValue(dataField, GetValueForField(path, nodeCache, field.Value)));
}
}
}
