public async Task <IActionResult> PutOperationMovement(Guid id, OperationMovement operationMovement) { if (id != operationMovement.Id) { return(BadRequest()); } _context.Entry(operationMovement).State = EntityState.Modified; try { await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!OperationMovementExists(id)) { return(NotFound()); } else { throw; } } return(NoContent()); }
public async Task <IActionResult> PutCurrency(Guid id, Currency currency) { if (id != currency.Id) { return(BadRequest()); } _context.Entry(currency).State = EntityState.Modified; try { await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!CurrencyExists(id)) { return(NotFound()); } else { throw; } } return(NoContent()); }
public async Task <IActionResult> PutExpense(long id, Expense expense) { if (id != expense.Id) { return(BadRequest()); } _context.Entry(expense).State = EntityState.Modified; try { await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!ExpenseExists(id)) { return(NotFound()); } else { throw; } } return(NoContent()); }
public async Task <IActionResult> PutInstitutionBranch(Guid id, InstitutionBranch institutionBranch) { if (id != institutionBranch.Id) { return(BadRequest()); } _context.Entry(institutionBranch).State = EntityState.Modified; try { await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!InstitutionBranchExists(id)) { return(NotFound()); } else { throw; } } return(NoContent()); }
public async Task <IHttpActionResult> PutExpenses(long id, Expenses expenses) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } if (id != expenses.Id) { return(BadRequest()); } db.Entry(expenses).State = EntityState.Modified; try { await db.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!ExpensesExists(id)) { return(NotFound()); } else { throw; } } return(StatusCode(HttpStatusCode.NoContent)); }
public async Task CreateExpense(ExpenseRequest expenseRequest) { var expense = _mapper.Map <Expense>(expenseRequest); var countOfExpenses = (await GetExpenses(expense.ExpenseDate.Month, expense.ExpenseDate.Year)).Count; expense.ExpenseNo = $"{countOfExpenses + 1}/{expense.ExpenseDate.Month}/{expense.ExpenseDate.Year}"; await _dbContext.Set <Expense>().AddAsync(expense); await _dbContext.SaveChangesAsync(); }
public async Task <bool> Handle(StandingOrderProceedRequest request, CancellationToken cancellationToken) { if (request == null) { throw new ArgumentNullException(nameof(request)); } var standingOrder = await context.StandingOrderSet.FirstOrDefaultAsync(it => it.Id == request.Id, cancellationToken); if (standingOrder != null && standingOrder.UserId != request.UserId) { return(false); } var newTransaction = new Transaction { UserId = standingOrder.UserId, AccountId = standingOrder.AccountId, CategoryId = standingOrder.CategoryId, Created = DateTime.UtcNow, Type = standingOrder.Type, Description = standingOrder.Description, Amount = standingOrder.Amount }; await context.TransactionSet.AddAsync(newTransaction, cancellationToken); standingOrder.Installment = DateTime.UtcNow.AddMonths(1); await context.SaveChangesAsync(cancellationToken); return(true); }
public async Task <bool> Handle(CategoryEditRequest request, CancellationToken cancellationToken) { if (request == null) { throw new ArgumentNullException(nameof(request)); } var category = await context.CategorySet.FirstOrDefaultAsync(it => it.Id == request.Id, cancellationToken); // check if we aren't editing someone else's category if (category != null && category.UserId != request.UserId) { return(false); } // new category, otherwise we're editing our existing one if (category == null) { category = new Category { UserId = request.UserId }; await context.CategorySet.AddAsync(category, cancellationToken); } category.Name = request.Name; category.Description = request.Description; await context.SaveChangesAsync(cancellationToken); return(true); }
public async Task <bool> Handle(AccountEditRequest request, CancellationToken cancellationToken) { if (request == null) { throw new ArgumentNullException(nameof(request)); } var account = await context.AccountSet.FirstOrDefaultAsync(it => it.Id == request.Id, cancellationToken); // check if we aren't editing someone else's account if (account != null && account.UserId != request.UserId) { return(false); } // new account, otherwise we're editing our existing one if (account == null) { account = new Data.Account { UserId = request.UserId, Created = DateTime.UtcNow }; await context.AccountSet.AddAsync(account, cancellationToken); } account.Name = request.Name; account.IBAN = request.IBAN; await context.SaveChangesAsync(cancellationToken); return(true); }
public async Task <bool> Handle(StandingOrderEditRequest request, CancellationToken cancellationToken) { if (request == null) { throw new ArgumentNullException(nameof(request)); } var standingOrder = await context.StandingOrderSet.FirstOrDefaultAsync(it => it.Id == request.Id, cancellationToken); if (standingOrder != null && standingOrder.UserId != request.UserId) { return(false); } if (standingOrder == null) { standingOrder = new StandingOrder { UserId = request.UserId, }; await context.StandingOrderSet.AddAsync(standingOrder, cancellationToken); } standingOrder.AccountId = request.AccountId; standingOrder.CategoryId = request.CategoryId; standingOrder.Type = request.Type; standingOrder.Description = request.Description; standingOrder.Amount = request.Amount; standingOrder.Installment = request.Installment; await context.SaveChangesAsync(cancellationToken); return(true); }
public override async Task <ChargeResponse> Charge(ChargeRequest request, ServerCallContext context) { var tokenClaims = tokenClaimsAccessor.TokenClaims; var user = await dbContext.Users.FindIfNullThrowAsync(tokenClaims.UserId); user.Charge(request.Amount); await dbContext.SaveChangesAsync(); return(new ChargeResponse { Balance = user.Balance, }); }
public async Task <RegistrationResult> Handle(RegistrationRequest request, CancellationToken cancellationToken) { if (request == null) { throw new ArgumentNullException(nameof(request)); } var alreadyExisting = await context.UserSet.AnyAsync( it => it.UserName.ToLower() == request.UserName.ToLower(), cancellationToken ); if (alreadyExisting) { return(new RegistrationResult { Success = false, Message = $"Username `{request.UserName}` is already taken." }); } var passwordHash = await MD5.HashAsync(request.Password, cancellationToken); var user = new Data.User { UserName = request.UserName, Password = passwordHash, FirstName = request.FirstName, LastName = request.LastName }; await context.UserSet.AddAsync(user, cancellationToken); await context.SaveChangesAsync(cancellationToken); return(new RegistrationResult { Success = true }); }
public async Task <bool> Handle(TransactionEditRequest request, CancellationToken cancellationToken) { if (request == null) { throw new ArgumentNullException(nameof(request)); } var transaction = await context.TransactionSet.FirstOrDefaultAsync(it => it.Id == request.Id, cancellationToken); // check if we aren't editing someone else's transaction if (transaction != null && transaction.UserId != request.UserId) { return(false); } if (transaction == null) { transaction = new Transaction { UserId = request.UserId, Created = DateTime.UtcNow, }; await context.TransactionSet.AddAsync(transaction, cancellationToken); } else { transaction.Modified = DateTime.UtcNow; } transaction.AccountId = request.AccountId; transaction.CategoryId = request.CategoryId; transaction.Type = request.Type; transaction.Description = request.Description; transaction.Amount = request.Amount; transaction.Pending = request.Pending; await context.SaveChangesAsync(cancellationToken); return(true); }
public override async Task <AddDomainResponse> AddDomain(AddDomainRequest request, ServerCallContext context) { var payer = await dbContext.Users.FindIfNullThrowAsync(request.PayUserId); var system = await dbContext.Systems.FirstOrDefaultAsync(); var domain = new DomainEntity(Guid.Parse(request.Id), payer, Resources.Zero, system); var userDomainAssignment = new UserDomainAssignment(Guid.Parse(request.PayUserAssignmentId), domain, payer); dbContext.Domains.Add(domain); dbContext.UserDomainAssignments.Add(userDomainAssignment); dbContext.BillingCycleEntries.Add(new BillingCycleEntry(domain.BillingCycleSubject)); dbContext.UseCycleEntries.Add(new UseCycleEntry(domain.UseCycleSubject)); dbContext.ManagementFeeEntries.Add(new ManagementFeeEntry(domain.Payer)); await dbContext.SaveChangesAsync(); return(new AddDomainResponse { }); }
public async Task CommitAsync() { await _expensesDbContext.SaveChangesAsync(); }