public async Task <IActionResult> PutContribuinte(Guid id, Contribuinte contribuinte)
{
if (id != contribuinte.Id)
{
return(BadRequest());
}
_context.Entry(contribuinte).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ContribuinteExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <ActionResult <MathHistory> > Create(MathHistory mathHistory)
{
// Runs equation through SolveMath to return an answer
mathHistory.Answer = MathSolver.SolveMath(mathHistory.Equation);
_context.MathHistories.Add(mathHistory);
await _context.SaveChangesAsync();
return(CreatedAtAction(nameof(GetById), new { id = mathHistory.Id }, mathHistory));
}
/// <summary>
/// Adds the async.
/// </summary>
/// <returns>The async.</returns>
/// <param name="newOperation">New operation.</param>
/// <param name="ct">Ct.</param>
public async Task <Operation> AddAsync(Operation newOperation, CancellationToken ct = default(CancellationToken))
{
_context.Operations.Add(newOperation);
await _context.SaveChangesAsync(ct);
return(newOperation);
}
private async Task <bool> SaveAsync(Expense expense)
{
db.Expenses.Add(expense);
await db.SaveChangesAsync();
return(true);
}
private async Task <bool> SaveAsync(Person person)
{
_dbContext.Persons.Add(person);
await _dbContext.SaveChangesAsync();
return(true);
}
public async Task <ActionResult <CalculationLog> > PostCalculationLog(CalculationLog calculationLog)
{
calculationLog.PerformCalc();
_context.Logs.Add(calculationLog);
await _context.SaveChangesAsync();
return(calculationLog);
}
public async Task <IEnumerable <CalculoIR> > SaveAll(IEnumerable <CalculoIR> calculos)
{
_context.CalculoIRs.AddRange(calculos);
await _context.SaveChangesAsync();
return(calculos);
}
public async Task <ActionResult <Calculation> > NewCalculation([FromBody] Calculation calculationVm)
{
try
{
if (!ModelState.IsValid)
{
_logger.LogError("Invalid calculation model object from request");
return(BadRequest("Invalid model object"));
}
if (!PostalCodeStrategyMap.ContainsKey(calculationVm.PostalCode))
{
_logger.LogError("No tax strategy configured for the given postal code");
return(BadRequest("Invalid postal code"));
}
var taxStrategyType = PostalCodeStrategyMap[calculationVm.PostalCode];
var taxStrategy = _factory.GetTaxStrategy(taxStrategyType);
var taxDue = taxStrategy.CalculateTax(calculationVm.AnnualSalary);
var calculation = new Calculation
{
PostalCode = calculationVm.PostalCode,
AnnualSalary = calculationVm.AnnualSalary,
CalculatedTax = taxDue,
CreatedOn = DateTime.Now
};
_context.Calculations.Add(calculation);
await _context.SaveChangesAsync();
return(new JsonResult(calculation));
}
catch (Exception ex)
{
_logger.LogError($"Something went wrong inside NewCalculation action: {ex.Message}");
return(StatusCode(500, "Internal server error"));
}
}
public async Task <Contribuinte> Save(Contribuinte contribuinte)
{
var contribuinteDb = _context.Contribuintes.FirstOrDefault(c => c.Cpf.Equals(contribuinte.Cpf));
if (contribuinteDb != null)
{
contribuinteDb.Nome = contribuinte.Nome;
contribuinteDb.Dependentes = contribuinte.Dependentes;
contribuinteDb.Renda = contribuinte.Renda;
_context.Entry(contribuinteDb).State = EntityState.Modified;
contribuinte = contribuinteDb;
}
else
{
_context.Contribuintes.Add(contribuinte);
}
await _context.SaveChangesAsync();
return(contribuinte);
}
public async Task <ActionResult <ApiResponse> > Create(TaxCalculationInput taxInput)
{
try
{
var result = _factory.GetCalculator(taxInput.PostalCode);
var tax = result.calculator.Calculate(taxInput.Income, result.settings);
var addResult = await _context.TaxValues.AddAsync(new TaxValue { Name = taxInput.Name, PostalCode = taxInput.PostalCode.ToUpper(), Income = taxInput.Income, Tax = tax });
var commitResult = await _context.SaveChangesAsync();
return(new ActionResult <ApiResponse>(new ApiResponse {
Success = true, Result = addResult.Entity
}));
}
catch (Exception ex)
{
return(new ActionResult <ApiResponse>(new ApiResponse {
Success = false, Message = ex.Message, Details = ex.Source, StackTrace = ex.StackTrace
}));
}
}
public async Task Insert(Operations operations)
{
await _calculatorContext.Operations.AddAsync(operations);
await _calculatorContext.SaveChangesAsync();
}
