/// <summary>
/// Create Transaction Queue
/// </summary>
/// <param name="transactionQueue"></param>
/// <returns></returns>
public async Task CreateOutboundTransactionQueue(TransactionQueueOutbound transactionQueue)
{
DateTime dateCreated = DateTime.UtcNow;
transactionQueue.DateCreated = dateCreated;
await dbConnection.TransactionQueueOutbound.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 Outbound Transaction To History
/// </summary>
/// <param name="transactionQueueItem"></param>
/// <returns></returns>
private async Task LogOutboundTransactionToHistory(TransactionQueueOutbound transactionQueueItem)
{
TransactionQueueOutboundHistory transactionHistory = new TransactionQueueOutboundHistory();
transactionHistory.TransactionQueueOutboundId = transactionQueueItem.TransactionQueueOutboundId;
transactionHistory.TransactionCode = transactionQueueItem.TransactionCode;
transactionHistory.Payload = transactionQueueItem.Payload;
transactionHistory.ExchangeName = transactionQueueItem.ExchangeName;
transactionHistory.SentToExchange = transactionQueueItem.SentToExchange;
transactionHistory.DateOutboundTransactionCreated = transactionQueueItem.DateCreated;
transactionHistory.DateSentToExchange = transactionQueueItem.DateSentToExchange;
transactionHistory.DateToResendToExchange = transactionQueueItem.DateToResendToExchange;
await _inventoryManagementDataService.CreateOutboundTransactionQueueHistory(transactionHistory);
await _inventoryManagementDataService.DeleteOutboundTransactionQueueEntry(transactionQueueItem.TransactionQueueOutboundId);
}
/// <summary>
/// Submit Purchase Order
/// </summary>
/// <param name="purchaseOrderDataTransformation"></param>
/// <returns></returns>
public async Task <ResponseModel <PurchaseOrderDataTransformation> > SubmitPurchaseOrder(PurchaseOrderDataTransformation purchaseOrderDataTransformation)
{
ResponseModel <PurchaseOrderDataTransformation> returnResponse = new ResponseModel <PurchaseOrderDataTransformation>();
PurchaseOrder purchaseOrder = new PurchaseOrder();
int accountId = purchaseOrderDataTransformation.AccountId;
int purchaseOrderId = purchaseOrderDataTransformation.PurchaseOrderId;
try
{
_purchaseOrderManagementDataService.OpenConnection(_connectionStrings.PrimaryDatabaseConnectionString);
_purchaseOrderManagementDataService.BeginTransaction((int)IsolationLevel.ReadCommitted);
purchaseOrder = await _purchaseOrderManagementDataService.GetPurchaseOrder(accountId, purchaseOrderId);
if (purchaseOrder == null)
{
_purchaseOrderManagementDataService.RollbackTransaction();
returnResponse.ReturnMessage.Add("Purchase Order not found");
returnResponse.ReturnStatus = false;
return(returnResponse);
}
if (purchaseOrder.OrderTotal == 0.00)
{
_purchaseOrderManagementDataService.RollbackTransaction();
returnResponse.ReturnMessage.Add("Purchase Order has not value.");
returnResponse.ReturnStatus = false;
return(returnResponse);
}
purchaseOrder.PurchaseOrderStatusId = PurchaseOrderStatuses.Submitted;
await _purchaseOrderManagementDataService.UpdateDatabase();
purchaseOrder = await _purchaseOrderManagementDataService.GetPurchaseOrder(accountId, purchaseOrderId);
TransactionQueueOutbound transactionQueue = new TransactionQueueOutbound();
transactionQueue.Payload = GeneratePurchaseOrderSubmittedPayload(purchaseOrder);
transactionQueue.TransactionCode = TransactionQueueTypes.PurchaseOrderSubmitted;
transactionQueue.ExchangeName = MessageQueueExchanges.PurchaseOrderManagement;
await _purchaseOrderManagementDataService.CreateOutboundTransactionQueue(transactionQueue);
//await _purchaseOrderManagementDataService.UpdateDatabase();
_purchaseOrderManagementDataService.CommitTransaction();
returnResponse.ReturnStatus = true;
purchaseOrderDataTransformation.PurchaseOrderStatusId = purchaseOrder.PurchaseOrderStatusId;
}
catch (Exception ex)
{
_purchaseOrderManagementDataService.RollbackTransaction();
returnResponse.ReturnStatus = false;
returnResponse.ReturnMessage.Add(ex.Message);
}
finally
{
_purchaseOrderManagementDataService.CloseConnection();
}
returnResponse.Entity = purchaseOrderDataTransformation;
return(returnResponse);
}
/// <summary>
/// Update Sales Order Detail
/// </summary>
/// <param name="salesOrderDetailDataTransformation"></param>
/// <returns></returns>
public async Task <ResponseModel <SalesOrderDetailDataTransformation> > UpdateSalesOrderDetail(SalesOrderDetailDataTransformation salesOrderDetailDataTransformation)
{
ResponseModel <SalesOrderDetailDataTransformation> returnResponse = new ResponseModel <SalesOrderDetailDataTransformation>();
SalesOrderDetail salesOrderDetail = new SalesOrderDetail();
try
{
int accountId = salesOrderDetailDataTransformation.AccountId;
int salesOrderId = salesOrderDetailDataTransformation.SalesOrderId;
int salesOrderDetailId = salesOrderDetailDataTransformation.SalesOrderDetailId;
//
// Validate Shipped Quantity
//
if (salesOrderDetailDataTransformation.CurrentShippedQuantity == 0)
{
returnResponse.ReturnMessage.Add("Invalid Shipped Quantity");
returnResponse.ReturnStatus = false;
return(returnResponse);
}
//
// Begin a Serializable Transaction
//
_inventoryManagementDataService.OpenConnection(_connectionStrings.PrimaryDatabaseConnectionString);
_inventoryManagementDataService.BeginTransaction((int)IsolationLevel.Serializable);
//
// Get Sales Order Header
//
SalesOrder salesOrder = await _inventoryManagementDataService.GetSalesOrderHeader(accountId, salesOrderId);
if (salesOrder == null)
{
_inventoryManagementDataService.RollbackTransaction();
returnResponse.ReturnMessage.Add("Sales Order not found");
returnResponse.ReturnStatus = false;
return(returnResponse);
}
//
// Get Sales Order Detail
//
salesOrderDetail = await _inventoryManagementDataService.GetSalesOrderDetailForUpdate(salesOrderDetailId);
if (salesOrderDetail == null)
{
_inventoryManagementDataService.RollbackTransaction();
returnResponse.ReturnMessage.Add("Sales Order Detail not found");
returnResponse.ReturnStatus = false;
return(returnResponse);
}
//
// Update Sales Order Shipped Quantity
//
salesOrderDetail.ShippedQuantity = salesOrderDetail.ShippedQuantity + salesOrderDetailDataTransformation.CurrentShippedQuantity;
await _inventoryManagementDataService.UpdateSalesOrderDetail(salesOrderDetail);
//
// Get Product Record with an exclusive update lock
//
Product product = await _inventoryManagementDataService.GetProductInformationForUpdate(salesOrderDetail.ProductId);
if (product == null)
{
_inventoryManagementDataService.RollbackTransaction();
returnResponse.ReturnMessage.Add("Product not found");
returnResponse.ReturnStatus = false;
return(returnResponse);
}
//
// Reduce Product OnHand Quantity by the quantity shipped
//
product.OnHandQuantity = product.OnHandQuantity - salesOrderDetailDataTransformation.CurrentShippedQuantity;
await _inventoryManagementDataService.UpdateProduct(product);
//
// Create Inventory Transaction Record
//
InventoryTransaction inventoryTransaction = new InventoryTransaction();
inventoryTransaction.EntityId = salesOrderDetail.SalesOrderDetailId;
inventoryTransaction.MasterEntityId = salesOrderDetail.MasterSalesOrderDetailId;
inventoryTransaction.ProductId = salesOrderDetail.ProductId;
inventoryTransaction.UnitCost = product.AverageCost;
inventoryTransaction.Quantity = salesOrderDetailDataTransformation.CurrentShippedQuantity;
inventoryTransaction.TransactionDate = DateTime.UtcNow;
await _inventoryManagementDataService.CreateInventoryTransaction(inventoryTransaction);
//
// Create Transaction Queue record and create inventory transaction payload
//
TransactionQueueOutbound transactionQueue = new TransactionQueueOutbound();
transactionQueue.Payload = GenerateInventoryTransactionPayload(inventoryTransaction);
transactionQueue.TransactionCode = TransactionQueueTypes.InventoryShipped;
transactionQueue.ExchangeName = MessageQueueExchanges.InventoryManagement;
await _inventoryManagementDataService.CreateOutboundTransactionQueue(transactionQueue);
//await _inventoryManagementDataService.UpdateDatabase();
//
// Commit Transaction
//
_inventoryManagementDataService.CommitTransaction();
returnResponse.ReturnStatus = true;
}
catch (Exception ex)
{
_inventoryManagementDataService.RollbackTransaction();
returnResponse.ReturnStatus = false;
returnResponse.ReturnMessage.Add(ex.Message);
}
finally
{
_inventoryManagementDataService.CloseConnection();
}
returnResponse.Entity = salesOrderDetailDataTransformation;
return(returnResponse);
}
/// <summary>
/// Update Purchase Order Detail
/// </summary>
/// <param name="purchaseOrderDetailDataTransformation"></param>
/// <returns></returns>
public async Task <ResponseModel <PurchaseOrderDetailDataTransformation> > UpdatePurchaseOrderDetail(PurchaseOrderDetailDataTransformation purchaseOrderDetailDataTransformation)
{
ResponseModel <PurchaseOrderDetailDataTransformation> returnResponse = new ResponseModel <PurchaseOrderDetailDataTransformation>();
PurchaseOrderDetail purchaseOrderDetail = new PurchaseOrderDetail();
try
{
int accountId = purchaseOrderDetailDataTransformation.AccountId;
int purchaseOrderId = purchaseOrderDetailDataTransformation.PurchaseOrderId;
int purchaseOrderDetailId = purchaseOrderDetailDataTransformation.PurchaseOrderDetailId;
if (purchaseOrderDetailDataTransformation.CurrentReceivedQuantity == 0)
{
returnResponse.ReturnMessage.Add("Invalid Received Quantity");
returnResponse.ReturnStatus = false;
return(returnResponse);
}
_inventoryManagementDataService.OpenConnection(_connectionStrings.PrimaryDatabaseConnectionString);
_inventoryManagementDataService.BeginTransaction((int)IsolationLevel.Serializable);
PurchaseOrder purchaseOrder = await _inventoryManagementDataService.GetPurchaseOrderHeader(accountId, purchaseOrderId);
if (purchaseOrder == null)
{
_inventoryManagementDataService.RollbackTransaction();
returnResponse.ReturnMessage.Add("Purchase Order not found");
returnResponse.ReturnStatus = false;
return(returnResponse);
}
purchaseOrderDetail = await _inventoryManagementDataService.GetPurchaseOrderDetailForUpdate(purchaseOrderDetailId);
if (purchaseOrderDetail == null)
{
_inventoryManagementDataService.RollbackTransaction();
returnResponse.ReturnMessage.Add("Purchase Order Detail not found");
returnResponse.ReturnStatus = false;
return(returnResponse);
}
purchaseOrderDetail.ReceivedQuantity = purchaseOrderDetail.ReceivedQuantity + purchaseOrderDetailDataTransformation.CurrentReceivedQuantity;
await _inventoryManagementDataService.UpdatePurchaseOrderDetail(purchaseOrderDetail);
Product product = await _inventoryManagementDataService.GetProductInformationForUpdate(purchaseOrderDetail.ProductId);
if (product == null)
{
_inventoryManagementDataService.RollbackTransaction();
returnResponse.ReturnMessage.Add("Product not found");
returnResponse.ReturnStatus = false;
return(returnResponse);
}
double newAverageCost = CalculateAverageCost(product.OnHandQuantity, product.AverageCost, purchaseOrderDetailDataTransformation.CurrentReceivedQuantity, purchaseOrderDetail.UnitPrice);
if (newAverageCost != 0)
{
product.AverageCost = newAverageCost;
}
product.OnHandQuantity = product.OnHandQuantity + purchaseOrderDetailDataTransformation.CurrentReceivedQuantity;
await _inventoryManagementDataService.UpdateProduct(product);
InventoryTransaction inventoryTransaction = new InventoryTransaction();
inventoryTransaction.EntityId = purchaseOrderDetail.PurchaseOrderDetailId;
inventoryTransaction.MasterEntityId = purchaseOrderDetail.MasterPurchaseOrderDetailId;
inventoryTransaction.ProductId = purchaseOrderDetail.ProductId;
inventoryTransaction.UnitCost = purchaseOrderDetail.UnitPrice;
inventoryTransaction.Quantity = purchaseOrderDetailDataTransformation.CurrentReceivedQuantity;
inventoryTransaction.TransactionDate = DateTime.UtcNow;
await _inventoryManagementDataService.CreateInventoryTransaction(inventoryTransaction);
TransactionQueueOutbound transactionQueue = new TransactionQueueOutbound();
transactionQueue.Payload = GenerateInventoryTransactionPayload(inventoryTransaction);
transactionQueue.TransactionCode = TransactionQueueTypes.InventoryReceived;
transactionQueue.ExchangeName = MessageQueueExchanges.InventoryManagement;
await _inventoryManagementDataService.CreateOutboundTransactionQueue(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 = purchaseOrderDetailDataTransformation;
return(returnResponse);
}
/// <summary>
/// Upload Products
/// </summary>
/// <param name="products"></param>
/// <returns></returns>
public async Task <ResponseModel <List <ProductDataTransformation> > > UploadProducts(int accountId, List <ProductDataTransformation> products)
{
ResponseModel <List <ProductDataTransformation> > returnResponse = new ResponseModel <List <ProductDataTransformation> >();
try
{
_inventoryManagementDataService.OpenConnection(_connectionStrings.PrimaryDatabaseConnectionString);
List <Product> productsAdded = new List <Product>();
foreach (ProductDataTransformation productItem in products)
{
_inventoryManagementDataService.BeginTransaction((int)IsolationLevel.Serializable);
ProductBusinessRules <ProductDataTransformation> productBusinessRules = new ProductBusinessRules <ProductDataTransformation>(productItem, _inventoryManagementDataService);
ValidationResult validationResult = await productBusinessRules.Validate();
if (validationResult.ValidationStatus == false)
{
_inventoryManagementDataService.RollbackTransaction();
continue;
}
Product product = new Product();
product.AccountId = accountId;
product.ProductNumber = productItem.ProductNumber;
product.Description = productItem.Description;
product.UnitPrice = productItem.UnitPrice;
product.BinLocation = productItem.BinLocation;
await _inventoryManagementDataService.CreateProduct(product);
//await _inventoryManagementDataService.UpdateDatabase();
TransactionQueueOutbound transactionQueue = new TransactionQueueOutbound();
transactionQueue.Payload = GenerateProductUpdatePayload(product);
transactionQueue.TransactionCode = TransactionQueueTypes.ProductUpdated;
transactionQueue.ExchangeName = MessageQueueExchanges.InventoryManagement;
await _inventoryManagementDataService.CreateOutboundTransactionQueue(transactionQueue);
//await _inventoryManagementDataService.UpdateDatabase();
_inventoryManagementDataService.CommitTransaction();
productsAdded.Add(product);
}
foreach (ProductDataTransformation productItem in products)
{
Product product = productsAdded.Where(x => x.ProductNumber == productItem.ProductNumber).FirstOrDefault();
if (product != null)
{
continue;
}
product = await _inventoryManagementDataService.GetProductInformationByProductNumber(productItem.ProductNumber, accountId);
if (product == null)
{
continue;
}
productItem.ProductId = product.ProductId;
ProductBusinessRules <ProductDataTransformation> productBusinessRules = new ProductBusinessRules <ProductDataTransformation>(productItem, _inventoryManagementDataService);
ValidationResult validationResult = await productBusinessRules.Validate();
if (validationResult.ValidationStatus == false)
{
_inventoryManagementDataService.RollbackTransaction();
returnResponse.ReturnMessage = validationResult.ValidationMessages;
returnResponse.ReturnStatus = validationResult.ValidationStatus;
return(returnResponse);
}
_inventoryManagementDataService.BeginTransaction((int)IsolationLevel.Serializable);
product = await _inventoryManagementDataService.GetProductInformationForUpdate(productItem.ProductId);
product.ProductNumber = productItem.ProductNumber;
product.Description = productItem.Description;
product.UnitPrice = productItem.UnitPrice;
product.BinLocation = productItem.BinLocation;
await _inventoryManagementDataService.UpdateProduct(product);
TransactionQueueOutbound transactionQueue = new TransactionQueueOutbound();
transactionQueue.Payload = GenerateProductUpdatePayload(product);
transactionQueue.TransactionCode = TransactionQueueTypes.ProductUpdated;
transactionQueue.ExchangeName = MessageQueueExchanges.InventoryManagement;
await _inventoryManagementDataService.CreateOutboundTransactionQueue(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();
}
return(returnResponse);
}
/// <summary>
/// Update Product
/// </summary>
/// <param name="productDataTransformation"></param>
/// <returns></returns>
public async Task <ResponseModel <ProductDataTransformation> > UpdateProduct(ProductDataTransformation productDataTransformation)
{
ResponseModel <ProductDataTransformation> returnResponse = new ResponseModel <ProductDataTransformation>();
Product product = new Product();
try
{
_inventoryManagementDataService.OpenConnection(_connectionStrings.PrimaryDatabaseConnectionString);
_inventoryManagementDataService.BeginTransaction((int)IsolationLevel.Serializable);
ProductBusinessRules <ProductDataTransformation> productBusinessRules = new ProductBusinessRules <ProductDataTransformation>(productDataTransformation, _inventoryManagementDataService);
ValidationResult validationResult = await productBusinessRules.Validate();
if (validationResult.ValidationStatus == false)
{
_inventoryManagementDataService.RollbackTransaction();
returnResponse.ReturnMessage = validationResult.ValidationMessages;
returnResponse.ReturnStatus = validationResult.ValidationStatus;
return(returnResponse);
}
int productId = productDataTransformation.ProductId;
product = await _inventoryManagementDataService.GetProductInformationForUpdate(productId);
product.ProductNumber = productDataTransformation.ProductNumber;
product.Description = productDataTransformation.Description;
product.UnitPrice = productDataTransformation.UnitPrice;
product.BinLocation = productDataTransformation.BinLocation;
await _inventoryManagementDataService.UpdateProduct(product);
TransactionQueueOutbound transactionQueue = new TransactionQueueOutbound();
transactionQueue.Payload = GenerateProductUpdatePayload(product);
transactionQueue.TransactionCode = TransactionQueueTypes.ProductUpdated;
transactionQueue.ExchangeName = MessageQueueExchanges.InventoryManagement;
await _inventoryManagementDataService.CreateOutboundTransactionQueue(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 = productDataTransformation;
return(returnResponse);
}
/// <summary>
/// Get Outbound Transaction Queue Item By Id
/// </summary>
/// <param name="transactionQueueId"></param>
/// <returns></returns>
public async Task <TransactionQueueOutbound> GetOutboundTransactionQueueItemById(int transactionQueueId)
{
TransactionQueueOutbound transactionQueueItem = await dbConnection.TransactionQueueOutbound.Where(x => x.TransactionQueueOutboundId == transactionQueueId).FirstOrDefaultAsync();
return(transactionQueueItem);
}
/// <summary>
/// Delete Outbound Transaction Queue Entry
/// </summary>
/// <param name="transactionQueueId"></param>
/// <returns></returns>
public async Task DeleteOutboundTransactionQueueEntry(int transactionQueueId)
{
TransactionQueueOutbound transactionQueue = await dbConnection.TransactionQueueOutbound.Where(x => x.TransactionQueueOutboundId == transactionQueueId).FirstOrDefaultAsync();
dbConnection.TransactionQueueOutbound.Remove(transactionQueue);
}
/// <summary>
/// Update Transaction Queue
/// </summary>
/// <param name="transactionQueue"></param>
/// <returns></returns>
public async Task UpdateOutboundTransactionQueue(TransactionQueueOutbound transactionQueue)
{
await Task.Delay(0);
}
