private async Task <AnualBalance> CreateBalances(AnualBalance entity)
{
try
{
var newBalances = new List <Balance>();
foreach (var monthValue in Enum.GetValues(typeof(EMonth)))
{
newBalances.Add(new Balance()
{
AnualBalanceId = entity.Id, Month = (EMonth)monthValue, Positive = true
});
}
await _context.Balances.AddRangeAsync(newBalances);
_context.Entry(entity).State = EntityState.Modified;
entity.Balances = newBalances;
await _context.SaveChangesAsync();
return(entity);
}
catch (Exception ex)
{
var logger = _loggerFactory.CreateLogger <DataContext>();
logger.LogError(ex.Message);
return(null);
}
}
public async Task <AnualBalance> CalculateAndSaveYear(AnualBalance anualBalance)
{
try
{
anualBalance.AnualBalanceResult = 0;
List <Balance> balances = await GetBalancesFromYear(anualBalance.Id);
foreach (Balance balance in balances)
{
anualBalance.AnualBalanceResult += balance.BalanceResult;
}
anualBalance.Positive = (anualBalance.AnualBalanceResult >= 0) ? true : false;
_context.Update(anualBalance);
await _context.SaveChangesAsync();
return(anualBalance);
}
catch (Exception)
{
return(null);
}
}
public async Task <AnualBalance> Add(AnualBalance anualBalance, int userId)
{
try
{
//Validates model.
if (anualBalance == null)
{
return(null);
}
//Assign the validated user id to the Anual Balance
anualBalance.UserId = userId;
if (!await UniqueYear(userId, anualBalance.Year))
{
return(null);
}
//Initialize the anual balance result.
anualBalance.Result = 0;
anualBalance.Positive = true;
await _context.AddAsync(anualBalance);
await _context.SaveChangesAsync();
return(anualBalance);
}
catch (Exception)
{
return(null);
}
}
public async Task <bool> UniqueMonthValidation(Balance newBalance)
{
try
{
AnualBalance anualBalance = await _context.AnualBalances
.Include(b => b.Balances)
.ThenInclude(m => m.Month)
.Where(a => a.Id == newBalance.AnualBalanceId)
.FirstOrDefaultAsync();
if (anualBalance != null)
{
foreach (Balance _bal in anualBalance.Balances)
{
if (_bal.Month.Id == newBalance.MonthId)
{
return(false);
}
}
return(true);
}
return(false);
}
catch (Exception)
{
throw new Exception("Internal Error UniqueMonthValidation");
}
}
public async Task <AnualBalance> CalculateResult(AnualBalance entity)
{
try
{
if (entity == null)
{
return(null);
}
_context.Entry(entity).State = EntityState.Modified;
double total = 0;
entity.Balances.ForEach(b => total += b.Result);
entity.Result = total;
entity.Positive = entity.Result >= 0;
await _context.SaveChangesAsync();
return(entity);
}
catch (Exception ex)
{
var logger = _loggerFactory.CreateLogger <DataContext>();
logger.LogError(ex.Message);
return(null);
}
}
public async Task <IActionResult> Edit(int id, [Bind("Id,Year,AnualBalanceResult")] AnualBalance anualBalance)
{
if (id != anualBalance.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
await _repository.Update(anualBalance);
}
catch (DbUpdateConcurrencyException)
{
if (!_repository.AnualBalanceExists(anualBalance.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(anualBalance));
}
public async Task <IActionResult> PutAnualBalance(int id, AnualBalance anualBalance)
{
try
{
if (id != anualBalance.Id)
{
return(BadRequest());
}
if (await _repository.Update(anualBalance) == null)
{
return(BadRequest());
}
return(NoContent());
}
catch (Exception)
{
if (!_repository.Exist(id))
{
return(NotFound());
}
else
{
return(BadRequest());
}
}
}
public async Task <IActionResult> Create([Bind("Id,Year,AnualBalanceResult")] AnualBalance anualBalance)
{
if (ModelState.IsValid)
{
await _repository.Add(anualBalance);
return(RedirectToAction(nameof(Index)));
}
return(View(anualBalance));
}
public async Task <AnualBalance> Update(AnualBalance entity)
{
try
{
_context.Update(entity);
await _context.SaveChangesAsync();
return(entity);
}
catch (Exception)
{
return(null);
}
}
public async Task <ActionResult <AnualBalance> > PostAnualBalance(AnualBalance anualBalance)
{
if (anualBalance == null || !_anualBalanceRepository.AvailableAnualBalance(anualBalance.Year))
{
return(BadRequest(new ApiResponse(400)));
}
var result = await _anualBalanceRepository.AddAsync(anualBalance);
if (result == null)
{
return(BadRequest(new ApiResponse(400)));
}
return(CreatedAtAction("GetAnualBalance", new { id = result.Id }, result));
}
private async Task <AnualBalance> CreateAnualBalance(AnualBalance entity)
{
try
{
await _context.AnualBalances.AddAsync(entity);
await _context.SaveChangesAsync();
return(entity);
}
catch (Exception ex)
{
var logger = _loggerFactory.CreateLogger <DataContext>();
logger.LogError(ex.Message);
return(null);
}
}
public async Task <AnualBalance> Update(AnualBalance entity)
{
try
{
if (entity == null)
{
return(null);
}
_context.Entry(entity).State = EntityState.Modified;
await _context.SaveChangesAsync();
return(entity);
}
catch (Exception)
{
return(null);
}
}
public async Task <ActionResult <AnualBalance> > PostAnualBalance(AnualBalance entity)
{
var user = await _repository.ValidUser(GetTokenUserId());
if (user == null)
{
return(NotFound());
}
var anualBalance = await _repository.Add(entity, user.Id);
if (anualBalance == null)
{
return(BadRequest());
}
await _repository.AddMonths(anualBalance.Id, user.Id);
return(Created("POST", anualBalance));
}
public async Task <AnualBalance> Add(AnualBalance entity)
{
try
{
if (entity != null)
{
entity.AnualBalanceResult = 0;
_context.Add(entity);
await _context.SaveChangesAsync();
return(entity);
}
return(null);
}
catch (Exception)
{
return(null);
}
}
public async Task <AnualBalance> Delete(int id)
{
try
{
AnualBalance anualBalanaceToRemove = await Get(id);
if (anualBalanaceToRemove.Balances.Count > 0)
{
return(null);
}
_context.AnualBalances.Remove(anualBalanaceToRemove);
await _context.SaveChangesAsync();
return(anualBalanaceToRemove);
}
catch (Exception)
{
return(null);
}
}
public async Task <AnualBalance> AddAsync(AnualBalance entity)
{
try
{
var result = await CreateAnualBalance(entity);
if (result == null)
{
throw new Exception();
}
result = await CreateBalances(entity);
return(entity);
}
catch (Exception ex)
{
var logger = _loggerFactory.CreateLogger <DataContext>();
logger.LogError(ex.Message);
return(null);
}
}
public async Task <AnualBalance> UpdateAsync(AnualBalance entity)
{
throw new NotImplementedException();
}
public async Task <IActionResult> UpdateAnualBalance(int id, AnualBalance anualBalance)
{
return(BadRequest(new ApiResponse(405, "Method not implemented")));
}
