/// <summary>
/// Update Transaction Queue Semaphore
/// </summary>
/// <param name="transactionQueueSemaphore"></param>
/// <returns></returns>
public async Task UpdateTransactionQueueSemaphore(TransactionQueueSemaphore transactionQueueSemaphore)
{
await Task.Delay(0);
DateTime dateUpdated = DateTime.UtcNow;
transactionQueueSemaphore.DateUpdated = dateUpdated;
}
/// <summary>
/// Create Transaction Queue Semaphore
/// </summary>
/// <param name="transactionQueueSemaphore"></param>
/// <returns></returns>
public async Task CreateTransactionQueueSemaphore(TransactionQueueSemaphore transactionQueueSemaphore)
{
DateTime dateCreated = DateTime.UtcNow;
transactionQueueSemaphore.DateCreated = dateCreated;
transactionQueueSemaphore.DateUpdated = dateCreated;
await dbConnection.TransactionQueueSemaphores.AddAsync(transactionQueueSemaphore);
}
/// <summary>
/// Get Transaction Queue Semaphore
/// </summary>
/// <param name="semaphoreKey"></param>
/// <returns></returns>
public async Task <TransactionQueueSemaphore> GetTransactionQueueSemaphore(string semaphoreKey)
{
StringBuilder sqlBuilder = new StringBuilder();
sqlBuilder.AppendLine(" SELECT * FROM TransactionQueueSemaphores WITH (UPDLOCK) WHERE ");
sqlBuilder.AppendLine(" SemaphoreKey = @SemaphoreKey ");
string sqlStatement = sqlBuilder.ToString();
SqlParameter semaphoreKeyParameter = new SqlParameter("SemaphoreKey", semaphoreKey);
TransactionQueueSemaphore transactionQueue = await dbConnection.TransactionQueueSemaphores.FromSqlRaw(sqlStatement, semaphoreKeyParameter).FirstOrDefaultAsync();
return(transactionQueue);
}
/// <summary>
/// Process Messages
/// </summary>
/// <returns></returns>
public async Task <ResponseModel <List <MessageQueue> > > ProcessMessages(string inboundSemaphoreKey, ConnectionStrings connectionStrings)
{
ResponseModel <List <MessageQueue> > returnResponse = new ResponseModel <List <MessageQueue> >();
returnResponse.Entity = new List <MessageQueue>();
TransactionQueueSemaphore transactionQueueSemaphore = null;
lock (_processingLock)
{
if (_processing == true)
{
Console.WriteLine("Processing iteration aborted");
return(returnResponse);
}
_processing = true;
}
try
{
_inventoryManagementDataService.OpenConnection(connectionStrings.PrimaryDatabaseConnectionString);
_inventoryManagementDataService.BeginTransaction((int)IsolationLevel.Serializable);
Console.WriteLine("Get Lock at " + DateTime.Now.ToString());
transactionQueueSemaphore = await _inventoryManagementDataService.GetTransactionQueueSemaphore(inboundSemaphoreKey);
if (transactionQueueSemaphore == null)
{
transactionQueueSemaphore = new TransactionQueueSemaphore();
transactionQueueSemaphore.SemaphoreKey = inboundSemaphoreKey;
await _inventoryManagementDataService.CreateTransactionQueueSemaphore(transactionQueueSemaphore);
}
else
{
await _inventoryManagementDataService.UpdateTransactionQueueSemaphore(transactionQueueSemaphore);
}
List <TransactionQueueInbound> transactionQueue = await _inventoryManagementDataService.GetInboundTransactionQueue();
foreach (TransactionQueueInbound transactionQueueItem in transactionQueue)
{
int senderId = transactionQueueItem.SenderTransactionQueueId;
string exchangeName = transactionQueueItem.ExchangeName;
string transactionCode = transactionQueueItem.TransactionCode;
TransactionQueueInboundHistory transactionHistory = await _inventoryManagementDataService.GetInboundTransactionQueueHistoryBySender(senderId, exchangeName);
if (transactionHistory != null)
{
await LogDuplicateMessage(transactionQueueItem);
await _inventoryManagementDataService.DeleteInboundTransactionQueueEntry(transactionQueueItem.TransactionQueueInboundId);
}
else if (transactionCode == TransactionQueueTypes.PurchaseOrderSubmitted)
{
await PurchaseOrderSubmitted(transactionQueueItem);
await _inventoryManagementDataService.DeleteInboundTransactionQueueEntry(transactionQueueItem.TransactionQueueInboundId);
}
else if (transactionCode == TransactionQueueTypes.SalesOrderSubmitted)
{
await SalesOrderSubmitted(transactionQueueItem);
await _inventoryManagementDataService.DeleteInboundTransactionQueueEntry(transactionQueueItem.TransactionQueueInboundId);
}
else if (transactionCode == TransactionQueueTypes.Acknowledgement)
{
await ProcessAcknowledgement(transactionQueueItem);
await _inventoryManagementDataService.DeleteInboundTransactionQueueEntry(transactionQueueItem.TransactionQueueInboundId);
}
}
await _inventoryManagementDataService.UpdateDatabase();
_inventoryManagementDataService.CommitTransaction();
_inventoryManagementDataService.CloseConnection();
}
catch (Exception ex)
{
_inventoryManagementDataService.RollbackTransaction();
returnResponse.ReturnStatus = false;
returnResponse.ReturnMessage.Add(ex.Message);
}
finally
{
_inventoryManagementDataService.CloseConnection();
_processing = false;
}
return(returnResponse);
}
/// <summary>
/// Get Messages To Send
/// </summary>
/// <param name="messageQueueConfigurations"></param>
/// <param name="outboundSemaphoreKey"></param>
/// <param name="connectionStrings"></param>
/// <returns></returns>
private async Task <ResponseModel <List <MessageQueue> > > GetMessagesToSend(List <IMessageQueueConfiguration> messageQueueConfigurations, string outboundSemaphoreKey, ConnectionStrings connectionStrings)
{
TransactionQueueSemaphore transactionQueueSemaphore = null;
ResponseModel <List <MessageQueue> > returnResponse = new ResponseModel <List <MessageQueue> >();
returnResponse.Entity = new List <MessageQueue>();
try
{
_inventoryManagementDataService.OpenConnection(connectionStrings.PrimaryDatabaseConnectionString);
_inventoryManagementDataService.BeginTransaction((int)IsolationLevel.Serializable);
transactionQueueSemaphore = await _inventoryManagementDataService.GetTransactionQueueSemaphore(outboundSemaphoreKey);
if (transactionQueueSemaphore == null)
{
transactionQueueSemaphore = new TransactionQueueSemaphore();
transactionQueueSemaphore.SemaphoreKey = outboundSemaphoreKey;
await _inventoryManagementDataService.CreateTransactionQueueSemaphore(transactionQueueSemaphore);
}
else
{
await _inventoryManagementDataService.UpdateTransactionQueueSemaphore(transactionQueueSemaphore);
}
List <TransactionQueueOutbound> transactionQueue = await _inventoryManagementDataService.GetOutboundTransactionQueue();
foreach (TransactionQueueOutbound transactionQueueItem in transactionQueue)
{
MessageQueue message = new MessageQueue();
message.ExchangeName = transactionQueueItem.ExchangeName;
message.TransactionQueueId = transactionQueueItem.TransactionQueueOutboundId;
message.TransactionCode = transactionQueueItem.TransactionCode;
message.Payload = transactionQueueItem.Payload;
IMessageQueueConfiguration messageQueueConfiguration = messageQueueConfigurations.Where(x => x.TransactionCode == message.TransactionCode).FirstOrDefault();
if (messageQueueConfiguration == null)
{
break;
}
ResponseModel <MessageQueue> messageQueueResponse = messageQueueConfiguration.SendMessage(message);
if (messageQueueResponse.ReturnStatus == true)
{
transactionQueueItem.SentToExchange = true;
transactionQueueItem.DateSentToExchange = DateTime.UtcNow;
await _inventoryManagementDataService.UpdateOutboundTransactionQueue(transactionQueueItem);
returnResponse.Entity.Add(message);
}
else
{
break;
}
}
await _inventoryManagementDataService.UpdateDatabase();
_inventoryManagementDataService.CommitTransaction();
_inventoryManagementDataService.CloseConnection();
}
catch (Exception ex)
{
_inventoryManagementDataService.RollbackTransaction();
returnResponse.ReturnStatus = false;
returnResponse.ReturnMessage.Add(ex.Message);
}
finally
{
_inventoryManagementDataService.CloseConnection();
}
return(returnResponse);
}
/// <summary>
/// Send Queue Messages
/// </summary>
/// <param name="messageQueueConfigurations"></param>
/// <param name="outboundSemaphoreKey"></param>
/// <param name="connectionStrings"></param>
/// <returns></returns>
public async Task <ResponseModel <List <MessageQueue> > > SendQueueMessages(List <IMessageQueueConfiguration> messageQueueConfigurations, string outboundSemaphoreKey, ConnectionStrings connectionStrings)
{
ResponseModel <List <MessageQueue> > returnResponse = new ResponseModel <List <MessageQueue> >();
returnResponse.Entity = new List <MessageQueue>();
lock (_sendingLock)
{
if (_sending)
{
Console.WriteLine("Aborted iteration still sending");
return(returnResponse);
}
_sending = true;
}
TransactionQueueSemaphore transactionQueueSemaphore = null;
try
{
_loggingManagementDataService.OpenConnection(connectionStrings.PrimaryDatabaseConnectionString);
_loggingManagementDataService.BeginTransaction((int)IsolationLevel.Serializable);
transactionQueueSemaphore = await _loggingManagementDataService.GetTransactionQueueSemaphore(outboundSemaphoreKey);
if (transactionQueueSemaphore == null)
{
transactionQueueSemaphore = new TransactionQueueSemaphore();
transactionQueueSemaphore.SemaphoreKey = outboundSemaphoreKey;
await _loggingManagementDataService.CreateTransactionQueueSemaphore(transactionQueueSemaphore);
}
else
{
await _loggingManagementDataService.UpdateTransactionQueueSemaphore(transactionQueueSemaphore);
}
List <AcknowledgementsQueue> acknowledgementsQueue = await _loggingManagementDataService.ProcessAcknowledgementsQueue();
foreach (AcknowledgementsQueue transactionQueueItem in acknowledgementsQueue)
{
MessageQueue message = new MessageQueue();
message.ExchangeName = transactionQueueItem.ExchangeName;
message.TransactionQueueId = transactionQueueItem.SenderTransactionQueueId;
message.TransactionCode = TransactionQueueTypes.Acknowledgement;
message.QueueName = transactionQueueItem.AcknowledgementQueue;
IMessageQueueConfiguration messageQueueConfiguration = messageQueueConfigurations.FirstOrDefault();
if (messageQueueConfiguration == null)
{
break;
}
ResponseModel <MessageQueue> messageQueueResponse = messageQueueConfiguration.SendAcknowledgementMessage(message);
if (messageQueueResponse.ReturnStatus == true)
{
await _loggingManagementDataService.DeleteAcknowledgementsQueue(transactionQueueItem.AcknowledgementsQueueId);
returnResponse.Entity.Add(message);
}
}
await _loggingManagementDataService.UpdateDatabase();
_loggingManagementDataService.CommitTransaction();
_loggingManagementDataService.CloseConnection();
}
catch (Exception ex)
{
_loggingManagementDataService.RollbackTransaction();
returnResponse.ReturnStatus = false;
returnResponse.ReturnMessage.Add(ex.Message);
}
finally
{
_loggingManagementDataService.CloseConnection();
_sending = false;
}
return(returnResponse);
}
