/// <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);
