public async Task <SyncedEntityIds> SyncEntitiesAsync(SyncEntities model)
{
(var conn, var uowTransaction) = _unitOfWork.StartTransaction();
var accountIds = new int[model.Accounts.Count];
var categoryIds = new int[model.Categories.Count];
var transactionIds = new int[model.Transactions.Count];
var upcomingExpenseIds = new int[model.UpcomingExpenses.Count];
var debtIds = new int[model.Debts.Count];
for (var i = 0; i < accountIds.Length; i++)
{
var account = _mapper.Map <Account>(model.Accounts[i]);
int id = await _accountsRepository.CreateAsync(account, conn, uowTransaction);
accountIds[i] = id;
}
for (var i = 0; i < categoryIds.Length; i++)
{
var category = _mapper.Map <Category>(model.Categories[i]);
int id = await _categoriesRepository.CreateAsync(category, conn, uowTransaction);
categoryIds[i] = id;
}
for (var i = 0; i < transactionIds.Length; i++)
{
var transaction = _mapper.Map <Transaction>(model.Transactions[i]);
int id = await _transactionsRepository.CreateAsync(transaction, conn, uowTransaction);
transactionIds[i] = id;
}
for (var i = 0; i < upcomingExpenseIds.Length; i++)
{
var upcomingExpense = _mapper.Map <UpcomingExpense>(model.UpcomingExpenses[i]);
int id = await _upcomingExpensesRepository.CreateAsync(upcomingExpense, conn, uowTransaction);
upcomingExpenseIds[i] = id;
}
for (var i = 0; i < debtIds.Length; i++)
{
var debt = _mapper.Map <Debt>(model.Debts[i]);
int id = await _debtsRepository.CreateAsync(debt, conn, uowTransaction);
debtIds[i] = id;
}
_unitOfWork.CommitTransaction(conn, uowTransaction);
return(new SyncedEntityIds(accountIds, categoryIds, transactionIds, upcomingExpenseIds, debtIds));
}
public async Task <Transaction> RegisterOutgoingTransactionAsync(
Transaction transaction,
VirtualAssetsAccountNumber virtualAssetsAccountNumber)
{
transaction.Status = TransactionStatus.Created;
var originatorSession = await _vaspClient.CreateOriginatorSessionAsync(virtualAssetsAccountNumber.VaspCode);
_originatorSessionsDict.TryAdd(originatorSession.Id, originatorSession);
transaction.SessionId = originatorSession.Id;
await _transactionsRepository.CreateAsync(transaction);
await _sessionsRepository.CreateAsync(originatorSession.SessionInfo);
await originatorSession.SessionRequestAsync(_vaspInformation);
transaction.Status = TransactionStatus.SessionRequested;
await _transactionsRepository.UpdateAsync(transaction);
return(transaction);
}
public async Task <ServiceResult <int> > CreateAsync(int groupId, ClaimsPrincipal user, TransactionRequestModel transaction)
{
var group = groupsRepository.Get(groupId);
if (group is null)
{
return(ServiceResult <int> .Error(404, "Group was not found"));
}
var authorizationResult = await authorizationService.AuthorizeAsync(user, group, GroupOperations.Read);
if (!authorizationResult.Succeeded)
{
return(ServiceResult <int> .Error(401, "Unauthorized"));
}
var authenticatedUser = await usersManager.GetUserAsync(user);
var transactionEntity = new Transaction()
{
Amount = transaction.Amount,
Description = transaction.Description,
CategoryId = transaction.CategoryId,
UserId = authenticatedUser.Id,
GroupId = groupId
};
var result = await transactionsRepository.CreateAsync(transactionEntity);
if (result is null)
{
return(ServiceResult <int> .Error(500, "Could not create transaction"));
}
await actionService.CreateAsync(group.Id, authenticatedUser.Id, "Transaction", $"{authenticatedUser.UserName} has added transaction");
return(ServiceResult <int> .Success(TransactionViewModel.FromModel(result)));
}
public async Task <int> CreateAsync(CreateTransaction model)
{
if (!model.FromAccountId.HasValue && !model.ToAccountId.HasValue)
{
throw new ArgumentException("AccountId is missing.");
}
if (model.FromAccountId.HasValue &&
!(await _accountsRepository.ExistsAsync(model.FromAccountId.Value, model.UserId)))
{
throw new ArgumentException("FromAccount doesn't belong to user with specified userId.");
}
if (model.ToAccountId.HasValue &&
!(await _accountsRepository.ExistsAsync(model.ToAccountId.Value, model.UserId)))
{
throw new ArgumentException("ToAccount doesn't belong to user with specified userId.");
}
var transaction = _mapper.Map <Transaction>(model);
return(await _transactionsRepository.CreateAsync(transaction));
}
public async Task <TransactionDomainModel> CreateTransaction(TransactionDomainModel transaction)
{
return(await _transactionsRepository.CreateAsync(transaction));
}
