Subversion Repositories Integrator Subversion

package br.com.ec.controller.managedbean;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.List;

import javax.inject.Inject;
import javax.inject.Named;
import javax.persistence.Transient;

import org.primefaces.model.chart.Axis;
import org.primefaces.model.chart.AxisType;
import org.primefaces.model.chart.BarChartModel;
import org.primefaces.model.chart.ChartSeries;
import org.springframework.context.annotation.Scope;

import br.com.ec.core.generic.GenericService;
import br.com.ec.core.util.DataUtils;
import br.com.ec.core.util.VerificadorUtil;
import br.com.ec.domain.dto.MeusResultadosDTO;
import br.com.ec.domain.dto.ParametrosConsultaVendasDTO;
import br.com.ec.domain.dto.ParametrosRelatorioVendasDTO;
import br.com.ec.domain.model.Avaliacao;
import br.com.ec.domain.model.AvaliacaoFuncionario;
import br.com.ec.domain.model.AvaliacaoProduto;
import br.com.ec.domain.model.Produto;
import br.com.ec.domain.model.Usuario;
import br.com.ec.domain.model.Vigencia;
import br.com.ec.domain.service.avaliacao.AvaliacaoService;
import br.com.ec.domain.service.avaliacaofuncionario.AvaliacaoFuncionarioService;
import br.com.ec.domain.service.seguranca.ContextoSeguranca;
import br.com.ec.domain.service.usuario.UsuarioService;
import br.com.ec.domain.service.venda.VendaService;
import br.com.ec.domain.service.vendedor.VendedorService;
import br.com.ec.domain.service.vigencia.VigenciaService;
import br.com.ec.domain.shared.ConstantesSEC;
import br.com.ec.web.generic.AbstractBean;

@Named
@Scope("view")
public class MeusResultadosBean extends AbstractBean<MeusResultadosDTO> implements Serializable {

        private static final long serialVersionUID = 1L;
       
        private UsuarioService usuarioService;
        private VendaService vendaService;
        private VendedorService vendedorService;
        private VigenciaService vigenciaService;
        private AvaliacaoFuncionarioService avaliacaoFuncionarioService;
        private AvaliacaoService avaliacaoService;
       
        private Vigencia vigenciaAtual;
        private Vigencia vigenciaAnterior;
        private MeusResultadosDTO resumoAntigo;
        private MeusResultadosDTO resumoPromocaoInterna;
        private MeusResultadosDTO resumoPromocaoInternaAnterior;
       
        private ContextoSeguranca contextoSeguranca;
       
        List<Vigencia> ultimasVigencias;
        List<Produto> produtosPromocaoInterna;
        List<Produto> produtosPromocaoInternaAnterior;
       
        private BarChartModel historico;
        private BarChartModel historicoPercentual;

        @Inject
        public MeusResultadosBean(UsuarioService usuarioService, VendaService vendaService, VendedorService vendedorService,
                        VigenciaService vigenciaService, AvaliacaoFuncionarioService avaliacaoFuncionarioService, AvaliacaoService avaliacaoService,
                        ContextoSeguranca contextoSeguranca) {
                this.usuarioService = usuarioService;
                this.vendaService = vendaService;
                this.vendedorService = vendedorService;
                this.vigenciaService = vigenciaService;
                this.avaliacaoFuncionarioService = avaliacaoFuncionarioService;
                this.avaliacaoService = avaliacaoService;
                this.contextoSeguranca = contextoSeguranca;
        }
       
        @Override
        public void preCarregamento() {
                setUltimasVigencias(vigenciaService.consultarUltimasVigencias());
                Usuario usuarioSelecionado = usuarioService.consultarPorId(contextoSeguranca.obterUsuario());
               
                if (!getUltimasVigencias().isEmpty()) {
                        if (getUltimasVigencias().size() >= 1) {
                                setVigenciaAtual(retornarVigenciaDoPeriodo(getUltimasVigencias(), DataUtils.getDataAtual()));
                                Avaliacao avaliacaoAtual = avaliacaoService.consultarAvaliacaoDaVigencia(getVigenciaAtual());
                                if (VerificadorUtil.naoEstaNulo(avaliacaoAtual)) {
                                        List<AvaliacaoProduto> listaProdutosPromocao = avaliacaoService.consultarProdutosPromocaoInterna(avaliacaoAtual.getSequencial());
                                        List<Produto> produtosDaPromocao = new ArrayList<Produto>();
                                        for (AvaliacaoProduto avaliacaoProduto : listaProdutosPromocao) {
                                                produtosDaPromocao.add(avaliacaoProduto.getProduto());
                                        }
                                        setProdutosPromocaoInterna(produtosDaPromocao);
                                }
                               
                               
                                MeusResultadosDTO colaborador = new MeusResultadosDTO();
                                colaborador.setUsuario(usuarioSelecionado);
                                colaborador.setRankingVendedor(vendaService.consultarRankingVendedor(vendedorService.consultarVendedorPorPessoa(usuarioSelecionado.getPessoa()), getVigenciaAtual(), true));
                                setEntidade(colaborador);
                                colaborador.getRankingVendedor().setPercentualMetaMensal(calcularPorcentagemDaMetaMensal());
                                colaborador.getRankingVendedor().setPercentualMetaMensalVivo(calcularPorcentagemDaMetaMensalVivo());
                                colaborador.getRankingVendedor().setPercentualMetaDiaria(calcularPorcentagemDaMetaDiaria());
                               
                                if (!getProdutosPromocaoInterna().isEmpty()) {
                                        MeusResultadosDTO colaboradorPromocaoInterna = new MeusResultadosDTO();
                                        colaboradorPromocaoInterna.setUsuario(usuarioSelecionado);
                                        colaboradorPromocaoInterna.setRankingVendedor(vendaService.consultarRankingPromocaoInternaDoVendedor(vendedorService.consultarVendedorPorPessoa(usuarioSelecionado.getPessoa()),
                                                        DataUtils.getDataComHorarioMinimo(DataUtils.getPrimeiroDiaDoMesAtual()),
                                                        DataUtils.getDataComHorarioMaximo(DataUtils.getUltimoDiaDoMesAtual()),
                                                        getProdutosPromocaoInterna()));
                                        setResumoPromocaoInterna(colaboradorPromocaoInterna);
                                }
                        }
                        if (getUltimasVigencias().size() >= 2) {
                                Date dataAnterior = DataUtils.acrescentarMeses(DataUtils.getDataAtual(), -1);
                                setVigenciaAnterior(retornarVigenciaDoPeriodo(getUltimasVigencias(), dataAnterior));
                               
                                Avaliacao avaliacaoAnterior = avaliacaoService.consultarAvaliacaoDaVigencia(getVigenciaAnterior());
                                if (VerificadorUtil.naoEstaNulo(avaliacaoAnterior)) {
                                        List<AvaliacaoProduto> listaProdutosPromocao = avaliacaoService.consultarProdutosPromocaoInterna(avaliacaoAnterior.getSequencial());
                                        List<Produto> produtosDaPromocao = new ArrayList<Produto>();
                                        for (AvaliacaoProduto avaliacaoProduto : listaProdutosPromocao) {
                                                produtosDaPromocao.add(avaliacaoProduto.getProduto());
                                        }
                                        setProdutosPromocaoInternaAnterior(produtosDaPromocao);
                                }
                               
                                MeusResultadosDTO colaboradorAnterior = new MeusResultadosDTO();
                                colaboradorAnterior.setUsuario(usuarioSelecionado);
                                colaboradorAnterior.setRankingVendedor(vendaService.consultarRankingVendedor(vendedorService.consultarVendedorPorPessoa(usuarioSelecionado.getPessoa()), getVigenciaAnterior(), true));
                                setResumoAntigo(colaboradorAnterior);
                               
                                if (!getProdutosPromocaoInternaAnterior().isEmpty()) {
                                        MeusResultadosDTO colaboradorPromocaoInternaAnterior = new MeusResultadosDTO();
                                        colaboradorPromocaoInternaAnterior.setUsuario(usuarioSelecionado);
                                        colaboradorPromocaoInternaAnterior.setRankingVendedor(vendaService.consultarRankingPromocaoInternaDoVendedor(vendedorService.consultarVendedorPorPessoa(usuarioSelecionado.getPessoa()),
                                                        DataUtils.getDataComHorarioMinimo(DataUtils.getPrimeiroDiaDoMesAnterior()),
                                                        DataUtils.getDataComHorarioMaximo(DataUtils.getUltimoDiaDoMesAnterior()),
                                                        getProdutosPromocaoInternaAnterior()));
                                        setResumoPromocaoInternaAnterior(colaboradorPromocaoInternaAnterior);
                                }
                        }
                }
               
                /*
                MeusResultadosDTO colaboradorPromocaoInterna = new MeusResultadosDTO();
                colaboradorPromocaoInterna.setUsuario(usuarioSelecionado);
               
                Vigencia vigenciaAtual = retornarVigenciaDoPeriodo(getUltimasVigencias(), DataUtils.getPrimeiroDiaDoMesAtual());
                Avaliacao avaliacaoAtual = avaliacaoService.consultarAvaliacaoDaVigencia(vigenciaAtual);
                List<AvaliacaoProduto> listaProdutosPromocao = new ArrayList<AvaliacaoProduto>();
                listaProdutosPromocao = avaliacaoService.consultarProdutosPromocaoInterna(avaliacaoAtual.getSequencial());
                colaboradorPromocaoInterna.setRankingVendedor(vendaService.consultarRankingPromocaoInternaDoVendedor(vendedorService.consultarVendedorPorPessoa(usuarioSelecionado.getPessoa()),
                                DataUtils.getDataComHorarioMinimo(DataUtils.getPrimeiroDiaDoMesAtual()),
                                DataUtils.getDataComHorarioMaximo(DataUtils.getUltimoDiaDoMesAtual()),
                                ConstantesSEC.ProdutosPromocaoInterna.PRODUTOS));
                setResumoPromocaoInterna(colaboradorPromocaoInterna);
               
               
                MeusResultadosDTO colaboradorPromocaoInternaAnterior = new MeusResultadosDTO();
                colaboradorPromocaoInternaAnterior.setUsuario(usuarioSelecionado);
                colaboradorPromocaoInternaAnterior.setRankingVendedor(vendaService.consultarRankingPromocaoInternaDoVendedor(vendedorService.consultarVendedorPorPessoa(usuarioSelecionado.getPessoa()),
                                DataUtils.getDataComHorarioMinimo(DataUtils.getPrimeiroDiaDoMesAnterior()),
                                DataUtils.getDataComHorarioMaximo(DataUtils.getUltimoDiaDoMesAnterior()),
                                ConstantesSEC.ProdutosPromocaoInterna.PRODUTOS_MES_ANTERIOR));
                setResumoPromocaoInternaAnterior(colaboradorPromocaoInternaAnterior);
                */
        }
       
        private Vigencia retornarVigenciaDoPeriodo(List<Vigencia> ultimasVigencias, Date dataAtual) {
                for (Vigencia vigencia : ultimasVigencias) {
                        if (vigencia.getDataInicio().before(dataAtual) && vigencia.getDataFim().after(dataAtual)) {
                                return vigencia;
                        }
                }
                return null;
        }
       
        @Override
        public void limparEntidade() {
                setEntidade(new MeusResultadosDTO());
        }

        @Override
        public GenericService<MeusResultadosDTO> getService() {
                return null;
        }
       
        @Override
        public MeusResultadosDTO getEntidade() {
                return entidade;
        }

        @Override
        public MeusResultadosDTO getId() {
                return getEntidade();
        }
       
        public Vigencia getVigenciaAtual() {
                return vigenciaAtual;
        }
        public void setVigenciaAtual(Vigencia vigenciaAtual) {
                this.vigenciaAtual = vigenciaAtual;
        }
       
        public Vigencia getVigenciaAnterior() {
                return vigenciaAnterior;
        }
        public void setVigenciaAnterior(Vigencia vigenciaAnterior) {
                this.vigenciaAnterior = vigenciaAnterior;
        }
       
        public MeusResultadosDTO getResumoAntigo() {
                return resumoAntigo;
        }
        public void setResumoAntigo(MeusResultadosDTO resumoAntigo) {
                this.resumoAntigo = resumoAntigo;
        }
       
        public MeusResultadosDTO getResumoPromocaoInterna() {
                return resumoPromocaoInterna;
        }
        public void setResumoPromocaoInterna(MeusResultadosDTO resumoPromocaoInterna) {
                this.resumoPromocaoInterna = resumoPromocaoInterna;
        }
       
        public MeusResultadosDTO getResumoPromocaoInternaAnterior() {
                return resumoPromocaoInternaAnterior;
        }
        public void setResumoPromocaoInternaAnterior(MeusResultadosDTO resumoPromocaoInternaAnterior) {
                this.resumoPromocaoInternaAnterior = resumoPromocaoInternaAnterior;
        }
       
        public List<Vigencia> getUltimasVigencias() {
                return ultimasVigencias;
        }
        public void setUltimasVigencias(List<Vigencia> ultimasVigencias) {
                this.ultimasVigencias = ultimasVigencias;
        }
       
        public List<Produto> getProdutosPromocaoInterna() {
                return produtosPromocaoInterna;
        }
        public void setProdutosPromocaoInterna(List<Produto> produtosPromocaoInterna) {
                this.produtosPromocaoInterna = produtosPromocaoInterna;
        }
       
        public List<Produto> getProdutosPromocaoInternaAnterior() {
                return produtosPromocaoInternaAnterior;
        }
        public void setProdutosPromocaoInternaAnterior(List<Produto> produtosPromocaoInternaAnterior) {
                this.produtosPromocaoInternaAnterior = produtosPromocaoInternaAnterior;
        }
       
        public BarChartModel getHistorico() {
                if (VerificadorUtil.estaNulo(historico)) {
                        consultarHistorico();
                }
                return historico;
        }
        public void setHistorico(BarChartModel historico) {
                this.historico = historico;
        }
       
        public BarChartModel getHistoricoPercentual() {
                if (VerificadorUtil.estaNulo(historicoPercentual)) {
                        consultarHistoricoPercentual();
                }
                return historicoPercentual;
        }
        public void setHistoricoPercentual(BarChartModel historicoPercentual) {
                this.historicoPercentual = historicoPercentual;
        }
       
        /***************************************************************/

        public Double calcularPorcentagemDaMetaMensal() {
                return verificarMetas(getEntidade().getRankingVendedor().getAvaliacaoFuncionario()) ?
                                consultarPorcentagem(getEntidade().getRankingVendedor().getAvaliacaoFuncionario().getValorMetaMensal(),
                                        getEntidade().getRankingVendedor().getValorTotalVendido()) : 0.0;
        }
       
        public Double calcularPorcentagemDaMetaMensalVivo() {
                return verificarMetasVivo(getEntidade().getRankingVendedor().getAvaliacaoFuncionario()) ?
                                consultarPorcentagem(getEntidade().getRankingVendedor().getAvaliacaoFuncionario().getValorMetaMensalVivo(),
                                        getEntidade().getRankingVendedor().getValorTotalVendidoVivo()) : 0.0;
        }
       
        public Double calcularPorcentagemDaMetaDiaria() {
                Integer quantidadeDiasNoMes = new GregorianCalendar().getActualMaximum (Calendar.DAY_OF_MONTH);
                return verificarMetas(getEntidade().getRankingVendedor().getAvaliacaoFuncionario()) ?
                                consultarPorcentagem(getEntidade().getRankingVendedor().getAvaliacaoFuncionario().getValorMetaMensal() / quantidadeDiasNoMes,
                                        getEntidade().getRankingVendedor().getValorTotalVendidoDoDia()) : 0.0;
        }
       
        public String retornarEstiloMetaDiaria() {
                Integer quantidadeDiasNoMes = new GregorianCalendar().getActualMaximum (Calendar.DAY_OF_MONTH);
                return verificarMetas(getEntidade().getRankingVendedor().getAvaliacaoFuncionario()) ?
                                retornarEstilo(getEntidade().getRankingVendedor().getAvaliacaoFuncionario().getValorMetaMensal() / quantidadeDiasNoMes,
                                        getEntidade().getRankingVendedor().getValorTotalVendidoDoDia()) : "red-intense";
        }
       
        public String retornarEstiloMetaMensal() {
                return verificarMetas(getEntidade().getRankingVendedor().getAvaliacaoFuncionario()) ?
                                retornarEstilo(getEntidade().getRankingVendedor().getAvaliacaoFuncionario().getValorMetaMensal(),
                                        getEntidade().getRankingVendedor().getValorTotalVendido()) : "red-intense";
        }
       
        public String retornarEstiloMetaMensalVivo() {
                return verificarMetasVivo(getEntidade().getRankingVendedor().getAvaliacaoFuncionario()) ?
                                retornarEstilo(getEntidade().getRankingVendedor().getAvaliacaoFuncionario().getValorMetaMensalVivo(),
                                        getEntidade().getRankingVendedor().getValorTotalVendidoVivo()) : "red-intense";
        }
       
        private boolean verificarMetas(AvaliacaoFuncionario avaliacaoFuncionario) {
                if (VerificadorUtil.naoEstaNulo(avaliacaoFuncionario)) {
                        if (VerificadorUtil.naoEstaNulo(avaliacaoFuncionario.getValorMetaMensal())) {
                                return true;
                        }
                }
                return false;
        }
       
        private boolean verificarMetasVivo(AvaliacaoFuncionario avaliacaoFuncionario) {
                if (VerificadorUtil.naoEstaNulo(avaliacaoFuncionario)) {
                        if (VerificadorUtil.naoEstaNulo(avaliacaoFuncionario.getValorMetaMensalVivo())) {
                                return true;
                        }
                }
                return false;
        }
       
        private String retornarEstilo(Double valorMetaMensal, Double valorTotal) {
                if (VerificadorUtil.naoEstaNuloOuVazio(valorMetaMensal)) {
                        Double percentualRealizado = valorTotal * 100 / valorMetaMensal;
                        if (percentualRealizado < 75) {
                                return "red-intense";
                        } else {
                                if (percentualRealizado < 100) {
                                        return "blue-madison";
                                } else {
                                        if (percentualRealizado < 125) {
                                                return "green-haze";
                                        } else {
                                                return "green-seagreen";
                                        }
                                }
                        }
                }
                return "purple";
        }
       
        private Double consultarPorcentagem(Double valorTotal, Double valor) {
                if (VerificadorUtil.naoEstaNuloOuVazio(valorTotal) && VerificadorUtil.naoEstaNuloOuVazio(valor)) {
                        return (valor * 100 / valorTotal) / 100;
                }
                return 0.0;
        }
       
        public Integer getQuantidadeMinimaComissaoPromocaoInterna() {
                return ConstantesSEC.ProdutosPromocaoInterna.QUANTIDADE_MINIMA_RECEBIMENTO;
        }
       
        public void consultarHistorico() {
                ParametrosRelatorioVendasDTO parametrosRelatorioVendas = new ParametrosRelatorioVendasDTO();
                parametrosRelatorioVendas.iniciarDatasAtuais();
                if (VerificadorUtil.naoEstaNulo(getEntidade())) {
                        parametrosRelatorioVendas.setVendedor(getEntidade().getRankingVendedor().getVendedor());
                       
                        ParametrosConsultaVendasDTO parametrosConsulta = new ParametrosConsultaVendasDTO(parametrosRelatorioVendas);
                        historico = new BarChartModel();
                        historico.setShowPointLabels(true);
                        historico.setDatatipFormat("<span>R$ %2$d</span><span style='display:none;'>%2$d</span>");
                        historico.setShowDatatip(true);
                        historico.setTitle("");
                        Axis xAxis = historico.getAxis(AxisType.X);
                        xAxis.setLabel("MESES");
                        Axis yAxis = historico.getAxis(AxisType.Y);
                    yAxis.setLabel("VALORES");
                        Integer mesAtual = new Integer(parametrosRelatorioVendas.getMes());
                        Integer anoAtual = new Integer(parametrosRelatorioVendas.getAno());
                        Integer quantidadeMesesAnteriores = 13;
                       
                        mesAtual = mesAtual - quantidadeMesesAnteriores + 1;
                        if (mesAtual <= 0) {
                                mesAtual = mesAtual + 12;
                                anoAtual--;
                        }
                        ChartSeries linha = new ChartSeries();
                        for (int mes = 1; mes <= quantidadeMesesAnteriores; quantidadeMesesAnteriores--) {
                                if (mesAtual == 13) {
                                        mesAtual = 1;
                                        anoAtual++;
                                }
                                Double valorAcumulado = new Double(0.0);
                                Calendar dataInicial = DataUtils.obterCalendario(DataUtils.obterData(1, mesAtual - 1, anoAtual));
                                parametrosConsulta.setDataInicial(dataInicial.getTime());
                                int qntMaximaDias = dataInicial.getActualMaximum(Calendar.DAY_OF_MONTH);
                                parametrosConsulta.setDataFinal(DataUtils.obterCalendario(DataUtils.obterData(qntMaximaDias, mesAtual - 1, anoAtual)).getTime());
                                parametrosConsulta.setIndicadorComissionado(true);
                                valorAcumulado = vendaService.obterValorTotalBrutoDeVendasPorLojaEePeriodo(parametrosConsulta);
                                String descricaoLinha = mesAtual.toString() + "/" + anoAtual;
                                linha.set(descricaoLinha, valorAcumulado);
                        mesAtual++;
                        }
                        historico.addSeries(linha);
                }
        }
       
        public void consultarHistoricoPercentual() {
                ParametrosRelatorioVendasDTO parametrosRelatorioVendas = new ParametrosRelatorioVendasDTO();
                parametrosRelatorioVendas.iniciarDatasAtuais();
                if (VerificadorUtil.naoEstaNulo(getEntidade())) {
                        parametrosRelatorioVendas.setVendedor(getEntidade().getRankingVendedor().getVendedor());
                       
                        ParametrosConsultaVendasDTO parametrosConsulta = new ParametrosConsultaVendasDTO(parametrosRelatorioVendas);
                        historicoPercentual = new BarChartModel();
                        historicoPercentual.setShowPointLabels(true);
                        historicoPercentual.setDatatipFormat("<span>%2$d%</span><span style='display:none;'>%2$d</span>");
                        historicoPercentual.setShowDatatip(true);
                        historicoPercentual.setTitle("");
                        Axis xAxis = historicoPercentual.getAxis(AxisType.X);
                        xAxis.setLabel("MESES");
                        Axis yAxis = historicoPercentual.getAxis(AxisType.Y);
                    yAxis.setLabel("PERCENTUAIS");
                        Integer mesAtual = new Integer(parametrosRelatorioVendas.getMes());
                        Integer anoAtual = new Integer(parametrosRelatorioVendas.getAno());
                        Integer quantidadeMesesAnteriores = 13;
                       
                        mesAtual = mesAtual - quantidadeMesesAnteriores + 1;
                        if (mesAtual <= 0) {
                                mesAtual = mesAtual + 12;
                                anoAtual--;
                        }
                        ChartSeries linha = new ChartSeries();
                        for (int mes = 1; mes <= quantidadeMesesAnteriores; quantidadeMesesAnteriores--) {
                                if (mesAtual == 13) {
                                        mesAtual = 1;
                                        anoAtual++;
                                }
                                Double valorAcumulado = new Double(0.0);
                                Calendar dataInicial = DataUtils.obterCalendario(DataUtils.obterData(1, mesAtual - 1, anoAtual));
                                parametrosConsulta.setDataInicial(dataInicial.getTime());
                                int qntMaximaDias = dataInicial.getActualMaximum(Calendar.DAY_OF_MONTH);
                                parametrosConsulta.setDataFinal(DataUtils.obterCalendario(DataUtils.obterData(qntMaximaDias, mesAtual - 1, anoAtual)).getTime());
                                parametrosConsulta.setIndicadorComissionado(true);
                                valorAcumulado = vendaService.obterValorTotalBrutoDeVendasPorLojaEePeriodo(parametrosConsulta);
                                String descricaoLinha = mesAtual.toString() + "/" + anoAtual;
                               
                                AvaliacaoFuncionario avaliacaoFuncionario = avaliacaoFuncionarioService.consultarAvaliacaoFuncionarioPelaData(parametrosRelatorioVendas.getVendedor(), DataUtils.getDataComHorarioMinimo(parametrosConsulta.getDataFinal()));
                                Double percentualMetaMensal = 0.0;
                                if (VerificadorUtil.naoEstaNulo(avaliacaoFuncionario)) {
                                        percentualMetaMensal = avaliacaoFuncionario.retornarPercentualRealizado(valorAcumulado);
                                }
                               
                                linha.set(descricaoLinha, percentualMetaMensal * 100);
                        mesAtual++;
                        }
                        historicoPercentual.addSeries(linha);
                }
        }
       
        public String produtosPromocaoInterna() {
                return ConstantesSEC.ProdutosPromocaoInterna.PRODUTOS.replace("'", "");
        }
       
        public String produtosPromocaoInternaMesAnterior() {
                return ConstantesSEC.ProdutosPromocaoInterna.PRODUTOS_MES_ANTERIOR.replace("'", "");
        }
       
}