//Erhalt einer neuen Nachricht
private void NewMessageReceived(string message)
{
App.Current.Dispatcher.Invoke(() =>
{
MessagesReceived.Add(message);
});
}
protected Type CreateMockActor <TMockActor>(ConcurrentDictionary <Tuple <Guid, Type>, object> mocks) where TMockActor : ActorBase
{
ItShouldDo((actorAccess) => MessagesReceived.GetOrAdd(Guid.NewGuid(), new MockMessages(actorAccess.Context.Self.ToActorMetaData().Path, typeof(T))));
Console.WriteLine("Setting Up Actor " + typeof(TMockActor).Name + " with " + mocks.Count + " items ....");
foreach (var mock in mocks)
{
var builder = new ContainerBuilder();
builder.RegisterType <TMockActor>();
var mockActorState = new MockActorState();
if (Container.IsRegistered <IMockActorState>())
{
var state = (MockActorState)Container.Resolve <IMockActorState>();
mockActorState = state ?? mockActorState;
}
mockActorState.MockSetUpMessages = mockActorState.MockSetUpMessages ?? new List <MockSetUpMessage>();
mockActorState.MockSetUpMessages.Add(new MockSetUpMessage(typeof(TMockActor), mock.Key.Item2, mock.Value));
Console.WriteLine("When Received is " + mock.Key.Item2 + " The response will be " + mock.Value);
builder.RegisterType <IMockActorState>();
builder.Register <IMockActorState>(c => mockActorState);
builder.Update(Container);
}
var state1 = (MockActorState)Container.Resolve <IMockActorState>();
Console.WriteLine("State now has " + state1.MockSetUpMessages.Count + " items ....");
return(typeof(TMockActor));
}
protected void Page_Load(object sender, EventArgs e)
{
int id = Convert.ToInt32(Session["ID"]);
string connectionString;
SqlConnection cnn;
connectionString = WebConfigurationManager.ConnectionStrings["constr"].ConnectionString;
cnn = new SqlConnection(connectionString);
cnn.Open();
SqlDataAdapter sqlData = new SqlDataAdapter("showMessages", cnn);
sqlData.SelectCommand.CommandType = CommandType.StoredProcedure;
sqlData.SelectCommand.Parameters.AddWithValue("@id", id);
DataTable dataTable = new DataTable();
sqlData.Fill(dataTable);
MessagesReceived.DataSource = dataTable;
MessagesReceived.DataBind();
cnn.Close();
cnn.Open();
SqlCommand cmd = new SqlCommand("updateMessageSeen", cnn);
cmd.Parameters.Add(new SqlParameter("@ID", id));
cmd.CommandType = System.Data.CommandType.StoredProcedure;
SqlDataReader rdr = cmd.ExecuteReader();
rdr.Close();
cnn.Close();
}
override public void sendMessage(TransientMessage Message)
{
if (TCPState != TCPState.Active)
{
// We do not have an active connection so take the outgoing message
// and put it on the Received messages queue with and error and
// let the connection instanciator deal with it.
Message.MessageStatus = TransientMessageStatus.NoConnection;
lock (MessagesReceived)
{
MessagesReceived.Enqueue(Message);
}
MessageReceivedWaitHandle.Set();
}
// Put the outbound message on the queue
lock (MessagesToSend)
{
MessagesToSend.Enqueue(Message);
}
// Wake up the connect to do some work
MessageToSendWaitHandle.Set();
Console.WriteLine(DateTime.Now.ToString() + " " + CurrentThread.Name + "Message set to writer");
} // End public override void sendMessage(TransientMessage Message)
private async void UpdateLocalMessages(object state)
{
if (Interlocked.CompareExchange(ref updating, 1, 0) == 0)
{
try {
// stop timer to avoid reentrance while we await messages
timer.Change(-1, -1);
// wait all messages to arrive
messages = await GetMessagesAsync();
// after receiving all messages, raise the event to notify all listeners
MessagesReceived?.Invoke(this, new MessagesReceivedEventArgs()
{
Messages = messages
});
// restart timer for next iteration
timer.Change(POLL_INTERVAL, -1);
} catch (RpcException) {
// error contacting the server. as timer was not re-enabled we just ignore and return
} finally {
Interlocked.Exchange(ref updating, 0); // reset back to not entered
}
}
}
public void ConfigurePipeline(IPipelineBuilder builder)
{
builder.Run(m =>
{
MessagesReceived.Add(m);
return(Task.CompletedTask);
});
}
/// <summary>
/// Create Messages Received
/// </summary>
/// <param name="messagesReceived"></param>
/// <returns></returns>
public async Task CreateMessagesReceived(MessagesReceived messagesReceived)
{
DateTime dateCreated = DateTime.UtcNow;
messagesReceived.DateCreated = dateCreated;
await dbConnection.MessagesReceived.AddAsync(messagesReceived);
}
private void NewMessagesReceived(string message)
{
//write new message in Collection to display in GUI
//switch thread to GUI thread to avoid problems
App.Current.Dispatcher.Invoke(() =>
{
MessagesReceived.Add(message);
});
}
/// <summary>
/// Get Message Received
/// </summary>
/// <param name="senderId"></param>
/// <param name="exchangeName"></param>
/// <param name="transactionCode"></param>
/// <param name="queueName"></param>
/// <returns></returns>
public async Task <MessagesReceived> GetMessageReceived(int senderId, string exchangeName, string transactionCode, string queueName)
{
MessagesReceived messagesReceived = await dbConnection.MessagesReceived.Where(x =>
x.SenderTransactionQueueId == senderId &&
x.ExchangeName == exchangeName &&
x.TransactionCode == transactionCode &&
x.QueueName == queueName)
.FirstOrDefaultAsync();
return(messagesReceived);
}
private void SendMessage()
{
clientcom.SendMessage(ClientName + ": " + NewMessage); // Clients sollen den Namen vor der Nachricht haben
MessagesReceived.Add("YOU: " + NewMessage); // der Sender soll statt eigenem Namen ein YOU haben
// EXTRA: wenn Nachricht abgeschickt => Nachricht aus Eingabefeld löschen!
NewMessage = "";
RaisePropertyChanged("NewMessage");
// Testzwecke:
//messagesReceived = "Hallo";
//RaisePropertyChanged("MessagesReceived");
}
private void tabControlKeyDown(object sender, KeyEventArgs e)
{
if (e.Key == Key.Delete && SelectedMessage != null)
{
if (TabRecvSentIndex == 0)
{
MessagesReceived.Remove(SelectedMessage);
}
else
{
MessagesSent.Remove(SelectedMessage);
}
}
}
public override void InterceptResponse(dk.gov.oiosi.extension.wcf.Interceptor.Channels.InterceptorMessage interceptorMessage)
{
string action = interceptorMessage.GetHeaders().Action;
List <XmlDocument> receivedMessagesWithSameAction;
MessagesReceived.TryGetValue(action, out receivedMessagesWithSameAction);
if (receivedMessagesWithSameAction == null)
{
receivedMessagesWithSameAction = new List <XmlDocument>();
MessagesReceived.Add(action, receivedMessagesWithSameAction);
}
receivedMessagesWithSameAction.Add(interceptorMessage.GetBody());
}
private void LocalReceive(RemoteData data)
{
if (data.State == GameStateQuery.Message)
{
MessagesReceived?.Invoke(new List <object> {
data.MessageText
});
}
else if (data.State == GameStateQuery.Pause)
{
// TODO: now its only ignore
}
else if (data.State == GameStateQuery.Start)
{
}
else if (data.State == GameStateQuery.Resign)
{
}
else if (data.State == GameStateQuery.Move)
{
MoveReceived?.Invoke(data.Move as Tuple <BPosition, BPosition>);
}
}
/// <summary>
/// Commit Inbound Message
/// </summary>
/// <param name="messageQueue"></param>
/// <returns></returns>
public async Task <ResponseModel <MessageQueue> > CommitInboundMessage(MessageQueue messageQueue, ConnectionStrings connectionStrings)
{
ResponseModel <MessageQueue> returnResponse = new ResponseModel <MessageQueue>();
try
{
_loggingManagementDataService.OpenConnection(connectionStrings.PrimaryDatabaseConnectionString);
_loggingManagementDataService.BeginTransaction((int)IsolationLevel.ReadCommitted);
MessagesSent existingMessageSent = await _loggingManagementDataService.GetMessageSent(messageQueue.TransactionQueueId, messageQueue.ExchangeName, messageQueue.TransactionCode);
if (messageQueue.QueueName != string.Empty && messageQueue.QueueName != null)
{
MessagesReceived existingMessageReceived = await _loggingManagementDataService.GetMessageReceived(messageQueue.TransactionQueueId, messageQueue.ExchangeName, messageQueue.TransactionCode, messageQueue.QueueName);
if (existingMessageReceived != null)
{
returnResponse.ReturnStatus = true;
return(returnResponse);
}
}
if (existingMessageSent == null)
{
MessagesSent messageSent = new MessagesSent();
messageSent.ExchangeName = messageQueue.ExchangeName;
messageSent.SenderTransactionQueueId = messageQueue.TransactionQueueId;
messageSent.TransactionCode = messageQueue.TransactionCode;
messageSent.Payload = messageQueue.Payload;
if (messageSent.TransactionCode == MessageQueueExchanges.ProductUpdated)
{
messageSent.AcknowledgementsRequired = MessageExchangeFanouts.ProductUpdated;
messageSent.AcknowledgementsReceived = 0;
}
else if (messageSent.TransactionCode == MessageQueueExchanges.PurchaseOrderSubmitted)
{
messageSent.AcknowledgementsRequired = MessageExchangeFanouts.PurchaseOrderSubmitted;
messageSent.AcknowledgementsReceived = 0;
}
else if (messageSent.TransactionCode == MessageQueueExchanges.SalesOrderSubmitted)
{
messageSent.AcknowledgementsRequired = MessageExchangeFanouts.SalesOrderSubmitted;
messageSent.AcknowledgementsReceived = 0;
}
else if (messageSent.TransactionCode == MessageQueueExchanges.InventoryReceived)
{
messageSent.AcknowledgementsRequired = MessageExchangeFanouts.InventoryReceived;
messageSent.AcknowledgementsReceived = 0;
}
else if (messageSent.TransactionCode == MessageQueueExchanges.InventoryShipped)
{
messageSent.AcknowledgementsRequired = MessageExchangeFanouts.InventoryShipped;
messageSent.AcknowledgementsReceived = 0;
}
if (messageQueue.QueueName != string.Empty && messageQueue.QueueName != null)
{
existingMessageSent.AcknowledgementsReceived = existingMessageSent.AcknowledgementsReceived + 1;
}
await _loggingManagementDataService.CreateMessagesSent(messageSent);
}
if (messageQueue.QueueName != string.Empty && messageQueue.QueueName != null)
{
if (existingMessageSent != null)
{
existingMessageSent.AcknowledgementsReceived = existingMessageSent.AcknowledgementsReceived + 1;
await _loggingManagementDataService.UpdateMessagesSent(existingMessageSent);
}
MessagesReceived messageReceived = new MessagesReceived();
messageReceived.ExchangeName = messageQueue.ExchangeName;
messageReceived.SenderTransactionQueueId = messageQueue.TransactionQueueId;
messageReceived.TransactionCode = messageQueue.TransactionCode;
messageReceived.Payload = messageQueue.Payload;
messageReceived.QueueName = messageQueue.QueueName;
await _loggingManagementDataService.CreateMessagesReceived(messageReceived);
if (existingMessageSent.AcknowledgementsReceived == existingMessageSent.AcknowledgementsRequired)
{
AcknowledgementsQueue acknowledgementsQueue = new AcknowledgementsQueue();
acknowledgementsQueue.ExchangeName = messageQueue.ExchangeName;
acknowledgementsQueue.SenderTransactionQueueId = messageQueue.TransactionQueueId;
acknowledgementsQueue.TransactionCode = messageQueue.TransactionCode;
if (acknowledgementsQueue.TransactionCode == MessageQueueExchanges.ProductUpdated)
{
acknowledgementsQueue.AcknowledgementQueue = MessageQueueEndpoints.InventoryQueue;
}
else if (acknowledgementsQueue.TransactionCode == MessageQueueExchanges.PurchaseOrderSubmitted)
{
acknowledgementsQueue.AcknowledgementQueue = MessageQueueEndpoints.PurchaseOrderQueue;
}
else if (acknowledgementsQueue.TransactionCode == MessageQueueExchanges.SalesOrderSubmitted)
{
acknowledgementsQueue.AcknowledgementQueue = MessageQueueEndpoints.SalesOrderQueue;
}
else if (acknowledgementsQueue.TransactionCode == MessageQueueExchanges.InventoryReceived)
{
acknowledgementsQueue.AcknowledgementQueue = MessageQueueEndpoints.InventoryQueue;
}
else if (acknowledgementsQueue.TransactionCode == MessageQueueExchanges.InventoryShipped)
{
acknowledgementsQueue.AcknowledgementQueue = MessageQueueEndpoints.InventoryQueue;
}
await _loggingManagementDataService.CreateAcknowledgementsQueue(acknowledgementsQueue);
}
}
await _loggingManagementDataService.UpdateDatabase();
_loggingManagementDataService.CommitTransaction();
returnResponse.ReturnStatus = true;
}
catch (Exception ex)
{
_loggingManagementDataService.RollbackTransaction();
returnResponse.ReturnStatus = false;
returnResponse.ReturnMessage.Add(ex.Message);
}
finally
{
_loggingManagementDataService.CloseConnection();
}
returnResponse.Entity = messageQueue;
return(returnResponse);
}
Task IGangMember.HandleAsync(GangMessageTypes type,
byte[] data, GangAudit audit)
{
MessagesReceived.Add(new Message(type, data, audit?.Version));
return(Task.CompletedTask);
}
private void ShowSendBtnClicked()
{
clientVar.Send(ChatName + ": " + Message);
MessagesReceived.Add("You: " + Message);
}
public void ClearAllMessages()
{
MessagesReceived.Clear();
}
private async void IoTHubDeviceService_MessageReceived(object sender, MessageEventArgs e)
{
//await SoundService.PlayAudioFileAsync("alienvoice01.wav");
MessagesReceived.Insert(0, e.MessageString);
Debug.WriteLine(String.Format("Received message: {0}", e.MessageString));
}
} // End public override void sendMessage(TransientMessage Message)
override public void start()
{
CurrentThread = Thread.CurrentThread;
Console.WriteLine(DateTime.Now.ToString() + " " + CurrentThread.Name + "Starting");
while (true)
{
/*
* try
* {
* IPHostEntry hostInfo;
*
* // Attempt to resolve DNS for given host or address
* hostInfo = Dns.GetHostEntry(IPAddress);
*
* // Display the primary host name
* Console.WriteLine(CurrentThread.Name + "\tCanonical Name: " + hostInfo.HostName);
*
* HostName = hostInfo.HostName;
*
* // Display list of IP addresses for this host
* Console.WriteLine(CurrentThread.Name + "\tIP Addresses: ");
* foreach (IPAddress ipaddr in hostInfo.AddressList)
* {
* Console.WriteLine(CurrentThread.Name + "\t\t" +ipaddr.ToString());
* }
* Console.WriteLine(CurrentThread.Name);
*
* // Display list of alias names for this host
* Console.WriteLine(CurrentThread.Name + "\tAliases: ");
* foreach (String alias in hostInfo.Aliases)
* {
* Console.WriteLine(CurrentThread.Name + "\t\t" + alias + " ");
*
* }
* Console.WriteLine(CurrentThread.Name + "\n");
* }
* catch (Exception e)
* {
* Console.WriteLine( CurrentThread.Name + "\tUnable to resolve host: " + this.IPAddress.ToString() + " " + e.ToString() + "\n" + e.StackTrace + "\n");
* }
*/
if (ConnectionMode == HSMSConnectionMode.Active ||
ConnectionMode == HSMSConnectionMode.ActivePassthru)
{
Console.WriteLine(DateTime.Now.ToString() + " " + CurrentThread.Name + "Attempting to connect");
tcpclnt = new TcpClient();
try
{
tcpclnt.Connect("192.168.1.65", 5000); // use the ipaddress as in the server program
}
catch (Exception e)
{
Console.WriteLine(DateTime.Now.ToString() + " " + CurrentThread.Name + "\tUnable to connect to 192.168.1.65 port 5000: " + this.IPAddress.ToString() + " " + e.ToString() + "\n" + e.StackTrace + "\n");
}
IOStream = tcpclnt.GetStream();
HSMSReader = new HSMSReader(IOStream, ref ReceivedSECSMessages, ref ReceivedSECSMessagesWH);
ReaderThread = new Thread(new ThreadStart(HSMSReader.start));
ReaderThread.Name = CurrentThread.Name + "HSMSReader:";
ReaderThread.Start();
HSMSWriter = new HSMSWriter(IOStream, MessagesToSend, MessageToSendWaitHandle);
WriterThread = new Thread(new ThreadStart(HSMSWriter.start));
WriterThread.Name = CurrentThread.Name + "HSMSWriter:";
WriterThread.Start();
TCPState = TCPState.Active;
}
else
{
tcpListener = new TcpListener(System.Net.IPAddress.Parse("192.168.1.24"), 5000);
tcpListener.Start();
Console.WriteLine(DateTime.Now.ToString() + " " + CurrentThread.Name + "Accepting Client");
tcpclnt = tcpListener.AcceptTcpClient();
Console.WriteLine(DateTime.Now.ToString() + " " + CurrentThread.Name + "Accepted Client");
IOStream = tcpclnt.GetStream();
HSMSReader = new HSMSReader(IOStream, ref ReceivedSECSMessages, ref ReceivedSECSMessagesWH);
ReaderThread = new Thread(new ThreadStart(HSMSReader.start));
ReaderThread.Name = CurrentThread.Name + "HSMSReader:";
ReaderThread.Start();
Console.WriteLine(DateTime.Now.ToString() + " " + CurrentThread.Name + "Finished Starting Reader");
HSMSWriter = new HSMSWriter(IOStream, MessagesToSend, MessageToSendWaitHandle);
WriterThread = new Thread(new ThreadStart(HSMSWriter.start));
WriterThread.Name = CurrentThread.Name + "HSMSWriter:";
WriterThread.Start();
Console.WriteLine(DateTime.Now.ToString() + " " + CurrentThread.Name + "Finished Starting Writer");
TCPState = TCPState.Active;
}
/*
* try
* {
*
* Console.WriteLine("Connecting.....");
*
* // tcpclnt.Connect("192.168.1.65", 5000); // use the ipaddress as in the server program
*
* Console.WriteLine("Connected");
* Console.Write("Enter the string to be transmitted : ");
*
* String str = Console.ReadLine();
*
*
* HSMSHeader header = new HSMSHeader();
*
* header.SessionID = 1;
* header.SType = (Byte)STypeValues.SelectReq;
*
* byte[] message = new byte[14];
* message[0] = 0;
* message[1] = 0;
* message[2] = 0;
* message[3] = 10;
* byte[] ba = header.Encode();
*
* message[4] = ba[0];
* message[5] = ba[1];
* message[6] = ba[2];
* message[7] = ba[3];
* message[8] = ba[4];
* message[9] = ba[5];
* message[10] = ba[6];
* message[11] = ba[7];
* message[12] = ba[8];
* message[13] = ba[9];
*
* Console.WriteLine("Transmitting.....");
*
* // stm.Write(message, 0, message.Length);
*
* // byte[] bb = new byte[100];
* // int k = stm.Read(bb, 0, 100);
* //stm. string hex = BitConverter.ToString(bb);
*
* // Console.WriteLine( "Returned " + k +" Bytes :" + hex );
* // for (int i = 0; i < k; i++)
* // Console.Write(Convert..ToChar(bb[i]));
*
* tcpclnt.Close();
* }
*
* catch (Exception e)
* {
* Console.WriteLine( CurrentThread.Name + " Error..... " + e.StackTrace);
* }
*
*/
// Thread.Sleep(10000);
while (true)
{
Console.WriteLine(DateTime.Now.ToString() + " " + CurrentThread.Name + "Blocking for message from Reader Thread");
ReceivedSECSMessagesWH.WaitOne();
SECSMessage ReceivedMessage = null;
Console.WriteLine(DateTime.Now.ToString() + " " + CurrentThread.Name + "Received Inbound message from Reader Thread");
lock (ReceivedSECSMessages)
{
ReceivedMessage = ReceivedSECSMessages.Dequeue();
}
if (ReceivedMessage.IsValidMessage == false)
{
Console.WriteLine(DateTime.Now.ToString() + " " + CurrentThread.Name + "Inbound message Indicates I/O has link failed");
TransientMessage TM1 = new TransientMessage();
TM1.MessageStatus = TransientMessageStatus.NoConnection;
lock (MessagesReceived)
{
MessagesReceived.Enqueue(TM1);
}
MessageReceivedWaitHandle.Set();
Console.WriteLine(DateTime.Now.ToString() + " " + CurrentThread.Name + "Instructing Writer Thread to terminate.");
break;
}
TransientMessage TM = new TransientMessage();
TM.SECSData = ReceivedMessage;
TM.MessageStatus = TransientMessageStatus.IncommingMessage;
TM.ReceivedFrom = ConnectionName;
lock (MessagesReceived)
{
MessagesReceived.Enqueue(TM);
}
MessageReceivedWaitHandle.Set();
Console.WriteLine(DateTime.Now.ToString() + " " + CurrentThread.Name + "Inbound message passed to connection owner");
} // End while (true)
IOStream.Close();
if (tcpListener != null)
{
tcpListener.Stop();
}
tcpListener = null;
IOStream = null;
HSMSReader = null;
ReaderThread = null;
WriterThread = null;
HSMSWriter = null;
} // End // End while (true)
} // End public void start()
private async void IotHubDeviceService_MessageReceived(object sender, Models.MessageEventArgs e)
{
MessagesReceived.Insert(0, e.MessageString);
//Debug.WriteLine(String.Format("Received message: {0}", e.MessageString));
}
