public void SendCommandLog(string commandId, DateTime startTime, DateTime endTime, Dictionary <string, string> comp, bool screenshots)
{
var logData = new Dictionary <string, IValue>();
var encoder = new JsonEncoder();
logData["time"] = new StringValue(startTime.ToString("yyyy-M-d HH:mm:ss"));
logData["name"] = new StringValue($"{commandId,-20}");
var duration = endTime.Subtract(startTime);
logData["duration"] = new StringValue(duration.ToString(@"mm\:ss"));
logData["result"] = new StringValue(comp["result"]);
logData["arg"] = new StringValue(comp["arg"]);
if (screenshots)
{
_screenshotReport = screenshots;
}
var bytes = encoder.Encode(new DictionaryValue(logData));
string result = Encoding.UTF8.GetString(bytes);
string channelStr = "<color=#94D8FF>[COMMAND]</color> " + result;
Debug.Log(channelStr);
_logData.Add(result);
}
public void Should_Add_Request_Body()
{
//Given
HttpSettings settings = new HttpSettings();
BodyModel model = new BodyModel
{
Id = 1234567,
Active = true,
name = "Rob Test",
Parts = new []
{
"Legs",
"Arms",
"Head"
},
SubModel = new BodySubModel
{
Description = "Body Sub Model Description",
Dttm = DateTime.Now.Date,
Type = "different type"
}
};
//When
settings.SetJsonRequestBody(model);
//Then
Assert.NotNull(settings.RequestBody);
var actual = JsonEncoder.DeserializeObject <BodyModel>(Encoding.UTF8.GetString(settings.RequestBody));
Assert.Equal(model, actual);
}
/// <summary>
/// Will encode the argument to a Json string using the Connection's JsonEncoder, then will send it to the server.
/// </summary>
/// <returns>True if the plugin was able to send out the message</returns>
public bool Send(object arg)
{
if (arg == null)
{
throw new ArgumentNullException("arg");
}
lock (SyncRoot)
{
if (this.State != ConnectionStates.Connected)
{
return(false);
}
string json = JsonEncoder.Encode(arg);
if (string.IsNullOrEmpty(json))
{
HTTPManager.Logger.Error("SignalR Connection", "Failed to JSon encode the given argument. Please try to use an advanced JSon encoder(check the documentation how you can do it).");
}
else
{
Transport.Send(json);
}
}
return(true);
}
public override void EncodeTyped(ref JsonEncoder encoder, T pairs)
{
encoder.Write("{");
bool first = true;
foreach (var kvp in pairs)
{
if (!first)
{
encoder.Write(", ");
}
else
{
first = false;
}
encoder.EncodeString(kvp.Key);
encoder.Write(": ");
this.valueEncoder.EncodeTyped(ref encoder, kvp.Value);
}
encoder.Write("}");
return;
}
/// <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);
}
}
}
}
}
}
private void MonitoredItem_Notification(MonitoredItem monitoredItem, MonitoredItemNotificationEventArgs e)
{
try
{
if (e.NotificationValue == null || monitoredItem.Subscription.Session == null)
{
return;
}
JsonEncoder encoder = new JsonEncoder(
monitoredItem.Subscription.Session.MessageContext, false);
encoder.WriteNodeId("MonitoredItem", monitoredItem.ResolvedNodeId);
e.NotificationValue.Encode(encoder);
var json = encoder.Close();
var bytes = new UTF8Encoding(false).GetBytes(json);
foreach (var publisher in m_publishers)
{
try
{
publisher.Publish(new ArraySegment <byte>(bytes));
}
catch (Exception ex)
{
Utils.Trace(ex, "Failed to publish message, dropping....");
}
}
}
catch (Exception exception)
{
Utils.Trace(exception, "Error processing monitored item notification.");
}
}
public void Test_WriteMultipleEncodeablesWithFieldNames()
{
var expected = "{\"bar_1\":{\"Foo\":\"bar_1\"},\"bar_2\":{\"Foo\":\"bar_2\"},\"bar_3\":{\"Foo\":\"bar_3\"}}";
TestContext.Out.WriteLine("Expected:");
_ = PrettifyAndValidateJson(expected);
var encodeables = new List <FooBarEncodeable> {
new FooBarEncodeable(), new FooBarEncodeable(), new FooBarEncodeable()
};
try
{
var encoder = new JsonEncoder(Context, true, null, false);
foreach (var encodeable in encodeables)
{
encoder.WriteEncodeable(encodeable.Foo, encodeable, typeof(FooBarEncodeable));
}
var encoded = encoder.CloseAndReturnText();
TestContext.Out.WriteLine("Encoded:");
TestContext.Out.WriteLine(encoded);
TestContext.Out.WriteLine("Formatted Encoded:");
_ = PrettifyAndValidateJson(encoded);
Assert.That(encoded, Is.EqualTo(expected));
}
finally
{
encodeables.ForEach(e => e.Dispose());
}
}
public void Test_WriteMultipleEncodeablesWithoutFieldNames(bool topLevelIsArray, string expected)
{
TestContext.Out.WriteLine("Expected:");
_ = PrettifyAndValidateJson(expected);
var encodeables = new List <FooBarEncodeable> {
new FooBarEncodeable(), new FooBarEncodeable(), new FooBarEncodeable()
};
try
{
var encoder = new JsonEncoder(Context, true, null, topLevelIsArray);
foreach (var encodeable in encodeables)
{
encoder.WriteEncodeable(null, encodeable, typeof(FooBarEncodeable));
}
var encoded = encoder.CloseAndReturnText();
TestContext.Out.WriteLine("Encoded:");
TestContext.Out.WriteLine(encoded);
TestContext.Out.WriteLine("Formatted Encoded:");
_ = PrettifyAndValidateJson(encoded);
Assert.That(encoded, Is.EqualTo(expected));
}
finally
{
encodeables.ForEach(e => e.Dispose());
}
}
public void TestFieldValueEscapedArray(string fieldname, string foo, string expected)
{
TestContext.Out.WriteLine("Expected:");
_ = PrettifyAndValidateJson(expected);
using (var encodeable = new FooBarEncodeable(fieldname, foo))
{
var list = new List <IEncodeable>()
{
encodeable, encodeable
};
using (var encoder = new JsonEncoder(Context, true))
{
encoder.WriteEncodeableArray(encodeable.FieldName, list, typeof(FooBarEncodeable));
var encoded = encoder.CloseAndReturnText();
TestContext.Out.WriteLine("Encoded:");
TestContext.Out.WriteLine(encoded);
TestContext.Out.WriteLine("Formatted Encoded:");
_ = PrettifyAndValidateJson(encoded);
Assert.That(encoded, Is.EqualTo(expected));
}
}
}
private void RunWriteEncodeableArrayTest(string fieldName, List <FooBarEncodeable> encodeables, string expected, bool topLevelIsArray, bool noExpectedValidation = false)
{
try
{
if (!noExpectedValidation)
{
TestContext.Out.WriteLine("Expected:");
_ = PrettifyAndValidateJson(expected);
}
var encoder = new JsonEncoder(Context, true, null, topLevelIsArray);
encoder.WriteEncodeableArray(
fieldName,
encodeables.Cast <IEncodeable>().ToList(),
typeof(FooBarEncodeable));
var encoded = encoder.CloseAndReturnText();
TestContext.Out.WriteLine("Encoded:");
TestContext.Out.WriteLine(encoded);
TestContext.Out.WriteLine("Formatted Encoded:");
_ = PrettifyAndValidateJson(encoded);
Assert.That(encoded, Is.EqualTo(expected));
}
finally
{
encodeables.ForEach(e => e.Dispose());
}
}
/// <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();
}
}
}
public void Test_WriteSingleEncodeableWithName()
{
var expected = "{\"bar_1\":{\"Foo\":\"bar_1\"}}";
TestContext.Out.WriteLine("Expected:");
_ = PrettifyAndValidateJson(expected);
using (var encodeable = new FooBarEncodeable())
{
using (var encoder = new JsonEncoder(Context, true, false))
{
encoder.WriteEncodeable(encodeable.Foo, encodeable, typeof(FooBarEncodeable));
var encoded = encoder.CloseAndReturnText();
TestContext.Out.WriteLine("Encoded:");
TestContext.Out.WriteLine(encoded);
TestContext.Out.WriteLine("Formatted Encoded:");
_ = PrettifyAndValidateJson(encoded);
Assert.That(encoded, Is.EqualTo(expected));
}
}
}
public static void Encode <T>(TextWriter writer, T value)
{
var jsonEncoder = new JsonEncoder(writer);
var encoder = GetEncoder <T>();
encoder.EncodeTyped(ref jsonEncoder, value);
}
private void PrintValueAsJson(string name, DataValue value)
{
var jsonEncoder = new JsonEncoder(m_session.MessageContext, JsonReversible);
jsonEncoder.WriteDataValue(name, value);
var textbuffer = jsonEncoder.CloseAndReturnText();
// prettify
using (var stringWriter = new StringWriter())
{
try
{
using (var stringReader = new StringReader(textbuffer))
{
var jsonReader = new JsonTextReader(stringReader);
var jsonWriter = new JsonTextWriter(stringWriter)
{
Formatting = Formatting.Indented,
Culture = CultureInfo.InvariantCulture
};
jsonWriter.WriteToken(jsonReader);
Console.WriteLine(stringWriter.ToString());
}
}
catch (Exception ex)
{
Console.WriteLine("Failed to format the JSON output:", ex.Message);
Console.WriteLine(textbuffer);
Console.WriteLine(stringWriter.ToString());
ExitCode = ExitCode.ErrorJSONDecode;
throw;
}
}
}
/// <summary>
/// Encode DataSet message header
/// </summary>
private void EncodeDataSetMessageHeader(JsonEncoder encoder)
{
if ((DataSetMessageContentMask & JsonDataSetMessageContentMask.DataSetWriterId) != 0)
{
encoder.WriteString(nameof(DataSetWriterId), DataSetWriterId.ToString());
}
if ((DataSetMessageContentMask & JsonDataSetMessageContentMask.SequenceNumber) != 0)
{
encoder.WriteUInt32(nameof(SequenceNumber), SequenceNumber);
}
if ((DataSetMessageContentMask & JsonDataSetMessageContentMask.MetaDataVersion) != 0)
{
encoder.WriteEncodeable(nameof(MetaDataVersion), MetaDataVersion, typeof(ConfigurationVersionDataType));
}
if ((DataSetMessageContentMask & JsonDataSetMessageContentMask.Timestamp) != 0)
{
encoder.WriteDateTime(nameof(Timestamp), Timestamp);
}
if ((DataSetMessageContentMask & JsonDataSetMessageContentMask.Status) != 0)
{
encoder.WriteStatusCode(nameof(Status), Status);
}
}
/// <summary>
/// Encode ReplyTo
/// </summary>
private void EncodeReplyTo(JsonEncoder jsonEncoder)
{
if ((NetworkMessageContentMask & JsonNetworkMessageContentMask.ReplyTo) != 0)
{
jsonEncoder.WriteString("ReplyTo", ReplyTo);
}
}
/// <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);
}
}
public static ISagaConfigurator <TS, TD> UseRabbitMQTransport <TS, TD>(this ISagaConfigurator <TS, TD> sagaConfigurator,
RabbitConfiguration config)
where TS : Saga <TD>
where TD : SagaState
{
var sagaType = typeof(TS);
var messageHandlerType = typeof(IHandleMessage <>).GetGenericTypeDefinition();
var interfaces = sagaType.GetInterfaces();
foreach (var i in interfaces)
{
if (!i.IsGenericType)
{
continue;
}
var openGeneric = i.GetGenericTypeDefinition();
if (!openGeneric.IsAssignableFrom(messageHandlerType))
{
continue;
}
var messageType = i.GetGenericArguments().First();
sagaConfigurator.Services.AddSingleton(typeof(ISubscriber),
typeof(RabbitSubscriber <>).MakeGenericType(messageType));
}
if (!_initialized)
{
var encoder = new JsonEncoder();
sagaConfigurator.Services.AddSingleton <IEncoder>(encoder);
sagaConfigurator.Services.AddSingleton <IDecoder>(encoder);
sagaConfigurator.Services.AddSingleton <IQueueReferenceFactory, QueueReferenceFactory>();
sagaConfigurator.Services.AddSingleton <IMessageParser, MessageParser>();
sagaConfigurator.Services.AddSingleton <IPublisher, RabbitPublisher>();
sagaConfigurator.Services.AddSingleton <IPublisherChannelFactory, PublisherChannelFactory>();
sagaConfigurator.Services.AddSingleton <IConnectionFactory>(ctx =>
{
var connectionFactory = new ConnectionFactory()
{
HostName = config.HostName,
UserName = config.UserName,
Password = config.Password,
Port = AmqpTcpEndpoint.UseDefaultPort,
DispatchConsumersAsync = true
};
return(connectionFactory);
});
sagaConfigurator.Services.AddSingleton <IBusConnection, RabbitPersistentConnection>();
_initialized = true;
}
return(sagaConfigurator);
}
public void JsonEncoder_Constructor2()
{
using (var jsonEncoder = new JsonEncoder(m_context, false))
{
TestEncoding(jsonEncoder);
_ = jsonEncoder.CloseAndReturnText();
}
}
public void JsonEncoder_Constructor_Streamwriter_Reflection2()
{
using (var jsonEncoder = new JsonEncoder(m_context, false, false, m_memoryStream, true, StreamSize))
{
TestEncoding(jsonEncoder);
var result = jsonEncoder.CloseAndReturnText();
}
}
public void JsonEncoder_Constructor_Streamwriter2()
{
using (var jsonEncoder = new JsonEncoder(m_context, false, false, m_memoryStream, true, StreamSize))
{
TestEncoding(jsonEncoder);
int length = jsonEncoder.Close();
var result = Encoding.UTF8.GetString(m_memoryStream.ToArray());
}
}
public void Test_WriteSingleEncodeableWithNameAndArrayAsTopLevel_Expect_Exception()
{
using (var encodeable = new FooBarEncodeable())
{
var encoder = new JsonEncoder(Context, true, null, true);
Assert.Throws <ServiceResultException>(() => encoder.WriteEncodeable(encodeable.Foo, encodeable, typeof(FooBarEncodeable)));
}
}
public void JsonEncoder_Constructor_Recyclable_Streamwriter2()
{
using (var memoryStream = new Microsoft.IO.RecyclableMemoryStream(m_memoryManager))
using (var jsonEncoder = new JsonEncoder(m_context, false, false, memoryStream, false, StreamSize))
{
TestEncoding(jsonEncoder);
int length = jsonEncoder.Close();
var result = Encoding.UTF8.GetString(m_memoryStream.ToArray());
}
}
public void BeforeTest()
{
container = new CompositionContainer();
fileSystem = new MockFileSystem();
encoder = new JsonEncoder(fileSystem);
config = new JsonEncoderConfiguration();
input = new EncodeEventQueueImp();
input.Open();
}
async Task DiscoverUdp(IPAddress local, IPEndPoint ep)
{
XTrace.WriteLine("DiscoverUdp: {0} -> {1}", local, ep);
// 构建请求
var enc = new JsonEncoder();
var msg = enc.CreateRequest("Api/Info", null);
var req = msg.ToPacket().ReadBytes();
var udp = new UdpClient(ep.AddressFamily)
{
EnableBroadcast = true
};
if (local != null)
{
udp.Client.Bind(new IPEndPoint(local, Rand.Next(1000, 60000)));
}
// 发送
udp.Send(req, req.Length, ep);
// 多次接收
while (true)
{
try
{
var source = new CancellationTokenSource(3_000);
var rs = await udp.ReceiveAsync(source.Token);
if (rs.Buffer != null)
{
msg = new DefaultMessage();
msg.Read(rs.Buffer);
if (enc.Decode(msg, out var action, out var code, out var data) && code == 0)
{
// 解码结果
var result = enc.DecodeResult(action, data, msg);
XTrace.WriteLine("Receive[{0}] {1}", udp.Client.LocalEndPoint, result.ToJson());
var ai = enc.Convert(result, typeof(ApiItem)) as ApiItem;
if (ai != null)
{
Invoke(() => ShowItem(ai));
}
}
}
}
catch (OperationCanceledException)
{
break;
}
}
}
private void MonitoredItem_Notification(MonitoredItem monitoredItem, MonitoredItemNotificationEventArgs e)
{
try
{
MonitoredItemNotification notification = e.NotificationValue as MonitoredItemNotification;
if (notification == null)
{
return;
}
DataValue value = notification.Value as DataValue;
if (value == null)
{
return;
}
using (var encoder = new JsonEncoder(monitoredItem.Subscription.Session.MessageContext, false))
{
string applicationURI = monitoredItem.Subscription.Session.Endpoint.Server.ApplicationUri;
encoder.WriteString("ApplicationUri", applicationURI);
encoder.WriteString("DisplayName", monitoredItem.DisplayName);
encoder.WriteNodeId("MonitoredItem", monitoredItem.ResolvedNodeId);
// suppress output of server timestamp in json by setting it to minvalue
value.ServerTimestamp = DateTime.MinValue;
encoder.WriteDataValue("Value", value);
string json = encoder.CloseAndReturnText();
var properties = new Dictionary <string, string>();
properties.Add("content-type", "application/opcua+uajson");
properties.Add("deviceName", Id);
if (SharedAccessKey != null)
{
properties.Add("source", "mapping");
properties.Add("deviceKey", SharedAccessKey);
}
try
{
Module.Publish(new Message(json, properties));
}
catch (Exception ex)
{
Console.WriteLine("Opc.Ua.Client.SampleModule: Failed to publish message, dropping...");
Console.WriteLine(ex.ToString());
}
}
}
catch (Exception exception)
{
Console.WriteLine("Opc.Ua.Client.SampleModule: Error processing monitored item notification.");
Console.WriteLine(exception.ToString());
}
}
public override void EncodeTyped(ref JsonEncoder encoder, T?value)
{
if (value == null)
{
encoder.Write("null");
}
else
{
this.valueEncoder.EncodeTyped(ref encoder, value.GetValueOrDefault());
}
}
public override void EncodeTyped(ref JsonEncoder encoder, T value)
{
if (value == null)
{
encoder.Write("null");
}
else
{
this.valueEncoder.EncodeTyped(ref encoder, value);
}
}
public void AfterTest()
{
container.Dispose();
container = null;
fileSystem = null;
encoder = null;
config = null;
input = null;
}
/// <summary>
/// Serialize the specified object into a json string.
/// </summary>
/// <param name="obj">Object to convert to a json string.</param>
public static string Serialize(object obj)
{
string result = JsonEncoder.Encode(CurrentJsonSerializer, obj);
if (!string.IsNullOrEmpty(result) && (CurrentJsonSerializer.Options & EncodeOptions.PrettyPrint) == EncodeOptions.PrettyPrint)
{
return(JsonFormatter.PrettyPrint(result));
}
return(result);
}
private void MonitoredItem_Notification(MonitoredItem monitoredItem, MonitoredItemNotificationEventArgs e)
{
try
{
if (e.NotificationValue == null || monitoredItem.Subscription.Session == null)
{
return;
}
JsonEncoder encoder = new JsonEncoder(
monitoredItem.Subscription.Session.MessageContext, false);
encoder.WriteNodeId("MonitoredItem", monitoredItem.ResolvedNodeId);
e.NotificationValue.Encode(encoder);
var json = encoder.Close();
var bytes = new UTF8Encoding(false).GetBytes(json);
foreach (var publisher in m_publishers)
{
try
{
publisher.Publish(new ArraySegment<byte>(bytes));
}
catch(Exception ex)
{
Utils.Trace(ex, "Failed to publish message, dropping....");
}
}
}
catch (Exception exception)
{
Utils.Trace(exception, "Error processing monitored item notification.");
}
}
private void NotificationsCTRL_ItemsAdded(object sender, ListItemActionEventArgs e)
{
try
{
foreach (NotificationMessageListCtrl.ItemData item in e.Items)
{
if (item.NotificationMessage == null || item.Subscription.Session == null)
{
return;
}
JsonEncoder encoder = new JsonEncoder(
item.Subscription.Session.MessageContext, false);
foreach (MonitoredItem monitoredItem in item.Subscription.MonitoredItems)
{
encoder.WriteNodeId("MonitoredItem", monitoredItem.ResolvedNodeId);
item.NotificationMessage.Encode(encoder);
var json = encoder.Close();
try
{
m_massTransitPublisher.Publish(json);
Utils.Trace(null, "Publishing: " + json);
}
catch (Exception ex)
{
Utils.Trace(ex, "Failed to publish message, dropping....");
}
}
}
}
catch (Exception exception)
{
Utils.Trace(exception, "Error processing monitored item notification.");
}
}
private void NotificationsCTRL_ItemsAdded(object sender, ListItemActionEventArgs e)
{
try
{
foreach (NotificationMessageListCtrl.ItemData item in e.Items)
{
if (item.NotificationMessage == null || item.Subscription.Session == null)
{
return;
}
JsonEncoder encoder = new JsonEncoder(
item.Subscription.Session.MessageContext, false);
foreach (MonitoredItem monitoredItem in item.Subscription.MonitoredItems)
{
encoder.WriteNodeId("MonitoredItem", monitoredItem.ResolvedNodeId);
((DataChangeNotification)((NotificationData)item.NotificationMessage.NotificationData[0].Body)).MonitoredItems[0].Encode(encoder);
string json = encoder.Close();
json = json.Replace("\\", "");
byte[] bytes = new UTF8Encoding(false).GetBytes(json);
foreach (var publisher in m_publishers)
{
try
{
publisher.Publish(new ArraySegment<byte>(bytes));
Utils.Trace(null, "Publishing: " + json);
}
catch (Exception ex)
{
Utils.Trace(ex, "Failed to publish message, dropping....");
}
}
}
}
}
catch (Exception exception)
{
Utils.Trace(exception, "Error processing monitored item notification.");
}
}
