public decimal?Calcular(GDASession sessao, IProdutoCalculo produto, decimal total, ArredondarAluminio arredondarAluminio,
bool calcularMultiploDe5, bool nf, int numeroBeneficiamentos, int alturaBeneficiamento,
int larguraBeneficiamento)
{
/* Chamado 41410. */
if (ValidarQuantidadeDecimal && produto.Qtde % 1 > 0)
{
throw new Exception("Somente produtos calculados por Qtd. decimal podem possuir números decimais no campo Quantidade.");
}
var qtdeAmbiente = produto.QtdeAmbiente > 0
? produto.QtdeAmbiente
: 1;
return(Calcular(
sessao,
produto,
qtdeAmbiente,
total,
arredondarAluminio,
calcularMultiploDe5,
nf,
numeroBeneficiamentos,
alturaBeneficiamento,
larguraBeneficiamento
));
}
public decimal?CalcularValor(GDASession sessao, IContainerCalculo container, IProdutoCalculo produto,
decimal baseCalculo)
{
produto.InicializarParaCalculo(sessao, container);
var compra = produto is ProdutosCompra;
var nf = produto is ProdutosNf;
var alturaBenef = this.NormalizarAlturaLarguraBeneficiamento(
produto.AlturaBenef,
container,
(int)produto.DadosProduto.DadosGrupoSubgrupo.TipoCalculo(nf, compra));
var larguraBenef = this.NormalizarAlturaLarguraBeneficiamento(
produto.LarguraBenef,
container,
(int)produto.DadosProduto.DadosGrupoSubgrupo.TipoCalculo(nf, compra));
return(CalcularValor(
sessao,
produto,
baseCalculo,
compra,
nf,
alturaBenef,
larguraBenef
));
}
protected override decimal Calcular(GDASession sessao, IProdutoCalculo produto, int qtdeAmbiente, decimal total,
ArredondarAluminio arredondarAluminio, bool calcularMultiploDe5, bool nf, int numeroBeneficiamentos,
int alturaBeneficiamento, int larguraBeneficiamento)
{
float totM2Temp = produto.TotM;
CalcularTotalM2(sessao, produto, calcularMultiploDe5, nf, totM2Temp);
float totM2Preco = CalcularTotalM2ParaCalculoPreco(
sessao,
produto,
qtdeAmbiente,
calcularMultiploDe5,
nf,
numeroBeneficiamentos,
totM2Temp
);
float areaMinima = AreaMinima(produto, numeroBeneficiamentos);
float totM2Calc = totM2Preco < (areaMinima * produto.Qtde * qtdeAmbiente)
? (areaMinima * produto.Qtde * qtdeAmbiente)
: totM2Preco;
return(total / (totM2Calc > 0 ? (decimal)totM2Calc : 1));
}
private void CalcularTotalM2CalculoAreaMinima(IProdutoCalculo produto, int qtdeAmbiente, bool nf,
int numeroBeneficiamentos, bool compra, float totM2Preco)
{
float m2Minimo = AreaMinima(produto, numeroBeneficiamentos, nf, compra) * produto.Qtde * qtdeAmbiente;
produto.TotM2Calc = totM2Preco < m2Minimo ? m2Minimo : totM2Preco;
}
private void CalculaTotalM2(GDASession sessao, IProdutoCalculo produto, bool calcMult5, int numeroBenef)
{
if (produto.Altura > 0 && produto.Largura > 0 &&
(produto.TotM == 0 || produto.DadosProduto.DadosGrupoSubgrupo.ProdutoEVidro()))
{
var quantidadeOriginalProduto = produto.Qtde;
var quantidadeCalcularM2 = CalcularQuantidadeProdutoModulado(produto);
// Caso o produto seja chapa (altura ou largura > 2500), seja vendido por qtd e seja produto de produção,
// não calcula múltiplo de 5
calcMult5 = !(produto.Altura > 2500 || produto.Largura > 2500) && calcMult5;
try
{
produto.Qtde = quantidadeCalcularM2;
produto.TotM = CalculoM2.Instance.Calcular(sessao, produto.Container, produto, calcMult5);
produto.TotM2Calc = CalculoM2.Instance.CalcularM2Calculo(sessao, produto.Container, produto, true,
calcMult5, numeroBenef);
}
finally
{
produto.Qtde = quantidadeOriginalProduto;
}
}
}
private float Calcular(IProdutoCalculo produto, bool calcularMultiploDe5, int altura, int largura, float qtde)
{
int adicionarValorRedondo = AdicionarValorRedondo(produto);
altura += adicionarValorRedondo;
int larguraRedondo = produto.Redondo
? altura
: 1000;
// Se a largura estiver zerada, deve considerar a altura no cálculo e não 1000 como estava,
// para não calcular errado, chamado 7564
largura = adicionarValorRedondo + (
largura == 0
? larguraRedondo
: largura
);
altura = ArredondarAlturaBox(produto, altura);
if (!calcularMultiploDe5)
{
// Se não for para recalcular utilizando múltiplo de 5, deve retornar mais de duas casas decimais
return(largura * altura / 1000000f * qtde);
}
var calculo = CalcularMultiploDe5(produto, altura, largura, qtde);
var m2 = AjustaCalculoM2(calculo);
// Alteração feita para vidros com m2 menor que 0.01 ficar com esta medida, para que o valor
// não fique zerado, quando fizer a alteração para calcular vidro com x casas decimais,
// utilizar esta opção somente se estiver sendo utilizada 2 casas decimais
return(Math.Max((float)m2, 0.01f));
}
protected override void Calcular(GDASession sessao, IProdutoCalculo produto, int qtdeAmbiente,
ArredondarAluminio arredondarAluminio, bool calcularMultiploDe5, bool nf, int numeroBeneficiamentos,
int alturaBeneficiamento, int larguraBeneficiamento, bool compra, decimal custoCompra, bool usarChapaVidro,
bool valorBruto)
{
float decimosAltura = produto.Altura - (int)produto.Altura;
float alturaArredondada = produto.Altura;
if (!produto.DadosProduto.DadosGrupoSubgrupo.ProdutoEAluminio())
{
arredondarAluminio = ArredondarAluminio.NaoArredondar;
}
if (arredondarAluminio != ArredondarAluminio.NaoArredondar && ValorArredondar > 0)
{
alturaArredondada = Arredondar(produto, decimosAltura) ?? alturaArredondada;
if (arredondarAluminio == ArredondarAluminio.ArredondarEAtualizarProduto)
{
produto.Altura = alturaArredondada;
}
}
produto.CustoProd = custoCompra * ObterBaseCalculo(produto, (decimal)alturaArredondada, qtdeAmbiente, false);
var baseCalculo = ObterBaseCalculo(produto, (decimal)alturaArredondada, qtdeAmbiente, true);
if (!valorBruto)
{
produto.Total = produto.ValorUnit * baseCalculo;
}
else
{
produto.TotalBruto = produto.ValorUnitarioBruto * baseCalculo;
}
}
private void CalcularTotalBrutoProduto(GDASession sessao, IProdutoCalculo produto)
{
if (produto.TotalBruto == 0 && (produto.IdProduto == 0 || produto.Total > 0))
{
ValorBruto.Instance.Calcular(sessao, produto.Container, produto);
}
}
public void Calcular(GDASession sessao, IContainerCalculo container, IProdutoCalculo produto)
{
produto.InicializarParaCalculo(sessao, container);
decimal valorTabela = produto.DadosProduto.ValorTabela(false);
decimal valorCliente = produto.DadosProduto.ValorTabela(true);
int tipoCalculoProduto = (int)produto.DadosProduto.DadosGrupoSubgrupo.TipoCalculo();
if (valorTabela < valorCliente)
{
produto.ValorDescontoCliente = 0;
produto.ValorAcrescimoCliente = CalculaValorTotal(sessao, produto, tipoCalculoProduto,
valorCliente - valorTabela);
}
else if (valorTabela > valorCliente)
{
produto.ValorAcrescimoCliente = 0;
produto.ValorDescontoCliente = CalculaValorTotal(sessao, produto, tipoCalculoProduto,
valorTabela - valorCliente);
}
else
{
produto.ValorAcrescimoCliente = 0;
produto.ValorDescontoCliente = 0;
}
}
private decimal?CalcularValor(GDASession sessao, IProdutoCalculo produto, decimal baseCalculo,
bool compra, bool nf, int alturaBeneficiamento, int larguraBeneficiamento)
{
bool calcularMultiploDe5 = produto.DadosProduto.DadosGrupoSubgrupo.TipoCalculo(nf, compra) == TipoCalculoGrupoProd.M2;
if (produto.Container is Pedido || produto.Container is PedidoEspelho)
{
calcularMultiploDe5 = produto.DadosProduto.DadosGrupoSubgrupo.TipoCalculo(nf, compra) == TipoCalculoGrupoProd.M2 && !produto.Container.IsPedidoProducaoCorte;
}
var estrategia = ValorUnitarioStrategyFactory.Instance.RecuperaEstrategia(produto, nf, compra);
var valorUnitario = estrategia.Calcular(
sessao,
produto,
baseCalculo,
ArredondarAluminio.ArredondarApenasCalculo,
calcularMultiploDe5,
nf,
produto.Beneficiamentos.CountAreaMinimaSession(null),
alturaBeneficiamento,
larguraBeneficiamento
);
return(valorUnitario);
}
public void Calcular(GDASession sessao, IContainerCalculo container, IProdutoCalculo produto)
{
produto.InicializarParaCalculo(sessao, container);
produto.TotalBruto = produto.Total - DescontoValorBruto(produto);
CalcularValorUnitarioBruto(sessao, produto);
}
private void CalcularTotalM2(GDASession sessao, IProdutoCalculo produto, bool calcMult5, bool compra)
{
if (!compra)
{
produto.TotM = CalculoM2.Instance.Calcular(sessao, produto.Container, produto,
calcMult5 && DeveCalcularMultiploDe5);
}
}
protected virtual decimal AplicarProduto(decimal percentual, IProdutoCalculo produto)
{
decimal valorCalculado = Math.Round(percentual / 100 * PrecoTabelaCliente(produto), 2);
AplicarValorProduto(produto, valorCalculado);
return(valorCalculado);
}
protected virtual void AplicarValorResidual(GDASession sessao, IProdutoCalculo produto, decimal valorResidual)
{
if (produto != null && valorResidual != 0)
{
AplicarValorProduto(produto, valorResidual);
RecalcularValorUnitario(sessao, produto);
}
}
protected override decimal Calcular(GDASession sessao, IProdutoCalculo produto, int qtdeAmbiente, decimal total,
ArredondarAluminio arredondarAluminio, bool calcularMultiploDe5, bool nf, int numeroBeneficiamentos,
int alturaBeneficiamento, int larguraBeneficiamento)
{
decimal divisor = Divisor(produto);
return(total / divisor);
}
private decimal Divisor(IProdutoCalculo produto, int qtdeAmbiente, int metroLinear)
{
float divisor = (metroLinear / 1000F) * (produto.Qtde * qtdeAmbiente);
divisor = divisor > 0 ? divisor : 1;
return((decimal)divisor);
}
/// <summary>
/// Cria no produto cálculo as variáveis necessárias para permitir seu uso nos métodos de cálculo.
/// </summary>
public static void InicializarParaCalculo(this IProdutoCalculo produtoCalculo, GDASession sessao,
IContainerCalculo container)
{
produtoCalculo.Container = container ?? new ContainerCalculoDTO();
produtoCalculo.DadosProduto = new DadosProdutoDTO(sessao, produtoCalculo);
ObterAmbientes(container, produtoCalculo);
}
protected override decimal AplicarProduto(decimal percentual, IProdutoCalculo produto)
{
decimal valorCalculado = Math.Round(percentual / 100 * (PrecoTabelaCliente(produto) + produto.ValorAcrescimo - produto.ValorDesconto), 2);
AplicarValorProduto(produto, valorCalculado);
return(valorCalculado);
}
private void CalcularValorUnitarioBruto(GDASession sessao, IProdutoCalculo produto)
{
var valorUnitario = ValorUnitario.Instance.CalcularValor(sessao, produto.Container, produto, produto.TotalBruto);
if (valorUnitario.HasValue)
{
produto.ValorUnitarioBruto = valorUnitario.Value;
}
}
public void Calcular(GDASession sessao, IContainerCalculo container, IProdutoCalculo produto)
{
var valorUnitario = RecalcularValor(sessao, container, produto, false);
if (valorUnitario.HasValue && produto != null)
{
produto.ValorUnit = valorUnitario.Value;
}
}
private void CalculaTotalM2(GDASession sessao, IProdutoCalculo produto)
{
if (produto.Altura > 0 && produto.Largura > 0)
{
var calcularMultiploDe5 = produto.DadosProduto.DadosGrupoSubgrupo.ProdutoEVidro() && produto.DadosProduto.DadosGrupoSubgrupo.TipoCalculo() != TipoCalculoGrupoProd.Qtd;
produto.TotM = CalculoM2.Instance.Calcular(sessao, produto.Container, produto, calcularMultiploDe5);
}
}
protected override float?Arredondar(IProdutoCalculo produto, float decimosAltura)
{
if (produto.Altura < 6)
{
return(6f);
}
return(null);
}
private int LarguraProduto(IProdutoCalculo produto)
{
if ((produto?.Container?.MaoDeObra).GetValueOrDefault() && (produto?.Redondo).GetValueOrDefault() && produto?.Largura == 0)
{
return((int)produto.Altura);
}
return(produto.Largura);
}
private float AplicarM2MinimoChapaVidro(IProdutoCalculo produto, bool possuiChapaVidro, float m2)
{
if (possuiChapaVidro)
{
float perc = produto.DadosProduto.DadosChapaVidro.PercentualAcrescimoM2ChapaVidro(m2);
return((float)Math.Round(m2 * (1 + perc), Geral.NumeroCasasDecimaisTotM));
}
return(m2);
}
private decimal ObterBaseCalculo(IProdutoCalculo produto, int alturaBeneficiamento, int larguraBeneficiamento,
int qtdeAmbiente)
{
var metroLinear = (produto.Altura * alturaBeneficiamento)
+ (produto.Largura * larguraBeneficiamento);
return(qtdeAmbiente
* (decimal)produto.Qtde
* (decimal)(metroLinear / 1000));
}
private int AdicionarValorRedondo(IProdutoCalculo produto)
{
if (produto.Redondo)
{
return(produto.Espessura < 12
? Geral.AdicionalVidroRedondoAte12mm
: Geral.AdicionalVidroRedondoAcima12mm);
}
return(0);
}
protected virtual void RemoverBeneficiamentos(IProdutoCalculo produto)
{
var beneficiamentos = produto.Beneficiamentos ?? GenericBenefCollection.Empty;
foreach (var beneficiamento in beneficiamentos)
{
RemoverValorBeneficiamento(beneficiamento);
}
produto.Beneficiamentos = beneficiamentos;
}
protected override decimal CalcularTotalBeneficiamentosProduto(IProdutoCalculo produto)
{
decimal totalAtual = 0;
foreach (var beneficiamento in (produto.Beneficiamentos ?? GenericBenefCollection.Empty))
{
totalAtual += beneficiamento.TotalBruto + beneficiamento.ValorAcrescimo - beneficiamento.ValorDesconto;
}
return(totalAtual);
}
protected override decimal AplicarProduto(decimal percentual, IProdutoCalculo produto)
{
var baseCalculo = BaseCalculoTotalProduto(produto);
percentual = (decimal)produto.PercDescontoQtde;
decimal valorCalculado = Math.Round(baseCalculo * percentual, 2);
AplicarValorProduto(produto, valorCalculado);
return(valorCalculado);
}
private void IncluirDescontoPorQuantidade(IProdutoCalculo produto)
{
if (produto.PercDescontoQtde > 0)
{
var fatorMultiplicacao = produto.PercDescontoQtde < 100
? 1 - (produto.PercDescontoQtde / 100)
: 0;
produto.Total *= (decimal)fatorMultiplicacao;
}
}
