/// <summary>
/// Inventory Shipped
/// </summary>
/// <param name="transaction"></param>
/// <returns></returns>
private async Task InventoryShipped(TransactionQueueInbound transaction)
{
InventoryTransactionPayload payload = JsonConvert.DeserializeObject <InventoryTransactionPayload>(transaction.Payload);
int productMasterId = payload.ProductId;
Product product = await _salesOrderManagementDataService.GetProductInformationByProductMasterForUpdate(productMasterId);
if (product != null)
{
product.OnHandQuantity = product.OnHandQuantity - payload.Quantity;
product.CommittedQuantity = product.CommittedQuantity - payload.Quantity;
await _salesOrderManagementDataService.UpdateProduct(product);
}
SalesOrderDetail salesOrderDetail = await _salesOrderManagementDataService.GetSalesOrderDetailForUpdate(payload.MasterEntityId);
if (salesOrderDetail != null)
{
salesOrderDetail.ShippedQuantity = salesOrderDetail.ShippedQuantity + payload.Quantity;
await _salesOrderManagementDataService.UpdateSalesOrderDetail(salesOrderDetail);
}
await LogSuccessfullyProcessed(transaction);
}
/// <summary>
/// Product Updated
/// </summary>
/// <param name="transaction"></param>
private async Task ProductUpdated(TransactionQueueInbound transaction)
{
ProductUpdatePayload payload = JsonConvert.DeserializeObject <ProductUpdatePayload>(transaction.Payload);
int productMasterId = payload.ProductId;
Product product = await _salesOrderManagementDataService.GetProductInformationByProductMasterForUpdate(productMasterId);
if (product != null)
{
product.ProductNumber = payload.ProductNumber;
product.Description = payload.Description;
product.UnitPrice = payload.UnitPrice;
await _salesOrderManagementDataService.UpdateProduct(product);
}
else
{
product = new Product();
product.AccountId = payload.AccountId;
product.ProductNumber = payload.ProductNumber;
product.ProductMasterId = payload.ProductId;
product.Description = payload.Description;
product.UnitPrice = payload.UnitPrice;
await _salesOrderManagementDataService.CreateProduct(product);
}
await LogSuccessfullyProcessed(transaction);
}
/// <summary>
/// Create Inbound Transaction Queue
/// </summary>
/// <param name="transactionQueue"></param>
/// <returns></returns>
public async Task CreateInboundTransactionQueue(TransactionQueueInbound transactionQueue)
{
DateTime dateCreated = DateTime.UtcNow;
transactionQueue.DateCreated = dateCreated;
await dbConnection.TransactionQueueInbound.AddAsync(transactionQueue);
}
/// <summary>
/// Process Acknowledgement
/// </summary>
/// <param name="transaction"></param>
private async Task ProcessAcknowledgement(TransactionQueueInbound transaction)
{
int transactionId = transaction.SenderTransactionQueueId;
TransactionQueueOutbound transactionQueueItem = await _inventoryManagementDataService.GetOutboundTransactionQueueItemById(transactionId);
if (transactionQueueItem != null)
{
await LogOutboundTransactionToHistory(transactionQueueItem);
}
}
/// <summary>
/// Log Successfully Processed
/// </summary>
/// <param name="transaction"></param>
/// <returns></returns>
private async Task LogSuccessfullyProcessed(TransactionQueueInbound transaction)
{
TransactionQueueInboundHistory transactionHistory = new TransactionQueueInboundHistory();
transactionHistory.TransactionQueueInboundId = transaction.TransactionQueueInboundId;
transactionHistory.SenderTransactionQueueId = transaction.SenderTransactionQueueId;
transactionHistory.TransactionCode = transaction.TransactionCode;
transactionHistory.Payload = transaction.Payload;
transactionHistory.ExchangeName = transaction.ExchangeName;
transactionHistory.ProcessedSuccessfully = true;
transactionHistory.DuplicateMessage = false;
transactionHistory.ErrorMessage = string.Empty;
transactionHistory.DateCreatedInbound = transaction.DateCreated;
await _inventoryManagementDataService.CreateInboundTransactionQueueHistory(transactionHistory);
}
/// <summary>
/// Log Duplicate Message
/// </summary>
/// <param name="transactionQueueItem"></param>
/// <returns></returns>
private async Task LogDuplicateMessage(TransactionQueueInbound transactionQueueItem)
{
// log history as duplicate
TransactionQueueInboundHistory transactionHistory = new TransactionQueueInboundHistory();
transactionHistory.TransactionQueueInboundId = transactionQueueItem.TransactionQueueInboundId;
transactionHistory.SenderTransactionQueueId = transactionQueueItem.SenderTransactionQueueId;
transactionHistory.TransactionCode = transactionQueueItem.TransactionCode;
transactionHistory.Payload = transactionQueueItem.Payload;
transactionHistory.ExchangeName = transactionQueueItem.ExchangeName;
transactionHistory.ProcessedSuccessfully = false;
transactionHistory.DuplicateMessage = true;
transactionHistory.ErrorMessage = string.Empty;
transactionHistory.DateCreatedInbound = transactionQueueItem.DateCreated;
await _salesOrderManagementDataService.CreateInboundTransactionQueueHistory(transactionHistory);
}
/// <summary>
/// Inventory Received
/// </summary>
/// <param name="transaction"></param>
/// <returns></returns>
private async Task InventoryReceived(TransactionQueueInbound transaction)
{
InventoryTransactionPayload payload = JsonConvert.DeserializeObject <InventoryTransactionPayload>(transaction.Payload);
int productMasterId = payload.ProductId;
Product product = await _salesOrderManagementDataService.GetProductInformationByProductMasterForUpdate(productMasterId);
if (product != null)
{
product.OnHandQuantity = product.OnHandQuantity + payload.Quantity;
await _salesOrderManagementDataService.UpdateProduct(product);
}
await LogSuccessfullyProcessed(transaction);
}
/// <summary>
/// Inventory Received
/// </summary>
/// <param name="transaction"></param>
private async Task InventoryReceived(TransactionQueueInbound transaction)
{
InventoryTransactionPayload payload = JsonConvert.DeserializeObject <InventoryTransactionPayload>(transaction.Payload);
int purchaseOrderDetailId = payload.MasterEntityId;
PurchaseOrderDetail purchaseOrderDetail = await _purchaseOrderManagementDataService.GetPurchaseOrderDetailForUpdate(purchaseOrderDetailId);
if (purchaseOrderDetail != null)
{
purchaseOrderDetail.ReceiviedQuantity = purchaseOrderDetail.ReceiviedQuantity + payload.Quantity;
await _purchaseOrderManagementDataService.UpdatePurchaseOrderDetail(purchaseOrderDetail);
}
await LogSuccessfullyProcessed(transaction);
}
/// <summary>
/// Sales Order Submitted
/// </summary>
/// <param name=""></param>
private async Task SalesOrderSubmitted(TransactionQueueInbound transaction)
{
SalesOrderUpdatePayload payload = JsonConvert.DeserializeObject <SalesOrderUpdatePayload>(transaction.Payload);
SalesOrder salesOrder = new SalesOrder();
salesOrder.AccountId = payload.AccountId;
salesOrder.AddressLine1 = payload.AddressLine1;
salesOrder.AddressLine2 = payload.AddressLine2;
salesOrder.City = payload.City;
salesOrder.Region = payload.Region;
salesOrder.PostalCode = payload.PostalCode;
salesOrder.CustomerName = payload.CustomerName;
salesOrder.SalesOrderStatusId = SalesOrderStatuses.Open;
salesOrder.SalesOrderNumber = payload.SalesOrderNumber;
salesOrder.MasterSalesOrderId = payload.SalesOrderId;
salesOrder.OrderTotal = payload.OrderTotal;
await _inventoryManagementDataService.CreateSalesOrder(salesOrder);
await _inventoryManagementDataService.UpdateDatabase();
foreach (SalesOrderDetailUpdatePayload detail in payload.SalesOrderDetails)
{
SalesOrderDetail salesOrderDetail = new SalesOrderDetail();
salesOrderDetail.AccountId = payload.AccountId;
salesOrderDetail.MasterSalesOrderDetailId = detail.SalesOrderDetailId;
salesOrderDetail.SalesOrderId = salesOrder.SalesOrderId;
salesOrderDetail.ProductId = detail.ProductMasterId;
salesOrderDetail.ProductNumber = detail.ProductNumber;
salesOrderDetail.ProductDescription = detail.ProductDescription;
salesOrderDetail.UnitPrice = detail.UnitPrice;
salesOrderDetail.OrderQuantity = detail.OrderQuantity;
salesOrderDetail.ShippedQuantity = 0;
salesOrderDetail.OrderTotal = detail.UnitPrice * detail.OrderQuantity;
await _inventoryManagementDataService.CreateSalesOrderDetail(salesOrderDetail);
}
await LogSuccessfullyProcessed(transaction);
}
/// <summary>
/// Purchase Order Submitted
/// </summary>
/// <param name=""></param>
private async Task PurchaseOrderSubmitted(TransactionQueueInbound transaction)
{
PurchaseOrderUpdatePayload payload = JsonConvert.DeserializeObject <PurchaseOrderUpdatePayload>(transaction.Payload);
PurchaseOrder purchaseOrder = new PurchaseOrder();
purchaseOrder.AccountId = payload.AccountId;
purchaseOrder.AddressLine1 = payload.AddressLine1;
purchaseOrder.AddressLine2 = payload.AddressLine2;
purchaseOrder.City = payload.City;
purchaseOrder.Region = payload.Region;
purchaseOrder.PostalCode = payload.PostalCode;
purchaseOrder.SupplierName = payload.SupplierName;
purchaseOrder.PurchaseOrderStatusId = PurchaseOrderStatuses.Open;
purchaseOrder.PurchaseOrderNumber = payload.PurchaseOrderNumber;
purchaseOrder.MasterPurchaseOrderId = payload.PurchaseOrderId;
purchaseOrder.OrderTotal = payload.OrderTotal;
await _inventoryManagementDataService.CreatePurchaseOrder(purchaseOrder);
await _inventoryManagementDataService.UpdateDatabase();
foreach (PurchaseOrderDetailUpdatePayload detail in payload.PurchaseOrderDetails)
{
PurchaseOrderDetail purchaseOrderDetail = new PurchaseOrderDetail();
purchaseOrderDetail.AccountId = payload.AccountId;
purchaseOrderDetail.MasterPurchaseOrderDetailId = detail.PurchaseOrderDetailId;
purchaseOrderDetail.PurchaseOrderId = purchaseOrder.PurchaseOrderId;
purchaseOrderDetail.ProductId = detail.ProductMasterId;
purchaseOrderDetail.ProductNumber = detail.ProductNumber;
purchaseOrderDetail.ProductDescription = detail.ProductDescription;
purchaseOrderDetail.UnitPrice = detail.UnitPrice;
purchaseOrderDetail.OrderQuantity = detail.OrderQuantity;
purchaseOrderDetail.ReceivedQuantity = 0;
purchaseOrderDetail.OrderTotal = detail.UnitPrice * detail.OrderQuantity;
await _inventoryManagementDataService.CreatePurchaseOrderDetail(purchaseOrderDetail);
}
await LogSuccessfullyProcessed(transaction);
}
/// <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
{
_inventoryManagementDataService.OpenConnection(connectionStrings.PrimaryDatabaseConnectionString);
_inventoryManagementDataService.BeginTransaction((int)IsolationLevel.ReadCommitted);
TransactionQueueInbound transactionQueue = new TransactionQueueInbound();
transactionQueue.ExchangeName = messageQueue.ExchangeName;
transactionQueue.SenderTransactionQueueId = messageQueue.TransactionQueueId;
transactionQueue.TransactionCode = messageQueue.TransactionCode;
transactionQueue.Payload = messageQueue.Payload;
await _inventoryManagementDataService.CreateInboundTransactionQueue(transactionQueue);
await _inventoryManagementDataService.UpdateDatabase();
_inventoryManagementDataService.CommitTransaction();
returnResponse.ReturnStatus = true;
}
catch (Exception ex)
{
_inventoryManagementDataService.RollbackTransaction();
returnResponse.ReturnStatus = false;
returnResponse.ReturnMessage.Add(ex.Message);
}
finally
{
_inventoryManagementDataService.CloseConnection();
}
returnResponse.Entity = messageQueue;
return(returnResponse);
}
/// <summary>
/// Delete Inbound Transaction Queue Entry
/// </summary>
/// <param name="transactionQueueId"></param>
/// <returns></returns>
public async Task DeleteInboundTransactionQueueEntry(int transactionQueueId)
{
TransactionQueueInbound transactionQueue = await dbConnection.TransactionQueueInbound.Where(x => x.TransactionQueueInboundId == transactionQueueId).FirstOrDefaultAsync();
dbConnection.TransactionQueueInbound.Remove(transactionQueue);
}
