public void ItWillValidateTransaction()
{
var transaction = new TransactionDomainModel
{
Symbol = "ABC",
TradeDate = new DateTime(year: 2020, month: 1, day: 1),
TradePrice = 100,
Quantity = 1,
Notional = 100
};
using (var mock = AutoMock.GetLoose())
{
mock.Mock <IDateTimeService>()
.Setup(x => x.HasDateTimeAlreadyOccurred(It.IsAny <DateTime>()))
.Returns(true);
var service = mock.Create <TransactionService>();
var result = service.ValidateTransaction(transaction);
Assert.NotNull(result);
Assert.Empty(result);
Assert.True(result.IsValid);
}
}
public async Task <string> AddUpdateUser(TransactionVM transactionVM)
{
TransactionDomainModel transactionDM = new TransactionDomainModel();
AutoMapper.Mapper.Map(transactionVM, transactionDM);
return(await transactionBusiness.AddUpdateTransaction(transactionDM));
}
public ModelStateDictionary ValidateTransaction(TransactionDomainModel inputModel)
{
var errors = new ModelStateDictionary();
if (string.IsNullOrWhiteSpace(inputModel.Symbol))
{
errors.AddModelError("Symbol", "A symbol is required for the transaction.");
}
if (inputModel.TradeDate == default)
{
errors.AddModelError("TradeDate", "A trade date is required for the transaction.");
}
else if (!_dateTimeHelper.HasDateTimeAlreadyOccurred(inputModel.TradeDate))
{
errors.AddModelError("TradeDate", "The transaction must have already occurred.");
}
if (inputModel.TradePrice <= decimal.Zero)
{
errors.AddModelError("TradePrice", "The trade price must be greater than zero.");
}
if (inputModel.Quantity == decimal.Zero)
{
errors.AddModelError("Quantity", "The quantity cannot be equal to zero.");
}
if (inputModel.Notional == decimal.Zero)
{
errors.AddModelError("Notional", "The notional cannot be equal to zero.");
}
return(errors);
}
public void ItWillInvalidateTransaction()
{
var transaction = new TransactionDomainModel
{
Symbol = string.Empty,
TradeDate = new DateTime(year: 2020, month: 1, day: 1),
TradePrice = -1,
Quantity = 0,
Notional = 0
};
using (var mock = AutoMock.GetLoose())
{
mock.Mock <IDateTimeService>()
.Setup(x => x.HasDateTimeAlreadyOccurred(It.IsAny <DateTime>()))
.Returns(false);
var service = mock.Create <TransactionService>();
var result = service.ValidateTransaction(transaction);
Assert.NotNull(result);
Assert.Equal(5, result.Count());
Assert.False(result.IsValid);
}
}
public string AddOut(TransactionDomainModel ts)
{
if ((Convert.ToInt32(ts.AccountID) == 0) || (Convert.ToInt32(ts.Amount) == 0) || (Convert.ToInt32(ts.TransactionType) == 0) || (ts.Date == Convert.ToDateTime("01-01-0001")))
{
return("One or more fields are empty");
}
else
{
account acc = accRep.SingleOrDefault(x => x.ID == ts.AccountID);
transaction trans = new transaction();
if (acc.Amount < ts.Amount)
{
return("Insufficient funds");
}
else
{
trans.AccountID = ts.AccountID;
trans.Amount = Convert.ToDouble(ts.Amount);
acc.Amount -= trans.Amount;
trans.TransactionType = ts.TransactionType;
trans.AccountTransferTo = ts.AccountTransferTo;
trans.Date = ts.Date;
accRep.Update(acc);
tsRep.Insert(trans);
return("");
}
}
}
public string Edit(TransactionDomainModel ts)
{
if ((Convert.ToInt32(ts.AccountID) == 0) || (Convert.ToInt32(ts.Amount) == 0) || (Convert.ToInt32(ts.TransactionType) == 0) || (ts.Date == Convert.ToDateTime("01-01-0001")))
{
return("One or more fields are empty");
}
else
{
trans_type t_type = tRep.SingleOrDefault(x => x.ID == ts.TransactionType);
transaction trans = tsRep.SingleOrDefault(x => x.ID == ts.ID);
if (ts.AccountID == ts.AccountTransferTo)
{
return("You cant transfer from and to one account");
}
if (t_type.Description != "Transfer" && ts.AccountTransferTo != null)
{
return("Speciefied operation is not transfer, so it can't have 'transfer to' field");
}
trans.AccountID = ts.AccountID;
trans.Amount = Convert.ToDouble(ts.Amount);
trans.TransactionType = ts.TransactionType;
if (t_type.Description == "Transfer" && ts.AccountTransferTo == null)
{
return("No destination account of the transfer was specified");
}
trans.AccountTransferTo = ts.AccountTransferTo;
trans.Date = ts.Date;
tsRep.Update(trans);
return("");
}
}
public async Task <TransactionToReturnVM> GetTransactionById(int id)
{
TransactionToReturnVM transactionToReturnVM = new TransactionToReturnVM();
TransactionDomainModel transactionDomainModel = await transactionBusiness.GetTransactionById(id);
AutoMapper.Mapper.Map(transactionDomainModel, transactionToReturnVM);
return(transactionToReturnVM);
}
public List <TransactionDomainModel> CategorySort(TransactionDomainModel DM)
{
List <TransactionDomainModel> list = tsRep.GetAll(x => x.TransactionType == DM.TransactionType).Select(m => new TransactionDomainModel {
ID = m.ID, AccountID = m.AccountID, Amount = m.Amount, TransactionType = DM.TransactionType, AccountTransferTo = m.AccountTransferTo, Date = m.Date
}).ToList();
return(list);
}
public string ConfirmEditTransaction(TransactionsViewModel vm)
{
TransactionDomainModel acc_dm = new TransactionDomainModel();
var mapper_accs = new MapperConfiguration(cfg => cfg.CreateMap <TransactionsViewModel, TransactionDomainModel>()).CreateMapper();
var transaction = mapper_accs.Map <TransactionsViewModel, TransactionDomainModel>(vm);
string response = ts.Edit(transaction);
return(response);
}
public string ConfirmAddTransferTransaction(TransactionsViewModel vm)
{
TransactionDomainModel ts_dm = new TransactionDomainModel();
var mapper_accs = new MapperConfiguration(cfg => cfg.CreateMap <TransactionsViewModel, TransactionDomainModel>()).CreateMapper();
var trans = mapper_accs.Map <TransactionsViewModel, TransactionDomainModel>(vm);
string response = ts.AddTransfer(trans);
return(response);
}
public ActionResult ConfirmCategorySort(TransactionsViewModel vm)
{
TransactionDomainModel ts_dm = new TransactionDomainModel();
var mapper_accs = new MapperConfiguration(cfg => cfg.CreateMap <TransactionsViewModel, TransactionDomainModel>()).CreateMapper();
var trans = mapper_accs.Map <TransactionsViewModel, TransactionDomainModel>(vm);
List <TransactionDomainModel> ts_listDomain = ts.CategorySort(trans);
List <TransactionsViewModel> VM_ts_list = new List <TransactionsViewModel>();
var mapper_ts = new MapperConfiguration(cfg => cfg.CreateMap <TransactionDomainModel, TransactionsViewModel>()).CreateMapper();
var transactions = mapper_ts.Map <IEnumerable <TransactionDomainModel>, List <TransactionsViewModel> >(ts_listDomain);
return(View(transactions));
}
public async Task UpdateAsync(TransactionDomainModel transaction)
{
var transactionEntityModel = _mapper.Map <TransactionEntityModel>(transaction);
var parameters = CreateParametersForUpdateAsync(transactionEntityModel);
using var connection = _connectionFactory.NewConnection();
await connection.OpenAsync();
await connection.QueryAsync(
"StoUpdateTransaction",
parameters,
commandType : CommandType.StoredProcedure);
}
public async Task <TransactionDomainModel> CreateAsync(TransactionDomainModel transaction)
{
var transactionEntityModel = _mapper.Map <TransactionEntityModel>(transaction);
var parameters = CreateParametersForCreateAynsc(transactionEntityModel);
using var connection = _connectionFactory.NewConnection();
await connection.OpenAsync();
var result = await connection.QueryAsync <TransactionEntityModel>(
"StoCreateTransaction",
parameters,
commandType : CommandType.StoredProcedure);
return(_mapper.Map <TransactionDomainModel>(result.SingleOrDefault()));
}
public async Task <TransactionDomainModel> GetTransactionById(int id)
{
TransactionDomainModel transaction = new TransactionDomainModel();
var model = await transactionRepository.SingleOrDefault(t => t.tra_id == id);
if (model != null)
{
transaction.tra_id = model.tra_id;
transaction.tra_type = model.tra_type;
transaction.voucherNo = model.voucherNo;
transaction.acc_id = model.acc_id;
transaction.description = model.description;
transaction.totalAmount = model.totalAmount;
transaction.user_id = model.user_id;
transaction.totalQty = model.totalQty;
transaction.barcode = model.barcode;
}
return(transaction);
}
public async Task <string> AddUpdateTransaction(TransactionDomainModel transaction)
{
string status = "";
if (transaction.tra_id > 0)
{
tblTransaction transactionToUpdate = await transactionRepository.SingleOrDefault(t => t.tra_id == transaction.tra_id);
if (transactionToUpdate != null)
{
transactionToUpdate.tra_type = transaction.tra_type;
transactionToUpdate.voucherNo = transaction.voucherNo;
transactionToUpdate.acc_id = transaction.acc_id;
transactionToUpdate.description = transaction.description;
transactionToUpdate.totalAmount = transaction.totalAmount;
transactionToUpdate.user_id = transaction.user_id;
transactionToUpdate.totalQty = transaction.totalQty;
transactionToUpdate.barcode = transaction.barcode;
await transactionRepository.Update(transactionToUpdate);
status = "updated";
}
}
else
{
tblTransaction transactionToAdd = new tblTransaction();
transactionToAdd.tra_type = transaction.tra_type;
transactionToAdd.voucherNo = transaction.voucherNo;
transactionToAdd.acc_id = transaction.acc_id;
transactionToAdd.description = transaction.description;
transactionToAdd.totalAmount = transaction.totalAmount;
transactionToAdd.user_id = transaction.user_id;
transactionToAdd.totalQty = transaction.totalQty;
transactionToAdd.barcode = transaction.barcode;
await transactionRepository.Insert(transactionToAdd);
status = "added";
}
return(status);
}
public async Task DeleteTransaction(TransactionDomainModel transaction)
{
await _transactionsRepository.DeleteAsync(transaction.TransactionId, transaction.AccessKey);
}
public async Task <TransactionDomainModel> CreateTransaction(TransactionDomainModel transaction)
{
return(await _transactionsRepository.CreateAsync(transaction));
}
public async Task UpdateTransaction(TransactionDomainModel transaction)
{
await _transactionsRepository.UpdateAsync(transaction);
}
