public static bool UpdateContractScopeIsValid(this Contract contract, UpdateContractCommand command)
{
return(AssertionConcern.IsSatisfiedBy(
AssertionConcern.AssertNotNull(command.IdCompany, "Empresa não informada"),
AssertionConcern.AssertTrue(!(command.DateStart > contract.DateEnd), "Data de início maior que a data de fim")
));
}
public async Task <IActionResult> Update(UpdateContractCommand updateContractCommand)
{
var result = await Mediator.Send(updateContractCommand);
if (result.Success == false)
{
return(result.ApiResult);
}
return(NoContent());
}
public async Task <DataRequestResult> UpdateCustomerContractAsync(UpdateContractCommand request)
{
try
{
using IDbConnection DbCon = connection;
var currentContract = DbCon.Get <Contract>(request.ContractId);
if (currentContract == null)
{
return(await Task.FromResult(new DataRequestResult { IsSuccess = false, ErrorMessage = "Specific contract is not exists." }));
}
var age = CalculateAge(request.CustomerDOB);
// Find convarage Plan based on new customer country and sale date
var covaragePlanIds = DbCon.GetAll <CoveragePlan>()
.Where(a => request.SaleDate.Date >= a.EligibilityDateFrom.Date &&
request.SaleDate.Date <= a.EligibilityDateTo.Date &&
(string.IsNullOrWhiteSpace(a.EligibilityCountry) || a.EligibilityCountry.ToLower() == request.CustomerCountry.ToLower()))
.Select(a => a.Id).ToList();
if (!covaragePlanIds.Any())
{
return(await Task.FromResult(new DataRequestResult { IsSuccess = false, ErrorMessage = "Covarage plan is not exists." }));
}
// Find Rate Chart based on new Age and Gender
var rateCharts = DbCon.GetAll <RateChart>().Where(a => covaragePlanIds.Any(x => x == a.CoveragePlanId) &&
a.CustomerGender == request.Gender && (a.CustomerAge == "<=40" ? age <= 40 : age > 40)).FirstOrDefault();
if (rateCharts != null)
{
// Insert new customer contract
currentContract.CustomerName = request.CustomerName;
currentContract.CustomerAddress = request.CustomerAddress;
currentContract.CustomerGender = request.Gender;
currentContract.CustomerCountry = request.CustomerCountry;
currentContract.CustomerDOB = request.CustomerDOB;
currentContract.SaleDate = request.SaleDate;
currentContract.RateChartId = rateCharts.Id;
var contractId = DbCon.Update <Contract>(currentContract);
return(await Task.FromResult(new DataRequestResult { IsSuccess = true, ErrorMessage = string.Empty }));
}
else
{
return(await Task.FromResult(new DataRequestResult { IsSuccess = false, ErrorMessage = "Rate chart is not exists" }));
}
}
catch (Exception ex)
{
return(await Task.FromResult(new DataRequestResult { IsSuccess = false, ErrorMessage = ex.Message }));
}
}
static async Task <bool> UpdateContractCommand()
{
var commandContext = new UpdateContractCommandContext();
var createContractCommand = new UpdateContractCommand();
commandContext.Name = "new name";
commandContext.id = "26270cfa2422b2c4ebf158285e0200a5";
var result = await createContractCommand.Execute(commandContext);
return(true);
}
public void UpdateContract(UpdateContractCommand command)
{
if (!this.UpdateContractScopeIsValid(command))
{
return;
}
this.DateStart = command.DateStart;
this.DateEnd = command.DateEnd;
this.IdCompany = command.IdCompany;
//this.IdPlan = command.IdPlan;
this.StatusContract = command.StatusContract;
this.Note = command.Note;
}
public Task <HttpResponseMessage> Put(int id, [FromBody] dynamic body)
{
var command = new UpdateContractCommand(
idContract: id,
idCompany: (int)body.idCompany,
idDayOfMonth: (int)body.idDayOfMonth,
dateStart: (DateTime)body.dateStart,
dateEnd: (DateTime)body.dateEnd,
statusContract: (EStatusContract)body.statusContract,
note: (string)body.note
);
var contract = _service.Update(command);
return(CreateResponse(HttpStatusCode.OK, contract));
}
public Contract Update(UpdateContractCommand command)
{
var contract = _repository.GetById(command.IdContract);
contract.UpdateContract(command);
_repository.Update(contract);
//Atualiza a empresa com contrato
if (!command.StatusContract.Equals(EStatusContract.Vigente))
{
var company = _repositoryCompany.GetById(command.IdCompany);
company.UpdateHaveContract(false);
_repositoryCompany.Update(company);
}
if (Commit())
{
return(contract);
}
return(null);
}
public async Task <IActionResult> Edit(Guid id, UpdateContractCommand request, IFormFile pdf)
{
if (id != request.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
if (pdf != null)
{
using (var memoryStream = new MemoryStream())
{
await pdf.CopyToAsync(memoryStream);
request.File = memoryStream.ToArray();
}
}
var result = await _mediator.Send(request);
return(Result(request, result, "alterado"));
}
return(View(request));
}
public async Task <IActionResult> Update(Guid Id, [FromBody] UpdateContractCommand command)
{
return(Ok(await Mediator.Send(command)));
}
public async Task <ActionResult <DataRequestResult> > UpdateContract(UpdateContractCommand updateContractCommand)
{
return(await Mediator.Send(updateContractCommand));
}
public async Task <IActionResult> UpdateContract([FromBody] UpdateContractCommand command)
{
await Mediator.Send(command);
return(NoContent());
}
