/// <summary>
/// Update Messages Sent
/// </summary>
/// <param name="messagesSent"></param>
/// <returns></returns>
public async Task UpdateMessagesSent(MessagesSent messagesSent)
{
await Task.Delay(0);
DateTime dateUpdated = DateTime.UtcNow;
messagesSent.DateUpdated = dateUpdated;
}
/// <summary>
/// Create Messages Sent
/// </summary>
/// <param name="messagesSent"></param>
/// <returns></returns>
public async Task CreateMessagesSent(MessagesSent messagesSent)
{
DateTime dateCreated = DateTime.UtcNow;
messagesSent.DateCreated = dateCreated;
messagesSent.DateUpdated = dateCreated;
await dbConnection.MessagesSent.AddAsync(messagesSent);
}
/// <summary>
/// Get Message Sent
/// </summary>
/// <param name="senderId"></param>
/// <param name="exchangeName"></param>
/// <param name="transactionCode"></param>
/// <returns></returns>
public async Task <MessagesSent> GetMessageSent(int senderId, string exchangeName, string transactionCode)
{
MessagesSent messagesSent = await dbConnection.MessagesSent.Where(x =>
x.SenderTransactionQueueId == senderId &&
x.ExchangeName == exchangeName &&
x.TransactionCode == transactionCode)
.FirstOrDefaultAsync();
return(messagesSent);
}
private async void SendDeviceMessage(string Team, string correlationId, string MessageText)
{
DeviceToCloudMessage deviceMessage = new DeviceToCloudMessage()
{
Team = Team, MessageText = MessageText
};
Debug.WriteLine(MessageText);
MessagesSent.Insert(0, MessageText);
await iotHubDeviceService.SendDeviceToCloudMessagesAsync(deviceMessage, correlationId);
}
private void btnNewEmailClick(object sender, RoutedEventArgs e)
{
NewEmailWindow wnd = new NewEmailWindow();
wnd.Owner = this;
wnd.Width = 0.8 * this.ActualWidth;
wnd.Height = 0.8 * this.ActualHeight;
this.Opacity = 0.5;
wnd.ShowDialog();
MessagesSent.Add(wnd.Email);
this.Opacity = 1;
}
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 InterceptRequest(dk.gov.oiosi.extension.wcf.Interceptor.Channels.InterceptorMessage interceptorMessage)
{
string action = interceptorMessage.GetHeaders().Action;
List <XmlDocument> sentMessagesWithSameAction;
MessagesSent.TryGetValue(action, out sentMessagesWithSameAction);
if (sentMessagesWithSameAction == null)
{
sentMessagesWithSameAction = new List <XmlDocument>();
MessagesSent.Add(action, sentMessagesWithSameAction);
}
sentMessagesWithSameAction.Add(interceptorMessage.GetBody());
}
public void Send(TransportMessage message, IEnumerable <Peer> peers, SendContext context)
{
var peerList = peers.ToList();
if (peerList.Any())
{
_messages.Add(new TransportMessageSent(message, peerList, context));
}
var deserializedMessage = _messageSerializer.Deserialize(message.MessageTypeId, message.MessageBytes);
if (deserializedMessage != null)
{
MessagesSent.Add(deserializedMessage);
}
}
public void Send(TransportMessage message, IEnumerable <Peer> peerIds)
{
var targets = peerIds.ToArray();
if (targets.Length != 0)
{
_messages.Add(new TransportMessageSent(message, targets));
}
var deserializedMessage = _messageSerializer.Deserialize(message.MessageTypeId, message.MessageBytes);
if (deserializedMessage != null)
{
MessagesSent.Add(deserializedMessage);
}
}
public void Delete()
{
//defait les relations de suivi
foreach (var followee in Followees)
{
followee.Followers.Remove(this);
}
Followees.Clear();
foreach (var follower in Followers)
{
follower.Followees.Remove(this);
}
Followers.Clear();
//supprime les messages envoyés ou reçus
Model.Messages.RemoveRange(MessagesSent);
MessagesSent.Clear();
Model.Messages.RemoveRange(MessagesReceived);
MessagesReceived.Clear();
//supprime le membre lui-meme
Model.Members.Remove(this);
}
/// <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);
}
private void OnMessagesSent()
{
MessagesSent?.Invoke(this, _settings.Verbose);
}
