public List <ContratacaoProduto> CalcularPremioCapitalComCustoFixo(DateTime dataNascimentoTitular,
Model.Enum.SexoEnum sexoTitular,
string ufTitular,
string cboTitular,
Model.Enum.SexoEnum sexoConjuge,
DateTime dataNascimentoConjuge,
short periodicidade,
short prazoCerto,
short tempoPrazoAntecipado,
short idadePagamentoAntecipado,
short prazoDecrescimo,
ModeloPropostaCompleto modeloProposta)
{
return(CalcularPremioCapital(dataNascimentoTitular,
sexoTitular,
ufTitular,
cboTitular,
periodicidade,
sexoConjuge,
dataNascimentoConjuge,
prazoCerto,
tempoPrazoAntecipado,
idadePagamentoAntecipado,
prazoDecrescimo,
modeloProposta,
EnumTipoCalculoPremioCapital.CalculoComCustoFixo));
}
public RegrasContratacao ObterRegrasContratacao(ModeloPropostaCompleto modeloProposta,
long cpfTitular,
DateTime dataNascimentoTitular,
Model.Enum.SexoEnum sexoTitular,
string ufTitular,
Produto.Profissao profissaoTitular,
short periodicidade,
Model.Enum.SexoEnum sexoConjuge,
DateTime dataNascimentoConjuge,
short prazoCerto,
short tempoPrazoAntecipado,
short idadePagamentoAntecipado,
short prazoDecrescimo,
Model.Enum.TipoRelacaoSegurado tipoRelacaoSegurado,
decimal renda)
{
var produtosParaSimulacao = this.ObterProdutosSemRestricoes(modeloProposta.Produtos, tipoRelacaoSegurado, profissaoTitular, dataNascimentoTitular, ufTitular);
var limitesOperacionais = this.ObterLimitesDisponiveis(modeloProposta.PoliticaAceitacao, cpfTitular, dataNascimentoTitular, ufTitular, profissaoTitular, renda, modeloProposta.Produtos);
var calculo = CalcularPremioCapitalSemCustoFixo(dataNascimentoTitular, sexoTitular, ufTitular, profissaoTitular.CBO, periodicidade, sexoConjuge, dataNascimentoConjuge, prazoCerto, tempoPrazoAntecipado, idadePagamentoAntecipado, prazoDecrescimo, modeloProposta);
var retorno = MontarRegrasContratacao(limitesOperacionais, calculo);
retorno.TicketMinimo = (decimal)modeloProposta.TicketMinimo.GetValueOrDefault();
return(retorno);
}
/// <summary>
/// Obtém modelo de proposta com base nas informações do modelo de proposta do serviço (versão completa)
/// </summary>
/// <param name="modeloProposta">modelo de proposta</param>
/// <returns>modelo de proposta preenchido</returns>
private ModeloPropostaCompleto ObterModeloPropostaCompletoApi(ModeloPropostaEsb modeloProposta)
{
var modeloPropostaApi = new ModeloPropostaCompleto();
modeloPropostaApi.Id = modeloProposta.Codigo;
modeloPropostaApi.Nome = modeloProposta.Descricao;
modeloPropostaApi.DataUltimaAlteracao = DateTime.Now; /*alterar*/
var keyValueNamespace = ServiceWcf <IGerirProposta> .UseSync(ger => ger.BuscarSchemaNamespacePorModelo(modeloProposta.Codigo));
modeloPropostaApi.Namespace = keyValueNamespace.Value;
var keyValuePolitica = ServiceWcf <IGerirProposta> .UseSync(ger => ger.BuscarPolitica(modeloProposta.Codigo, DateTime.Now, EnumTipoPolitica.VALIDACAO));
modeloPropostaApi.PoliticaValidacao = keyValuePolitica.Value;
ServicoPoliticaAceitacao servicoPolitica = new ServicoPoliticaAceitacao();
var resultadoPoliticaAceitacao = ServiceWcf <INegociacaoService> .UseSync(n => n.ObterLimitesOperacionais(new Contrato.ParametroLimitesOperacionais
{
CodigoModeloProposta = modeloProposta.Codigo,
DataVigencia = DateTime.Now
}));
modeloPropostaApi.PoliticaAceitacao = servicoPolitica.ObterLimitesOperacionais(resultadoPoliticaAceitacao.Valor);
modeloPropostaApi.TicketMinimo = (float)resultadoPoliticaAceitacao.Valor.MinimoContribuicaoClientesNovos;
ServicoProduto servicoProduto = new ServicoProduto();
var produtosFiltrados = modeloProposta.Produtos.Where(p => !p.EstahRestrito).ToList();
modeloPropostaApi.Produtos = new List <Model.Produto>();
foreach (Contrato.ProdutoNegociado produto in modeloProposta.Produtos.Where(p => !p.EstahRestrito))
{
modeloPropostaApi.DiasVencimento = ObterDiasVencimento(modeloPropostaApi.DiasVencimento, produto.RegraCobranca.DiasVencimento);
var produtoFormasCobranca = produto.RegraCobranca.FormasDeCobranca.Select(f => f.FormaCobranca).ToList();
modeloPropostaApi.FormasPagamento = ObterFormasPagamento(modeloPropostaApi.FormasPagamento, produtoFormasCobranca);
var produtoPeriodicidadesInt = produto.RegraCobranca.Periodicidades.Select(p => (int)p).ToList();
modeloPropostaApi.Periodicidades = ObterPeriodicidades(modeloPropostaApi.Periodicidades, produtoPeriodicidadesInt);
var produtoApi = servicoProduto.ObterProduto(produto, resultadoPoliticaAceitacao.Valor.LimitesOperacionais, produtosFiltrados);
modeloPropostaApi.Produtos.Add(produtoApi);
}
bool existeTipoConjuge = ExisteTipoProponenteConjuge(modeloProposta.Produtos);
modeloPropostaApi.Questionarios = ObterQuestionariosCompleto(modeloProposta.Codigo, modeloProposta.Perguntas, existeTipoConjuge);
PreencherInformacoesAdicionais(modeloProposta, modeloPropostaApi);
return(modeloPropostaApi);
}
private void CalcularRepasse(
DateTime dataNascimentoTitular,
Cobertura cobertura,
Model.Produto produto,
ModeloPropostaCompleto modeloProposta,
Dictionary <int, decimal> valoresRepasse,
List <Cobertura> coberturasNaoExibidas)
{
if (cobertura != null && cobertura.EhServico && cobertura.ValorServicoSomadoNaCoberturaDeReferencia)
{
decimal valorRepasse = 0;
int idItemProduto = 0;
if (cobertura.ValoresRepassadoAoCliente != null)
{
valorRepasse = cobertura.ValoresRepassadoAoCliente.Where(
c => (c.TipoRepasseCliente == ContratosEnum.TipoRepasseClienteEnum.PorIdade &&
dataNascimentoTitular.Idade() >= c.IdadeInicial &&
dataNascimentoTitular.Idade() <= c.IdadeFinal) ||
(c.TipoRepasseCliente == ContratosEnum.TipoRepasseClienteEnum.Fixo))
.Sum(x => x.Valor);
}
if (cobertura.ValorServicoSomadoNaCoberturaDeReferencia && produto.ReferenciaCoberturaId.HasValue)
{
idItemProduto = produto.Coberturas.Find(x => x.IdCoberturaEsim.GetValueOrDefault() == produto.ReferenciaCoberturaId.Value).IdEsim.GetValueOrDefault();
}
else
{
idItemProduto = cobertura.IdEsim.GetValueOrDefault();
}
if (idItemProduto != 0 && valorRepasse != 0)
{
if (valoresRepasse.ContainsKey(idItemProduto))
{
valorRepasse += valoresRepasse[idItemProduto];
valoresRepasse.Remove(idItemProduto);
}
valoresRepasse.Add(idItemProduto, valorRepasse);
}
if (cobertura.EhServico && !cobertura.ExibeServicoNaListaDeCobertura)
{
coberturasNaoExibidas.Add(cobertura);
}
}
}
private short ObterFormaContratacaoDoModelo(int idItemProduto, ModeloPropostaCompleto modelo)
{
var produtos = modelo.Produtos.Where(p => p.Coberturas.Any(c => c.IdEsim == idItemProduto)).ToList();
if (!produtos.Any())
{
return(0);
}
var coberturas = produtos.SelectMany(p => p.Coberturas.Where(c => c.IdEsim == idItemProduto)).ToList();
if (!coberturas.Any())
{
return(0);
}
return(coberturas.First().FormasContratacao.First(fc => fc.EhOpcaoPadrao).Id);
}
private static ContratosEnum.TipoRendaEnum ObterTipoRenda(ModeloPropostaCompleto modeloProposta, Cobertura cobertura)
{
var tipoRenda = ContratosEnum.TipoRendaEnum.NaoSeAplica;
try
{
var formaContratacaoPadrao = cobertura.FormasContratacao.Single(x => x.EhOpcaoPadrao);
var formaContratacao = (ContratosEnum.FormaContratacaoEnum)formaContratacaoPadrao.Id;
if (formaContratacao == ContratosEnum.FormaContratacaoEnum.RendaMensal)
{
var rendaPadrao = cobertura.Rendas.Single(x => x.EhPadrao);
tipoRenda = (ContratosEnum.TipoRendaEnum)rendaPadrao.Tipo.Id;
}
}
catch (Exception)
{
}
return(tipoRenda);
}
private short?ObterClasseDeRiscoPadrao(ModeloPropostaCompleto modeloProposta, int idProduto, int idItemProduto)
{
var produto = modeloProposta.Produtos.FirstOrDefault(p => p.Id == idProduto);
if (produto == null)
{
return(null);
}
var cobertura = produto.Coberturas.FirstOrDefault(c => c.IdEsim == idItemProduto);
if (cobertura == null)
{
return(null);
}
if (cobertura.ClasseDeRiscoPadraoParaContratacao == null)
{
return(null);
}
return(cobertura.ClasseDeRiscoPadraoParaContratacao.Id);
}
private Produto.ParametrosCalculo CriarParametroDeCalculo(Model.Enum.SexoEnum sexoTitular,
DateTime dataNascimentoTitular,
string ufTitular,
string cboTitular,
short periodicidade,
short PrazoCerto,
short TempoPrazoAntecipado,
short IdadePagamentoAntecipado,
short PrazoDecrescimo,
ModeloPropostaCompleto modeloProposta,
Cobertura cobertura,
Model.Produto produto)
{
ValidarCobertura(cobertura, produto);
//TODO: Repassar valores de serviços marcados ao cliente
return(new Produto.ParametrosCalculo
{
ValorBeneficio = cobertura.CapitalSegurado,
ValorPremio = cobertura.Premio,
DataCalculo = DateTime.Now,
DataInicioVigencia = DateTime.Now,
ItemProdutoId = cobertura.IdEsim.GetValueOrDefault(),
PrazoCobertura = ObterPrazoCobertura(PrazoCerto, TempoPrazoAntecipado),
Segurado = new Produto.Segurado {
Sexo = (ContratosEnum.SexoEnum)Enum.Parse(typeof(ContratosEnum.SexoEnum), Enum.GetName(typeof(Model.Enum.SexoEnum), sexoTitular)), DataNascimento = dataNascimentoTitular, UF = ufTitular, ProfissaoCBO = cboTitular
},
FormaContratacaoId = ObterFormaContratacaoDoModelo(cobertura.IdEsim.GetValueOrDefault(), modeloProposta),
IdentificadorExterno = cobertura.IdEsim.ToString(),
PeriodicidadeId = ObterPeriodicidade(periodicidade),
TipoRenda = ObterTipoRenda(modeloProposta, cobertura),
ClasseRiscoId = ObterClasseDeRiscoPadrao(modeloProposta, produto.IdEsim.GetValueOrDefault(), cobertura.IdEsim.GetValueOrDefault()),
PrazoDecrecimo = PrazoDecrescimo,
IdadePagamentoAntecipado = IdadePagamentoAntecipado,
TempoPrazoAntecipado = TempoPrazoAntecipado
});
}
private List <Produto.ParametrosCalculo> GerarParametrosParaCalculo(
DateTime dataNascimentoTitular,
Model.Enum.SexoEnum sexoTitular,
string ufTitular,
string cboTitular,
short periodicidade,
Model.Enum.SexoEnum sexoConjuge,
DateTime dataNascimentoConjuge,
short PrazoCerto,
short TempoPrazoAntecipado,
short IdadePagamentoAntecipado,
short PrazoDecrescimo,
ModeloPropostaCompleto modeloProposta,
Model.Produto produto,
Dictionary <int, decimal> valoresRepasse,
List <Model.Cobertura> coberturasNaoExibidas)
{
var retorno = new List <Produto.ParametrosCalculo>();
foreach (var cobertura in produto.Coberturas)
{
try
{
CalcularRepasse(dataNascimentoTitular, cobertura, produto, modeloProposta, valoresRepasse, coberturasNaoExibidas);
var parametroDeCalculo = CriarParametroDeCalculo(sexoTitular, dataNascimentoTitular, ufTitular, cboTitular, periodicidade, PrazoCerto, TempoPrazoAntecipado, IdadePagamentoAntecipado, PrazoDecrescimo, modeloProposta, cobertura, produto);
AdicionarConjuge(sexoConjuge, dataNascimentoConjuge, parametroDeCalculo);
parametroDeCalculo.EhSimulacao = true;
retorno.Add(parametroDeCalculo);
}
catch (ProdutoException) { }
}
return(retorno);
}
private List <ContratacaoProduto> CalcularPremioCapital(DateTime dataNascimentoTitular,
Model.Enum.SexoEnum sexoTitular,
string ufTitular,
string cboTitular,
short periodicidade,
Model.Enum.SexoEnum sexoConjuge,
DateTime dataNascimentoConjuge,
short prazoCerto,
short tempoPrazoAntecipado,
short idadePagamentoAntecipado,
short prazoDecrescimo,
ModeloPropostaCompleto modeloProposta,
EnumTipoCalculoPremioCapital tipoCalculoPremio)
{
var coberturasCalculadas = new List <ContratacaoCobertura>();
var parametrosCalculo = new List <Produto.ParametrosCalculo>();
var valoresRepasse = new Dictionary <int, decimal>();
var coberturasNaoExibidas = new List <Model.Cobertura>();
foreach (var produto in modeloProposta.Produtos)
{
parametrosCalculo.AddRange(GerarParametrosParaCalculo(dataNascimentoTitular,
sexoTitular,
ufTitular,
cboTitular,
periodicidade,
sexoConjuge,
dataNascimentoConjuge,
prazoCerto,
tempoPrazoAntecipado,
idadePagamentoAntecipado,
prazoDecrescimo,
modeloProposta,
produto,
valoresRepasse,
coberturasNaoExibidas));
}
try
{
AbaterValorServicos(valoresRepasse, parametrosCalculo);
var resultado = ServiceWcf <ICalculoService> .UseSync(s => s.CalcularValorContribuicaoBeneficio(parametrosCalculo));
if (resultado.HouveErrosDuranteProcessamento)
{
throw new CalculoException(string.Join(Environment.NewLine, resultado.Mensagens));
}
coberturasCalculadas.AddRange(resultado.Valor.Select(calculo => new ContratacaoCobertura
{
CapitalSegurado = calculo.ValorBeneficio,
ModelosProposta = new List <string> {
modeloProposta.Nome
},
Premio = tipoCalculoPremio == EnumTipoCalculoPremioCapital.CalculoSemCustoFixo ? ObterPremioSemCustoFixo(calculo.ValorPremioComercial, calculo.CustoFixoCarregamento) : calculo.ValorPremioComercial,
IdItemProduto = Convert.ToInt32(calculo.IdentificadorExterno),
CustoFixo = calculo.CustoFixoCarregamento
}));
AdicionarValorServicos(valoresRepasse, coberturasCalculadas);
}
catch (TimeoutException)
{
AdicionarObservacaoTimeout(parametrosCalculo);
}
catch (CommunicationException)
{
AdicionarObservacaoTimeout(parametrosCalculo);
}
return(RetornarProdutosPreenchidos(modeloProposta.Produtos,
coberturasCalculadas,
coberturasNaoExibidas, prazoCerto,
tempoPrazoAntecipado,
idadePagamentoAntecipado,
prazoDecrescimo));
}
