public async Task <ResponseModel <ProductDataTransformation> > UpdateProduct(ProductDataTransformation productDataTransformation)
{
ResponseModel <ProductDataTransformation> returnResponse = new ResponseModel <ProductDataTransformation>();
Product product = new Product();
try
{
_productManagementDataService.OpenConnection(_connectionStrings.PrimaryDatabaseConnectionString);
_productManagementDataService.BeginTransaction((int)IsolationLevel.Serializable);
ProductBusinessRules <ProductDataTransformation> productBusinessRules = new ProductBusinessRules <ProductDataTransformation>(productDataTransformation, _productManagementDataService);
ValidationResult validationResult = await productBusinessRules.Validate();
if (validationResult.ValidationStatus == false)
{
_productManagementDataService.RollbackTransaction();
returnResponse.ReturnMessage = validationResult.ValidationMessages;
returnResponse.ReturnStatus = validationResult.ValidationStatus;
return(returnResponse);
}
product = _mapper.Map <Product>(productDataTransformation);
product.Dimension = _mapper.Map <Dimension>(productDataTransformation);
product.SalesInformation = _mapper.Map <SalesInformation>(productDataTransformation);
product.PurchaseInformation = _mapper.Map <PurchaseInformation>(productDataTransformation);
product.InventoryAccount = _mapper.Map <InventoryAccount>(productDataTransformation);
await _productManagementDataService.UpdateProduct(product);
await _productManagementDataService.UpdateDatabase();
_productManagementDataService.CommitTransaction();
returnResponse.ReturnStatus = true;
}
catch (Exception ex)
{
_productManagementDataService.RollbackTransaction();
returnResponse.ReturnStatus = false;
returnResponse.ReturnMessage.Add(ex.Message);
}
finally
{
_productManagementDataService.CloseConnection();
}
returnResponse.Entity = productDataTransformation;
return(returnResponse);
}
/// <summary>
/// Create Product
/// </summary>
/// <param name="product"></param>
/// <param name="transaction"></param>
/// <returns></returns>
public Product CreateProduct(Product product, out TransactionalInformation transaction)
{
transaction = new TransactionalInformation();
try
{
ProductBusinessRules productBusinessRules = new ProductBusinessRules();
ValidationResult results = productBusinessRules.Validate(product);
bool validationSucceeded = results.IsValid;
IList <ValidationFailure> failures = results.Errors;
if (validationSucceeded == false)
{
transaction = ValidationErrors.PopulateValidationErrors(failures);
return(product);
}
// Begin session
_dataService.CreateSession();
var param = product.ToDynamicParametersForInsert();
_dataService.ProductRepository.Insert(ProductScript.Insert, param, CommandType.Text);
_dataService.CommitTransaction(true);
transaction.ReturnStatus = true;
transaction.ReturnMessage.Add("successfully!");
}
catch (Exception ex)
{
string errorMessage = ex.Message;
transaction.ReturnMessage.Add(errorMessage);
transaction.ReturnStatus = false;
// Logging:
Log4NetLogger.log.Error(ex.Message);
}
finally
{
_dataService.CloseSession();
}
return(product);
}
/// <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);
}
