public ChatMessageReceived(string roomId, Guid senderId, TextMessageData message)
{
SenderId = senderId;
Message = message;
RoomId = roomId;
Timestamp = DateTime.UtcNow;
}
void ToolStripItem_Click(object sender, EventArgs e)
{
if (sender == null || !(sender is ToolStripItem))
{
return;
}
ToolStripItem item = sender as ToolStripItem;
if (item == null)
{
return;
}
if (item.Tag == null || !(item.Tag is TextMessageData))
{
if (item.OwnerItem != null && item.OwnerItem is ToolStripMenuItem)
{
ToolStripMenuItem owner = item.OwnerItem as ToolStripMenuItem;
owner.DropDownItems.Remove(item);
if (owner.DropDownItems.Count == 0)
{
if (owner.Owner != null)
{
ToolStrip toolStrip = owner.Owner;
toolStrip.Items.Remove(owner);
}
}
}
return;
}
TextMessageData textMessageData = item.Tag as TextMessageData;
if (textMessageData == null)
{
return;
}
UserInfo userInfo = SocketCommService.GetUserInfo(textMessageData.IPAddress);
if (userInfo == null)
{
return;
}
//MessageBox.Show(textMessageData.Text, string.Format("Received From {0} at {1}", userInfo.UserName, textMessageData.ReceiptTime));
ReceivedMessageForm receivedMEssageForm = new ReceivedMessageForm(textMessageData, userInfo);
receivedMEssageForm.Show();
if (item.OwnerItem != null && item.OwnerItem is ToolStripMenuItem)
{
ToolStripMenuItem owner = item.OwnerItem as ToolStripMenuItem;
owner.DropDownItems.Remove(item);
if (owner.DropDownItems.Count == 0)
{
if (owner.Owner != null)
{
ToolStrip toolStrip = owner.Owner;
toolStrip.Items.Remove(owner);
}
}
}
}
public async Task FlushAsync()
{
MeasurementData measurements;
TextMessageData messages;
this.m_measurementLock.Lock();
this.m_messageLock.Lock();
try {
measurements = this.m_triggerMeasurements;
messages = this.m_triggerMessages;
this.m_gaugeTriggerSerivce.Set(0D);
this.m_triggerMeasurements = new MeasurementData();
this.m_triggerMessages = new TextMessageData();
} finally {
this.m_messageLock.Unlock();
this.m_measurementLock.Unlock();
}
await Task.WhenAll(
this.PublishData(this.m_messageTriggerTopic, messages),
this.PublishData(this.m_measurementTriggerTopic, measurements)
).ConfigureAwait(false);
}
public ReceivedMessageForm(TextMessageData textMessageData, UserInfo userInfo)
{
if (textMessageData == null)
{
throw new ArgumentNullException("textMessageData", "Something is wrong. TextMessageData should not be null.");
}
ReceivedTextMessageData = textMessageData;
if (userInfo == null)
{
throw new Exception("Text message received from unknown user");
}
ReceivedUserInfo = userInfo;
InitializeComponent();
StringBuilder stringBuilder = new StringBuilder("Received message from ");
stringBuilder.Append(ReceivedUserInfo.UserName);
if (userInfo.LogOnName != ReceivedUserInfo.UserName)
{
stringBuilder.AppendFormat(" [{0}]", ReceivedUserInfo.LogOnName);
}
stringBuilder.AppendFormat(" ({0})", ReceivedUserInfo.MachineName);
stringBuilder.AppendFormat("{0}at {1}", Environment.NewLine, ReceivedTextMessageData.ReceiptTime);
MessegeInfoLabel.Text = stringBuilder.ToString();
MessegeTextBox.Text = ReceivedTextMessageData.Text;
}
public void Notify(object data)
{
if (data == null || !(data is TextMessageData))
{
return;
}
TextMessageData textMessageData = data as TextMessageData;
if (textMessageData == null)
{
return;
}
if (IPMessengerNotifyIcon.ContextMenuStrip == null)
{
ProcessTextMessage(textMessageData);
return;
}
else if (IPMessengerNotifyIcon.ContextMenuStrip.InvokeRequired)
{
if (ProcessTextMessageDelegateInstance == null)
{
ProcessTextMessageDelegateInstance = new ProcessTextMessageDelegate(ProcessTextMessage);
}
IPMessengerNotifyIcon.ContextMenuStrip.BeginInvoke(ProcessTextMessageDelegateInstance, textMessageData);
}
else
{
ProcessTextMessage(textMessageData);
}
}
private static void ShowRecivedMessages()
{
while (TextMessageQueue.Count > 0)
{
TextMessageData data = TextMessageQueue.Dequeue();
Console.WriteLine(data);
}
}
public static IEnumerable <Message> Convert(TextMessageData messages)
{
return(messages.Messages.Select(msg => new Message {
Data = msg.Data,
Timestamp = msg.Timestamp.ToDateTime(),
PlatformTimestamp = msg.PlatformTime.ToDateTime(),
SensorId = ObjectId.Parse(msg.SensorID),
Location = new GeoJsonPoint <GeoJson2DGeographicCoordinates>(new GeoJson2DGeographicCoordinates(msg.Longitude, msg.Latitude)),
Encoding = (MessageEncoding)msg.Encoding
}).ToList());
}
public Task SendMessage(TextMessageData textMessage)
{
if (textMessage == null)
{
throw new ArgumentNullException(nameof(textMessage));
}
textMessage.EnsureIsValid <TextMessageData, TextMessageValidator>();
var @event = new ChatMessageReceived(_state.RoomId, _state.UserId, textMessage);
return(_state.Room.NotifyEverybody(@event));
}
public RemoteTriggerQueue(IOptions <QueueSettings> options, IInternalMqttClient client)
{
this.m_gaugeTriggerSerivce = Metrics.CreateGauge("router_trigger_messages_queued", "Number of messages in the trigger queue.");
this.m_triggerMeasurements = new MeasurementData();
this.m_triggerMessages = new TextMessageData();
this.m_measurementLock = new SpinLockWrapper();
this.m_messageLock = new SpinLockWrapper();
this.m_client = client;
this.m_messageTriggerTopic = options.Value.TriggerQueueTemplate.Replace("$type", "messages");
this.m_measurementTriggerTopic = options.Value.TriggerQueueTemplate.Replace("$type", "measurements");
}
private async Task SendBatchToRouterAsync(int start, int count, IList<TextMessage> messages)
{
var data = new TextMessageData();
for(var idx = start; idx < start + count; idx++) {
var message = messages[idx];
data.Messages.Add(message);
}
var result = await this.m_router.RouteAsync(data, default).ConfigureAwait(false);
this.m_logger.LogInformation("Sent {inputCount} messages to the router. {outputCount} " +
"messages have been accepted. Router response ID: {responseID}.",
data.Messages.Count, result.Count, new Guid(result.ResponseID.Span));
}
public Task SendMessage(TextMessageData textMessage)
{
if (textMessage == null)
{
throw new ArgumentNullException(nameof(textMessage));
}
var command = new SendMessageCommand
{
RoomId = _roomId,
Text = textMessage.Text
};
return(_context.Send(command));
}
private void ProcessTextMessage(TextMessageData textMessageData)
{
if (textMessageData == null)
{
return;
}
UserInfo userInfo = SocketCommService.GetUserInfo(textMessageData.IPAddress);
if (userInfo == null)
{
return;
}
ContextMenuStrip contextMenuStrip = IPMessengerNotifyIcon.ContextMenuStrip;
if (contextMenuStrip == null)
{
//MessageBox.Show(textMessageData.Text, string.Format("Received From {0} at {1}", userInfo.UserName, textMessageData.ReceiptTime));
ReceivedMessageForm receivedMEssageForm = new ReceivedMessageForm(textMessageData, userInfo);
receivedMEssageForm.Show();
return;
}
ToolStripMenuItem receivedMessagesToolStripMenuItem;
if (contextMenuStrip.Items.ContainsKey("Received Messages") == false)
{
receivedMessagesToolStripMenuItem = new ToolStripMenuItem("Received Messages");
receivedMessagesToolStripMenuItem.Name = "Received Messages";
int exitIndex = contextMenuStrip.Items.IndexOfKey("Exit");
contextMenuStrip.Items.Insert(exitIndex, receivedMessagesToolStripMenuItem);
}
else
{
receivedMessagesToolStripMenuItem = contextMenuStrip.Items["Received Messages"] as ToolStripMenuItem;
}
string key = string.Format("{0} at {1}", userInfo.UserName, textMessageData.ReceiptTime);
ToolStripItem toolStripItem = receivedMessagesToolStripMenuItem.DropDownItems.Add(key);
toolStripItem.Name = key;
toolStripItem.Tag = textMessageData;
toolStripItem.Click += new EventHandler(ToolStripItem_Click);
IPMessengerNotifyIcon.Tag = textMessageData;
string balloonToolTipText = string.Format("Received message from {0}", userInfo.UserName);
IPMessengerNotifyIcon.ShowBalloonTip(1000, "Received Message", balloonToolTipText, ToolTipIcon.Info);
}
void IPMessengerNotifyIcon_BalloonTipClicked(object sender, EventArgs e)
{
if (IPMessengerNotifyIcon.Tag == null || (IPMessengerNotifyIcon.Tag is TextMessageData) == false)
{
return;
}
TextMessageData textMessageData = IPMessengerNotifyIcon.Tag as TextMessageData;
if (textMessageData == null)
{
return;
}
UserInfo userInfo = SocketCommService.GetUserInfo(textMessageData.IPAddress);
if (userInfo == null)
{
return;
}
ContextMenuStrip contextMenuStrip = IPMessengerNotifyIcon.ContextMenuStrip;
if (contextMenuStrip != null && contextMenuStrip.Items.ContainsKey("Received Messages"))
{
ToolStripMenuItem receivedMessagesToolStripMenuItem = contextMenuStrip.Items["Received Messages"] as ToolStripMenuItem;
if (receivedMessagesToolStripMenuItem != null)
{
string key = string.Format("{0} at {1}", userInfo.UserName, textMessageData.ReceiptTime);
int index = receivedMessagesToolStripMenuItem.DropDownItems.IndexOfKey(key);
if (index >= 0)
{
receivedMessagesToolStripMenuItem.DropDownItems.RemoveAt(index);
if (receivedMessagesToolStripMenuItem.DropDownItems.Count == 0)
{
contextMenuStrip.Items.Remove(receivedMessagesToolStripMenuItem);
}
}
}
}
//MessageBox.Show(textMessageData.Text, string.Format("Received From {0} at {1}", userInfo.UserName, textMessageData.ReceiptTime));
ReceivedMessageForm receivedMEssageForm = new ReceivedMessageForm(textMessageData, userInfo);
receivedMEssageForm.Show();
}
public override Task <RoutingResponse> EnqueueBulkMessages(TextMessageData request, ServerCallContext context)
{
RoutingResponse response;
using (this.m_duration.NewTimer()) {
this.m_logger.LogDebug("Bulk ingress request with {count} messages.", request.Messages.Count);
try {
var dto = new List <Message>();
foreach (var raw in request.Messages)
{
var message = MessageProtobufConverter.Convert(raw);
if (MessageValidator.Validate(message))
{
dto.Add(message);
}
}
this.m_queue.AddRange(dto);
this.m_messageRequests.Inc();
response = new RoutingResponse {
Count = dto.Count,
Message = "Messages queued.",
ResponseID = ByteString.CopyFrom(Guid.NewGuid().ToByteArray())
};
} catch (FormatException ex) {
this.m_logger.LogWarning("Received messages from an invalid sensor. Exception: {exception}", ex);
response = new RoutingResponse {
Count = 0,
Message = "Messages not queued. Invalid sensor ID.",
ResponseID = ByteString.CopyFrom(Guid.NewGuid().ToByteArray())
};
}
}
return(Task.FromResult(response));
}
public static TextMessageData Convert(IEnumerable <Message> messages)
{
var textData = new TextMessageData();
foreach (var message in messages)
{
var m = new TextMessage {
Latitude = message.Latitude,
Longitude = message.Longitude,
SensorID = message.SensorID.ToString(),
Timestamp = Timestamp.FromDateTime(message.Timestamp),
PlatformTime = Timestamp.FromDateTime(message.PlatformTimestamp),
Data = message.Data,
Encoding = System.Convert.ToInt32(message.Encoding)
};
textData.Messages.Add(m);
}
return(textData);
}
public TextMessage(string text)
: base(new MsgHeaderData(EMsgDataType.Text))
{
_TextMessageData = new TextMessageData(null, text);
}
public TextMessage(SerializationInfo info, StreamingContext context)
: base(info, context)
{
_TextMessageData = info.GetValue("TextMessageData", typeof(TextMessageData)) as TextMessageData;
}
public TextMessage(string text)
: base(new MsgHeaderData(EMsgDataType.Text))
{
_TextMessageData = new TextMessageData(null, text);
}
public async Task <RoutingResponse> RouteAsync(TextMessageData data, CancellationToken ct)
{
var client = new IngressRouter.IngressRouterClient(this.m_channel);
return(await client.EnqueueBulkMessagesAsync(data, cancellationToken : ct));
}
public Task SendMessage(TextMessageData textMessage)
{
return(_player.SendMessage(textMessage));
}
public TextMessage(SerializationInfo info, StreamingContext context)
: base(info, context)
{
_TextMessageData = info.GetValue("TextMessageData", typeof(TextMessageData)) as TextMessageData;
}
