private static ParametrosCalculoPmbac ObterParametrosCalculoPmbac(CoberturaContratada cobertura, DateTime dataExecucao, decimal valorProvisaoAnterior)
{
return(new ParametrosCalculoPmbac()
{
Competencia = dataExecucao,
ContribuicaoMensal = cobertura.Historico?.ValorContribuicao,
DataAssinatura = cobertura.DataAssinatura,
DataInicioVigencia = cobertura.DataInicioVigencia,
DataNascimentoCliente = cobertura.DataNascimento,
IdClasseRisco = (cobertura.ClasseRiscoId != null && cobertura.ClasseRiscoId != 0) ? (short)cobertura.ClasseRiscoId : (short?)null,
IdItemProduto = cobertura.ItemProdutoId,
IdSexoSegurado = cobertura.Sexo,
TipoFormaContratacaoId = (short)cobertura.TipoFormaContratacaoId,
TipoRendaId = (short)cobertura.TipoRendaId.GetValueOrDefault(),
Identificador = cobertura.ItemCertificadoApoliceId,
CapitalSegurado = cobertura.Historico?.ValorCapital,
Periodicidade = ObterPeriodicidade(cobertura.Historico?.PeriodicidadeId),
Fracionamento = (int)ObterPeriodicidade(cobertura.Historico?.PeriodicidadeId),
PrazoPagamento = (short)cobertura.PrazoPagamentoEmAnos.GetValueOrDefault(),
PrazoDiferimento = cobertura.PrazoPagamentoEmAnos,
PrazoDecrescimo = cobertura.PrazoDecrescimoEmAnos != null
? (short)cobertura.PrazoDecrescimoEmAnos
: (short?)null,
ValorRenda = cobertura.Historico?.ValorBeneficio,
DataNascimentoFilho = cobertura.Historico?.DataNascimentoBeneficiario,
NumeroContribuicoes = cobertura.NumeroContribuicao,
IdadePagamentoAntecipado = cobertura.DataNascimento.Year + cobertura.PrazoPagamentoEmAnos.GetValueOrDefault(),
DataUltimaCorrecaoMonetaria = cobertura.DataUltimaCorrecaoMonetaria,
ValorProvisaoAnterior = valorProvisaoAnterior,
DataSaldamento = cobertura.DataSaldamento
});
}
public CalculadorEvento(CoberturaContratada coberturaContratada, EventoOperacional eventooperacional, ICalculoFacade calculo, IProvisoes provisao)
{
_coberturaContratada = coberturaContratada;
_eventooperacional = eventooperacional;
_calculo = calculo;
_provisao = provisao;
}
public async Task Salvar(CoberturaContratada dto)
{
const string proc = "sp_CriarCoberturaContratada";
var objeto = CarregarParametros(dto);
dto.Id = await CreateCommand.ExecuteScalarAsync <Guid>(proc, objeto, commandType : CommandType.StoredProcedure);
}
public CalculadorProvisaoPMBACProvider(CoberturaContratada coberturacontratada, ICalculoFacade calculo, EventoOperacional eventooperacional, IProvisoes provisao)
{
parametrosProvisaoCalculo = new ParametrosProvisaoCalculo();
parametrosProvisaoCalculo.ItemCertificadoApoliceId = coberturacontratada.ItemCertificadoApoliceId;
parametrosProvisaoCalculo.tipoprovisao = Domain.Enum.TipoProvisaoEnum.PMBAC;
Calculadores.Add(new Premio.Calculadores.CalculadorProvisaoMatematicaBeneficioAConceder(coberturacontratada, calculo, eventooperacional, parametrosProvisaoCalculo, provisao));
}
public CalculadorProvisaoMatematicaBeneficioAConceder(CoberturaContratada coberturacontratada, ICalculoFacade calculo, EventoOperacional eventooperacional, ParametrosProvisaoCalculo parametrosProvisaoCalculo, IProvisoes provisao)
{
_coberturacontratada = coberturacontratada;
_calculo = calculo;
_eventooperacional = eventooperacional;
_parametrosProvisaoCalculo = parametrosProvisaoCalculo;
_provisao = provisao;
}
public EventoEmissaoPremio CriarProvisao(EventoEmissaoPremio evento, CoberturaContratada cobertura)
{
if (cobertura.RegimeFinanceiroId.Equals(TipoRegimeFinanceiroEnum.ReparticaoSimples))
{
return(evento);
}
//Processo para gerar pmbac
return(evento);
}
private async Task SalvarCobertura(CoberturaContratada cobertura)
{
await _coberturaDao.Salvar(cobertura);
if (cobertura.Historico != null)
{
cobertura.Historico.AdicionarCobertura(cobertura);
cobertura.Historico.InformaStatus(StatusCobertura.StatusCoberturaEnum.Activa, DateTime.Now);
await _historicoDao.Salvar(cobertura.Historico);
}
}
private async Task <HistoricoCoberturaContratada> RetornaHistoricoCoberturaPeloIdentificador(string ItemCertificadoApoliceId, decimal valorbeneficio, decimal valorcapital, StatusCobertura.StatusCoberturaEnum statuscobertura)
{
itemCertificadoApoliceId = Convert.ToInt64(ItemCertificadoApoliceId);
coberturacontratada = await _cobertura.ObterPorItemCertificado(itemCertificadoApoliceId);
coberturacontratada.Historico.ValorBeneficio = valorbeneficio;
coberturacontratada.Historico.ValorCapital = valorcapital;
coberturacontratada.Historico.InformaStatus(statuscobertura, DateTime.Now);
coberturacontratada.Historico.AdicionarCobertura(coberturacontratada);
return(coberturacontratada.Historico);
}
public async Task Validar(CoberturaContratada cobertura)
{
var existe = await _coberturas.Contem(cobertura.ItemCertificadoApoliceId);
Assertion.IsFalse(existe, $"O identificador externo {cobertura.ItemCertificadoApoliceId} já foi implantado anteriormente.").Validate();
if (cobertura.RegimeFinanceiroId.Equals((short)TipoRegimeFinanceiroEnum.Capitalizacao))
{
_facade.ValidarDadosCalculoPMBAC(cobertura, new DateTime(DateTime.Today.Year, DateTime.Today.Month, 1));
}
}
public void EntaoUmaCoberturaContratadaDeveConter(Table param)
{
var saida = param.CreateSet <ImplantacaoParam>().First();
_coberturas = InstanceFactory.Resolve <ICoberturas>();
_coberturaDto = _coberturas.ObterPorItemCertificado(_itemCertificadoApoliceId).Result;
Assert.That(_param.IdExterno, Is.EqualTo(_coberturaDto.ItemCertificadoApoliceId));
Assert.That(_param.ItemProdutoId, Is.EqualTo(_coberturaDto.ItemProdutoId));
Assert.That(_param.DataInicioVigencia, Is.EqualTo(_coberturaDto.DataInicioVigencia));
Assert.That(_param.ClasseRiscoId, Is.EqualTo(_coberturaDto.ClasseRiscoId));
Assert.That(_param.TipoFormaContratacaoId, Is.EqualTo(_coberturaDto.TipoFormaContratacaoId));
Assert.That(_param.TipoRendaId, Is.EqualTo(_coberturaDto.TipoRendaId));
Assert.That(_param.InscricaoId, Is.EqualTo(_coberturaDto.InscricaoId));
Assert.That(_param.Matricula, Is.EqualTo(_coberturaDto.Matricula));
}
public static IEnumerable <CoberturaContratada> ObterCoberturasDaProposta(this IProposta proposta)
{
var coberturas = new List <CoberturaContratada>();
foreach (var produto in proposta.Produtos)
{
foreach (var cobertura in produto.Coberturas)
{
var coberturaContratada = new CoberturaContratada(long.Parse(cobertura.IdentificadorExterno))
{
InscricaoId = produto.InscricaoCertificado,
ItemProdutoId = cobertura.CodigoItemProduto,
DataInicioVigencia = cobertura.InicioVigencia,
DataAssinatura = proposta.DataAssinatura,
DataNascimento = proposta.Proponente.DataNascimento,
Matricula = proposta.Proponente.Matricula,
Sexo = proposta.Proponente.Sexo,
TipoFormaContratacaoId = (int)cobertura.Contratacao?.TipoFormaContratacao,
ProdutoId = produto.Codigo,
ClasseRiscoId = cobertura.ClasseRisco,
TipoRendaId = (int)cobertura.Contratacao?.TipoDeRenda,
DataFimVigencia = cobertura.FimVigencia,
PrazoPagamentoEmAnos = cobertura.Prazos?.PagamentoEmAnos,
PrazoCoberturaEmAnos = cobertura.Prazos?.CoberturaEmAnos,
PrazoDecrescimoEmAnos = cobertura.Prazos?.DecrescimoEmAnos,
};
if (produto.Matricula != proposta.Proponente.Matricula && proposta.Proponente.Conjuge != null)
{
if (produto.Matricula == proposta.Proponente.Conjuge.Matricula)
{
coberturaContratada.Matricula = proposta.Proponente.Conjuge.Matricula;
coberturaContratada.Sexo = proposta.Proponente.Conjuge.Sexo;
coberturaContratada.DataNascimento = proposta.Proponente.Conjuge.DataNascimento;
}
}
coberturaContratada.Historico = ObterHistorico(coberturaContratada, produto.Beneficiarios, proposta.DadosPagamento?.Periodicidade,
cobertura.ValorBeneficio, cobertura.ValorCapital, cobertura.ValorContribuicao, proposta.DataImplantacao);
coberturas.Add(coberturaContratada);
}
}
return(coberturas);
}
public static IEnumerable <HistoricoCoberturaContratada> ToHistoricoCoberturas(this IProposta proposta)
{
foreach (var produto in proposta.Produtos)
{
var beneficiario = produto.Beneficiarios?.OrderByDescending(d => d.DataNascimento).FirstOrDefault();
foreach (var cobertura in produto.Coberturas)
{
var cobContratada = new CoberturaContratada(Convert.ToInt64(cobertura.IdentificadorExterno));
yield return(new HistoricoCoberturaContratada(cobContratada)
{
SexoBeneficiario = beneficiario?.Sexo,
DataNascimentoBeneficiario = beneficiario?.DataNascimento,
PeriodicidadeId = (short)proposta.DadosPagamento.Periodicidade
});
}
}
}
public void FixtureSetUp()
{
_eventoImplantacao = EventoImplantacaoBuilder.UmEvento(_identificador)
.Com(CoberturaContratadaBuilder.Uma().ComPrazo(5, 1, 1)
.Com(DadosProdutoBuilder.Um().Padrao()).Build())
.Build();
_eventos = GetInstance <IEventosBase <EventoImplantacao> >();
_coberturas = GetInstance <ICoberturas>();
_eventos.Salvar(_eventoImplantacao).Wait();
_cobertura = _eventoImplantacao.Coberturas.First();
_historicoId = _cobertura.Historico.Id;
_coberturaCadastrada = _coberturas.ObterPorItemCertificado(_cobertura.ItemCertificadoApoliceId).Result;
}
public static HistoricoCoberturaContratada ObterHistorico(CoberturaContratada coberturaContratada,
List <IBeneficiario> beneficiarios, Periodicidade?periodicidade,
decimal valorBeneficio, decimal valorCapital, decimal valorContribuicao, DateTime dataImplantacao)
{
var beneficiarioMaisNovo = beneficiarios?.OrderByDescending(x => x.DataNascimento).FirstOrDefault();
var dto = new HistoricoCoberturaContratada(coberturaContratada)
{
SexoBeneficiario = beneficiarioMaisNovo?.Sexo,
DataNascimentoBeneficiario = beneficiarioMaisNovo?.DataNascimento,
PeriodicidadeId = (int)periodicidade.GetValueOrDefault(),
ValorBeneficio = valorBeneficio,
ValorCapital = valorCapital,
ValorContribuicao = valorContribuicao
};
dto.InformaStatus(StatusCobertura.StatusCoberturaEnum.Activa, dataImplantacao);
return(dto);
}
public static HistoricoCoberturaContratada ObterHistorico(CoberturaContratada coberturaContratada,
List <IBeneficiario> beneficiarios, Periodicidade?periodicidade,
decimal valorBeneficio, decimal valorCapital, decimal valorContribuicao)
{
var dto = new HistoricoCoberturaContratada(coberturaContratada);
var beneficiarioMaisNovo = beneficiarios?.OrderByDescending(x => x.DataNascimento).FirstOrDefault();
dto.SexoBeneficiario = beneficiarioMaisNovo?.Sexo;
dto.DataNascimentoBeneficiario = beneficiarioMaisNovo?.DataNascimento;
if (periodicidade != null)
{
dto.PeriodicidadeId = (int)periodicidade;
}
dto.ValorBeneficio = valorBeneficio;
dto.ValorCapital = valorCapital;
dto.ValorContribuicao = valorContribuicao;
return(dto);
}
public object CarregarParametros(CoberturaContratada dto)
{
return(new
{
dto.EventoId,
dto.InscricaoId,
dto.ItemCertificadoApoliceId,
dto.ItemProdutoId,
dto.ClasseRiscoId,
dto.TipoFormaContratacaoId,
dto.TipoRendaId,
dto.DataNascimento,
dto.Sexo,
CodigoProduto = dto.ProdutoId,
dto.Matricula,
dto.DataInicioVigencia,
dto.DataFimVigencia,
dto.DataAssinatura,
dto.IndiceBeneficioId,
IndiceContribuicaoId = dto.IndiceContribuicaoId.GetValueOrDefault(),
dto.ModalidadeCoberturaId,
dto.ProdutoId,
dto.RegimeFinanceiroId,
dto.TipoItemProdutoId,
dto.NomeProduto,
dto.NumeroBeneficioSusep,
dto.NumeroProcessoSusep,
dto.PlanoFipSusep,
dto.TipoProvisoes,
dto.PermiteResgateParcial,
dto.PrazoCoberturaEmAnos,
dto.PrazoDecrescimoEmAnos,
dto.PrazoPagamentoEmAnos,
dto.NumeroContribuicoesInicial
});
}
public static ProvisaoCoberturaBuilder UmBuilder(CoberturaContratada cobertura, TipoProvisaoEnum tipoProvisao)
{
return(new ProvisaoCoberturaBuilder(cobertura, (short)tipoProvisao));
}
public void FixtureSetUp()
{
_retorno = new CoberturaContratada();
_mockRepository = MockRepository.GenerateMock <ICoberturaContratadaRepository>();
_controller = new CoberturaController(_mockRepository);
}
public CoberturaContext(CoberturaContratada cobertura)
{
Data = cobertura;
Instance = null;
}
public static void Validar(this EventoEmissaoPremio evento, CoberturaContratada cobertura)
{
var coberturaValidate = Assertion.NotNull(cobertura, "O Evento não possui cobertura cadastrada.");
coberturaValidate.Validate();
}
private static ParametrosCalculoPmbac ObterParametrosCalculoPmbac(CoberturaContratada cobertura, DateTime dataExecucao)
{
return(ObterParametrosCalculoPmbac(cobertura, dataExecucao, default(decimal)));
}
public ProvisaoMatematicaBeneficioAConceder CalcularPMBAC(CoberturaContratada cobertura, DateTime dataExecucao, decimal valorProvisaoAnterior)
{
return(MapearPMBAC(_calculoService.CalcularPmbac(ObterParametrosCalculoPmbac(cobertura, dataExecucao, valorProvisaoAnterior))));
}
public virtual void ValidarDadosCalculoPMBAC(CoberturaContratada cobertura, DateTime dataExecucao)
{
_calculoService.CalcularPmbac(ObterParametrosCalculoPmbac(cobertura, dataExecucao));
}
public static ChaveProduto ChaveProduto(this CoberturaContratada cob)
{
return(new ChaveProduto(cob.ItemProdutoId, cob.TipoFormaContratacaoId, cob.TipoRendaId, cob.DataAssinatura));
}
private ProvisaoCoberturaBuilder(CoberturaContratada cobertura, short tipoProvisaoId)
{
Instance = new ProvisaoCobertura(cobertura, tipoProvisaoId);
}
public CalculadorEventoCobertura(CoberturaContratada coberturaContratada, EventoCobertura eventooperacional, ICalculoFacade calculo, IProvisoes provisao) : base(coberturaContratada, eventooperacional, calculo, provisao)
{
eventooperacional.MovimentosProvisao = movimentosProvisao;
}
private HistoricoCoberturaContratadaBuilder(CoberturaContratada cobertura)
{
Instance = new HistoricoCoberturaContratada(cobertura);
}
