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