/// <summary>
/// Obtém as políticas de aceitação de todas as propostas de um determinado CNPJ
/// </summary>
/// <param name="cnpj">CNPJ do parceiro</param>
/// <param name="canalVenda">Canal de venda</param>
/// <returns></returns>
public IQueryable <PoliticaAceitacao> ObterTodos(long cnpj, short canalVenda)
{
var pesquisa = new PesquisaModelosDeProposta();
pesquisa.Cnpj = cnpj;
pesquisa.CanalDeVenda = canalVenda; /*verificar*/
var resultadoPesquisarModelos = ServiceWcf <INegociacaoService> .UseSync(n => n.PesquisarModelosDeProposta(pesquisa));
if (resultadoPesquisarModelos.HouveErrosDuranteProcessamento)
{
throw new Exception(string.Join(", ", resultadoPesquisarModelos.Mensagens));
}
var listaModeloProposta = resultadoPesquisarModelos.Valor;
var politicas = new List <PoliticaAceitacao>();
foreach (var modeloPropostaEsb in listaModeloProposta)
{
PoliticaAceitacao politicaAceitacao = ObterLimitesOperacionais(modeloPropostaEsb.Codigo);
if (politicaAceitacao == null)
{
continue;
}
politicas.Add(politicaAceitacao);
}
return(politicas.AsQueryable());
}
/// <summary>
/// Constrói um objeto de produto para retorno com o resultado do serviço de produtos e limites
/// </summary>
/// <param name="codigoModeloProposta">Código do modelo de proposta</param>
/// <param name="politicasIds"></param>
/// <returns></returns>
public PoliticaAceitacao ObterLimitesOperacionais(string codigoModeloProposta, PoliticaDeAceitacao politicaAceitacao = null)
{
if (politicaAceitacao == null)
{
var parametroPoliticaAceitacao = ObterParametroLimitesOperacionais(codigoModeloProposta);
var resultadoPoliticaAceitacao = ServiceWcf <INegociacaoService> .UseSync(n => n.ObterLimitesOperacionais(parametroPoliticaAceitacao));
politicaAceitacao = resultadoPoliticaAceitacao.Valor;
}
var limites = politicaAceitacao.LimitesOperacionais;
var politica = new PoliticaAceitacao();
politica.DataUltimaAlteracao = politicaAceitacao.DataInicioVigencia;
politica.CigarrosExame = politicaAceitacao.QtdeMaximaCigarrosExame;
politica.CigarrosRecusa = politicaAceitacao.QtdeMaximaCigarrosRecusa;
politica.ImcMaximoExame = (int)politicaAceitacao.IMCMaximoExame; /*verificar*/
politica.ImcMaximoRecusa = (int)politicaAceitacao.IMCMaximoRecusa; /*verificar*/
politica.ImcMinimoExame = (int)politicaAceitacao.IMCMinimoExame; /*verificar*/
politica.ImcMinimoRecusa = (int)politicaAceitacao.IMCMinimoRecusa; /*verificar*/
politica.LimitesOperacionaisPorFaixaEtaria = new List <LimiteOperacionalFaixaEtaria>();
politica.LimitesOperacionaisPorProfissao = new List <LimiteOperacionalProfissao>();
politica.LimitesOperacionaisPorRenda = new List <LimiteOperacionalRenda>();
foreach (var limite in limites)
{
IncluirLimites(limite, politica);
}
return(politica);
}
public async static Task <HttpResponseMessage> Run([HttpTrigger(AuthorizationLevel.Function, "get", "post", Route = null)] HttpRequestMessage req,
[DocumentDB("Venda", "Profissoes", Id = "id", CreateIfNotExists = true)] IAsyncCollector <dynamic> profissoes,
[DocumentDB("Venda", "Profissoes", Id = "id")] DocumentClient documents,
TraceWriter log)
{
Stopwatch sw = new Stopwatch();
sw.Start();
log.Info("Buscando todas as profissões no ESB.Pessoa v1");
var resultado = ServiceWcf <Mongeral.ESB.Pessoa.Contrato.v1.Operacoes.IPessoaService> .UseSync(pessoa => pessoa.ObterTodasAsProfissoes());
sw.Stop();
log.Info($"Terminou de buscar todas as profissões no ESB.Pessoa v1 em {sw.ElapsedMilliseconds}");
if (resultado.HouveErrosDuranteProcessamento)
{
profissoes = null;
var msg = String.Empty;
resultado.Mensagens.ForEach(m => msg += " \n " + m);
return(req.CreateErrorResponse(HttpStatusCode.InternalServerError, msg));
}
log.Info("Limpando coleção de Profissões.");
await documents.DeleteDocumentCollectionAsync(UriFactory.CreateDocumentCollectionUri("Venda", "Profissoes"));
log.Info("Terminou de limpar as profisões.");
log.Info("Salvando Profissões.");
var tasks = new List <Task>();
foreach (var profissao in resultado.Valor)
{
tasks.Add(profissoes.AddAsync(new
{
id = profissao.Id.ToString(),
profissao.Cbo,
profissao.CodigoIr,
profissao.CodigosDoSysPrev,
profissao.CodigoSysPrev,
profissao.Descricao,
profissao.ValorMaximoCapitalSegurado
}));
}
Task.WaitAll(tasks.ToArray());
log.Info("Terminou de salvar Profissões.");
return(req.CreateResponse(HttpStatusCode.OK));
}
/// <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 Contrato.ModeloProposta ObterModeloPropostaDoServico(string codigoModelo)
{
var modeloPropostaObtido = ServiceWcf <INegociacaoService> .UseSync(n => n.ObterModeloProposta(new Contrato.ModeloProposta {
Codigo = codigoModelo
}));
if (modeloPropostaObtido.HouveErrosDuranteProcessamento)
{
throw new Exception($"Erro ao obter o modelo de proposta com código '{codigoModelo}'");
}
if (!modeloPropostaObtido.HouveErrosDuranteProcessamento && modeloPropostaObtido.Valor != null)
{
return(modeloPropostaObtido.Valor);
}
return(null);
}
private Contrato.PoliticaDeAceitacao ObterPoliticaAceitacaoDoServico(string codigoModelo)
{
var parametros = ObterParametroPoliticaDeAceitacao(codigoModelo);
var resultadoPoliticaAceitacao = ServiceWcf <INegociacaoService> .UseSync(n => n.ObterLimitesOperacionais(new Contrato.ParametroLimitesOperacionais()
{
CodigoModeloProposta = codigoModelo, DataVigencia = DateTime.Now
}));
if (resultadoPoliticaAceitacao.HouveErrosDuranteProcessamento)
{
throw new Exception($"Erro ao obter a política de aceitação do modelo de proposta com código '{codigoModelo}'");
}
if (!resultadoPoliticaAceitacao.HouveErrosDuranteProcessamento && resultadoPoliticaAceitacao.Valor != null)
{
return(resultadoPoliticaAceitacao.Valor);
}
return(null);
}
private List <CapitalSegurado> ObterCapitalSegurado(PesquisaCapitalSegurado parametros)
{
var resultado = ServiceWcf <IAcumuloDeCapitalService> .UseSync(s => s.ObterCapitalSegurado(parametros));
if (resultado.HouveErrosDuranteProcessamento)
{
var obs = new Observacao
{
ID = 21,
Descricao = "Não foi possível validar os Capitais Acumulados",
Itens = resultado.Mensagens
};
}
else
{
if (resultado.Mensagens != null && resultado.Mensagens.Count > 0)
{
resultado.Mensagens.ForEach(x => Mensagens.Add(new Observacao(descricao: x)));
}
}
return(resultado.Valor);
}
public static async Task <HttpResponseMessage> Run([HttpTrigger(AuthorizationLevel.Function, "get", "post", Route = null)] HttpRequestMessage req,
[DocumentDB("Venda", "ModelosNegocio", Id = "id", CreateIfNotExists = true, CollectionThroughput = 4000)] IAsyncCollector <dynamic> modelosNegocio,
[DocumentDB("Venda", "ModelosNegocio", Id = "id")] DocumentClient collectionModelosNegocio,
TraceWriter log)
{
var cnpjs = Environment.GetEnvironmentVariable("Clientes.Cnpj").Split(',');
var modelosNegocioRetornados = new ConcurrentDictionary <Tuple <string, string>, List <Model.ModeloProposta> >();
var modelosPropostaRetornados = new ConcurrentBag <ModeloProposta>();
Stopwatch sw = new Stopwatch();
sw.Start();
log.Info("Buscando modelos de proposta no ESB.Produto.v2");
try
{
Parallel.For(0, cnpjs.Length, i =>
{
var cnpjCanal = cnpjs[i].Split('|');
var servicoModeloProposta = new ServicoModeloProposta();
short?canalVenda;
if (cnpjCanal.Length > 1)
{
canalVenda = short.Parse(cnpjCanal[1]);
}
else
{
canalVenda = null;
}
var pesquisa = new PesquisaModelosDeProposta
{
Cnpj = Int64.Parse(cnpjCanal[0]),
CanalDeVenda = canalVenda.GetValueOrDefault(0)
};
var resultadoPesquisarModelos = ServiceWcf <INegociacaoService> .UseSync(neg => neg.PesquisarModelosDeProposta(pesquisa));
if (resultadoPesquisarModelos.HouveErrosDuranteProcessamento)
{
throw new ApplicationException(string.Join(", ", resultadoPesquisarModelos.Mensagens));
}
resultadoPesquisarModelos.Valor.ForEach(rpm => modelosPropostaRetornados.Add(rpm));
var resultado = servicoModeloProposta.ObterTodos(resultadoPesquisarModelos.Valor);
modelosNegocioRetornados.TryAdd(new Tuple <string, string>(cnpjCanal[0], canalVenda?.ToString()), resultado.ToList());
});
sw.Stop();
log.Info($"Terminou de buscar os modelos de proposta no ESB.Produto.v2 em {sw.ElapsedMilliseconds}");
log.Info("Limpando coleção de modelos de negócio.");
var deleteMnCollection = collectionModelosNegocio.DeleteDocumentCollectionAsync(UriFactory.CreateDocumentCollectionUri("Venda", "ModelosNegocio"));
await deleteMnCollection;
log.Info("Terminou de limpar os modelos de negócio.");
log.Info("Salvando modelos de negócio.");
var tasksInsertMn = new List <Task>();
foreach (var modeloNegocio in modelosNegocioRetornados)
{
Task.Run(async() => {
var data = new
{
Cnpj = modeloNegocio.Key.Item1.Trim(),
CanalVenda = modeloNegocio.Key.Item2,
Modelos = modeloNegocio.Value
};
var size = Encoding.UTF8.GetBytes(await Task.Factory.StartNew(() => JsonConvert.SerializeObject(data)));
if (size.Length > 2000000)
{
decimal i = 0m;
do
{
tasksInsertMn.Add(modelosNegocio.AddAsync(new
{
data.Cnpj,
data.CanalVenda,
Modelos = data.Modelos.GetRange((int)i * 8, (int)i * 8 + 8 > data.Modelos.Count ? data.Modelos.Count - (int)i * 8 : 8)
}));
i++;
} while (i < ((decimal)data.Modelos.Count / 8));
}
else
{
tasksInsertMn.Add(modelosNegocio.AddAsync(data));
};
}).Wait();
}
Task.WaitAll(tasksInsertMn.ToArray());
log.Info("Terminou de salvar modelos de negócio.");
}
catch (AggregateException agex)
{
var msg = string.Empty;
agex.InnerExceptions.ToList().ForEach(e => msg += $"{e.GetType().Name} \n " + e.Message);
return(req.CreateErrorResponse(HttpStatusCode.InternalServerError, msg));
}
catch (Exception ex)
{
return(req.CreateErrorResponse(HttpStatusCode.InternalServerError, ex.Message));
}
return(req.CreateResponse(HttpStatusCode.OK));
}
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));
}
