static async Task <bool> CreateContractCommand()
{
var commandContext = new CreateContractCommandContext();
var command = new CreateContractCommand();
var result = await command.Execute(commandContext);
return(true);
}
public async Task <IActionResult> Create(CreateContractCommand createContractCommand)
{
var result = await Mediator.Send(createContractCommand);
if (result.Success == false)
{
return(result.ApiResult);
}
return(Created(Url.Link("GetContractInfo", new { id = result.Data.Id }), result.Data));
}
public async Task <DataRequestResult> CreateCustomerContractAsync(CreateContractCommand request)
{
try
{
using IDbConnection DbCon = connection;
var age = CalculateAge(request.CustomerDOB);
// Find convarage Plan based on 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 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
var contract = new Contract
{
CustomerName = request.CustomerName,
CustomerAddress = request.CustomerAddress,
CustomerCountry = request.CustomerCountry,
CustomerGender = request.Gender,
CustomerDOB = request.CustomerDOB,
SaleDate = request.SaleDate,
RateChartId = rateCharts.Id
};
var contractId = DbCon.Insert <Contract>(contract);
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 }));
}
}
public Task <HttpResponseMessage> Post([FromBody] dynamic body)
{
var command = new CreateContractCommand(
idCompany: (int)body.idCompany,
idDayOfMonth: (int)body.idDayOfMonth,
dateStart: (DateTime)body.dateStart,
dateEnd: (DateTime)body.dateEnd,
note: (string)body.note
);
var contract = _service.Create(command);
return(CreateResponse(HttpStatusCode.Created, contract));
}
public Contract Create(CreateContractCommand command)
{
var contract = new Contract(command.DateStart, command.DateEnd, command.IdCompany, command.IdDayOfMonth /*,command.IdPlan*/, command.Note);
contract.Register();
_repository.Create(contract);
//Atualiza a empresa com contrato
var company = _repositoryCompany.GetById(command.IdCompany);
company.UpdateHaveContract(true);
_repositoryCompany.Update(company);
if (Commit())
{
return(contract);
}
return(null);
}
public async Task <IActionResult> Create(CreateContractCommand request, IFormFile pdf)
{
if (ModelState.IsValid)
{
if (pdf != null)
{
using (var memoryStream = new MemoryStream())
{
await pdf.CopyToAsync(memoryStream);
request.File = memoryStream.ToArray();
}
}
request.CreatedBy = new Guid(User.FindFirstValue(ClaimTypes.NameIdentifier));
var result = await _mediator.Send(request);
return(Result(request, result, "gravado"));
}
return(View(request));
}
public async Task <CommandResult> Create(CreateContractCommand cmd)
{
if (!cmd.PersonId.HasValue || !cmd.PlanId.HasValue)
{
return(new CommandResult(false, $"Parametro não encontrado", null));
}
var _plan = await planService.GetById(cmd.PlanId.Value);
var _plaData = (Plan)_plan.Data;
var _installments = (_plaData.Code?.ToUpper().Substring(0, 1)) switch
{
"T" => 3,
"S" => 6,
"A" => 12,
_ => 1,
};
var _contract = new Contract
{
PersonId = cmd.PersonId,
PlanId = cmd.PlanId,
RecordId = System.Guid.NewGuid(),
Amount = cmd.Amount,
BillingDay = cmd.BillingDay,
Installments = _installments,
Starts = cmd.Starts,
Ends = cmd.Ends,
Active = false
};
//var _amount = _plaData.
_contract.Id = await Task.FromResult(persistencia.SalvarNaBase("contract", _contract, Persistence.PersistenceMetodos.Inserir));
logger.LogInformation($"Cadastrado com sucesso, {_contract.RecordId}");
return(new CommandResult(true, $"Cadastrado com sucesso", _contract));
}
public async Task <IActionResult> Add([FromBody] CreateContractCommand command)
{
return(Ok(await Mediator.Send(command)));
}
public async Task <ActionResult <DataRequestResult> > CreateContract(CreateContractCommand createContractCommand)
{
return(await Mediator.Send(createContractCommand));
}
public async Task <CommandResult> Update(CreateContractCommand cmd)
{
throw new System.NotImplementedException();
}
public async Task <IActionResult> Put([FromBody] CreateContractCommand cmd)
{
var result = await service.Create(cmd);
return(Ok(result));
}
