/// <summary>
/// Encode DataSetMessages
/// </summary>
private void EncodeMessages(JsonEncoder encoder)
{
if (DataSetMessages != null && DataSetMessages.Count > 0)
{
if (HasSingleDataSetMessage)
{
// encode single dataset message
JsonDataSetMessage jsonDataSetMessage = DataSetMessages[0] as JsonDataSetMessage;
if (jsonDataSetMessage != null)
{
jsonDataSetMessage.Encode(encoder, kFieldMessages);
}
}
else
{
encoder.PushArray(kFieldMessages);
foreach (var message in DataSetMessages)
{
JsonDataSetMessage jsonDataSetMessage = message as JsonDataSetMessage;
if (jsonDataSetMessage != null)
{
jsonDataSetMessage.Encode(encoder);
}
}
encoder.PopArray();
}
}
}
/// <summary>
/// Encodes the object in the specified stream.
/// </summary>
/// <param name="messageContext">The context.</param>
/// <param name="stream">The stream to use.</param>
public override void Encode(IServiceMessageContext messageContext, Stream stream)
{
bool topLevelIsArray = !HasNetworkMessageHeader && !HasSingleDataSetMessage && !IsMetaDataMessage;
using (JsonEncoder encoder = new JsonEncoder(messageContext, true, topLevelIsArray, stream))
{
if (IsMetaDataMessage)
{
EncodeNetworkMessageHeader(encoder);
encoder.WriteEncodeable(kFieldMetaData, m_metadata, null);
return;
}
// handle no header
if (HasNetworkMessageHeader)
{
Encode(encoder);
}
else if (DataSetMessages != null && DataSetMessages.Count > 0)
{
if (HasSingleDataSetMessage)
{
// encode single dataset message
JsonDataSetMessage jsonDataSetMessage = DataSetMessages[0] as JsonDataSetMessage;
if (jsonDataSetMessage != null)
{
if (!jsonDataSetMessage.HasDataSetMessageHeader)
{
// If the NetworkMessageHeader and the DataSetMessageHeader bits are not set
// and SingleDataSetMessage bit is set, the NetworkMessage is a JSON object
// containing the set of name/value pairs defined for a single DataSet.
jsonDataSetMessage.EncodePayload(encoder, false);
}
else
{
// If the SingleDataSetMessage bit of the NetworkMessageContentMask is set,
// the content of the Messages field is a JSON object containing a single DataSetMessage.
jsonDataSetMessage.Encode(encoder);
}
}
}
else
{
// If the NetworkMessageHeader bit of the NetworkMessageContentMask is not set,
// the NetworkMessage is the contents of the Messages field (e.g. a JSON array of DataSetMessages).
foreach (var message in DataSetMessages)
{
JsonDataSetMessage jsonDataSetMessage = message as JsonDataSetMessage;
if (jsonDataSetMessage != null)
{
jsonDataSetMessage.Encode(encoder);
}
}
}
}
}
}
/// <summary>
/// Encodes the object and returns the resulting byte array.
/// </summary>
/// <returns></returns>
public override byte[] Encode()
{
ServiceMessageContext messageContext = new ServiceMessageContext();
messageContext.NamespaceUris = ServiceMessageContext.GlobalContext.NamespaceUris;
messageContext.ServerUris = ServiceMessageContext.GlobalContext.ServerUris;
bool topLevelIsArray = !HasNetworkMessageHeader && !HasSingleDataSetMessage;
using (JsonEncoder encoder = new JsonEncoder(messageContext, false, null, topLevelIsArray))
{
// handle no header
if (HasNetworkMessageHeader)
{
Encode(encoder);
}
else if (DataSetMessages != null && DataSetMessages.Count > 0)
{
if (HasSingleDataSetMessage)
{
// encode single dataset message
JsonDataSetMessage jsonDataSetMessage = DataSetMessages[0] as JsonDataSetMessage;
if (jsonDataSetMessage != null)
{
if (!jsonDataSetMessage.HasDataSetMessageHeader)
{
// (UA Specs:) If the NetworkMessageHeader and the DataSetMessageHeader bits are not set
// and SingleDataSetMessage bit is set, the NetworkMessage
// is a JSON object containing the set of name/value pairs defined for a single DataSet.
jsonDataSetMessage.EncodePayload(encoder, false);
}
else
{
// If the SingleDataSetMessage bit of the NetworkMessageContentMask is set,
// the content of the Messages field is a JSON object containing a single DataSetMessage.
jsonDataSetMessage.Encode(encoder);
}
}
}
else
{
// If the NetworkMessageHeader bit of the NetworkMessageContentMask is not set,
// the NetworkMessage is the contents of the Messages field (e.g. a JSON array of DataSetMessages).
foreach (var message in DataSetMessages)
{
JsonDataSetMessage jsonDataSetMessage = message as JsonDataSetMessage;
if (jsonDataSetMessage != null)
{
jsonDataSetMessage.Encode(encoder);
}
}
}
}
byte[] bytes = System.Text.Encoding.ASCII.GetBytes(encoder.CloseAndReturnText());
return(bytes);
}
}
/// <summary>
/// Encode Network Message Header
/// </summary>
private void EncodeNetworkMessageHeader(IEncoder jsonEncoder)
{
jsonEncoder.WriteString(nameof(MessageId), MessageId);
jsonEncoder.WriteString(nameof(MessageType), MessageType);
if (m_jsonNetworkMessageType == JSONNetworkMessageType.DataSetMessage)
{
if ((NetworkMessageContentMask & JsonNetworkMessageContentMask.PublisherId) != 0)
{
jsonEncoder.WriteString(nameof(PublisherId), PublisherId);
}
if ((NetworkMessageContentMask & JsonNetworkMessageContentMask.DataSetClassId) != 0)
{
if (HasSingleDataSetMessage)
{
JsonDataSetMessage jsonDataSetMessage = DataSetMessages[0] as JsonDataSetMessage;
if (jsonDataSetMessage?.DataSet?.DataSetMetaData?.DataSetClassId != null)
{
jsonEncoder.WriteString(nameof(DataSetClassId), jsonDataSetMessage.DataSet.DataSetMetaData.DataSetClassId.ToString());
}
}
}
}
else if (m_jsonNetworkMessageType == JSONNetworkMessageType.DataSetMetaData)
{
jsonEncoder.WriteString(nameof(PublisherId), PublisherId);
if (DataSetWriterId != null)
{
jsonEncoder.WriteUInt16(nameof(DataSetWriterId), DataSetWriterId.Value);
}
else
{
Utils.Trace("The JSON MetaDataMessage cannot be encoded: The DataSetWriterId property is missing for MessageId:{0}.", MessageId);
}
}
}
/// <summary>
/// Decode the stream from decoder parameter and produce a Dataset
/// </summary>
/// <param name="jsonDecoder"></param>
/// <param name="dataSetReaders"></param>
/// <returns></returns>
public void DecodeSubscribedDataSets(JsonDecoder jsonDecoder, IEnumerable <DataSetReaderDataType> dataSetReaders)
{
try
{
List <DataSetReaderDataType> dataSetReadersFiltered = new List <DataSetReaderDataType>();
// 1. decode network message header (PublisherId & DataSetClassId)
DecodeNetworkMessageHeader(jsonDecoder);
// ignore network messages that are not dataSet messages
if (m_jsonNetworkMessageType != JSONNetworkMessageType.DataSetMessage)
{
return;
}
//* 6.2.8.1 PublisherId
// The parameter PublisherId defines the Publisher to receive NetworkMessages from.
// If the value is null, the parameter shall be ignored and all received NetworkMessages pass the PublisherId filter. */
foreach (DataSetReaderDataType dataSetReader in dataSetReaders)
{
if (dataSetReader.PublisherId == Variant.Null)
{
dataSetReadersFiltered.Add(dataSetReader);
}
// publisher id
else if ((NetworkMessageContentMask & JsonNetworkMessageContentMask.PublisherId) != 0 &&
PublisherId != null &&
PublisherId.Equals(dataSetReader.PublisherId.Value.ToString()))
{
dataSetReadersFiltered.Add(dataSetReader);
}
}
if (dataSetReadersFiltered.Count == 0)
{
return;
}
dataSetReaders = dataSetReadersFiltered;
object messagesToken = null;
List <object> messagesList = null;
string messagesListName = string.Empty;
if (jsonDecoder.ReadField(kFieldMessages, out messagesToken))
{
messagesList = messagesToken as List <object>;
if (messagesList == null)
{
// this is a SingleDataSetMessage encoded as the conteten of Messages
jsonDecoder.PushStructure(kFieldMessages);
messagesList = new List <object>();
}
else
{
messagesListName = kFieldMessages;
}
}
else if (jsonDecoder.ReadField(JsonDecoder.RootArrayName, out messagesToken))
{
messagesList = messagesToken as List <object>;
messagesListName = JsonDecoder.RootArrayName;
}
else
{
// this is a SingleDataSetMessage encoded as the conteten of json
messagesList = new List <object>();
}
if (messagesList != null)
{
// atempt decoding for each data set reader
foreach (DataSetReaderDataType dataSetReader in dataSetReaders)
{
JsonDataSetReaderMessageDataType jsonMessageSettings = ExtensionObject.ToEncodeable(dataSetReader.MessageSettings)
as JsonDataSetReaderMessageDataType;
if (jsonMessageSettings == null)
{
// The reader MessageSettings is not set up corectly
continue;
}
JsonNetworkMessageContentMask networkMessageContentMask =
(JsonNetworkMessageContentMask)jsonMessageSettings.NetworkMessageContentMask;
if ((networkMessageContentMask & NetworkMessageContentMask) != NetworkMessageContentMask)
{
// The reader MessageSettings.NetworkMessageContentMask is not set up corectly
continue;
}
// initialize the dataset message
JsonDataSetMessage jsonDataSetMessage = new JsonDataSetMessage();
jsonDataSetMessage.DataSetMessageContentMask = (JsonDataSetMessageContentMask)jsonMessageSettings.DataSetMessageContentMask;
jsonDataSetMessage.SetFieldContentMask((DataSetFieldContentMask)dataSetReader.DataSetFieldContentMask);
// set the flag that indicates if dataset message shall have a header
jsonDataSetMessage.HasDataSetMessageHeader = (networkMessageContentMask & JsonNetworkMessageContentMask.DataSetMessageHeader) != 0;
jsonDataSetMessage.DecodePossibleDataSetReader(jsonDecoder, messagesList.Count, messagesListName, dataSetReader);
if (jsonDataSetMessage.DataSet != null)
{
m_uaDataSetMessages.Add(jsonDataSetMessage);
}
}
}
}
catch (Exception ex)
{
// Unexpected exception in DecodeSubscribedDataSets
Utils.Trace(ex, "JsonNetworkMessage.DecodeSubscribedDataSets");
}
}
