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); }