public async Task <TResult> Handle(TCommand request, CancellationToken cancellationToken)
{
//Validation
Type typeValidation = typeof(TCommand);
Assembly assembly = Assembly.GetAssembly(typeValidation);
var validatorBaseType = typeof(AbstractValidator <>).MakeGenericType(typeValidation);
var validatorType = assembly.GetTypes().FirstOrDefault(type => type.IsSubclassOf(validatorBaseType));
if (validatorType != null)
{
var validator = Activator.CreateInstance(validatorType);
var method = validatorBaseType.GetMethods().Where(m => m.Name == "Validate" && m.GetParameters()[0].ParameterType == typeValidation).First();
ValidationResult results = (ValidationResult)method.Invoke(validator, new object[] { request });
if (!results.IsValid)
{
List <APIResult> returnErrors = new List <APIResult>();
foreach (var error in results.Errors)
{
returnErrors.Add(new APIResult()
{
Result = -1,
ErrorMessage = error.ErrorMessage
});
}
throw new BusinessException(JsonConvert.SerializeObject(returnErrors));
}
}
if (request.CmdStyle == CommandStyles.Normal)
{
return(await HandleCommand(request, cancellationToken));
}
else if (request.CmdStyle == CommandStyles.Transaction)
{
if (CachingCommandTransaction.TryGetValue(request.CommandId, out CachingCommandTransactionModel transModel))
{
return(await HandleCommandTransaction(request, transModel, cancellationToken));
}
else
{
var conn = DALHelper.GetConnection();
conn.Open();
var trans = conn.BeginTransaction();
transModel = new CachingCommandTransactionModel()
{
Connection = conn,
Transaction = trans
};
if (CachingCommandTransaction.TrySetValue(request.CommandId, transModel))
{
return(await HandleCommandTransaction(request, transModel, cancellationToken));
}
else
{
throw new BusinessException("Common.CachingData.SetError");
}
}
}
else if (request.CmdStyle == CommandStyles.CommitTransaction)
{
if (!CachingCommandTransaction.TryGetValue(request.CommandId, out CachingCommandTransactionModel transModel))
{
throw new BusinessException("Common.CachingData.GetError");
}
transModel.Transaction.Commit();
transModel.Transaction.Dispose();
transModel.Connection.Dispose();
//Remove TransModel
CachingCommandTransaction.TryRemoveCaching <CachingCommandTransactionModel>(request.CommandId);
return(default(TResult));
}
else //Rollback Transaction
{
if (!CachingCommandTransaction.TryGetValue(request.CommandId, out CachingCommandTransactionModel transModel))
{
throw new BusinessException("Common.CachingData.GetError");
}
transModel.Transaction.Rollback();
transModel.Transaction.Dispose();
transModel.Connection.Dispose();
//Remove TransModel
CachingCommandTransaction.TryRemoveCaching <CachingCommandTransactionModel>(request.CommandId);
return(default(TResult));
}
}
public virtual Task <TResult> HandleCommandTransaction(TCommand request, CachingCommandTransactionModel trans, CancellationToken cancellationToken)
{
return(default(Task <TResult>));
}
public override async Task <int> HandleCommandTransaction(UpdateCommand request, CachingCommandTransactionModel trans, CancellationToken cancellationToken)
{
if ((request.Direction != 1 && request.Direction != 2) || request.CollectionId == 0 || string.IsNullOrEmpty(request.TraceCode) || request.Quantity <= 0)
{
throw new BusinessException("AddWrongInformation");
}
var employee = await WebHelper.HttpGet <Employee>(GlobalConfiguration.APIGateWayURI, AppUrl.GetEmployeeByUser, request.LoginSession.AccessToken);
if (employee == null)
{
throw new NotPermissionException();
}
var collection = (await collectionQueries.GetsByEmployeeId(employee.Id)).FirstOrDefault(c => c.Id == request.CollectionId);
if (collection == null)
{
throw new NotPermissionException();
}
collectionInventoryQueries.JoinTransaction(trans.Connection, trans.Transaction);
collectionInventoryRepository.JoinTransaction(trans.Connection, trans.Transaction);
collectionInventoryHistoryRepository.JoinTransaction(trans.Connection, trans.Transaction);
var inventory = await collectionInventoryQueries.GetByTraceCode(request.TraceCode);
if (inventory == null)
{
if (request.Direction == 0)
{
throw new BusinessException("Collection.Inventory.TraceCode.NotExisted");
}
await collectionInventoryRepository.Add(new MDM.UI.Collections.Models.CollectionInventory()
{
CollectionId = request.CollectionId,
ProductId = request.ProductId,
UoMId = request.UoMId,
TraceCode = request.TraceCode,
Quantity = request.Quantity,
ModifiedBy = request.LoginSession.Id,
ModifiedDate = DateTime.Now
});
await collectionInventoryHistoryRepository.Add(new MDM.UI.Collections.Models.CollectionInventoryHistory()
{
TraceCode = request.TraceCode,
CollectionId = request.CollectionId,
ProductId = request.ProductId,
UoMId = request.UoMId,
Direction = request.Direction,
Quantity = request.Quantity,
LastQuantity = request.Quantity,
CreatedDate = DateTime.Now,
CreatedBy = request.LoginSession.Id,
Reason = request.Reason
});
}
else
{
if (request.CollectionId != inventory.CollectionId)
{
throw new BusinessException("Collection.Inventory.TraceCode.NotSameCollection");
}
var quantity = inventory.Quantity + (request.Direction == 1 ? request.Quantity : -request.Quantity);
if (request.Direction == 0 && quantity < 0)
{
throw new BusinessException("Collection.Inventory.TraceCode.NotEnoughQuantity");
}
if (quantity == 0)
{
await collectionInventoryRepository.Delete(inventory.Id);
}
else
{
inventory.Quantity = quantity;
inventory.ModifiedDate = DateTime.Now;
inventory.ModifiedBy = request.LoginSession.Id;
await collectionInventoryRepository.Update(inventory);
}
await collectionInventoryHistoryRepository.Add(new MDM.UI.Collections.Models.CollectionInventoryHistory()
{
TraceCode = request.TraceCode,
CollectionId = request.CollectionId,
ProductId = request.ProductId,
UoMId = request.UoMId,
Direction = request.Direction,
Quantity = request.Quantity,
LastQuantity = quantity,
CreatedDate = DateTime.Now,
CreatedBy = request.LoginSession.Id,
Reason = request.Reason
});
}
return(0);
}
public override async Task <int> HandleCommandTransaction(UpdateItemStatusCommand request, CachingCommandTransactionModel trans, CancellationToken cancellationToken)
{
if (request.OrderId == 0 && request.OrderItemId == 0)
{
throw new BusinessException("OrderItem.NotExisted");
}
if (!Enum.IsDefined(typeof(RetailerOrderStatuses), request.StatusId))
{
throw new BusinessException("Order.NotExistedStatus");
}
retailerOrderQueries.JoinTransaction(trans.Connection, trans.Transaction);
var order = await retailerOrderQueries.Get(request.OrderId);
if (order != null)
{
if (request.StatusId == (int)RetailerOrderStatuses.Canceled && order.StatusId != (int)RetailerOrderStatuses.Ordered)
{
//Cancel the order that is comfirmed.
throw new BusinessException("Order.CantCanceled");
}
else if (order.StatusId <= request.StatusId)
{
//wrong step; dump data
throw new BusinessException("Order.WrongStep");
}
retailerOrderRepository.JoinTransaction(trans.Connection, trans.Transaction);
var item = order.Items.FirstOrDefault(i => i.Id == request.OrderItemId);
if (item == null)
{
throw new BusinessException("OrderItem.NotExisted");
}
item.StatusId = request.StatusId;
await retailerOrderRepository.UpdateItem(item);
await retailerOrderRepository.AddAudit(new UI.Models.RetailerOrderAudit()
{
RetailerId = order.RetailerId,
RetailerOrderId = order.Id,
RetailerOrderItemId = item.Id,
StatusId = request.StatusId,
CreatedBy = request.LoginSession.Id,
CreatedDate = DateTime.Now,
Note = string.Empty
});
order.StatusId = request.StatusId;
order = UpdateBuild(order, request.LoginSession);
return(await retailerOrderRepository.Update(order));
}
throw new BusinessException("OrderItem.NotExisted");
}
public async Task <TResult> Handle(TCommand request, CancellationToken cancellationToken)
{
//Validation
Type typeValidation = typeof(TCommand);
Assembly assembly = Assembly.GetAssembly(typeValidation);
var validatorBaseType = typeof(AbstractValidator <>).MakeGenericType(typeValidation);
var validatorType = assembly.GetTypes().FirstOrDefault(type => type.IsSubclassOf(validatorBaseType));
if (validatorType != null)
{
var validator = Activator.CreateInstance(validatorType);
var method = validatorBaseType.GetMethods().First(m => m.Name == "Validate" && m.GetParameters()[0].ParameterType == typeValidation);
ValidationResult results = (ValidationResult)method.Invoke(validator, new object[] { request });
if (!results.IsValid)
{
IEnumerable <ApiResult> returnErrors = from error
in results.Errors
select new ApiResult()
{
Result = -1, ErrorMessage = error.ErrorMessage
};
throw new BusinessException(JsonConvert.SerializeObject(returnErrors));
}
}
CachingCommandTransactionModel transModel = null;
switch (request.CmdStyle)
{
case CommandStyles.Normal:
return(await HandleCommand(request, cancellationToken));
case CommandStyles.Transaction:
if (CachingCommandTransaction.TryGetValue(CachingConstant.CACHINGCOMMAND, request.CommandId, out transModel))
{
return(await HandleCommandTransaction(request, transModel, cancellationToken));
}
var conn = DalHelper.GetConnection();
conn.Open();
var trans = conn.BeginTransaction();
transModel = new CachingCommandTransactionModel()
{
Connection = conn,
Transaction = trans
};
if (!CachingCommandTransaction.TrySetValue(CachingConstant.CACHINGCOMMAND, request.CommandId, transModel))
{
throw new BusinessException("Common.CachingData.SetError");
}
return(await HandleCommandTransaction(request, transModel, cancellationToken));
case CommandStyles.CommitTransaction:
if (!CachingCommandTransaction.TryGetValue(CachingConstant.CACHINGCOMMAND, request.CommandId, out transModel))
{
throw new BusinessException("Common.CachingData.GetError");
}
transModel.Transaction.Commit();
transModel.Transaction.Dispose();
transModel.Connection.Dispose();
//Remove TransModel
CachingCommandTransaction.TryRemoveValue <CachingCommandTransactionModel>(CachingConstant.CACHINGCOMMAND, request.CommandId);
return(default);
default:
if (!CachingCommandTransaction.TryGetValue(CachingConstant.CACHINGCOMMAND, request.CommandId, out transModel))
{
throw new BusinessException("Common.CachingData.GetError");
}
transModel.Transaction.Rollback();
transModel.Transaction.Dispose();
transModel.Connection.Dispose();
//Remove TransModel
CachingCommandTransaction.TryRemoveValue <CachingCommandTransactionModel>(CachingConstant.CACHINGCOMMAND, request.CommandId);
return(default);
}
}
