Subversion Repositories Integrator Subversion

package br.com.ec.domain.model;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Set;

import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.OneToMany;
import javax.persistence.SequenceGenerator;
import javax.persistence.Table;
import javax.persistence.Transient;
import javax.validation.constraints.NotNull;
import javax.validation.constraints.Size;
import javax.xml.bind.JAXBElement;

import org.hibernate.annotations.ForeignKey;
import org.hibernate.validator.constraints.NotEmpty;

import br.com.ec.controller.util.UtilBean;
import br.com.ec.core.interfaces.Alterar;
import br.com.ec.core.interfaces.Cadastrar;
import br.com.ec.core.util.DataUtils;
import br.com.ec.core.util.StringUtil;
import br.com.ec.core.util.VerificadorUtil;
import br.com.ec.domain.dto.ProdutoCustosDTO;
import br.com.ec.domain.model.tipos.TipoCorProduto;
import br.com.ec.domain.model.tipos.TipoEstiloProduto;
import br.com.ec.domain.model.tipos.TipoGenero;
import br.com.ec.domain.model.tipos.TipoProduto;
import br.com.ec.domain.shared.ConstantesSEC;
import br.com.ec.domain.util.CodigoBarraEAN;

@Entity
@Table(name="sec_produto", schema="sc_sec")
public class Produto implements Serializable, Cloneable {
         
        private static final long serialVersionUID = 1L;
       
        private Long sequencial;
        private Modelo modelo;
        private Tributacao tributacao;
        private Estampa estampa;
        private SubtipoProduto subtipoProduto;
        private String codigo;
        private String codigoRapido;
        private String codigoEAN;
        private String codigoEANTributado;
        private String descricao;
        private String descricaoEtiqueta;
        private String descricaoParaNotaFiscal;
        private String tipo;
        private String genero;
        private String estilo;
        private String cor;
        private String observacao;
        private Double valorCompra;
        private Double valorVarejo;
        private Double valorVarejoPromocional;
        private Double valorVarejoMaximo;
        private Double valorVarejoPopular;
        private Double valorAtacado;
        private Date dataOnline;
        private Date dataOnlineMercadoLivre;
        private Boolean indicadorFavorito;
        private Boolean indicadorComissionado;
        private Boolean indicadorPersonalizavel;
        private Boolean indicadorEmissaoNotaFiscal;
       
        private Double valorVarejoSimulacao;
        private Boolean sujeitoST;
        private Double aliquotaIPI;
        private Double aliquotaIPINotaFiscal;
        private Double aliquotaIcms;
        private Double aliquotaIcmsNotaFiscal;
        private Double aliquotaIcmsST;
        private Double aliquotaFecoep;
        private Boolean ativo;
       
        private String codigoNCM;
        private String codigoEST;
        private Set<ProdutoPedidoCompra> pedidosCompra;
        private Set<ProdutoLoja> estoques;
        private Set<FornecedorProduto> fornecedores;
        private Set<ProdutoRelacionado> relacionados;
        private Set<ProdutoRelacionado> relacionadosReverse;
       
        private List<TransferenciaProduto> transferenciasAbertas = new ArrayList<TransferenciaProduto>();
        private List<PedidoProduto> pedidosPendentes = new ArrayList<PedidoProduto>();
       
        private Boolean indicadorOnline;
        private Boolean indicadorOnlineMercadoLivre;
        private Date dataUltimaVenda;
//      private Set<ProdutoArquivo> fotos;
       
        public Produto() {}
       
        public Produto(Long sequencial) {
                this.sequencial = sequencial;
        }
       
        @Id
        @SequenceGenerator(name = "sq_produto")
        @GeneratedValue(strategy = GenerationType.IDENTITY)
        @Column(name="seq_produto", nullable=false)
        public Long getSequencial() {
                return sequencial;
        }
        public void setSequencial(Long sequencial) {
                this.sequencial = sequencial;
        }
       
        @ManyToOne
        @ForeignKey(name="fk_produto_modelo")
        @NotNull(message = "Parâmetro obrigatório não preenchido: Modelo do produto", groups = {Cadastrar.class, Alterar.class})
        @JoinColumn(name = "seq_modelo", referencedColumnName="seq_modelo", nullable=true)
        public Modelo getModelo() {
                return modelo;
        }
        public void setModelo(Modelo modelo) {
                this.modelo = modelo;
        }
       
        @ManyToOne
        @ForeignKey(name="fk_produto_tributacao")
        @JoinColumn(name = "seq_tributacao", referencedColumnName="seq_tributacao", nullable=true)
        public Tributacao getTributacao() {
                return tributacao;
        }
        public void setTributacao(Tributacao tributacao) {
                this.tributacao = tributacao;
        }
       
        @ManyToOne
        @ForeignKey(name="fk_produto_estampa")
        @JoinColumn(name = "seq_estampa", referencedColumnName="seq_estampa", nullable=true)
        public Estampa getEstampa() {
                return estampa;
        }
        public void setEstampa(Estampa estampa) {
                this.estampa = estampa;
        }
       
        @Column(name="cod_produto")
        @Size(max = 20, message = "Limite de caracteres ultrapassado: Código do Produto")
        @NotNull(message = "Parâmetro obrigatório não preenchido: Código do produto", groups = {Cadastrar.class, Alterar.class})
        @NotEmpty(message = "Parâmetro obrigatório não preenchido: Código do produto", groups = {Cadastrar.class, Alterar.class})
        public String getCodigo() {
                return codigo;
        }
        public void setCodigo(String codigo) {
                this.codigo = codigo;
        }
       
        @Column(name="cod_rapido_produto")
        @Size(max = 20, message = "Limite de caracteres ultrapassado: Código Rápido")
        public String getCodigoRapido() {
                return codigoRapido;
        }
        public void setCodigoRapido(String codigoRapido) {
                this.codigoRapido = codigoRapido;
        }
       
        @Column(name="cod_ean")
        @Size(max = 20, message = "Limite de caracteres ultrapassado: Código de Barras (EAN)")
        public String getCodigoEAN() {
                return codigoEAN;
        }
        public void setCodigoEAN(String codigoEAN) {
                this.codigoEAN = codigoEAN;
        }
       
        @Column(name="cod_ean_tributado")
        @Size(max = 20, message = "Limite de caracteres ultrapassado: Código de Barras Tributado (EAN)")
        public String getCodigoEANTributado() {
                return codigoEANTributado;
        }
        public void setCodigoEANTributado(String codigoEANTributado) {
                this.codigoEANTributado = codigoEANTributado;
        }
       
        @Column(name="dsc_produto")
        @Size(max = 250, message = "Limite de caracteres ultrapassado: Descrição do Produto")
        public String getDescricao() {
                return descricao;
        }
        public void setDescricao(String descricao) {
                this.descricao = StringUtil.setarUpperCaseComTrim(descricao);
        }
       
        @Column(name="dsc_etiqueta")
        @Size(max = 120, message = "Limite de caracteres ultrapassado: Descrição da Etiqueta")
        public String getDescricaoEtiqueta() {
                return descricaoEtiqueta;
        }
        public void setDescricaoEtiqueta(String descricaoEtiqueta) {
                this.descricaoEtiqueta = StringUtil.setarUpperCaseComTrim(descricaoEtiqueta);
        }
       
//      @Column(name="dsc_notafiscal")
//      @Size(max = 250, message = "Limite de caracteres ultrapassado: Descrição para Nota Fiscal do Produto")
        @Transient
        public String getDescricaoParaNotaFiscal() {
                return descricaoParaNotaFiscal;
        }
        public void setDescricaoParaNotaFiscal(String descricaoParaNotaFiscal) {
                this.descricaoParaNotaFiscal = descricaoParaNotaFiscal;
        }
       
        @Column(name="tip_produto")
        @NotNull(message = "Parâmetro obrigatório não preenchido: Tipo do produto", groups = {Cadastrar.class, Alterar.class})
        public String getTipo() {
                return tipo;
        }
        public void setTipo(String tipo) {
                this.tipo = tipo;
        }
       
        @ManyToOne
        @ForeignKey(name="fk_produto_subtipoproduto")
        @JoinColumn(name = "seq_subtipoproduto", referencedColumnName="seq_subtipoproduto", nullable=true)
        public SubtipoProduto getSubtipoProduto() {
                return subtipoProduto;
        }
        public void setSubtipoProduto(SubtipoProduto subtipoProduto) {
                this.subtipoProduto = subtipoProduto;
        }
       
        @Column(name="tip_genero")
        @NotNull(message = "Parâmetro obrigatório não preenchido: Gênero", groups = {Cadastrar.class, Alterar.class})
        public String getGenero() {
                return genero;
        }
        public void setGenero(String genero) {
                this.genero = genero;
        }
       
        @Column(name="tip_estilo")
        public String getEstilo() {
                return estilo;
        }
        public void setEstilo(String estilo) {
                this.estilo = estilo;
        }

        @Column(name="tip_cor")
        public String getCor() {
                return cor;
        }
        public void setCor(String cor) {
                this.cor = cor;
        }
       
        @Column(name="dsc_observacao")
        @Size(max = 1000, message = "Limite de caracteres ultrapassado: Observação")
        public String getObservacao() {
                return observacao;
        }
        public void setObservacao(String observacao) {
                this.observacao = StringUtil.setarUpperCaseComTrim(observacao);
        }
       
        @Column(name="val_compra")
        public Double getValorCompra() {
                return valorCompra;
        }
        public void setValorCompra(Double valorCompra) {
                this.valorCompra = valorCompra;
        }
       
        @Transient
        public String valorCompraFormatado() {
                if (VerificadorUtil.naoEstaNulo(getValorCompra())) {
                        return StringUtil.formatarValor(getValorCompra());
                }
                return StringUtil.formatarValor(0.0);
        }

        @Column(name="val_varejo")
        public Double getValorVarejo() {
                return valorVarejo;
        }
        public void setValorVarejo(Double valorVarejo) {
                this.valorVarejo = valorVarejo;
        }
       
        @Column(name="val_varejo_promocional")
        public Double getValorVarejoPromocional() {
                return valorVarejoPromocional;
        }
        public void setValorVarejoPromocional(Double valorVarejoPromocional) {
                this.valorVarejoPromocional = valorVarejoPromocional;
        }
       
        @Column(name="val_varejo_maximo")
        public Double getValorVarejoMaximo() {
                return valorVarejoMaximo;
        }
        public void setValorVarejoMaximo(Double valorVarejoMaximo) {
                this.valorVarejoMaximo = valorVarejoMaximo;
        }
       
        @Column(name="val_varejo_popular")
        public Double getValorVarejoPopular() {
                return valorVarejoPopular;
        }
        public void setValorAtacado(Double valorAtacado) {
                this.valorAtacado = valorAtacado;
        }
       
        @Column(name="val_atacado")
        public Double getValorAtacado() {
                return valorAtacado;
        }
        public void setValorVarejoPopular(Double valorVarejoPopular) {
                this.valorVarejoPopular = valorVarejoPopular;
        }
       
        @Column(name="dat_online")
        public Date getDataOnline() {
                return dataOnline;
        }
        public void setDataOnline(Date dataOnline) {
                this.dataOnline = dataOnline;
        }
       
        @Column(name="dat_online_mercadolivre")
        public Date getDataOnlineMercadoLivre() {
                return dataOnlineMercadoLivre;
        }
        public void setDataOnlineMercadoLivre(Date dataOnlineMercadoLivre) {
                this.dataOnlineMercadoLivre = dataOnlineMercadoLivre;
        }
       
        @Column(name="ind_favorito")
        public Boolean getIndicadorFavorito() {
                return indicadorFavorito;
        }
        public void setIndicadorFavorito(Boolean indicadorFavorito) {
                this.indicadorFavorito = indicadorFavorito;
        }
       
        @Column(name="ind_comissionado")
        public Boolean getIndicadorComissionado() {
                return indicadorComissionado;
        }
        public void setIndicadorComissionado(Boolean indicadorComissionado) {
                this.indicadorComissionado = indicadorComissionado;
        }
       
        @Column(name="ind_personalizavel")
        public Boolean getIndicadorPersonalizavel() {
                return indicadorPersonalizavel;
        }
        public void setIndicadorPersonalizavel(Boolean indicadorPersonalizavel) {
                this.indicadorPersonalizavel = indicadorPersonalizavel;
        }
       
        @Column(name="ind_emissao_nf")
        public Boolean getIndicadorEmissaoNotaFiscal() {
                if (VerificadorUtil.estaNulo(indicadorEmissaoNotaFiscal)) {
                        return false;
                }
                return indicadorEmissaoNotaFiscal;
        }
        public void setIndicadorEmissaoNotaFiscal(Boolean indicadorEmissaoNotaFiscal) {
                this.indicadorEmissaoNotaFiscal = indicadorEmissaoNotaFiscal;
        }
       
        @Column(name="ind_sujeito_st", nullable=false)
        public Boolean getSujeitoST() {
                if (VerificadorUtil.estaNulo(sujeitoST)) {
                        return false;
                }
                return sujeitoST;
        }
        public void setSujeitoST(Boolean sujeitoST) {
                this.sujeitoST = sujeitoST;
        }

        @Transient
        public Double getValorVarejoSimulacao() {
                if (VerificadorUtil.estaNulo(valorVarejoSimulacao)) {
                        return getValorVarejo();
                }
                return valorVarejoSimulacao;
        }
        public void setValorVarejoSimulacao(Double valorVarejoSimulacao) {
                this.valorVarejoSimulacao = valorVarejoSimulacao;
        }
       
        @Transient
        public Double getValorEm18x() {
                if (VerificadorUtil.naoEstaNulo(getValorVarejo())) {
                        return getValorVarejo() * 1.12;
                }
                return 0.0;
        }
       
        @Transient
        public Double getJurosValorEm18x() {
                if (VerificadorUtil.naoEstaNulo(getValorEm18x()) &&
                                VerificadorUtil.naoEstaNulo(getValorVarejo())) {
                        return getValorEm18x() - getValorVarejo();
                }
                return 0.0;
        }
       
        @Transient
        public Double getParcelasValorEm18x() {
                if (VerificadorUtil.naoEstaNulo(getValorEm18x())) {
                        if (getValorEm18x() > 0.0) {
                                return getValorEm18x()/18;
                        }
                }
                return 0.0;
        }
       
        @Column(name="val_aliquota_icms")
        public Double getAliquotaIcms() {
                return aliquotaIcms;
        }
        public void setAliquotaIcms(Double aliquotaIcms) {
                this.aliquotaIcms = aliquotaIcms;
        }
       
        @Transient
        public Double getAliquotaIcmsNotaFiscal() {
                return aliquotaIcmsNotaFiscal;
        }
        public void setAliquotaIcmsNotaFiscal(Double aliquotaIcmsNotaFiscal) {
                this.aliquotaIcmsNotaFiscal = aliquotaIcmsNotaFiscal;
        }
       
        @Column(name="val_aliquota_icms_st")
        public Double getAliquotaIcmsST() {
                return aliquotaIcmsST;
        }
        public void setAliquotaIcmsST(Double aliquotaIcmsST) {
                this.aliquotaIcmsST = aliquotaIcmsST;
        }
       
        @Column(name="val_aliquota_fecoep")
        public Double getAliquotaFecoep() {
                return aliquotaFecoep;
        }
        public void setAliquotaFecoep(Double aliquotaFecoep) {
                this.aliquotaFecoep = aliquotaFecoep;
        }
       
        @Column(name="val_aliquota_ipi")
        public Double getAliquotaIPI() {
                return aliquotaIPI;
        }
        public void setAliquotaIPI(Double aliquotaIPI) {
                this.aliquotaIPI = aliquotaIPI;
        }
       
        @Transient
        public Double getAliquotaIPINotaFiscal() {
                return aliquotaIPINotaFiscal;
        }
        public void setAliquotaIPINotaFiscal(Double aliquotaIPINotaFiscal) {
                this.aliquotaIPINotaFiscal = aliquotaIPINotaFiscal;
        }
       
        @Column(name="ind_ativo")
        public Boolean getAtivo() {
                return ativo;
        }
        public void setAtivo(Boolean ativo) {
                this.ativo = ativo;
        }
       
        @OneToMany(mappedBy="produto", cascade=CascadeType.ALL, orphanRemoval=true)
        public Set<ProdutoPedidoCompra> getPedidosCompra() {
                return pedidosCompra;
        }
        public void setPedidosCompra(Set<ProdutoPedidoCompra> pedidosCompra) {
                this.pedidosCompra = pedidosCompra;
        }
       
        @OneToMany(mappedBy="produto", cascade=CascadeType.ALL, orphanRemoval=true)
        public Set<ProdutoLoja> getEstoques() {
                return estoques;
        }
        public void setEstoques(Set<ProdutoLoja> estoques) {
                this.estoques = estoques;
        }
       
        @OneToMany(mappedBy="produto", cascade=CascadeType.ALL, orphanRemoval=true)
        public Set<FornecedorProduto> getFornecedores() {
                return fornecedores;
        }
        public void setFornecedores(Set<FornecedorProduto> fornecedores) {
                this.fornecedores = fornecedores;
        }
       
        @OneToMany(mappedBy="produto", cascade=CascadeType.ALL, orphanRemoval=true)
        public Set<ProdutoRelacionado> getRelacionados() {
                return relacionados;
        }
        public void setRelacionados(Set<ProdutoRelacionado> relacionados) {
                this.relacionados = relacionados;
        }
       
        @OneToMany(mappedBy="produtoRelacionado", cascade=CascadeType.ALL, orphanRemoval=true)
        public Set<ProdutoRelacionado> getRelacionadosReverse() {
                return relacionadosReverse;
        }
        public void setRelacionadosReverse(Set<ProdutoRelacionado> relacionadosReverse) {
                this.relacionadosReverse = relacionadosReverse;
        }
       
        @Transient
        public Boolean getIndicadorOnline() {
                if (VerificadorUtil.estaNulo(this.getDataOnline()) && VerificadorUtil.estaNulo(this.indicadorOnline)) {
                        setIndicadorOnline(false);
                } else {
                        setIndicadorOnline(true);
                }
                return indicadorOnline;
        }
        public void setIndicadorOnline(Boolean indicadorOnline) {
                this.indicadorOnline = indicadorOnline;
        }
        public void atualizarDataOnline() {
                if (VerificadorUtil.estaNulo(this.getDataOnline())) {
                        this.setDataOnline(DataUtils.getDataAtual());
                } else {
                        this.setDataOnline(null);
                }
        }
       
        @Transient
        public Boolean getIndicadorOnlineMercadoLivre() {
                if (VerificadorUtil.estaNulo(this.getDataOnlineMercadoLivre()) && VerificadorUtil.estaNulo(this.indicadorOnlineMercadoLivre)) {
                        setIndicadorOnlineMercadoLivre(false);
                } else {
                        setIndicadorOnlineMercadoLivre(true);
                }
                return indicadorOnlineMercadoLivre;
        }
        public void setIndicadorOnlineMercadoLivre(Boolean indicadorOnlineMercadoLivre) {
                this.indicadorOnlineMercadoLivre = indicadorOnlineMercadoLivre;
        }
        public void atualizarDataOnlineMercadoLivre() {
                if (VerificadorUtil.estaNulo(this.getDataOnlineMercadoLivre())) {
                        this.setDataOnlineMercadoLivre(DataUtils.getDataAtual());
                } else {
                        this.setDataOnlineMercadoLivre(null);
                }
        }
       
        @Transient
        public List<TransferenciaProduto> getTransferenciasAbertas() {
                return transferenciasAbertas;
        }
        public void setTransferenciasAbertas(List<TransferenciaProduto> transferenciasAbertas) {
                this.transferenciasAbertas = transferenciasAbertas;
        }
       
        @Transient
        public List<PedidoProduto> getPedidosPendentes() {
                return pedidosPendentes;
        }
        public void setPedidosPendentes(List<PedidoProduto> pedidosPendentes) {
                this.pedidosPendentes = pedidosPendentes;
        }
       
        @Transient
        public Date getDataUltimaVenda() {
                return dataUltimaVenda;
        }
        public void setDataUltimaVenda(Date dataUltimaVenda) {
                this.dataUltimaVenda = dataUltimaVenda;
        }
       
        @Transient
        public Integer getQuantidadeDiasUltimaVenda() {
                if (VerificadorUtil.naoEstaNulo(getDataUltimaVenda())) {
                        return DataUtils.calcularDiferenceEmDiasEntreDuasDatas(DataUtils.getDataAtual(), getDataUltimaVenda());
                }
                return null;
        }
       
        @Transient
        public ArrayList<ProdutoRelacionado> getCompativeis() {
                ArrayList<ProdutoRelacionado> compativeis = new ArrayList<ProdutoRelacionado>();
                if (VerificadorUtil.naoEstaNulo(getRelacionados())) {
                        compativeis.addAll(getRelacionados());
                }
                if (VerificadorUtil.naoEstaNulo(getRelacionadosReverse())) {
                        compativeis.addAll(getRelacionadosReverse());
                }
                return compativeis;
        }
       
        @Transient
        public String getCodigoNCM() {
                return codigoNCM;
        }
        public void setCodigoNCM(String codigoNCM) {
                this.codigoNCM = codigoNCM;
        }
       
        @Transient
        public String getCodigoEST() {
                return codigoEST;
        }
        public void setCodigoEST(String codigoEST) {
                this.codigoEST = codigoEST;
        }
       
        /*
        @OneToMany(mappedBy="produto", cascade=CascadeType.ALL, orphanRemoval=true)
        public Set<ProdutoArquivo> getFotos() {
                return fotos;
        }
        public void setFotos(Set<ProdutoArquivo> fotos) {
                this.fotos = fotos;
        }
        */
        /***************************************************************/
       
        @Transient
        public String getCodigoProdutoPadrao() {
                try {
                        return VerificadorUtil.naoEstaNulo(codigo) ? String.format("%06d", new Long(codigo.trim())) : "";
                } catch (Exception e) {
                        return "";
                }
        }

        public static void main(String[] args) {
//              System.out.println(String.format("%07d", new Long(12879)));
//              codigoBarras.gerarCodigoBarra(String.format("%012d", new Long(12879)));
//              System.out.println(codigoBarras.getCodigoBarra());
                System.out.println(CodigoBarraEAN.gerarCodigoBarras("6659"));
//              System.out.println(codigoBarras.longToEan13("900000012879"));
        }
       
        @Transient
        public String getCodigoDeBarrasProdutoPadrao() {
                try {
                        return VerificadorUtil.naoEstaNulo(codigo)? String.format("%07d", new Long(codigo)) : "";
//                      return VerificadorUtil.naoEstaNulo(codigo) ? StringUtils.rightPad(codigo, 12, "0") : "";
                } catch (Exception e) {
                        return "";
                }
        }
       
        @Transient
        public String getDescricaoDoModelo() {
                return VerificadorUtil.naoEstaNulo(modelo)? modelo.getDescricao() : "";
        }
       
        @Transient
        public String getDescricaoTecnicaDoModelo() {
                return VerificadorUtil.naoEstaNulo(modelo)? VerificadorUtil.naoEstaNulo(modelo.getDescricaoTecnica())? modelo.getDescricaoTecnica() : "" : "";
        }
       
        @Transient
        public String getDescricaoTecnicaDoModeloComParenteses() {
                return VerificadorUtil.naoEstaNulo(modelo)? VerificadorUtil.naoEstaNulo(modelo.getDescricaoTecnica())? " (" + modelo.getDescricaoTecnica() + ") " : "" : "";
        }
       
        @Transient
        public Long getSequencialDoModelo() {
                return VerificadorUtil.naoEstaNulo(modelo)? modelo.getSequencial() : null;
        }
       
        @Transient
        public Marca getMarcaDoModelo() {
                if (VerificadorUtil.naoEstaNulo(modelo)) {
                        if (VerificadorUtil.naoEstaNulo(modelo.getMarca())) {
                                return modelo.getMarca();
                        }
                }
                return null;
        }
       
        @Transient
        public String getDescricaoDaMarcaDoModelo() {
                return VerificadorUtil.naoEstaNulo(getMarcaDoModelo())? getMarcaDoModelo().getDescricao() : "";
        }
       
        @Transient
        public String getDescricaoComModeloCompletaComCodigo() {
                StringBuilder descricaoCompleta = new StringBuilder();
                descricaoCompleta.append("[");
                descricaoCompleta.append(getCodigoProdutoPadrao());
                descricaoCompleta.append("] ");
                if (VerificadorUtil.naoEstaNuloOuVazio(getDescricaoDoModelo())) {
                        descricaoCompleta.append(getDescricaoDoModelo());
                        descricaoCompleta.append(" - ");
                }
                descricaoCompleta.append(getDescricaoCompleta());
                return descricaoCompleta.toString();
        }
       
        @Transient
        public String getDescricaoComModeloCompleta() {
                StringBuilder descricaoCompleta = new StringBuilder();
                if (VerificadorUtil.naoEstaNuloOuVazio(getDescricaoDoModelo())) {
                        descricaoCompleta.append(getDescricaoDoModelo());
                        descricaoCompleta.append(" - ");
                }
                descricaoCompleta.append(getDescricaoCompleta());
                return descricaoCompleta.toString();
        }
       
        @Transient
        public String getDescricaoCompleta() {
                StringBuilder descricaoCompleta = new StringBuilder();
                if (VerificadorUtil.naoEstaNuloOuVazio(getEstilo())) {
                        descricaoCompleta.append(getDescricaoDoEstilo());
                        descricaoCompleta.append(" ");
                }
                descricaoCompleta.append(getDescricao());
                if (VerificadorUtil.naoEstaNuloOuVazio(getCor())) {
                        descricaoCompleta.append(" (");
                        descricaoCompleta.append(getDescricaoDaCor());
                        descricaoCompleta.append(")");
                }
                return descricaoCompleta.toString();
        }
       
        @Transient
        public String getDescricaoCompletaCapa() {
                StringBuilder descricaoCompleta = new StringBuilder();
                descricaoCompleta.append(getCodigo());
                descricaoCompleta.append(" - ");
                if (this.getTipo().equals(TipoProduto.CAPA.getValor())) {
                        descricaoCompleta.append("CAPA");
                }
                if (!this.getTipo().equals(TipoProduto.ACESSORIO.getValor())) {
                        descricaoCompleta.append(" ");
                        descricaoCompleta.append(getDescricaoDoModelo());
                }
                if (VerificadorUtil.naoEstaNuloOuVazio(this.getEstilo())) {
                        descricaoCompleta.append(" ");
                        descricaoCompleta.append(getDescricaoDoEstilo());
                }
                descricaoCompleta.append(" ");
                if (this.getDescricao().length() > 50) {
                        descricaoCompleta.append(getDescricao().substring(0, 50));
                } else {
                        descricaoCompleta.append(getDescricao());
                }
                if (VerificadorUtil.naoEstaNuloOuVazio(getCor())) {
                        descricaoCompleta.append(" (");
                        descricaoCompleta.append(getDescricaoDaCor());
                        descricaoCompleta.append(")");
                }
                return descricaoCompleta.toString();
        }
       
        @Transient
        public String getDescricaoDoTipo() {
                return VerificadorUtil.naoEstaNuloOuVazio(getTipo())? TipoProduto.parse(getTipo()).getDescricao() : null;
        }
       
        @Transient
        public String getDescricaoDoSubtipo() {
                return VerificadorUtil.naoEstaNuloOuVazio(getSubtipoProduto())? getSubtipoProduto().getDescricao() : "";
        }
       
        @Transient
        public String getDescricaoDoGenero() {
                return VerificadorUtil.naoEstaNuloOuVazio(getGenero())? TipoGenero.parse(getGenero()).getDescricao() : null;
        }
       
        @Transient
        public String getDescricaoDoEstilo() {
                return VerificadorUtil.naoEstaNuloOuVazio(getEstilo())? TipoEstiloProduto.parse(getEstilo()).getDescricao() : null;
        }
       
        @Transient
        public String getDescricaoDaCor() {
                return VerificadorUtil.naoEstaNuloOuVazio(getCor())? TipoCorProduto.parse(getCor()).getDescricao() : null;
        }
       
        @Transient
        public String getDescricaoNotaFiscal(String observacaoNotaFiscal) {
                StringBuilder descricaoCompleta = new StringBuilder();
                if (this.getTipo().equals(TipoProduto.CAPA.getValor())) {
                        descricaoCompleta.append("CAPA");
                }
                if (!this.getTipo().equals(TipoProduto.ACESSORIO.getValor()) /*&&
                                !this.getTipo().equals(TipoProduto.RESTAURANTE.getValor())*/) {
                        descricaoCompleta.append(" ");
                        descricaoCompleta.append(this.getDescricaoDoModelo());
                }
                if (VerificadorUtil.naoEstaNuloOuVazio(this.getEstilo())) {
                        descricaoCompleta.append(" ");
                        descricaoCompleta.append(this.getDescricaoDoEstilo());
                }
                descricaoCompleta.append(" ");
                if (this.getDescricao().length() > 50) {
                        descricaoCompleta.append(this.getDescricao().substring(0, 50));
                } else {
                        descricaoCompleta.append(this.getDescricao());
                }
                if (VerificadorUtil.naoEstaNuloOuVazio(this.getCor())) {
                        descricaoCompleta.append(" (");
                        descricaoCompleta.append(this.getDescricaoDaCor());
                        descricaoCompleta.append(")");
                }
                if (VerificadorUtil.naoEstaNuloOuVazio(observacaoNotaFiscal)) {
                        descricaoCompleta.append(" ");
                        descricaoCompleta.append(observacaoNotaFiscal);
                }
                return descricaoCompleta.toString().trim();
        }
       
        @Transient
        public Integer getQuantidadeEstoqueTotal() {
                Integer total = 0;
                /*
                for (ProdutoLoja estoque : estoques) {
                        total = total + estoque.getQuantidadeEstoque();
                }
                */
                return total;
        }
       
        @Transient
        public Boolean verificarSeQuantidadeEhMenor(Integer primeiro, Integer segundo) {
                if (VerificadorUtil.naoEstaNulo(primeiro) && VerificadorUtil.naoEstaNulo(segundo)) {
                        return primeiro <= segundo ? true : false;
                }
                return false;
        }
       
        public void atualizarDados(Produto produto) {
                this.codigo = produto.getCodigo();
                this.descricao = produto.getDescricao();
                this.valorCompra = produto.getValorCompra();
                this.valorVarejo = produto.getValorVarejo();
                if (produto.getQuantidadeEstoqueTotal() > 0) {
                        this.setAtivo(true);
                }
        }
       
        public void atualizarDadosNfe(nfce.java.TNFe.InfNFe.Det produtoNota) {
                if (VerificadorUtil.estaNuloOuVazio(this.getDescricao())) {
                        this.setDescricao(produtoNota.getProd().getXProd());
                }
                if (VerificadorUtil.estaNuloOuVazio(this.getGenero())) {
                        this.setGenero(TipoGenero.UNISSEX.getValor());
                }
               
                this.setCodigoEAN(StringUtil.retornarApenasNumeros(produtoNota.getProd().getCEAN()));
                this.setCodigoEANTributado(StringUtil.retornarApenasNumeros(produtoNota.getProd().getCEANTrib()));
                if (VerificadorUtil.naoEstaNulo(produtoNota.getProd().getNCM())) {             
                        this.setCodigoNCM(produtoNota.getProd().getNCM());
                }
                if (VerificadorUtil.naoEstaNulo(produtoNota.getProd().getCEST())) {
                        this.setCodigoEST(produtoNota.getProd().getCEST());
                }
               
                for (JAXBElement<?> elemento : produtoNota.getImposto().getContent()) {
                        if (elemento.getDeclaredType().equals(nfce.java.TNFe.InfNFe.Det.Imposto.ICMS.class)) {
                                nfce.java.TNFe.InfNFe.Det.Imposto.ICMS icms = (nfce.java.TNFe.InfNFe.Det.Imposto.ICMS) elemento.getValue();
                                if (VerificadorUtil.naoEstaNulo(icms.getICMS00())) {
                                        preencherAliquotaIcms(Double.valueOf(icms.getICMS00().getPICMS()));
                                }
                                if (VerificadorUtil.naoEstaNulo(icms.getICMS10())) {
                                        preencherAliquotaIcms(Double.valueOf(icms.getICMS10().getPICMS()));
                                }
                        }
                        if (elemento.getDeclaredType().equals(nfce.java.TIpi.class)) {
                                nfce.java.TIpi ipi = (nfce.java.TIpi) elemento.getValue();
                                if (VerificadorUtil.naoEstaNulo(ipi.getIPITrib())) {
                                        if (VerificadorUtil.naoEstaNulo(ipi.getIPITrib().getPIPI())) {
                                                Double aliquotaIPITrib = Double.valueOf(ipi.getIPITrib().getPIPI());
                                                if (aliquotaIPITrib > 0.0) {
                                                        this.setAliquotaIPINotaFiscal(aliquotaIPITrib);
                                                }
                                        }
                                }
                        }
                }
                if (VerificadorUtil.estaNulo(getAliquotaIcms())) {
                        this.setAliquotaIcmsNotaFiscal(0.0);
                        this.setAliquotaIcms(ConstantesSEC.NotaFiscal.Imposto.ALIQUOTA_INTERNA_ICMS_PADRAO_12);
                }
               
                if (VerificadorUtil.estaNulo(this.getValorCompra())) {
                        if (VerificadorUtil.naoEstaNulo(produtoNota.getProd().getVUnCom())) {
                                this.setValorCompra(retornarValorComDesconto(produtoNota.getProd()));
                        }
                }
        }
        private void preencherAliquotaIcms(Double aliquotaIcms) {
                if (aliquotaIcms > 0.0) {
                        this.setAliquotaIcmsNotaFiscal(aliquotaIcms);
                        this.setAliquotaIcms(aliquotaIcms);
                } else {
                        this.setAliquotaIcmsNotaFiscal(0.0);
                        this.setAliquotaIcms(ConstantesSEC.NotaFiscal.Imposto.ALIQUOTA_INTERNA_ICMS_PADRAO_12);
                }
        }
       
        public Double retornarValorComDesconto(nfce.java.TNFe.InfNFe.Det.Prod produto) {
                Double valor = 0.0;
                if (VerificadorUtil.naoEstaNuloOuVazio(produto.getVDesc())) {
                        valor = (new Double(produto.getVProd()) - new Double(produto.getVDesc())) / new Double(produto.getQCom()).intValue();
                } else {
                        valor = new Double(produto.getVUnCom());
                }
                return valor;
        }
       
        public Double retornarLucroBruto() {
                if (VerificadorUtil.naoEstaNulo(getValorCompra()) && VerificadorUtil.naoEstaNulo(getValorVarejo())) {
                        if (VerificadorUtil.naoEstaNulo(getValorVarejoPromocional())) {
                                return (getValorVarejoPromocional() / getValorCompra()) - 1.0;
                        } else {
                                return (getValorVarejo() / getValorCompra()) - 1.0;
                        }
                }
                return 0.0;
        }
       
        public Double retornarMargemBruta() {
                if (VerificadorUtil.naoEstaNulo(getValorCompra()) && VerificadorUtil.naoEstaNulo(getValorVarejo())) {
                        if (VerificadorUtil.naoEstaNulo(getValorVarejoPromocional())) {
                                return (100 - (getValorCompra()*100/getValorVarejoPromocional())) / 100;
                        } else {
                                return (100 - (getValorCompra()*100/getValorVarejo())) / 100;
                        }
                }
                return 0.0;
        }
       
        public Double retornarValorMargemBruta() {
                Double margemBruta = retornarMargemBruta();
                if (margemBruta > 0.0) {
                        if (VerificadorUtil.naoEstaNulo(getValorVarejoPromocional())) {
                                return margemBruta * getValorVarejoPromocional();
                        } else {
                                return margemBruta * getValorVarejo();
                        }
                }
                return 0.0;
        }
       
        @Transient
        public String retornarCorMargem() {
                Double margemBruta = retornarMargemBruta();
                if (margemBruta > 0.50) return "green";
                if (margemBruta > 0.34) return "orange";
                if (margemBruta < 0.35) return "red";
                return "black";
        }
       
        @Transient
        public String retornarCorMargemLucro() {
                Double margemBruta = calculoMargemAposCustos();
                if (margemBruta > 29.99) return "green";
                if (margemBruta > 14.99) return "orange";
                if (margemBruta < 15.0) return "red";
                return "black";
        }
       
        @Transient
        public String getFornecedorMenorValorComprado(Fornecedor fornecedorComprar) {
                FornecedorProduto menorValor = null;
                for (FornecedorProduto fornecedorProduto : this.getFornecedores()) {
                        if (menorValor == null) {
                                menorValor = fornecedorProduto;
                        } else {
                                if (VerificadorUtil.estaNulo(menorValor.getValorCompra()) &&
                                                VerificadorUtil.naoEstaNulo(fornecedorProduto.getValorCompra())) {
                                        menorValor = fornecedorProduto;
                                }
                                if (VerificadorUtil.naoEstaNulo(menorValor.getValorCompra()) &&
                                                VerificadorUtil.naoEstaNulo(fornecedorProduto.getValorCompra())) {
                                        if (menorValor.getValorCompra() > fornecedorProduto.getValorCompra()) {
                                                menorValor = fornecedorProduto;
                                        }
                                }
                        }
                }
                String menorValorComprado = "";
                if (VerificadorUtil.naoEstaNulo(menorValor)) {
                        menorValorComprado = "R$ " + formatarValor(menorValor.getValorCompra());
                        if (VerificadorUtil.naoEstaNulo(menorValor.getFornecedor().getNomeDaPessoa())) {
                                if (!menorValor.getFornecedor().equals(fornecedorComprar)) {
                                        menorValorComprado = menorValorComprado + ", " + menorValor.getFornecedor().getNomeDaPessoa();
                                }
                        }
                }
                return menorValorComprado;
        }
       
        private String formatarValor(Double valor) {
                return VerificadorUtil.naoEstaNulo(valor)? String.format("%.2f", valor) : "0,00";
        }
       
        @Override
        public int hashCode() {
                final int prime = 31;
                int result = 1;
                result = prime * result + ((codigo == null) ? 0 : codigo.hashCode());
                result = prime * result + ((sequencial == null) ? 0 : sequencial.hashCode());
                return result;
        }
       
        @Override
        public boolean equals(Object obj) {
                if (this == obj)
                        return true;
                if (obj == null)
                        return false;
                if (getClass() != obj.getClass())
                        return false;
                Produto other = (Produto) obj;
                if (codigo == null) {
                        if (other.codigo != null)
                                return false;
                } else if (!codigo.equals(other.codigo))
                        return false;
                if (sequencial == null) {
                        if (other.sequencial != null)
                                return false;
                } else if (!sequencial.equals(other.sequencial))
                        return false;
                return true;
        }
       
        @Transient
        public void prepararNovoProduto() {
                setAtivo(true);
                setIndicadorFavorito(false);
                setIndicadorComissionado(true);
                setIndicadorEmissaoNotaFiscal(false);
                setSujeitoST(false);
        }
       
        @Transient
        public boolean tipoProdutoEhCapa() {
                return getTipo().equals(TipoProduto.CAPA.getValor());
        }
       
        @Transient
        public boolean tipoProdutoEhPelicula() {
                return getTipo().equals(TipoProduto.PELICULA.getValor());
        }
       
        @Transient
        public boolean tipoProdutoEhCapaOuAcessorio() {
                return tipoProdutoEhCapa() || getTipo().equals(TipoProduto.ACESSORIO.getValor());
        }
       
        @Transient
        public boolean tipoProdutoEhCapaOuPelicula() {
                return tipoProdutoEhCapa() || tipoProdutoEhPelicula();
        }
       
        @Transient
        public boolean tipoProdutoEhServico() {
                return getTipo().equals(TipoProduto.SERVICO.getValor());
        }
       
        /*@Transient
        public boolean tipoProdutoEhRemedioOuOutros() {
                return getTipo().equals(TipoProduto.REMEDIO.getValor()) ||
                                getTipo().equals(TipoProduto.REMEDIO_CARTELA.getValor()) ||
                                getTipo().equals(TipoProduto.OUTROS.getValor());
        }*/
       
        @Transient
        public boolean tipoProdutoTributado() {
                return getTipo().equals(TipoProduto.ACESSORIO.getValor()) ||
                                getTipo().equals(TipoProduto.APARELHOS.getValor()) ||
                                getTipo().equals(TipoProduto.CAPA.getValor()) ||
                                getTipo().equals(TipoProduto.PELICULA.getValor());
        }
       
        @Transient
        public boolean tipoProdutoNaoTributado() {
                return /*getTipo().equals(TipoProduto.REMEDIO.getValor()) ||
                                getTipo().equals(TipoProduto.REMEDIO_CARTELA.getValor()) ||
                                getTipo().equals(TipoProduto.OUTROS.getValor()) ||*/
                                getTipo().equals(TipoProduto.SERVICO.getValor());
        }
       
        @Transient
        public Boolean verificarSeCodigoEhIgual(String codigoProduto) {
                if (codigoProduto.length() > 6 && VerificadorUtil.naoEstaNuloOuVazio(this.getCodigoEAN())) {
                        if (this.getCodigoEAN().equals(codigoProduto)) {
                                return true;
                        }
                }
                if (CodigoBarraEAN.validarCodigoBarras(codigoProduto)) {
                        return this.getCodigoProdutoPadrao().equals(CodigoBarraEAN.retornarCodigoDoCodigoBarras(codigoProduto));
                } else {
                        return this.getCodigoProdutoPadrao().equals(UtilBean.padraoCodigoProduto(codigoProduto));
                }
        }
       
        @Transient
        public String getCodigoNCMDaTributacao() {
                return VerificadorUtil.naoEstaNulo(getTributacao())? getTributacao().getCodigoNCM() : null;
        }
       
        @Transient
        public String getCodigoESTDaTributacao() {
                return VerificadorUtil.naoEstaNulo(getTributacao())? getTributacao().getCodigoEST() : null;
        }
       
        @Override
        public Produto clone() throws CloneNotSupportedException {
                return (Produto) super.clone();
        }
       
        @Transient
        public String corDaDescricaoPeloGenero() {
                if (VerificadorUtil.naoEstaNulo(getGenero())) {
                        if (getGenero().equals(TipoGenero.MASCULINO.getValor())) return "#1c82df";
                        if (getGenero().equals(TipoGenero.FEMININO.getValor())) return "#f06364";
                }
                return "black";
        }
       
        @Transient
        public Boolean getProdutoEmPromocao() {
                if (VerificadorUtil.naoEstaNulo(getValorVarejoPromocional())) {
                        return getValorVarejoPromocional() > 0.00;
                }
                return false;
        }
       
        @Transient
        public void prepararDadosParaDuplicacao(Produto produto) {
                this.modelo = produto.getModelo();
                this.tributacao = produto.getTributacao();
                this.descricao = produto.getDescricao();
                this.tipo = produto.getTipo();
                this.subtipoProduto = produto.getSubtipoProduto();
                this.estilo = produto.getEstilo();
                this.genero = produto.getGenero();
                this.cor = produto.getCor();
                this.observacao = produto.getObservacao();
                this.valorCompra = produto.getValorCompra();
                this.valorVarejo = produto.getValorVarejo();
                this.valorVarejoPromocional = produto.getValorVarejoPromocional();
                this.valorVarejoMaximo = produto.getValorVarejoMaximo();
                this.valorVarejoPopular = produto.getValorVarejoPopular();
                this.valorAtacado = produto.getValorAtacado();
                this.indicadorComissionado = produto.getIndicadorComissionado();
                this.indicadorEmissaoNotaFiscal = produto.getIndicadorEmissaoNotaFiscal();
                this.codigoNCM = produto.getCodigoNCM();
                this.codigoEST = produto.getCodigoEST();
                this.setSujeitoST(produto.getSujeitoST());
                this.setAliquotaIcms(produto.getAliquotaIcms());
                this.setAliquotaIcmsST(produto.getAliquotaIcmsST());
                this.setAliquotaFecoep(produto.getAliquotaFecoep());
                this.setAliquotaIPI(produto.getAliquotaIPI());
                this.setAtivo(true);
        }
       
        @Transient
        public void atualizarAliquotas(Fornecedor fornecedor) {
                if (VerificadorUtil.naoEstaNulo(getTributacao())) {
                        setAliquotaIPI(getTributacao().getAliquotaIPI());
                }
                               
                if (VerificadorUtil.naoEstaNulo(getTributacao())
                                && VerificadorUtil.naoEstaNulo(getAliquotaIcms())
                                && VerificadorUtil.naoEstaNulo(fornecedor)) {
                        if (getTributacao().getSujeitoST() && fornecedor.getSujeitoST()) {
                                setAliquotaIcmsST(getTributacao().mvaPorIcms(getAliquotaIcms()));
                                setAliquotaFecoep(getTributacao().getAliquotaFecoep());
                                setSujeitoST(true);
                        } else {
                                setAliquotaFecoep(null);
                                setAliquotaIcmsST(null);
                                setSujeitoST(false);
                        }
                } else if (VerificadorUtil.naoEstaNulo(getTributacao()) && VerificadorUtil.naoEstaNulo(getAliquotaIcms())) {
                        if (getTributacao().getSujeitoST()) {
                                setAliquotaIcmsST(getTributacao().mvaPorIcms(getAliquotaIcms()));
                                setAliquotaFecoep(getTributacao().getAliquotaFecoep());
                                setSujeitoST(true);
                        } else {
                                setAliquotaFecoep(null);
                                setAliquotaIcmsST(null);
                                setSujeitoST(false);
                        }
                }
        }
       
        @Transient
        public Double calculoIPI() {
                return (VerificadorUtil.naoEstaNulo(getAliquotaIPI()) &&
                                VerificadorUtil.naoEstaNulo(getValorCompra()))?
                                        getAliquotaIPI()/100 * getValorCompra() : 0.0;
        }
       
        @Transient
        public Double calculoICMS() {
                return (VerificadorUtil.naoEstaNulo(getAliquotaIcms()) &&
                                VerificadorUtil.naoEstaNulo(getAliquotaFecoep()) &&
                                VerificadorUtil.naoEstaNulo(getValorCompra()))?
                                (getAliquotaIcms()/100 + getAliquotaFecoep()/100) * getValorCompra() : 0.0;
        }
       
        @Transient
        public Double calculoICMSST() {
                if (getSujeitoST()) {
                        return VerificadorUtil.naoEstaNulo(getAliquotaIcmsST())
                                        && VerificadorUtil.naoEstaNulo(getAliquotaFecoep())
                                        && VerificadorUtil.naoEstaNulo(getTributacao())?
                                ((getTributacao().getAliquotaInterna()/100 + getAliquotaFecoep()/100) * baseCalculoICMSST()) - calculoICMS(): 0.0;
                }
                return 0.0;
        }
       
        @Transient
        public Double baseCalculoICMSST() {
                if (getSujeitoST()) {
                        if (VerificadorUtil.naoEstaNulo(getTributacao())) {
                                Double baseCalculoIPI = getValorCompra() + calculoIPI();
                                return baseCalculoIPI + (baseCalculoIPI * getTributacao().mvaPorIcms(getAliquotaIcms())/100);
                        }
                }
                return 0.0;
        }
       
        @Transient
        public Double aliquotaMvaProduto() {
                return VerificadorUtil.naoEstaNulo(getTributacao())? getTributacao().mvaPorIcms(getAliquotaIcms()) : 0.0;
        }
       
        @Transient
        public Double calculoTributosCompra() {
                 return VerificadorUtil.naoEstaNulo(getValorCompra())? getValorCompra() + calculoIPI() + calculoICMSST() : 0.0;
        }
       
        @Transient
        public List<ProdutoCustosDTO> custosProduto() {
                List<ProdutoCustosDTO> lista = new ArrayList<ProdutoCustosDTO>();
                ProdutoCustosDTO produtoCustosPix = new ProdutoCustosDTO();
                produtoCustosPix.setDescricaoFormaPagamento("PIX");
                produtoCustosPix.setValorVarejo(getValorVarejo());
                produtoCustosPix.setValorSimulacao(getValorVarejoSimulacao());
                produtoCustosPix.setValorCompra(getValorCompra());
                produtoCustosPix.setCustoTributosCompras(calculoTributosCompra());
                produtoCustosPix.setAliquotaMargemMinima(ConstantesSEC.NotaFiscal.Imposto.ALIQUOTA_MARGEM_MINIMA_DEB_PIX_15);
                lista.add(produtoCustosPix);
               
                ProdutoCustosDTO produtoCustosDebito = new ProdutoCustosDTO();
                produtoCustosDebito.setDescricaoFormaPagamento("DÉBITO");
                produtoCustosDebito.setValorVarejo(getValorVarejo());
                produtoCustosDebito.setValorSimulacao(getValorVarejoSimulacao());
                produtoCustosDebito.setValorCompra(getValorCompra());
                produtoCustosDebito.setCustoTributosCompras(calculoTributosCompra());
                produtoCustosDebito.setAliquotaFormaPagamento(ConstantesSEC.NotaFiscal.Imposto.ALIQUOTA_MAIOR_CARTAO_DEB_PIX_1);
                produtoCustosDebito.setAliquotaMargemMinima(ConstantesSEC.NotaFiscal.Imposto.ALIQUOTA_MARGEM_MINIMA_DEB_PIX_15);
                lista.add(produtoCustosDebito);
               
                ProdutoCustosDTO produtoCustosCredito = new ProdutoCustosDTO();
                produtoCustosCredito.setDescricaoFormaPagamento("CRÉDITO À VISTA");
                produtoCustosCredito.setValorVarejo(getValorVarejo());
                produtoCustosCredito.setValorSimulacao(getValorVarejoSimulacao());
                produtoCustosCredito.setValorCompra(getValorCompra());
                produtoCustosCredito.setCustoTributosCompras(calculoTributosCompra());
                produtoCustosCredito.setAliquotaFormaPagamento(ConstantesSEC.NotaFiscal.Imposto.ALIQUOTA_MAIOR_CARTAO_CRED_1X_3);
                produtoCustosCredito.setAliquotaMargemMinima(ConstantesSEC.NotaFiscal.Imposto.ALIQUOTA_MARGEM_MINIMA_CRED_1X_17_5);
                lista.add(produtoCustosCredito);
               
                ProdutoCustosDTO produtoCustosCreditoParcelado = new ProdutoCustosDTO();
                produtoCustosCreditoParcelado.setDescricaoFormaPagamento("PARCELADO");
                produtoCustosCreditoParcelado.setValorVarejo(getValorVarejo());
                produtoCustosCreditoParcelado.setValorSimulacao(getValorVarejoSimulacao());
                produtoCustosCreditoParcelado.setValorCompra(getValorCompra());
                produtoCustosCreditoParcelado.setCustoTributosCompras(calculoTributosCompra());
                produtoCustosCreditoParcelado.setAliquotaFormaPagamento(ConstantesSEC.NotaFiscal.Imposto.ALIQUOTA_MAIOR_CARTAO_PARCELADO_10_88);
                produtoCustosCreditoParcelado.setAliquotaMargemMinima(ConstantesSEC.NotaFiscal.Imposto.ALIQUOTA_MARGEM_MINIMA_PARCELADO_20);
                lista.add(produtoCustosCreditoParcelado);;
                return lista;
        }
       
        @Transient
        public Double calculoOperacao() {
                Double aliquota = ConstantesSEC.NotaFiscal.Imposto.ALIQUOTA_MEDIA_SIMPLES_NACIONAL_11 +
                                                  ConstantesSEC.NotaFiscal.Imposto.ALIQUOTA_MEDIA_COMISSOES_2 +
                                                  ConstantesSEC.NotaFiscal.Imposto.ALIQUOTA_MAIOR_CARTAO_PARCELADO_10_88;
                return VerificadorUtil.naoEstaNulo(getValorVarejoSimulacao())? calculoTributosCompra() + (getValorVarejoSimulacao()*aliquota/100) : 0.0;
        }
       
        @Transient
        public String valorCalculoOperacao() {
                return StringUtil.formatarValor(calculoOperacao());
        }
       
        @Transient
        public Double calculoValorAposCustos() {
                return VerificadorUtil.naoEstaNulo(getValorVarejoSimulacao())? getValorVarejoSimulacao() - calculoOperacao() : 0.0;
        }
       
        @Transient
        public Double calculoMargemAposCustos() {
                return VerificadorUtil.naoEstaNulo(getValorVarejoSimulacao())? calculoValorAposCustos() * 100 / calculoOperacao() : 0.0;
        }
       
        @Transient
        public String retornarLucroBrutoFormatado() {
                return StringUtil.formatarPercentual(calculoValorAposCustos());
        }
       
        @Transient
        public String retornarMargemBrutaFormatada() {
                try {
                        return StringUtil.formatarValorComDigitos(calculoMargemAposCustos().toString(), 2);
                } catch (Exception e) {
                        e.printStackTrace();
                }
                return "";
        }
       
        @Transient
        public Double calculoPrecoMinimo() {
                Double valorVarejoSimulacao = getValorVarejoSimulacao();
                setValorVarejoSimulacao(this.getValorCompra());
                Double valorMinimo = this.calculoOperacao();
                Double margem = 0.0;
                valorMinimo = valorMinimo + (valorMinimo / 100);
                if (valorMinimo > 0.0) {
                        while (margem < 15.0) {
                                valorMinimo = valorMinimo + (valorMinimo / 100);
                                setValorVarejoSimulacao(valorMinimo);
                                margem = calculoMargemAposCustos();
                        }
                }
                setValorVarejoSimulacao(valorVarejoSimulacao);
                return valorMinimo;
        }
       
}