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