public async Task CreateNewRoll(RollEntity oldRoll) { var nextRollDate = DateTimeOffset.UtcNow.AddMinutes(1); //if (oldRoll != null) //{ // nextRollDate = oldRoll.RollDate.AddMinutes(1); //} var newRoll = new RollEntity { IsFinished = false, RollDate = nextRollDate, WinningLat = null, WinningLng = null }; if (oldRoll != null) { newRoll.PreviousRollId = oldRoll.Id; } if (_transactionRepository.Add(newRoll) == 0) { throw new TransactionRepositoryException("Failed to add new roll"); } }
public bool Deposit(int id, double value) { if (value <= 0) { throw new BankAccountInvalidTransactionValueException(); } BankAccount bankAccount = GetById(id); Transaction transaction = new Transaction { Date = DateTime.Now, BankAccountId = bankAccount.Id, OperationType = OperationTypeEnum.Credit, Value = value }; bankAccount.Deposit(value); transaction = _repositoryTransaction.Add(transaction); if (transaction.Id > 0) { bankAccount.Transactions.Add(transaction); return(Update(bankAccount)); } else { return(false); } }
public TransactionDto Withdrawal(TransactionDto transactionDto) { var card = _cardRepository.GetCardByNumberAndSecurityCode(transactionDto.Number, transactionDto.SecurityCode); var cardDto = HydrateCardDto(card); var transaction = HydrateTransaction(transactionDto, cardDto); var balanceValidate = new BalanceValidation(card.Balance); if (card == null) { return(HydrateTransactionDto(transaction, ExceptionConstants.CARD_NOT_EXISTS)); } if (!card.Active) { return(HydrateTransactionDto(transaction, ExceptionConstants.CARD_BLOCKED)); } if (balanceValidate.negative) { return(HydrateTransactionDto(transaction, ExceptionConstants.INSUFFICIENT_BALANCE)); } if ((card.Number.Equals(transactionDto.Number))) { _cardRepository.UpdateBalance(card, (-transaction.Amount)); _repository.Add(transaction); } return(HydrateTransactionDto(transaction, ExceptionConstants.CREATE_SUCCESS)); }
protected override async Task <Unit> HandleValidatedCommand(AddTransferTransactionCommand command) { await _repository.Add( id : command.IdOrigin, financialYearId : command.FinancialYearId, transactionDate : command.TransactionDate, accountId : command.OriginAccountId, supplierId : null, amountInCents : -command.AmountInCents, isInternalTransfer : true, description : command.Description, comment : command.Comment, codeNames : command.CodeNames); await _repository.Add( id : command.IdDestination, financialYearId : command.FinancialYearId, transactionDate : command.TransactionDate, accountId : command.DestinationAccountId, supplierId : null, amountInCents : command.AmountInCents, isInternalTransfer : true, description : command.Description, comment : command.Comment, codeNames : command.CodeNames); return(Unit.Value); }
public async Task <IActionResult> AddAccount(int userId, AccountForCreationDto AccountForCreation) { var creator = await _userRepo.GetUser(userId); if (creator.Id != int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value)) { return(Unauthorized()); } var Account = _mapper.Map <Account>(AccountForCreation); Account.User = creator; Account.Balance = 0; Account.Active = true; Account.IsBank = false; _repo.Add(Account); if (await _repo.SaveAll()) { var jobToReturn = _mapper.Map <AccountForReturnDto>(Account); return(CreatedAtRoute("GetAccount", new { Name = Account.Name, userId = userId }, jobToReturn)); } throw new Exception("Creation of Account failed on save"); }
public Transaction PayTransaction(int senderId, int receiverId, decimal amount, string transDetail) { Transaction transaction = new Transaction() { SenderId = senderId, ReceiverId = receiverId, Amount = amount, Detail = transDetail, State = PaymentConstants.PAYMENT_STATE_SUCCESS, Type = PaymentConstants.PAYMENT_TYPE_PAY, Time = DateTime.Now }; Wallet senderWallet = _walletRepository.GetAll().Where(w => w.UserId == senderId).FirstOrDefault(); Wallet recieverWallet = _walletRepository.GetAll().Where(w => w.UserId == receiverId).FirstOrDefault(); if (senderWallet != null && recieverWallet != null) { senderWallet.Balance -= (double)amount; recieverWallet.Balance += (double)amount; _walletRepository.Update(senderWallet); _walletRepository.Update(recieverWallet); return(_transactionRepository.Add(transaction)); } return(null); }
public bool ConfirmOrder(int orderId, string currentUserId) { var order = GetOrder(orderId, i => i.Buyer, i => i.CurrentStatus, i => i.Seller, i => i.StatusLogs); if (order != null) { if (order.CurrentStatus != null) { if (order.BuyerId == currentUserId && order.CurrentStatus.Value == OrderStatuses.BuyerConfirming) { var mainCup = userProfileRepository.GetUserByName("palyerup"); if (mainCup != null) { decimal amount = order.AmmountSellerGet.Value; transactionRepository.Add(new Transaction { Amount = amount, Receiver = order.Seller, Sender = mainCup, Order = order, TransactionDate = DateTime.Now }); mainCup.Balance -= amount; order.Seller.Balance += amount; order.StatusLogs.AddLast(new StatusLog() { OldStatus = order.CurrentStatus, NewStatus = orderStatusRepository.GetOrderStatusByValue(OrderStatuses.PayingToSeller), TimeStamp = DateTime.Now }); order.CurrentStatus = orderStatusRepository.GetOrderStatusByValue(OrderStatuses.PayingToSeller); order.StatusLogs.AddLast(new StatusLog() { OldStatus = order.CurrentStatus, NewStatus = orderStatusRepository.GetOrderStatusByValue(OrderStatuses.ClosedSuccessfully), TimeStamp = DateTime.Now }); order.CurrentStatus = orderStatusRepository.GetOrderStatusByValue(OrderStatuses.ClosedSuccessfully); order.BuyerChecked = false; order.SellerChecked = false; //TempData["orderBuyStatus"] = "Спасибо за подтверждение сделки! Сделка успешно закрыта."; //return RedirectToAction("BuyDetails", "Order", new { id = order.Id }); return(true); } } } } return(false); }
public Transaction Deposit(decimal amount, int userId) { var deposit = new Transaction { UserId = userId, Amount = amount, Type = TypeTransaction.Deposit }; return(_repository.Add(deposit)); }
public void CreateOne() { Assert.AreEqual(0, _repo.GetAll().Count); Transaction transaction = new Transaction(1, (decimal)200.00, new Player(), 2020, 3); _repo.Add(transaction); Assert.AreEqual(1, _repo.GetAll().Count); Assert.AreEqual(transaction, _repo.GetTransactionById(transaction.Id)); }
public Transaction MakeDeposit(Guid accountId, decimal amount, Guid actionBy, bool applyFee) { try { Account account = _accountService.GetAccount(accountId); if (account == null) { throw new Exception("Account not found"); } bool hasAuthorize = _authenticationService.CheckAccountAuthorize(actionBy, account.Id); if (!hasAuthorize) { throw new Exception("Unauthorize to make transaction"); } Transaction transaction = new Transaction { Id = Guid.NewGuid(), AccoundId = accountId, Amount = amount, TransactionType = (int)GlobalConfig.TransactionType.DEPOSIT, ActionByCustomerId = account.CustomerId, IsActive = true, CreatedDate = DateTime.Now, }; transaction.TransactionFee = applyFee ? CalDepositFee(transaction.Amount) : 0; transaction.AmountAfterFee = transaction.Amount - transaction.TransactionFee; transaction.Amount = Math.Round(transaction.Amount, 2); transaction.TransactionFee = Math.Round(transaction.TransactionFee, 2); transaction.AmountAfterFee = Math.Round(transaction.AmountAfterFee, 2); if (transaction.AmountAfterFee < 0) { throw new Exception("Amount included fee can't less than zero."); } var result = _transactionRepository.Add(transaction); if (result == (int)GlobalConfig.Result.ERROR) { throw new Exception("Unable to create transaction."); } var applyResult = _accountService.ApplyToBalance(account, transaction.AmountAfterFee); if (!applyResult) { throw new Exception("Unable to update account balance amount."); } return(transaction); } catch (Exception ex) { throw ex; } }
public void Deposit(Transaction transaction) { transaction.TransactionType = TransactionType.Deposit; var account = _accountRepository.GetBy(transaction.AccountId); var value = transaction.Value; account.EncreaseBalance(value); _transactionRepository.Add(transaction); }
public IActionResult Add(AccountViewModel vm) { var userID = User.FindFirstValue(ClaimTypes.NameIdentifier); if (vm.AccountOfInterest.Name != null) { //Validate the new account ValidateAccount(vm, userID); //Confirm valid modelstate if (ModelState.IsValid) { //Convert the VMAccount to a DBAccount. Account account = new Account { Name = vm.AccountOfInterest.Name, UserID = userID, IsAsset = vm.AccountOfInterest.IsAsset, IsActive = vm.AccountOfInterest.IsActive }; //Add the account to the account table in the DB. _accountRepository.Add(account); //Gathering the data required to complete a transaction. CompleteAccountTransaction(vm, newAccount: true, userID); //Convert the VMTransaction to a DBTransaction Transaction transaction = new Transaction { UserID = userID, TransactionDate = vm.AccountTransaction.TransactionDate, TransactionTypeID = vm.AccountTransaction.TransactionTypeID, AccountID = vm.AccountTransaction.AccountID, CategoryID = vm.AccountTransaction.CategoryID, VendorID = vm.AccountTransaction.VendorID, Amount = vm.AccountTransaction.Amount, Description = vm.AccountTransaction.Description }; //Add the transaction to the transaction table in the DB to create the initial account balance. _transactionRepository.Add(transaction); TempData["Message"] = "Account successfully added."; return(RedirectToAction("Index")); } } return(View(vm)); }
public Transaction Deposit(Transaction transaction) { var bankAccount = _bankAccountRepository.Find(transaction.BankAccountId); if (bankAccount != null) { bankAccount.Balance += transaction.Amount; } _transactionRepository.Add(transaction); _bankAccountRepository.Update(bankAccount); return(transaction); }
public async Task Add(Transaction transaction) { if (!ExecutionValidations(new TransactionValidation(), transaction)) { return; } if (_transactionRepository.Find(f => f.Id == transaction.Id).Result.Any()) { Notify("A transaction with that ID already exists."); return; } await _transactionRepository.Add(transaction); }
public async Task <Response> Handle(CreateTransaction request, CancellationToken cancellationToken) { var response = new Response(); var sourceAccount = await _accountRepository.Get(request.SourceAccount); var targetAccount = await _accountRepository.Get(request.TargetAccount); var transaction = new FCamara.Domain.Entities.Transaction(sourceAccount, targetAccount, request.Amount, request.Type); if (!transaction.Valid) { response.AddNotifications(transaction.Notifications); } else { transaction.Transference(); if (!transaction.Valid) { response.AddNotifications(transaction.Notifications); } else { response.AddValue(await _repository.Add(transaction)); } await updateAccounts(sourceAccount, targetAccount); } return(response); }
public void UpdateEmployeeBalance(EmployeeDTO employee, string comment) { using (TransactionScope scope = new TransactionScope()) { var employeeToUpdate = _employees.GetById(employee.EmployeeID); var transaction = new VacationsDAL.Entities.Transaction { BalanceChange = employee.VacationBalance-employeeToUpdate.VacationBalance, Discription = comment, EmployeeID = employeeToUpdate.EmployeeID, TransactionDate = DateTime.UtcNow, TransactionTypeID = _transactionTypes.GetByType(TransactionTypeEnum.ForceBalanceChangeTransaction.ToString()).TransactionTypeID, TransactionID = Guid.NewGuid().ToString() }; employeeToUpdate.VacationBalance = employee.VacationBalance; _employees.Update(); _transactions.Add(transaction); scope.Complete(); } }
private async Task <List <Transaction> > RefreshTransactionsAsync(string userId, DateTime from, DateTime to) { // Will need an up to date account list, to refresh transactions. var accounts = await RefreshAccountsAsync(userId); // We have a list of accounts, with a potential variety of account providers, meaning we need to // use the correct consent for the correct provider. // Convert the consents to a dictionary, with "connector id" as key. Which we can look up when iterating // the accounts. // Here's hoping "connector-id" is the same as "provider_id". var consents = _consentService.GetConsents(userId); var providerConsents = consents.ToDictionary(x => x.ConnectorId); // This approach will only support one provider each. var result = new List <Transaction>(); foreach (var account in accounts) { var consent = providerConsents[account.Provider.ProviderId]; var transactions = await _trueLayerDataApi.GetTransactionsAsync(consent.AccessTokenRaw, account.AccountId, from, to); result.AddRange(transactions); _transactionRepository.Add(userId, account.AccountId, result); } return(result); }
public void TransactionInsertData() { Console.WriteLine(new string('*', 20)); Console.WriteLine("Enter the CategoryId, OperationId, Sum, Description"); Console.Write("CategoryId : "); int catId = Console.Read(); Console.Write("OperationId : "); int opId = Console.Read(); Console.Write("Sum : "); int sum = Console.Read(); Console.Write("Description : "); String description = Console.ReadLine(); //inserting Transaction transaction = new Transaction { CategoryId = catId, OperationId = opId, Sum = sum, Description = description }; transactionRepository.Add(transaction); TransactionShowData(); }
public Task <CommandResult> Handle(AddTransactionCommand command) { if (!command.Validate(out ValidationError error)) { return(CommandResult.Fail(error).AsTask()); } var user = userRepo.Get(command.UserId); if (user == null) { return(CommandResult.Fail(UserManagement.UserManagementError.UserNotFound()).AsTask()); } var transaction = trRepo.Add(new Transaction() { Amount = command.Amount, CheckNumber = command.CheckNumber, Date = command.Date, Description = command.Description, GoodsOrServicesGiven = command.GoodsOrServicesGiven, Type = (Entities.TransactionType)command.Type, UserId = command.UserId }); return(CommandResult <string> .Success(transaction.Id.ToString()).AsTask()); }
/// <summary> /// Creates a new transaction /// </summary> /// <param name="transactionType">The type of the transaction</param> /// <param name="account"><see cref="Account"/> entity</param> /// <param name="amount">Amount</param> /// <returns>Created transaction</returns> public Transaction CreateTransaction(TransactionType transactionType, Account account, Decimal amount) { if (transactionType == TransactionType.NotSpecified) { throw new ArgumentException("The transaction's type cann't be not specified"); } if (account == null) { throw new ArgumentNullException("account"); } if (amount <= 0) { throw new ArgumentException("Amount cann't be less or equal 0"); } if (!DoesTheAccountExist(account)) { throw new ArgumentException(String.Format("Account with ID {0} wasn't found", account.AccountId)); } var transaction = new Transaction { Account = account, Amount = amount, Type = transactionType, IsCommited = false }; _transactionRepository.Add(transaction); return(transaction); }
public void GetAllTransactionsAdded() { var firstAmount = 100; var firstDate = new DateTime(2018, 1, 1); var secondAmount = 200; var secondDate = new DateTime(2018, 1, 2); _transactionRepository.Add(new Transaction(firstAmount, firstDate)); _transactionRepository.Add(new Transaction(secondAmount, secondDate)); var transactions = _transactionRepository.GetAll(); Assert.AreEqual(firstAmount, transactions.First().Amount); Assert.AreEqual(firstDate, transactions.First().Date); Assert.AreEqual(secondAmount, transactions.Last().Amount); Assert.AreEqual(secondDate, transactions.Last().Date); }
public IActionResult Post([FromBody] DTO.Transaction transactionDTO) { var newTransaction = _mapper.Map <Transaction>(transactionDTO); _transactionRepo.Add(newTransaction); return(Created(string.Format("/api/transaction/{0}", newTransaction.ID), _mapper.Map <DTO.Transaction>(newTransaction))); }
public async Task <bool> RegisterTransaction(Transaction transaction) { if (transaction.Invalid) { return(false); } return(await _transactionRepository.Add(transaction)); }
public async Task <IResult <TransactionModel> > Handle(CreateTransactionCommand request, CancellationToken cancellationToken) { var transaction = new Transaction { AssetId = request.Input.AssetId, Wallet = request.Input.Wallet, CreatedAt = request.Input.CreatedAt, Amount = request.Input.Amount, CurrencyId = request.Input.CurrencyId, Rate = request.Input.Rate, Fee = request.Input.Fee, FeeCurrencyId = request.Input.FeeCurrencyId, OwnerId = _userIdAccesor.Id }; transaction = await _transactionRepository.Add(transaction, cancellationToken) .ConfigureAwait(false); var currencies = await _currencyRepository.GetAll() .ToListAsync(cancellationToken) .ConfigureAwait(false); var assets = await _assetRepository.GetAll() .ToListAsync(cancellationToken) .ConfigureAwait(false); var groups = await _groupRepository.GetAll() .ToListAsync(cancellationToken) .ConfigureAwait(false); var result = _mapper.Map <Transaction, TransactionModel>(transaction); if (currencies.Found(request.Input.CurrencyId, out var currency)) { result.Currency = _mapper.Map <Currency, CurrencyModel>(currency); } if (assets.Found(request.Input.AssetId, out var asset)) { result.Asset = _mapper.Map <Asset, AssetModel>(asset); if (groups.Found(asset.GroupId, out var group)) { result.Asset.Group = _mapper.Map <Group, GroupModel>(group); } } if (request.Input.FeeCurrencyId != null && currencies.Found(request.Input.FeeCurrencyId.Value, out var feeCurrency)) { result.FeeCurrency = _mapper.Map <Currency, CurrencyModel>(feeCurrency); } _userCacheService.Remove(CacheRegion.Transactions); return(result.AsResult()); }
public async Task <IActionResult> CreateRevenue(RevenueCreateViewModel model) { if (ModelState.IsValid) { var revenue = new Revenue() { Date = model.Date, Value = model.Value, RevenueType = model.RevenueType }; await AddOcassion(model.OccasionId, revenue); await repository.Add(revenue); return(RedirectToAction("list", "transaction")); } return(View()); }
public HttpResponseMessage PostTransaction(FraudTransactions.Models.Transaction transaction) { transaction = _repository.Add(transaction); var response = Request.CreateResponse <FraudTransactions.Models.Transaction>(HttpStatusCode.Created, transaction); string uri = Url.Route(null, new { id = transaction.Id }); response.Headers.Location = new Uri(Request.RequestUri, uri); return(response); }
public async Task Add(Transaction transaction) { if (_transactionRepository.Find(t => t.Id == transaction.Id).Result.Any()) { Notify("Already exists a transaction."); return; } await _transactionRepository.Add(transaction); }
public ActionResult <TransactionVM> CreateTransaction(TransactionDto transactionDto) { var transaction = _transactionMapper.Map(transactionDto); _transactionRepository.Add(transaction); _transactionRepository.SaveChanges(); return(CreatedAtAction(nameof(GetTransactionById), new { id = transaction.Id }, transaction)); }
public async Task <IActionResult> CreateRevenue(RevenueCreateViewModel model) { if (ModelState.IsValid) { var revenue = new Revenue() { Date = model.Date, Value = model.Value, RevenueType = model.RevenueType }; await AddOcassion(model.OccasionId, revenue); await repository.Add(revenue); return(Ok(revenue.ToJson())); } return(BadRequest(ModelState)); }
public TransactionDto CreateDeposit(int accountNo, decimal amount, string currencyID) { var bankAccount = _bankAccountRepository.FindByID(accountNo); if (bankAccount is null) { throw new InValidAccountNoException("Your account number does not exist!"); } if (amount <= 0) { throw new InValidAmountException("Your deposit amount cannot be equal to or less than 0!"); } if (currencyID.Length < 3) { throw new InValidAmountException("Your currency is not in correct format. Pass your currencyID!"); } var transactionCurrencyDto = _currencyRepository.FindByID(currencyID); if (transactionCurrencyDto is null) { throw new InValidCurrencyIDException("Your currency ID does not exist!"); } var accountExchangeRate = _currencyRepository.FindByID(bankAccount.CurrencyID).ExchangeRate; var currency = AutoMapper.Mapper.Map <CurrencyDto, Currency>(transactionCurrencyDto); //var bankAccount = AutoMapper.Mapper.Map<BankAccountDto, BankAccount>(bankAccountDto); bankAccount.Deposit(accountNo, amount, currency, accountExchangeRate); var transactionDto = new TransactionDto(); try { transactionDto = _transactionRepository.Add(bankAccount.Transactions.Last().TransactionID); } catch (Exception ex) { throw new Exception($"Something went wrong while processing your deposit. Try again later! {ex.Message}"); } return(transactionDto); }
public void Audit(ITransactionRepository transaction) { if (State.Id == (int) DataProviderResponseState.VinShort) transaction.Add(this); }