public void BuildBasicPropertiesByConfiguration()
{
const String contentType = "application/json";
const String contentEncoding = "UTF-8";
const String messageId = "one-id";
const Int64 timestamp = 123456789L;
var collection = new HeaderCollection(new Dictionary<String, Object>(StringComparer.OrdinalIgnoreCase)
{
{ "content_type", contentType },
{ "content_encoding", contentEncoding }
});
const String key = "foo";
const String value = "bar";
collection.AddHeader(key, value);
var resolver = new Mock<IMessageTypeResolver>();
resolver.Setup(_ => _.Resolve<Foo>()).Returns(EmptyMessageBinding.Instance);
var newId = new Mock<INewId>();
newId.Setup(_ => _.Next()).Returns(messageId);
var dateTimeProvider = new Mock<IDateTimeProvider>();
dateTimeProvider.Setup(_ => _.UtcNow()).Returns(timestamp.ToDateTimeOffset());
var message = new OutboundMessage<Foo>(new Foo(), collection);
var properties = message.BuildBasicProperties(resolver.Object, dateTimeProvider.Object, newId.Object);
Assert.Equal(messageId, properties.MessageId);
Assert.Equal(new AmqpTimestamp(timestamp), properties.Timestamp);
Assert.Equal(contentType, properties.ContentType);
Assert.Equal(contentEncoding, properties.ContentEncoding);
}
private static void Main()
{
const String routingKey = "routing_key";
const String endpointUrl = "amqp://*****:*****@localhost:5672/";
IMessageTypeResolver resolver = new MessageBindingResolver(typeof(Foo).Assembly);
var broker = Broker.New(_ =>
{
_.Endpoint(new Uri(endpointUrl, UriKind.Absolute));
_.ResolveMessageTypeBy(resolver);
});
var exchange = broker.DeclareDirectExchange("source_exchange");
var queue = broker.DeclareQueue("my_test_queue");
broker.DeclareExchangeBinding(exchange, queue, routingKey);
broker.SubscribeByAtLeastOnce(queue, _ => _.Consumes(new FooConsumer1()));
broker.SubscribeByAtLeastOnce(queue, _ => _.Consumes(new FooConsumer2()));
var connection = broker.Connect();
for (var i = 0; i < 5; i++)
{
var message = new OutboundMessage <Foo>(new Foo {
Bar = i
});
connection.PublishAsync(message, exchange, routingKey);
}
Console.ReadLine();
connection.Dispose();
}
protected void SendClientInfo()
{
var m = OutboundMessage.CreateReliable((byte)EngineMessage.InitialData, false, SequenceChannel.System);
short numVars = 0;
var allVars = Variable.GetEnumerable();
foreach (var v in allVars)
{
if (v.HasFlags(VariableFlags.Client))
{
numVars++;
}
}
m.Write(numVars);
foreach (var v in allVars)
{
if (v.HasFlags(VariableFlags.Client))
{
m.Write(v.Name);
m.Write(v.Value);
}
}
Send(m);
}
public OutboundQueueWorkerTests()
{
_queue = new InMemoryOutboundQueue();
var services = new ServiceCollection();
services
.AddSingleton <ILoggerFactory, NullLoggerFactory>()
.AddSingleton(typeof(ILogger <>), typeof(NullLogger <>))
.AddSingleton <IOutboundQueueConsumer, InMemoryOutboundQueue>()
.AddSilverback().WithConnectionTo <TestBroker>(options => options.AddDeferredOutboundConnector(_ => new InMemoryOutboundQueue()));
var serviceProvider = services.BuildServiceProvider(new ServiceProviderOptions {
ValidateScopes = true
});
serviceProvider.GetRequiredService <IOutboundRoutingConfiguration>()
.Add <IIntegrationMessage>(TestEndpoint.GetDefault());
_broker = (TestBroker)serviceProvider.GetRequiredService <IBroker>();
_broker.Connect();
_worker = new OutboundQueueWorker(serviceProvider, _broker, new NullLogger <OutboundQueueWorker>(), new MessageLogger(), true, 100); // TODO: Test order not enforced
InMemoryOutboundQueue.Clear();
_sampleOutboundMessage = new OutboundMessage <TestEventOne>(
new TestEventOne {
Content = "Test"
}, null, TestEndpoint.GetDefault());
_sampleOutboundMessage.RawContent =
new JsonMessageSerializer().Serialize(_sampleOutboundMessage.Content, _sampleOutboundMessage.Headers);
}
public Result Send(int bytesSent)
{
try
{
BytesToSend -= bytesSent;
TransmissionItterator += bytesSent;
// Still more to send.
if (BytesToSend > 0)
{
OutboundMessage
.Skip(TransmissionItterator)
.Take(Buffer.Length)
.ToArray()
.CopyTo(Buffer, 0);
Handler.BeginSend(Buffer, 0, Buffer.Length, SocketFlags.None, SocketMonitor.Send, this);
return(Result.Success);
}
Handler.Shutdown(SocketShutdown.Both);
Handler.Close();
// Data sent.
return(Result.Success);
}
catch (Exception e)
{
Handler.Shutdown(SocketShutdown.Both);
Handler.Close();
return(Result.Error(e));
}
}
public void BuildBasicProperties()
{
const String contentType = "application/xml";
const String contentEncoding = "UTF-16";
const String messageId = "one-id";
const Int64 timestamp = 123456789L;
var collection = new HeaderCollection(new Dictionary <String, Object>(StringComparer.OrdinalIgnoreCase)
{
{ "message_id", messageId },
{ "timestamp", timestamp },
{ "content_type", contentType },
{ "content_encoding", contentEncoding }
});
const String key = "foo";
const String value = "bar";
collection.AddHeader(key, value);
var resolver = new Mock <IMessageTypeResolver>();
resolver.Setup(_ => _.Resolve <Foo>()).Returns(EmptyMessageBinding.Instance);
var message = new OutboundMessage <Foo>(new Foo(), collection);
var properties = message.BuildBasicProperties(resolver.Object, null, null);
Assert.Equal(messageId, properties.MessageId);
Assert.Equal(new AmqpTimestamp(timestamp), properties.Timestamp);
Assert.Equal(contentType, properties.ContentType);
Assert.Equal(contentEncoding, properties.ContentEncoding);
Assert.Equal(value, collection[key]);
}
public void OBOAuth()
{
SymConfig symConfig = new SymConfig();
SymConfigLoader symConfigLoader = new SymConfigLoader();
symConfig = symConfigLoader.loadFromFile("C:/Users/Michael/Documents/Visual Studio 2017/Projects/apiClientDotNet/apiClientDotNetTest/Resources/testConfig3.json");
SymOBOAuth oboAuth = new SymOBOAuth(symConfig);
oboAuth.sessionAppAuthenticate();
SymOBOUserAuth auth = oboAuth.getUserAuth("*****@*****.**");
// auth.setSessionToken("eyJhbGciOiJSUzUxMiJ9.eyJzdWIiOiJzdGlzaGxlciIsImlzcyI6InN5bXBob255IiwiYXBwUGVybWlzc2lvbnMiOlsiQUNUX0FTX1VTRVIiLCJHRVRfQkFTSUNfQ09OVEFDVF9JTkZPIiwiR0VUX1BSRVNFTkNFIiwiTElTVF9VU0VSX1NUUkVBTVMiLCJNQU5BR0VfUk9PTVMiLCJTRU5EX01FU1NBR0VTIl0sImFwcEdyb3VwSWQiOiJhZG55LXcxNDYiLCJzZXNzaW9uSWQiOiJiNGI3N2NjMWUyYzg4ODAxMWNmNWI3MWI5YmQwYTZhNjJlNDI0MTMzMzJlMGRkNDk1NWQzYzk3ZjViNjE4MWMyNWE2MTVmYThkMjNmNjM2YmNmNDJiNTMxOGI4ZDlkNDgwMDAwMDE2NjhjZTIyOGNjMDAwMDUyYjAwMDAwMDAxOSIsInVzZXJJZCI6IjkwOTE1ODY3NzIxNzUzIn0.hSsZOBEH-OlUzOjDl_NhoxVTrlbJSEaxnmV0s5VQO92VgYaTBc0eUbcHaCYzmRtafil8dy_4_pOSMSR9VupDayklL9igT2cRHZGKvryR4_2hNDym3Xs-uYCxC83O1l9CTm2ISrSVgVabzVOznN23sZLQ6IoIj2EORS6B8eemGlGTWjZge1iav464kFosQ5glSDSecY4mTcbh4sYE3mwINlCEML5VqpEbc0Pdu1ZOesLMBHsa3KzlGuIUEjtigP4NZeYPc31G-rzxSKHWeMo3Mqwwk_0dSL6voQgw-29fly0uIGTF7wCSngk3g9n4Lv_0m4Yh5xDcyQ0h4RRxny-Sgg");
// symConfig.agentHost = "alphadyne.symphony.com";
SymOBOClient client = SymOBOClient.initOBOClient(symConfig, auth);
OutboundMessage message = new OutboundMessage();
message.message = "<messageML>Hello it is mike fron NET 2</messageML>";
apiClientDotNet.Models.Stream stream = new apiClientDotNet.Models.Stream();
stream.streamId = "IzgD3nNbpoaNJ6_To7Ds0n___pmCBYMrdA";
//stream.streamId = "AQpEsS9DJM1ZRrGF7Kb7i3___pui0wKcdA";
MessageClient messageClient = new MessageClient(client);
InboundMessage resp = messageClient.sendMessage(stream.streamId, message, false);
Assert.IsTrue(resp.message != null);
}
private void VerifyMessageHeaderIsPassed(Action <IOutboundMessage> setHeaderAction, Action <IInboundMessageHeaders> checkHeaderAction)
{
byte[] data;
var serializer = new XmlMessageSerializer();
OutboundMessage.Set(setHeaderAction);
var message = new PingMessage();
using (MemoryStream output = new MemoryStream())
{
serializer.Serialize(output, message);
data = output.ToArray();
}
Trace.WriteLine(OutboundMessage.Headers.MessageType);
Trace.WriteLine(Encoding.UTF8.GetString(data));
using (MemoryStream input = new MemoryStream(data))
{
serializer.Deserialize(input);
checkHeaderAction(CurrentMessage.Headers);
}
}
public void BuildBasicProperties()
{
const String contentType = "application/xml";
const String contentEncoding = "UTF-16";
const String messageId = "one-id";
const Int64 timestamp = 123456789L;
const String replyExchangeName = "reply-queue-name";
const String replyRoutingKey = "reply-queue-name";
String correlationId = Guid.NewGuid().ToString();
var directReplyConfiguration = new DirectReplyConfiguration(replyExchangeName, replyRoutingKey);
var collection = new HeaderCollection(new Dictionary<String, Object>(StringComparer.OrdinalIgnoreCase)
{
{ "message_id", messageId },
{ "timestamp", timestamp },
{ "content_type", contentType },
{ "content_encoding", contentEncoding },
{ "correlation_id", correlationId },
{ "reply_configuration", directReplyConfiguration }
});
const String key = "foo";
const String value = "bar";
collection.AddHeader(key, value);
var resolver = new Mock<IMessageTypeResolver>();
resolver.Setup(_ => _.Resolve<Foo>()).Returns(EmptyMessageBinding.Instance);
var message = new OutboundMessage<Foo>(new Foo(), collection);
var properties = message.BuildBasicProperties(resolver.Object, null, null);
Assert.Equal(messageId, properties.MessageId);
Assert.Equal(new AmqpTimestamp(timestamp), properties.Timestamp);
Assert.Equal(contentType, properties.ContentType);
Assert.Equal(contentEncoding, properties.ContentEncoding);
Assert.Equal(correlationId, properties.CorrelationId);
Assert.Equal(directReplyConfiguration.ToString(), properties.ReplyTo);
Assert.Equal(value, collection[key]);
}
public void OBOLogoutTest()
{
SymConfig symConfig = new SymConfig();
SymConfigLoader symConfigLoader = new SymConfigLoader();
symConfig = symConfigLoader.loadFromFile("C:/Users/Michael/Documents/Visual Studio 2017/Projects/apiClientDotNet/apiClientDotNetTest/Resources/testConfig3.json");
SymOBOAuth oboAuth = new SymOBOAuth(symConfig);
oboAuth.sessionAppAuthenticate();
SymOBOUserAuth auth = oboAuth.getUserAuth("*****@*****.**");
SymOBOClient client = SymOBOClient.initOBOClient(symConfig, auth);
OutboundMessage message = new OutboundMessage();
message.message = "<messageML>Hello Alexa</messageML>";
apiClientDotNet.Models.Stream stream = new apiClientDotNet.Models.Stream();
stream.streamId = "IzgD3nNbpoaNJ6_To7Ds0n___pmCBYMrdA";
MessageClient messageClient = new MessageClient(client);
InboundMessage resp = messageClient.sendMessage(stream.streamId, message, false);
auth.logout();
//Assert.IsTrue(resp.message != null);
}
public async Task OnMessageReceived_SingleMessage_Queued()
{
var outboundMessage = new OutboundMessage <TestEventOne>()
{
Message = new TestEventOne {
Content = "Test"
},
Headers =
{
{ "header1", "value1" },
{ "header2", "value2" }
},
Endpoint = TestEndpoint.Default
};
await _connector.RelayMessage(outboundMessage);
await _queue.Commit();
_queue.Length.Should().Be(1);
var queued = (await _queue.Dequeue(1)).First();
queued.Message.Endpoint.Should().Be(outboundMessage.Endpoint);
queued.Message.Headers.Count.Should().Be(2);
((IIntegrationMessage)queued.Message.Message).Id.Should().Be(outboundMessage.Message.Id);
}
public override Task ConsumeAsync(ConsumedMessage <Request> message)
{
return(Task.Factory
.StartNew(() =>
{
Console.WriteLine("[{0}]received '{1}' by '{2}' with correlation id {3}",
message.ConsumerTag,
message.Headers.MessageId,
GetType().Name,
message.Headers.CorrelationId);
var exchange = _broker.DeclareDirectExchange(message.Headers
.ReplyConfiguration
.ExchangeName);
var queue = _broker.DeclareQueue(message.Headers
.ReplyConfiguration
.RoutingKey);
_broker.DeclareExchangeBinding(exchange,
queue,
message.Headers.ReplyConfiguration.RoutingKey);
var outboundMessage = new OutboundMessage <Response>(new Response
{
BarBar = message.Content.Bar * 2
});
outboundMessage.SetCorrelationId(message.Headers.CorrelationId);
_connection.PublishAsync(outboundMessage,
exchange,
message.Headers.ReplyConfiguration.RoutingKey);
}));
}
public void Handle_MultipleKeyMembersMessages_KeyHeaderIsSet()
{
var message1 = new OutboundMessage <MultipleKeyMembersMessage>(
new MultipleKeyMembersMessage
{
Id = Guid.NewGuid(),
One = "1",
Two = "2",
Three = "3"
},
null,
new KafkaProducerEndpoint("test-endpoint"));
var message2 = new OutboundMessage <MultipleKeyMembersMessage>(
new MultipleKeyMembersMessage
{
Id = Guid.NewGuid(),
One = "a",
Two = "b",
Three = "c"
},
null,
new KafkaProducerEndpoint("test-endpoint"));
new KafkaPartitioningKeyBehavior().Handle(new[] { message1, message2 }, Task.FromResult);
message1.Headers.Should().ContainEquivalentOf(
new MessageHeader("x-kafka-partitioning-key", "One=1,Two=2"));
message2.Headers.Should().ContainEquivalentOf(
new MessageHeader("x-kafka-partitioning-key", "One=a,Two=b"));
}
public Task <IPublishResult> PublishAsync <TMessage>(OutboundMessage <TMessage> message,
Exchange exchange,
String routingKey = "")
where TMessage : class
{
return(_outboundChannel.PublishAsync(message, exchange, routingKey));
}
public async Task _newMessageFromClient(IncomingMessage inMessage)
{
User sender = usersOnline.FirstOrDefault(u => u.connectionId == inMessage.connectionId);
User receiver = usersOnline.FirstOrDefault(u => u.userid == inMessage.receiverId);
OutboundMessage outMessage = new OutboundMessage();
if (inMessage.instruction == 0)
{
outMessage.msgId = sender.nickName + DateTime.Now.ToString("yyyyMMddHHmmss");
outMessage.senderId = sender.userid;
outMessage.time = DateTime.Now.ToString("hh:mm");
outMessage.senderNickName = sender.nickName;
outMessage.senderNickColor = sender.nickColor;
outMessage.receiverId = receiver.userid;
outMessage.receiverNickName = receiver.nickName;
outMessage.receiverNickColor = receiver.nickColor;
outMessage.prvMsg = inMessage.prvMsg;
outMessage.msgColor = sender.msgColor;
outMessage.message = inMessage.message;
if (!outMessage.prvMsg)
{
if (lastOutboundMessages.Count < MAXLASTOUTMSG)
{
lastOutboundMessages.Add(outMessage);
}
else
{
for (int i = 0; i < MAXLASTOUTMSG - 1; i++)
{
lastOutboundMessages[i] = lastOutboundMessages[i + 1];
}
lastOutboundMessages[MAXLASTOUTMSG - 1] = outMessage;
}
}
if (outMessage.prvMsg)
{
//Clients.Caller.addMessage(outMessage);
await Clients.Caller.SendAsync("addMessage", outMessage);
if (sender.connectionId != receiver.connectionId)
{
//Clients.Client(Receiver.ConnectionId).addMessage(outMessage);
await Clients.Client(receiver.connectionId).SendAsync("addMessage", outMessage);
}
}
else
{
//Clients.All.broadcastMessage(outMessage);
await Clients.All.SendAsync("broadcastMessageReceived", outMessage);
}
}
return;
}
public void BuildBasicPropertiesByConfiguration()
{
const String contentType = "application/json";
const String contentEncoding = "UTF-8";
const String messageId = "one-id";
const Int64 timestamp = 123456789L;
var collection = new HeaderCollection(new Dictionary <String, Object>(StringComparer.OrdinalIgnoreCase)
{
{ "content_type", contentType },
{ "content_encoding", contentEncoding }
});
const String key = "foo";
const String value = "bar";
collection.AddHeader(key, value);
var resolver = new Mock <IMessageTypeResolver>();
resolver.Setup(_ => _.Resolve <Foo>()).Returns(EmptyMessageBinding.Instance);
var newId = new Mock <INewId>();
newId.Setup(_ => _.Next()).Returns(messageId);
var dateTimeProvider = new Mock <IDateTimeProvider>();
dateTimeProvider.Setup(_ => _.UtcNow()).Returns(timestamp.ToDateTimeOffset());
var message = new OutboundMessage <Foo>(new Foo(), collection);
var properties = message.BuildBasicProperties(resolver.Object, dateTimeProvider.Object, newId.Object);
Assert.Equal(messageId, properties.MessageId);
Assert.Equal(new AmqpTimestamp(timestamp), properties.Timestamp);
Assert.Equal(contentType, properties.ContentType);
Assert.Equal(contentEncoding, properties.ContentEncoding);
}
public void onIMMessage(Message message)
{
OutboundMessage outMessage = new OutboundMessage();
outMessage.message = "Hello " + message.user.displayName + "!";
this.symBotClient.getMessagesClient().sendMessage(message.stream.streamId, outMessage, true);
}
public async Task OnMessageReceived_SingleMessage_Queued()
{
var outboundMessage = new OutboundMessage <TestEventOne>(
new TestEventOne {
Content = "Test"
},
new[]
{
new MessageHeader("header1", "value1"),
new MessageHeader("header2", "value2")
},
TestEndpoint.GetDefault());
outboundMessage.RawContent = new JsonMessageSerializer().Serialize(outboundMessage.Content, outboundMessage.Headers);
await _connector.RelayMessage(outboundMessage);
await _queue.Commit();
(await _queue.GetLength()).Should().Be(1);
var queued = (await _queue.Dequeue(1)).First();
queued.Endpoint.Should().Be(outboundMessage.Endpoint);
queued.Headers.Count().Should().Be(3);
queued.Content.Should().BeEquivalentTo(new JsonMessageSerializer().Serialize(outboundMessage.Content, outboundMessage.Headers));
}
public override Task <IPublishResult> PublishAsync <TMessage>(OutboundMessage <TMessage> source,
Exchange exchange,
String routingKey)
{
var properties = BuildBasicProperties(source);
var body = BuildBody(source, properties);
var tcs = new TaskCompletionSource <Boolean>(properties);
var tag = Model.NextPublishSeqNo;
_confirms.TryAdd(tag, new Tuple <TaskCompletionSource <Boolean>, IMessage>(tcs, source));
try
{
Model.BasicPublish(exchange.Name,
routingKey,
false,
properties,
body);
}
catch (Exception exception)
{
Tuple <TaskCompletionSource <Boolean>, IMessage> tuple;
_confirms.TryRemove(tag, out tuple);
tcs.TrySetException(exception);
}
return(tcs.Task.ContinueWith(Result));
}
protected IBasicProperties BuildBasicProperties <TMessage>(OutboundMessage <TMessage> source)
where TMessage : class
{
return(source.BuildBasicProperties(Configuration.MessageTypeResolver,
DateTimeProvider,
Configuration.IdGenerator));
}
public static void Publish <T>(this IServiceBus bus, T message, Action <IOutboundMessage> messageHeaderAction)
where T : class
{
OutboundMessage.Set(messageHeaderAction);
bus.Publish(message);
}
public static void Send <T>(this IEndpoint endpoint, T message, Action <IOutboundMessage> messageHeaderAction)
where T : class
{
OutboundMessage.Set(messageHeaderAction);
endpoint.Send(message);
}
/// <summary>
/// Shows message status notification.
/// </summary>
public static void ShowNotification(OutboundMessage message, MessageDeliveryStatus status)
{
Argument.ExpectNotNull(() => message);
string notificationHeader;
if (message is SmsMessage)
{
notificationHeader = ResourcesHelper.GetString("SMS");
}
else if (message is MmsMessage)
{
notificationHeader = ResourcesHelper.GetString("MMS");
}
else
{
throw new NotSupportedException(String.Format(CultureInfo.InvariantCulture, "Message type {0} is not supported", message.GetType().Name));
}
XmlDocument toastXml = ToastNotificationManager.GetTemplateContent(ToastTemplateType.ToastText01);
XmlNodeList textElements = toastXml.GetElementsByTagName("text");
var builder = new StringBuilder();
builder.Append(notificationHeader);
builder.Append(" ");
builder.Append(ResourcesHelper.GetString("MessageSentTo"));
builder.Append(" ");
string phones = String.Join(", ", message.PhoneNumbers.Select(n => n.Number));
builder.Append(phones);
builder.Append(" ");
switch (status)
{
case MessageDeliveryStatus.DeliveredToNetwork:
builder.Append(ResourcesHelper.GetString("SuccessfullySent"));
break;
case MessageDeliveryStatus.DeliveredToTerminal:
builder.Append(ResourcesHelper.GetString("SuccessfullyDelivered"));
break;
case MessageDeliveryStatus.DeliveryImpossible:
builder.Append(ResourcesHelper.GetString("NotDelivered"));
break;
case MessageDeliveryStatus.Error:
builder.Append(ResourcesHelper.GetString("Error"));
break;
}
textElements[0].InnerText = builder.ToString();
var toast = new ToastNotification(toastXml);
ToastNotificationManager.CreateToastNotifier().Show(toast);
}
public void MessageRoomTest()
{
SymConfig symConfig = new SymConfig();
SymConfigLoader symConfigLoader = new SymConfigLoader();
symConfig = symConfigLoader.loadFromFile("C:/Users/Michael/Documents/Visual Studio 2017/Projects/apiClientDotNet/apiClientDotNetTest/Resources/testConfig.json");
SymBotAuth botAuth = new SymBotAuth(symConfig);
botAuth.authenticate();
SymBotClient botClient = SymBotClient.initBot(symConfig, botAuth);
OutboundMessage message = new OutboundMessage();
message.message = "<messageML>Hello world!</messageML>";
FileStream fileStream = File.OpenRead("C:/Users/Michael/Documents/Visual Studio 2017/Projects/apiClientDotNet/apiClientDotNetTest/Resources/AttachmentTest.txt");
List <FileStream> attachments = new List <FileStream>();
attachments.Add(fileStream);
message.attachments = attachments;
apiClientDotNet.Models.Stream stream = new apiClientDotNet.Models.Stream();
stream.streamId = "fu1cJFoklnYlR9vu1AOZ5X___pzXDKPXdA";
MessageClient messageClient = new MessageClient(botClient);
InboundMessage resp = messageClient.sendMessage(stream.streamId, message, false);
Assert.IsTrue(resp.messageId != null);
}
public void The_xml_message_serializer_should_rock_the_house()
{
byte[] serializedMessageData;
var serializer = new XmlMessageSerializer();
OutboundMessage.Set(x =>
{
x.SetSourceAddress("msmq://localhost/queue_name");
x.SetDestinationAddress("msmq://remotehost/queue_name");
x.SetResponseAddress("msmq://localhost/response_queue");
x.SetFaultAddress("msmq://localhost/fault_queue");
x.SetRetryCount(7);
});
using (MemoryStream output = new MemoryStream())
{
serializer.Serialize(output, _message);
serializedMessageData = output.ToArray();
Trace.WriteLine(Encoding.UTF8.GetString(serializedMessageData));
}
using (MemoryStream input = new MemoryStream(serializedMessageData))
{
SerializationTestMessage receivedMessage = serializer.Deserialize(input) as SerializationTestMessage;
Assert.AreEqual(_message, receivedMessage);
}
}
private static void Main()
{
const String routingKey = "routing_key";
const String endpointUrl = "amqp://*****:*****@localhost:5672/";
IMessageTypeResolver resolver = new MessageBindingResolver(typeof(Foo).Assembly);
var broker = Broker.New(_ =>
{
_.Endpoint(new Uri(endpointUrl, UriKind.Absolute));
_.ResolveMessageTypeBy(resolver);
});
var exchange = broker.DeclareDirectExchange("source_exchange");
var queue = broker.DeclareQueue("my_test_queue");
broker.DeclareExchangeBinding(exchange, queue, routingKey);
broker.SubscribeByAtLeastOnce(queue, _ => _.Consumes(new FooConsumer1()));
broker.SubscribeByAtLeastOnce(queue, _ => _.Consumes(new FooConsumer2()));
var connection = broker.Connect();
for (var i = 0; i < 5; i++)
{
var message = new OutboundMessage<Foo>(new Foo { Bar = i });
connection.PublishAsync(message, exchange, routingKey);
}
Console.ReadLine();
connection.Dispose();
}
private void SendMessageAsync()
{
var task = new Task(() =>
{
var symConfigLoader = new SymConfigLoader();
var configPathTwo = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Resources", "testConfigPsdevTwo.json");
var symConfigTwo = symConfigLoader.loadFromFile(configPathTwo);
var botAuthTwo = new SymBotRSAAuth(symConfigTwo);
botAuthTwo.authenticate();
var botClientTwo = SymBotClient.initBot(symConfigTwo, botAuthTwo);
// Find one BOT stream id
var streamClient = botClientTwo.getStreamsClient();
var streamTypes = new List <string>
{
"ROOM"
};
var result = streamClient.getUserStreams(streamTypes, false);
// Send to that stream a messages
var message = new OutboundMessage
{
message = "<messageML>Hello world! From .NET SDK Integration Test.</messageML>"
};
var stream = new apiClientDotNet.Models.Stream
{
streamId = result[0].id
};
var messageClient = new MessageClient(botClientTwo);
messageClient.sendMessage(stream.streamId, message, false);
}, TaskCreationOptions.AttachedToParent);
task.Start();
}
public ActionResult DeleteConfirmed(int id)
{
OutboundMessage outboundMessage = db.OutboundMessages.Find(id);
db.OutboundMessages.Remove(outboundMessage);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public void ReThrows_Exception_Given_Unhandled_Exception_Is_Thrown_When_Sending_OutboundMessage()
{
_mockSender.Setup(s => s.SendAsync(It.IsAny <Message>())).ThrowsAsync(new DivideByZeroException());
Func <Task> sendAction = async() => await _outboundGateway.SendAsync(OutboundMessage <MyEvent> .FromEntity(MyEvent.Default)).ConfigureAwait(false);
sendAction.Should().Throw <DivideByZeroException>();
}
public static void SendToAll(OutboundMessage m)
{
GameServer.Instance.Networking.SendToAll(m);
if (LocalClient != null)
{
LocalClient.Send(m);
}
}
public async Task SendAsync <TMessage>(OutboundMessage <TMessage> outboundMessage) where TMessage : class
{
var message = GenerateMessage(outboundMessage);
var sw = Stopwatch.StartNew();
await _sender.SendAsync(message).ConfigureAwait(false);
TrackDependency(sw, nameof(SendAsync), outboundMessage.UserProperties);
_logger.LogDebug(LogEventIds.OutboundGatewaySentSingle, $"Sent single message of {nameof(OutboundMessage<TMessage>)} type {typeof(TMessage).Name}");
}
public void NonDurableMessage()
{
var message = new OutboundMessage <Bar>(new Bar());
var properties = message.BuildBasicProperties(StubResolver <Bar>(null).Object,
StubDateTimeProvider().Object,
new Mock <INewId>().Object);
Assert.False(properties.Persistent);
}
public void DefaultContentType()
{
var message = new OutboundMessage <Bar>(new Bar());
var properties = message.BuildBasicProperties(StubResolver <Bar>(null).Object,
StubDateTimeProvider().Object,
new Mock <INewId>().Object);
Assert.Equal("application/json", properties.ContentType);
}
public void set(string gateway_name,int port,byte[] b_ip,string s_ip)
{
srv = Service.getInstance();
com1 = new Comm2IP.Comm2IP(b_ip, port, modem.AttachedTo , 115200); //modem comport
try
{
new Thread(new ThreadStart(com1.Run)).Start();
IPModemGateway gateway = new IPModemGateway(gateway_name, s_ip, port, "Huawei", "");
gateway.setIpProtocol(ModemGateway.IPProtocols.BINARY);
gateway.setProtocol(AGateway.Protocols.PDU);
gateway.setInbound(true);
gateway.setOutbound(true);
gateway.setSimPin("0000");
srv.addGateway(gateway);
// Start! (i.e. connect to all defined Gateways)
srv.startService();
// Send more than one message at once.
OutboundMessage[] msgArray = new OutboundMessage[contact_list.Count];
int count = 0;
foreach (int number in contact_list)
{
msgArray[count++] = new OutboundMessage(number.ToString(), sms.Content);
}
srv.sendMessages(msgArray);
//Console.WriteLine(msgArray[0]);
//Console.WriteLine(msgArray[1]);
}
catch (Exception e)
{
Console.WriteLine(e.Message);
Console.WriteLine(e.StackTrace);
Console.Read();
}
finally
{
com1.Stop();
srv.stopService();
}
}
static void Main(string[] args)
{
// Create new Service object - the parent of all and the main interface to you.
Service srv;
srv = Service.getInstance();
// *** The tricky part ***
// *** Comm2IP Driver ***
// Create (and start!) as many Comm2IP threads as the modems you are using.
// Be careful about the mappings - use the same mapping in the Gateway definition.
Comm2IP.Comm2IP com1 = new Comm2IP.Comm2IP(new byte[] { 127, 0, 0, 1 }, 12000, "com4", 115200);
try
{
Console.WriteLine("Example: Read messages from a serial gsm modem.");
Console.WriteLine(Library.getLibraryDescription());
Console.WriteLine("Version: " + Library.getLibraryVersion());
// Start the COM listening thread.
new Thread(new ThreadStart(com1.Run)).Start();
// Lets set some callbacks.
srv.setInboundMessageNotification(new InboundNotification());
srv.setCallNotification(new CallNotification());
srv.setGatewayStatusNotification(new GatewayStatusNotification());
// Create the Gateway representing the serial GSM modem.
// Due to the Comm2IP bridge, in SMSLib for .NET all modems are considered IP modems.
IPModemGateway gateway = new IPModemGateway("modem.com4", "127.0.0.1", 12000, "Huawei", "E220");
gateway.setIpProtocol(ModemGateway.IPProtocols.BINARY);
// Set the modem protocol to PDU (alternative is TEXT). PDU is the default, anyway...
gateway.setProtocol(AGateway.Protocols.PDU);
// Do we want the Gateway to be used for Inbound messages?
gateway.setInbound(true);
// Do we want the Gateway to be used for Outbound messages?
gateway.setOutbound(true);
// Let SMSLib know which is the SIM PIN.
gateway.setSimPin("0000");
// Explicit SMSC address set is required for some modems.
// Below is for VODAFONE GREECE - be sure to set your own!
gateway.setSmscNumber("+306942190000");
// Add the Gateway to the Service object.
srv.addGateway(gateway);
// Similarly, you may define as many Gateway objects, representing
// various GSM modems, add them in the Service object and control all of them.
// Start! (i.e. connect to all defined Gateways)
srv.startService();
// Printout some general information about the modem.
Console.WriteLine();
Console.WriteLine("Modem Information:");
Console.WriteLine(" Manufacturer: " + gateway.getManufacturer());
Console.WriteLine(" Model: " + gateway.getModel());
Console.WriteLine(" Serial No: " + gateway.getSerialNo());
Console.WriteLine(" SIM IMSI: " + gateway.getImsi());
Console.WriteLine(" Signal Level: " + gateway.getSignalLevel() + "dBm");
Console.WriteLine(" Battery Level: " + gateway.getBatteryLevel() + "%");
Console.WriteLine();
// Send one message.
// Remember to change the recipient!
OutboundMessage msg = new OutboundMessage("+3069...", "Hello from SMSLib for .NET");
srv.sendMessage(msg);
Console.WriteLine(msg);
// Send more than one message at once.
//OutboundMessage[] msgArray = new OutboundMessage[2];
//msgArray[0] = new OutboundMessage("+306948494037", "Hello from SMSLib for .NET (#1)");
//msgArray[1] = new OutboundMessage("+306948494037", "Hello from SMSLib for .NET (#2)");
//srv.sendMessages(msgArray);
//Console.WriteLine(msgArray[0]);
//Console.WriteLine(msgArray[1]);
Console.WriteLine("Press <ENTER> to terminate...");
Console.In.ReadLine();
}
catch (Exception e)
{
Console.WriteLine(e.Message);
Console.WriteLine(e.StackTrace);
}
finally
{
com1.Stop();
srv.stopService();
}
}
public void sendMessage(String message, String number)
{
OutboundMessage msg = new OutboundMessage(number, message);
srv.sendMessage(msg);
}
public void checkThreats(string desease,string location, InboundMessage msg)
{
if(desease.ToLower().Contains("dengue"))
{
url = "http://localhost/devfest/geocode.php?disease=" + desease + "&location="+location;
WebRequest request = HttpWebRequest.Create(url);
WebResponse response = request.GetResponse();
StreamReader reader = new StreamReader(response.GetResponseStream());
string urlText = reader.ReadToEnd();
if(urlText.Equals("alert")){
//Here the Alerts will be sent. For test case I am sending alert to my team member
OutboundMessage msg1 = new OutboundMessage("+923025474347", "Dengue Alert!!!\n Dengue is Spreading near "+location);
srv.sendMessage(msg1);
Console.WriteLine("Dengue Alert!!!\n Dengue is Spreading near " + location);
}
}
}
public void postData(AGateway gateway, InboundMessage msg, String[] mssg)
{
if(mssg.Length == 7)
{
//means complete message with login key
url = "http://localhost/devfest/geocode.php?key=" + mssg[1] + "&name=" + mssg[2] + "&cnic=" + mssg[3]
+ "&location=" + mssg[4].Trim() + "&disease=" + mssg[5] + "&contact=" + mssg[6];
a = false;
}
else if(mssg.Length == 2)
{
//just to identify that key is correct. not used yet
}
else if(mssg.Length == 5)
{
url = "http://localhost/devfest/geocodee.php?name=" + mssg[1] + "&cnic=" + mssg[2]
+ "&location=" + mssg[3].Trim() + "&disease=" + mssg[4] + "&contact=" + msg.getOriginator();
a = true;
//means complete message without login key
}
WebRequest request = HttpWebRequest.Create(url);
WebResponse response = request.GetResponse();
StreamReader reader = new StreamReader(response.GetResponseStream());
string urlText = reader.ReadToEnd();
Console.WriteLine(urlText);
try
{
// Uncomment following line if you wish to delete the message upon arrival.
gateway.deleteMessage(msg);
}
catch(Exception e)
{
Console.WriteLine("Oops!!! Something gone bad...");
Console.WriteLine(e.Message);
Console.WriteLine(e.StackTrace);
}
OutboundMessage msg1 = new OutboundMessage("+"+msg.getOriginator(), urlText);
srv.sendMessage(msg1);
if(a)
{
checkThreats(mssg[4],mssg[3].Trim(),msg);
}
else
{
checkThreats(mssg[5],mssg[4].Trim(),msg);
}
}
