public async Task <EventoAlteracao> ToEventoAlteracao(IProposta proposta)
{
var historicos = new List <HistoricoCoberturaContratada>();
foreach (var produto in proposta.Produtos)
{
var beneficiario = produto.Beneficiarios?.OrderByDescending(d => d.DataNascimento).FirstOrDefault();
foreach (var cobertura in produto.Coberturas)
{
var historico = new HistoricoCoberturaContratada(await _coberturas.ObterPorItemCertificado(long.Parse(cobertura.IdentificadorExterno)))
{
SexoBeneficiario = beneficiario?.Sexo,
DataNascimentoBeneficiario = beneficiario?.DataNascimento,
PeriodicidadeId = (short)proposta.DadosPagamento?.Periodicidade,
ValorBeneficio = cobertura.ValorBeneficio,
ValorCapital = cobertura.ValorCapital,
ValorContribuicao = cobertura.ValorContribuicao,
};
historico.InformaStatus(StatusCobertura.StatusCoberturaEnum.Activa, proposta.DataImplantacao);
historicos.Add(historico);
}
}
return(new EventoAlteracao(proposta.Identificador, proposta.IdentificadorCorrelacao, proposta.IdentificadorNegocio, proposta.DataExecucaoEvento)
.ComHistorico(historicos));
}
public async Task Dado_um_historico_de_implantacao_ao_salvar_deve_persistir_os_dados()
{
await _eventos.Salvar(_eventoImplantacao);
var dadosCobertura = _eventoImplantacao.Coberturas.First();
var dto = await _coberturas.ObterPorItemCertificado(dadosCobertura.ItemCertificadoApoliceId);
Assert.That(dto.Id, Is.EqualTo(dadosCobertura.Historico.CoberturaContratadaId));
Assert.That(dto.Historico.DataNascimentoBeneficiario, Is.EqualTo(dadosCobertura.Historico.DataNascimentoBeneficiario));
Assert.That(dto.Historico.SexoBeneficiario, Is.EqualTo(dadosCobertura.Historico.SexoBeneficiario));
Assert.That(dto.Historico.PeriodicidadeId, Is.EqualTo(dadosCobertura.Historico.PeriodicidadeId));
Assert.That(dto.Historico.ValorBeneficio, Is.EqualTo(dadosCobertura.Historico.ValorBeneficio));
Assert.That(dto.Historico.ValorCapital, Is.EqualTo(dadosCobertura.Historico.ValorCapital));
Assert.That(dto.Historico.ValorContribuicao, Is.EqualTo(dadosCobertura.Historico.ValorContribuicao));
}
public async Task Send(PortabilidadePremioContext context, IPipe <PortabilidadePremioContext> next)
{
foreach (var premio in context.Premios)
{
var instance = await _coberturas.ObterPorItemCertificado(premio.ItemCertificadoApoliceId);
await _stateMachine.RaiseEvent(instance, _stateMachine.PortabilidadePremio, new NotificacaoEvento <EventoPortabilidadePremio, PremioPortabilidade>(context.Evento, premio));
}
await next.Send(context);
}
public async Task Send(ImplantacaoContext context, IPipe <ImplantacaoContext> next)
{
foreach (var coberturaContratada in context.Coberturas)
{
var instance = await _coberturas.ObterPorItemCertificado(coberturaContratada.ItemCertificadoApoliceId) ?? coberturaContratada;
await _stateMachine.RaiseEvent(instance, _stateMachine.Implantar, new NotificacaoEvento <EventoImplantacao, CoberturaContratada>(context.Evento, coberturaContratada));
}
await next.Send(context);
}
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 Send(AlteracaoContext context, IPipe <AlteracaoContext> next)
{
foreach (var historico in context.Historicos)
{
historico.InformaStatus(StatusCobertura.StatusCoberturaEnum.Activa, DateTime.Now);
var instance = (await _coberturas.ObterPorItemCertificado(historico.Cobertura.ItemCertificadoApoliceId)) ?? historico.Cobertura;
await _stateMachine.RaiseEvent(instance, _stateMachine.Alterar, new NotificacaoEvento <EventoAlteracao, HistoricoCoberturaContratada>(context.Evento, historico));
}
await next.Send(context);
}
public void EntaoUmHistoricoDeCoberturaContrataCom(Table param)
{
var saida = param.CreateSet <ImplantacaoParam>().First();
_coberturas = InstanceFactory.Resolve <ICoberturas>();
var coberturaDto = _coberturas.ObterPorItemCertificado(_itemCertificadoApoliceId).Result;
Assert.That(_param.IdExterno, Is.EqualTo(coberturaDto.ItemCertificadoApoliceId));
Assert.That(saida.Periodicidade, Is.EqualTo(coberturaDto.Historico.PeriodicidadeId));
Assert.That(saida.DataNascimento, Is.EqualTo(coberturaDto.Historico.DataNascimentoBeneficiario));
Assert.That(saida.Sexo, Is.EqualTo(coberturaDto.Historico.SexoBeneficiario));
}
public async Task Send(AjustePremioContext context, IPipe <AjustePremioContext> next)
{
foreach (var premio in context.Premios)
{
if (!await _premios.VerificarUltimoPremio(premio.ItemCertificadoApoliceId, context.Evento.MovimentosPermitidos, premio.Numero))
{
Assertion.Fail($"O Ajuste não pode ser realizado. Não foi encontrada nenhum prêmio com o ItemCertificadoApoliceId: {premio.ItemCertificadoApoliceId} e com o Número da Parcela: { premio.Numero }.").Validate();
}
var instance = await _coberturas.ObterPorItemCertificado(premio.ItemCertificadoApoliceId);
await _stateMachine.RaiseEvent(instance, _stateMachine.AjustePremio, new NotificacaoEvento <EventoAjustePremio, Premio>(context.Evento as EventoAjustePremio, premio));
}
await next.Send(context);
}
public async Task Send(DesapropriacaoPremioContext context, IPipe <DesapropriacaoPremioContext> next)
{
foreach (var premio in context.Premios)
{
if (!await _premios.VerificarUltimoPremio(premio.ItemCertificadoApoliceId, context.Evento.MovimentosPermitidos, premio.Numero))
{
Assertion.Fail($"A Desapropriação não pode ser realizado. Não foi encontrada nenhuma apropropriação com o ItemCertificadoApoliceId {premio.ItemCertificadoApoliceId}, com o Número da Parcela { premio.Numero }.");
}
var instance = (await _coberturas.ObterPorItemCertificado(premio.ItemCertificadoApoliceId));
await _stateMachine.RaiseEvent(instance, _stateMachine.DesapropriarPremio, new NotificacaoEvento <EventoDesapropriacaoPremio, PremioDesapropriado>(context.Evento, premio));
}
await next.Send(context);
}
public async Task Send(ApropriacaoPremioContext context, IPipe <ApropriacaoPremioContext> next)
{
foreach (var premio in context.Premios)
{
if (!await _premios.VerificarUltimoPremio(premio.ItemCertificadoApoliceId, context.Evento.MovimentosPermitidos, premio.Numero))
{
Assertion.Fail($"A apropriação não pode ser realizado, para o ItemCertificadoApoliceId {premio.ItemCertificadoApoliceId}, com o Número da Parcela { premio.Numero }." +
$"O movimento anterior deve estar entre uma das opções permitidas: Emissão, Reemissão ou Desapropriação.");
}
var instance = (await _coberturas.ObterPorItemCertificado(premio.ItemCertificadoApoliceId));
await _stateMachine.RaiseEvent(instance, _stateMachine.ApropriarPremio, new NotificacaoEvento <EventoApropriacaoPremio, PremioApropriado>(context.Evento, premio));
}
await next.Send(context);
}
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 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 async Task Send(EmissaoPremioContext context, IPipe <EmissaoPremioContext> next)
{
foreach (var premio in context.Premios)
{
var existeEmissao = await _premios.Contem(premio.ItemCertificadoApoliceId);
if (existeEmissao)
{
if (!await _premios.VerificarUltimoPremio(premio.ItemCertificadoApoliceId,
context.Evento.MovimentosPermitidos, premio.Numero))
{
Assertion.Fail($"Já existe Emissão do Prêmio com o ItemCertificadoApoliceId: {premio.ItemCertificadoApoliceId} e com o Número da Parcela: {premio.Numero}. " +
$"O movimento anterior deve estar entre uma das opções permitidas: Cancelamento Emissão, Ajuste de Premio ou Cancelamento Ajuste.")
.Validate();
}
}
var instance = await _coberturas.ObterPorItemCertificado(premio.ItemCertificadoApoliceId);
await _stateMachine.RaiseEvent(instance, _stateMachine.EmitirPremio, new NotificacaoEvento <EventoEmissaoPremio, Premio>(context.Evento as EventoEmissaoPremio, premio));
}
await next.Send(context);
}
public async Task <Premio> CriarPremio(Premio premio, EventoPremio evento)
{
var cobertura = await _coberturas.ObterPorItemCertificado(premio.ItemCertificadoApoliceId);
if (!evento.RegimeFinanceiroPermitido.Contains(cobertura.RegimeFinanceiroId.GetValueOrDefault()))
{
return(null);
}
var contribuicoes = await ObterNumeroContribuicoes(premio, cobertura.NumeroContribuicoesInicial);
cobertura.ComNumeroContribuicoes(contribuicoes);
premio.ComCobertura(cobertura)
.ComTipoMovimento((short)evento.TipoMovimento)
.InformaEvento(evento);
await ValidarPremioAnterior(premio);
premio.AdicionarMovimentoProvisao(_calculador.CriarProvisao(premio));
return(premio);
}
