/// <summary> /// Executa o cálculo para o item informado. /// </summary> /// <param name="item">Item sobre o qual será calculada a rentabilidade.</param> protected virtual Data.ICalculoRentabilidadeResultado Calcular(IItemRentabilidade item) { var calculadora = ProvedorCalculadoraRentabilidade.Calculadora; var container = item as IItemRentabilidadeContainer; var subResultados = new List <Data.ICalculoRentabilidadeResultado>(); // Caso o itens possua outras itens filhos, // os mesmos deve ser calculados if (container != null) { foreach (var i in container.Itens) { subResultados.Add(Calcular(i)); } } // Executa o calculo da rentabilidae var resultadoCalculo = calculadora.Calcular(item); item.LimparRegistros(); resultadoCalculo.AplicarResultado(); return(CriaResultado(item, resultadoCalculo, subResultados)); }
/// <summary> /// Verifica se pode liberar o item. /// </summary> /// <param name="item"></param> /// <returns></returns> public bool PodeLiberar(IItemRentabilidade item) { var faixa = ObterFaixa(item); if (faixa?.RequerLiberacao ?? false) { if (!faixa.IdsFuncionario.Any() && !faixa.IdsTipoFuncionario.Any()) { return(Data.Helper.Config.PossuiPermissao(Data.Helper.Config.FuncaoMenuFinanceiro.ControleFinanceiroRecebimento)); } if (Data.Helper.UserInfo.GetUserInfo != null) { var usuario = Data.Helper.UserInfo.GetUserInfo; // Verifica se o funcionário logado ou o tipo de funcionário // tem permissão para a liberação return(faixa.IdsFuncionario.Contains((int)usuario.CodUser) || faixa.IdsTipoFuncionario.Contains((int)usuario.TipoUsuario)); } } return(true); }
/// <summary> /// Construtor padrão. /// </summary> /// <param name="indicadoresFinanceiros"></param> /// <param name="variaveisItem"></param> /// <param name="expressoesCalculo"></param> /// <param name="custoTotal"></param> /// <param name="item"></param> internal ResultadoRentabilidade( Mathematical.IVariavelCollection indicadoresFinanceiros, Mathematical.IVariavelCollection variaveisItem, Mathematical.IVariavelCollection expressoesCalculo, double custoTotal, IItemRentabilidade item) { item.Require(nameof(item)).NotNull(); IndicadoresFinanceiros = new Dictionary <string, decimal>(); VariaveisItem = new Dictionary <string, decimal>(); ExpressoesCalculo = new Dictionary <string, decimal>(); foreach (var i in indicadoresFinanceiros) { IndicadoresFinanceiros.Add(i.Nome, (decimal)i.ObterValor()); } foreach (var i in variaveisItem) { VariaveisItem.Add(i.Nome, (decimal)i.ObterValor()); } foreach (var i in expressoesCalculo) { ExpressoesCalculo.Add(i.Nome, (decimal)i.ObterValor()); } CustoTotal = (decimal)custoTotal; Item = item; }
/// <summary> /// Construtor padrão. /// </summary> /// <param name="provedorDescritores"></param> /// <param name="item"></param> /// <param name="culture"></param> public ItemRentabilidadeDataSource( IProvedorDescritorRegistroRentabilidade provedorDescritores, IItemRentabilidade item, System.Globalization.CultureInfo culture = null) { provedorDescritores.Require(nameof(provedorDescritores)).NotNull(); item.Require(nameof(item)).NotNull(); ProvedorDescritores = provedorDescritores; Item = item; Cultura = culture ?? System.Globalization.CultureInfo.CurrentCulture; }
/// <summary> /// Construtor padrão. /// </summary> /// <param name="itemRentabilidade"></param> /// <param name="executado">Identifica se o cálculo foi executado.</param> /// <param name="percentualRentabilidade"></param> /// <param name="rentabilidadeFinanceira"></param> /// <param name="itens">Itens associados.</param> public CalculoRentabilidadeResultado( IItemRentabilidade itemRentabilidade, bool executado, decimal percentualRentabilidade, decimal rentabilidadeFinanceira, IEnumerable <Item> itens) { ItemRentabilidade = itemRentabilidade; Executado = executado; PercentualRentabilidade = percentualRentabilidade; RentabilidadeFinanceira = rentabilidadeFinanceira; Itens = itens ?? new Item[0]; }
/// <summary> /// Realiza o cálculo dos valores da rentabilidade sobre a comissão. /// </summary> /// <param name="itemRentabilidade">Item onde será aplicado o cálculo.</param> /// <param name="idLoja">Identificador da loja.</param> /// <param name="idFunc">Identificador do funcionário.</param> /// <param name="forcaPercentualComissao">Identifica se é para forçar a atualização do percentual de comissão.</param> /// <returns></returns> public ResultadoComissaoRentabilidade Calcular(IItemRentabilidade itemRentabilidade, int idLoja, int?idFunc, bool forcaPercentualComissao) { var faixas = ObterFaixas(idLoja, idFunc); var faixa = faixas.FirstOrDefault(f => itemRentabilidade.PercentualRentabilidade > f.Inicio && itemRentabilidade.PercentualRentabilidade <= f.Fim); if (faixa != null && faixa.PercentualComissao < itemRentabilidade.PercentualComissao) { return(new ResultadoComissaoRentabilidade(false, faixa.PercentualComissao)); } return(new ResultadoComissaoRentabilidade(true, forcaPercentualComissao && faixa != null ? faixa.PercentualComissao : 0m)); }
/// <summary> /// Obtém a faixa com base no item informado. /// </summary> /// <param name="item"></param> /// <returns></returns> private Faixa ObterFaixa(IItemRentabilidade item) { var itemPedido = item as IItemRentabilidade <Data.Model.Pedido>; if (itemPedido != null) { var faixas = ObterFaixas((int)itemPedido.Proprietario.IdLoja); var faixa = faixas.FirstOrDefault(f => item.PercentualRentabilidade > f.Inicio && item.PercentualRentabilidade <= f.Fim); return(faixa); } return(null); }
/// <summary> /// Cria as constantes para o item informado. /// </summary> /// <param name="item"></param> /// <returns></returns> private Mathematical.IVariavelCollection CriarVariaveisItem(IItemRentabilidade item) { var constantes = new[] { new Mathematical.Constante(nameof(TipoVariavelItemRentabilidade.PrecoVenda), (double)item.PrecoVendaSemIPI), new Mathematical.Constante(nameof(TipoVariavelItemRentabilidade.PrecoCusto), (double)item.PrecoCusto), new Mathematical.Constante(nameof(TipoVariavelItemRentabilidade.PrazoMedio), item.PrazoMedio), new Mathematical.Constante(nameof(TipoVariavelItemRentabilidade.PICMSCompra), (double)item.PercentualICMSCompra), new Mathematical.Constante(nameof(TipoVariavelItemRentabilidade.PICMSVenda), (double)item.PercentualICMSVenda), new Mathematical.Constante(nameof(TipoVariavelItemRentabilidade.FatorICMSSubstituicao), (double)item.FatorICMSSubstituicao), new Mathematical.Constante(nameof(TipoVariavelItemRentabilidade.PIPICompra), (double)item.PercentualIPICompra), new Mathematical.Constante(nameof(TipoVariavelItemRentabilidade.PIPIVenda), (double)item.PercentualIPIVenda), new Mathematical.Constante(nameof(TipoVariavelItemRentabilidade.PComissao), (double)item.PercentualComissao), new Mathematical.Constante(nameof(TipoVariavelItemRentabilidade.CustosExtras), (double)item.CustosExtras), }; return(new Mathematical.VariavelCollection(constantes)); }
/// <summary> /// Executa o cálculo para o item informado. /// </summary> /// <param name="item">Item sobre o qual será calculada a rentabilidade.</param> protected override ICalculoRentabilidadeResultado Calcular(IItemRentabilidade item) { var possuiaRegistroRentabilidade = item.RegistrosRentabilidade.Any(); var resultado = base.Calcular(item); var itemProdutoPedido = item as IItemRentabilidade <Data.Model.ProdutosPedido>; if (itemProdutoPedido != null && resultado.Executado) { var tentativas = 20; var calcularComissaoBase = !possuiaRegistroRentabilidade; while (tentativas > 0) { var resultadoComissao = CalculadoraComissaoRentabilidade.Calcular(item, IdLoja, IdFunc, calcularComissaoBase); if (!resultadoComissao.Valido || calcularComissaoBase) { ((ItemRentabilidade)item).PercentualComissao = resultadoComissao.PercentualComissao; itemProdutoPedido.Proprietario.PercComissao = resultadoComissao.PercentualComissao * 100m; } if (resultadoComissao.Valido) { break; } // Recalcula a rentabilidade resultado = base.Calcular(item); if (!resultado.Executado) { break; } tentativas--; } } return(resultado); }
/// <summary> /// Executa o calculo da rentabilidade sobre o item informado. /// </summary> /// <param name="item"></param> /// <returns></returns> public ResultadoRentabilidade Calcular(IItemRentabilidade item) { item.Require(nameof(item)).NotNull(); var variaveisItem = CriarVariaveisItem(item); var agregador = new Mathematical.AggregateVariavelCollection(); agregador.Add(variaveisItem); agregador.Add(_variaveisIndicadoresFinanceiro); // Percorre as variáveis de calculo compiladas var variaveisCalculo = new Mathematical.VariavelCollection( _variaveisCalculo.Select(f => ((Mathematical.Formula)f).CreateCopy(agregador))); agregador.Add(variaveisCalculo); var formula = _formulaCalculo.CreateCopy(agregador); var custoTotal = formula.ObterValor(); return(new ResultadoRentabilidade(_variaveisIndicadoresFinanceiro, variaveisItem, variaveisCalculo, custoTotal, item)); }
/// <summary> /// Converte o item informado para um dicionario que /// será serializa para JSON. /// </summary> /// <param name="item"></param> /// <returns></returns> private IDictionary <string, object> ToJson(IItemRentabilidade item) { // Carrega os dados básicos do item var dados = new Dictionary <string, object> { { "Descricao", item.Descricao }, { "PercentualRentabilidade", item.PercentualRentabilidade.ToString("P", Cultura) }, { "RentabilidadeFinanceira", item.RentabilidadeFinanceira.ToString("R$#,##0.00;\\(R$#,##0.00\\)", Cultura) } }; foreach (var registro in item.RegistrosRentabilidade) { var descritor = registro.Descritor; // Verifica se o registro deve ser exibido no relatório if (descritor != null && descritor.ExibirRelatorio) { dados.Add(descritor.Nome, descritor.FormatarValor(registro, Cultura)); } } var container = item as IItemRentabilidadeContainer; if (container != null) { var itens = new List <IDictionary <string, object> >(); foreach (var item1 in container.Itens) { itens.Add(ToJson(item1)); } dados.Add("Itens", itens); } return(dados); }
/// <summary> /// Verifica se é necessário liberação para o item informado. /// </summary> /// <param name="item">Item que será verificado.</param> /// <returns></returns> public bool VerificarRequerLiberacao(IItemRentabilidade item) { var faixa = ObterFaixa(item); return(faixa?.RequerLiberacao ?? false); }
/// <summary> /// Cria o resultado do calculo da rentabilidade para o item informado. /// </summary> /// <param name="item"></param> /// <param name="resultadoCalculo"></param> /// <param name="subResultados">Sub resultados processados.</param> /// <returns></returns> protected override Data.ICalculoRentabilidadeResultado CriaResultado( IItemRentabilidade item, ResultadoRentabilidade resultadoCalculo, IEnumerable <Data.ICalculoRentabilidadeResultado> subResultados) { Data.ICalculoRentabilidadeResultado resultado; var itemPedido = item as IItemRentabilidade <Data.Model.PedidoEspelho>; var itemProdutoPedido = item as IItemRentabilidade <Data.Model.ProdutosPedidoEspelho>; var itemAmbientePedido = item as IItemRentabilidade <Data.Model.AmbientePedidoEspelho>; if (itemPedido != null) { resultado = MontarResultado ((IItemRentabilidadeComReferencias <Data.Model.PedidoEspelhoRentabilidade>)item, (x, y) => (int)x.Tipo == y.Tipo && x.IdRegistro == y.IdRegistro, (x, y) => y.Valor = x.Valor); var pedido = itemPedido.Proprietario; // Registra o evento para salvar o dados do pedido quando o resultado for salvo resultado.Salvando += (sender, e) => { var rentabilidade = pedido.RentabilidadeFinanceira = e.RentabilidadeFinanceira; var percentual = pedido.PercentualRentabilidade = e.PercentualRentabilidade * 100m; Data.DAL.PedidoEspelhoDAO.Instance.AtualizarRentabilidade(e.Sessao, pedido.IdPedido, percentual, rentabilidade); }; } else if (itemProdutoPedido != null) { resultado = MontarResultado ((IItemRentabilidadeComReferencias <Data.Model.ProdutoPedidoEspelhoRentabilidade>)item, (x, y) => (int)x.Tipo == y.Tipo && x.IdRegistro == y.IdRegistro, (x, y) => y.Valor = x.Valor); var produtoPedido = itemProdutoPedido.Proprietario; // Registra o evento para salvar o dados do pedido quando o resultado for salvo resultado.Salvando += (sender, e) => { var rentabilidade = produtoPedido.RentabilidadeFinanceira = e.RentabilidadeFinanceira; var percentual = produtoPedido.PercentualRentabilidade = e.PercentualRentabilidade * 100m; produtoPedido.PercComissao = item.PercentualComissao * 100m; Data.DAL.ProdutosPedidoEspelhoDAO.Instance.AtualizarRentabilidade(e.Sessao, produtoPedido.IdProdPed, percentual, rentabilidade, produtoPedido.PercComissao); }; } else if (itemAmbientePedido != null) { resultado = MontarResultado ((IItemRentabilidadeComReferencias <Data.Model.AmbientePedidoEspelhoRentabilidade>)item, (x, y) => (int)x.Tipo == y.Tipo && x.IdRegistro == y.IdRegistro, (x, y) => y.Valor = x.Valor); var ambiente = itemAmbientePedido.Proprietario; // Registra o evento para salvar o dados do pedido quando o resultado for salvo resultado.Salvando += (sender, e) => { var rentabilidade = ambiente.RentabilidadeFinanceira = e.RentabilidadeFinanceira; var percentual = ambiente.PercentualRentabilidade = e.PercentualRentabilidade * 100m; Data.DAL.AmbientePedidoEspelhoDAO.Instance.AtualizarRentabilidade(e.Sessao, ambiente.IdAmbientePedido, percentual, rentabilidade); }; } else { throw new NotSupportedException("Tipo do item de rentabilidade não suportado."); } var resultadosContainer = resultado as ICalculoRentabilidadeResultadoContainer; if (resultadosContainer != null) { foreach (var i in subResultados) { resultadosContainer.Adicionar(i); } } return(resultado); }
/// <summary> /// Cria o resultado do calculo da rentabilidade para o item informado. /// </summary> /// <param name="item"></param> /// <param name="resultadoCalculo"></param> /// <param name="subResultados">Sub resultados processados.</param> /// <returns></returns> protected override Data.ICalculoRentabilidadeResultado CriaResultado( IItemRentabilidade item, ResultadoRentabilidade resultadoCalculo, IEnumerable <Data.ICalculoRentabilidadeResultado> subResultados) { Data.ICalculoRentabilidadeResultado resultado; var itemNotaFiscal = item as IItemRentabilidade <Data.Model.NotaFiscal>; var itemProdutoNf = item as IItemRentabilidade <Data.Model.ProdutosNf>; var itemProdutoNfCusto = item as IItemRentabilidade <Data.Model.ProdutoNfCusto>; if (itemNotaFiscal != null) { resultado = MontarResultado ((IItemRentabilidadeComReferencias <Data.Model.NotaFiscalRentabilidade>)item, (x, y) => (int)x.Tipo == y.Tipo && x.IdRegistro == y.IdRegistro, (x, y) => y.Valor = x.Valor); var noteFiscal = itemNotaFiscal.Proprietario; // Registra o evento para salvar o dados da nota fiscal quando o resultado for salvo resultado.Salvando += (sender, e) => { var rentabilidade = noteFiscal.RentabilidadeFinanceira = e.RentabilidadeFinanceira; var percentual = noteFiscal.PercentualRentabilidade = e.PercentualRentabilidade * 100m; Data.DAL.NotaFiscalDAO.Instance.AtualizarRentabilidade(e.Sessao, noteFiscal.IdNf, percentual, rentabilidade); }; } else if (itemProdutoNf != null) { resultado = MontarResultado ((IItemRentabilidadeComReferencias <Data.Model.ProdutoNfRentabilidade>)item, (x, y) => (int)x.Tipo == y.Tipo && x.IdRegistro == y.IdRegistro, (x, y) => y.Valor = x.Valor); var produtoNf = itemProdutoNf.Proprietario; // Registra o evento para salvar o dados do produto da nota fiscal quando o resultado for salvo resultado.Salvando += (sender, e) => { var rentabilidade = produtoNf.RentabilidadeFinanceira = e.RentabilidadeFinanceira; var percentual = produtoNf.PercentualRentabilidade = e.PercentualRentabilidade * 100m; Data.DAL.ProdutosNfDAO.Instance.AtualizarRentabilidade(e.Sessao, produtoNf.IdProdNf, percentual, rentabilidade); }; } else if (itemProdutoNfCusto != null) { resultado = MontarResultado ((IItemRentabilidadeComReferencias <Data.Model.ProdutoNfCustoRentabilidade>)item, (x, y) => (int)x.Tipo == y.Tipo && x.IdRegistro == y.IdRegistro, (x, y) => y.Valor = x.Valor); var produtoNfCusto = itemProdutoNfCusto.Proprietario; // Registra o evento para salvar o dados do custo do produto da nota fiscal quando o resultado for salvo resultado.Salvando += (sender, e) => { var rentabilidade = produtoNfCusto.RentabilidadeFinanceira = e.RentabilidadeFinanceira; var percentual = produtoNfCusto.PercentualRentabilidade = e.PercentualRentabilidade * 100m; Data.DAL.ProdutoNfCustoDAO.Instance.AtualizarRentabilidade(e.Sessao, produtoNfCusto.IdProdNfCusto, percentual, rentabilidade); }; } else { throw new NotSupportedException("Tipo do item de rentabilidade não suportado."); } var resultadosContainer = resultado as ICalculoRentabilidadeResultadoContainer; if (resultadosContainer != null) { foreach (var i in subResultados) { resultadosContainer.Adicionar(i); } } return(resultado); }
/// <summary> /// Cria o resultado do calculo da rentabilidade para o item informado. /// </summary> /// <param name="item"></param> /// <param name="resultadoCalculo"></param> /// <param name="subResultados">Sub resultados processados.</param> /// <returns></returns> protected abstract Data.ICalculoRentabilidadeResultado CriaResultado( IItemRentabilidade item, ResultadoRentabilidade resultadoCalculo, IEnumerable <Data.ICalculoRentabilidadeResultado> subResultados);