package com.rjconsultores.ventaboletos.web.gui.controladores.catalogos;

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.StringWriter;
import java.math.BigDecimal;
import java.security.InvalidKeyException;
import java.security.KeyFactory;
import java.security.KeyStore;
import java.security.KeyStoreException;
import java.security.NoSuchAlgorithmException;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.Signature;
import java.security.SignatureException;
import java.security.UnrecoverableEntryException;
import java.security.cert.Certificate;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;
import java.security.spec.PKCS8EncodedKeySpec;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Calendar;
import java.util.Date;
import java.util.Enumeration;
import java.util.GregorianCalendar;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import org.apache.commons.codec.binary.Base64;
import org.apache.commons.io.IOUtils;
import org.apache.commons.lang.BooleanUtils;
import org.apache.commons.lang.StringUtils;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.brazilutils.br.cpfcnpj.Cnpj;
import org.brazilutils.br.cpfcnpj.Cpf;
import org.brazilutils.validation.ValidationException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Controller;
import org.zkforge.ckez.CKeditor;
import org.zkoss.util.resource.Labels;
import org.zkoss.zk.ui.Component;
import org.zkoss.zk.ui.Executions;
import org.zkoss.zk.ui.UiException;
import org.zkoss.zk.ui.event.DropEvent;
import org.zkoss.zk.ui.event.Event;
import org.zkoss.zk.ui.event.EventListener;
import org.zkoss.zk.ui.event.InputEvent;
import org.zkoss.zk.ui.event.UploadEvent;
import org.zkoss.zkplus.databind.BindingListModel;
import org.zkoss.zkplus.databind.BindingListModelList;
import org.zkoss.zul.Button;
import org.zkoss.zul.Checkbox;
import org.zkoss.zul.Combobox;
import org.zkoss.zul.Comboitem;
import org.zkoss.zul.Decimalbox;
import org.zkoss.zul.Groupbox;
import org.zkoss.zul.Image;
import org.zkoss.zul.Intbox;
import org.zkoss.zul.Label;
import org.zkoss.zul.Listitem;
import org.zkoss.zul.Messagebox;
import org.zkoss.zul.Radio;
import org.zkoss.zul.Row;
import org.zkoss.zul.Tab;
import org.zkoss.zul.Tabbox;
import org.zkoss.zul.Textbox;
import org.zkoss.zul.Timebox;

import com.rjconsultores.ventaboletos.constantes.ConstantesFuncionSistema;
import com.rjconsultores.ventaboletos.entidad.Categoria;
import com.rjconsultores.ventaboletos.entidad.Ciudad;
import com.rjconsultores.ventaboletos.entidad.ComEmpCategoria;
import com.rjconsultores.ventaboletos.entidad.ComEmpConferencia;
import com.rjconsultores.ventaboletos.entidad.ComEmpFormapago;
import com.rjconsultores.ventaboletos.entidad.ComEmpTipoEventoExtra;
import com.rjconsultores.ventaboletos.entidad.Empresa;
import com.rjconsultores.ventaboletos.entidad.EmpresaAdyenConfig;
import com.rjconsultores.ventaboletos.entidad.EmpresaAsistenciaDeViajeConfig;
import com.rjconsultores.ventaboletos.entidad.EmpresaCertificadoConfig;
import com.rjconsultores.ventaboletos.entidad.EmpresaCieloLinkConfig;
import com.rjconsultores.ventaboletos.entidad.EmpresaComprovantePassagemConfig;
import com.rjconsultores.ventaboletos.entidad.EmpresaConfigLayout;
import com.rjconsultores.ventaboletos.entidad.EmpresaContaBancaria;
import com.rjconsultores.ventaboletos.entidad.EmpresaCrediBancoConfig;
import com.rjconsultores.ventaboletos.entidad.EmpresaEmail;
import com.rjconsultores.ventaboletos.entidad.EmpresaEmailConfig;
import com.rjconsultores.ventaboletos.entidad.EmpresaEmailEComerce;
import com.rjconsultores.ventaboletos.entidad.EmpresaEmailFlexBus;
import com.rjconsultores.ventaboletos.entidad.EmpresaImposto;
import com.rjconsultores.ventaboletos.entidad.EmpresaIziPayConfig;
import com.rjconsultores.ventaboletos.entidad.EmpresaMercadoPagoConfig;
import com.rjconsultores.ventaboletos.entidad.EmpresaNequiConfig;
import com.rjconsultores.ventaboletos.entidad.EmpresaPMArtespConfig;
import com.rjconsultores.ventaboletos.entidad.EmpresaRecargaConfig;
import com.rjconsultores.ventaboletos.entidad.EmpresaSaferConfig;
import com.rjconsultores.ventaboletos.entidad.EmpresaSicfeConfig;
import com.rjconsultores.ventaboletos.entidad.Estado;
import com.rjconsultores.ventaboletos.entidad.FormaPago;
import com.rjconsultores.ventaboletos.entidad.ImpresionLayoutConfig;
import com.rjconsultores.ventaboletos.entidad.InscricaoEstadual;
import com.rjconsultores.ventaboletos.entidad.InstiFinanceira;
import com.rjconsultores.ventaboletos.entidad.OrgaoConcedente;
import com.rjconsultores.ventaboletos.entidad.Parada;
import com.rjconsultores.ventaboletos.entidad.TipoEventoExtra;
import com.rjconsultores.ventaboletos.entidad.TipoVenta;
import com.rjconsultores.ventaboletos.enums.EnumTipoCertificado;
import com.rjconsultores.ventaboletos.enums.EnumTipoIntegracao;
import com.rjconsultores.ventaboletos.enums.TipoCstGratuidade;
import com.rjconsultores.ventaboletos.enums.TipoEmail;
import com.rjconsultores.ventaboletos.enums.TipoOperacaoECommerce;
import com.rjconsultores.ventaboletos.exception.BusinessException;
import com.rjconsultores.ventaboletos.rest.MercadoPagoService;
import com.rjconsultores.ventaboletos.service.CategoriaService;
import com.rjconsultores.ventaboletos.service.CiudadService;
import com.rjconsultores.ventaboletos.service.EmpresaAdyenConfigService;
import com.rjconsultores.ventaboletos.service.EmpresaAsistenciaDeViajeConfigService;
import com.rjconsultores.ventaboletos.service.EmpresaCertificadoConfigService;
import com.rjconsultores.ventaboletos.service.EmpresaCieloLinkService;
import com.rjconsultores.ventaboletos.service.EmpresaComprovantePassagemConfigService;
import com.rjconsultores.ventaboletos.service.EmpresaConfigLayoutService;
import com.rjconsultores.ventaboletos.service.EmpresaCrediBancoConfigService;
import com.rjconsultores.ventaboletos.service.EmpresaEmailConfigService;
import com.rjconsultores.ventaboletos.service.EmpresaEmailEComerceService;
import com.rjconsultores.ventaboletos.service.EmpresaEmailFlexBusService;
import com.rjconsultores.ventaboletos.service.EmpresaEmailService;
import com.rjconsultores.ventaboletos.service.EmpresaImpostoService;
import com.rjconsultores.ventaboletos.service.EmpresaIziPayService;
import com.rjconsultores.ventaboletos.service.EmpresaMercadoPagoConfigService;
import com.rjconsultores.ventaboletos.service.EmpresaNequiConfigService;
import com.rjconsultores.ventaboletos.service.EmpresaPMArtespConfigService;
import com.rjconsultores.ventaboletos.service.EmpresaRecargaService;
import com.rjconsultores.ventaboletos.service.EmpresaSaferConfigService;
import com.rjconsultores.ventaboletos.service.EmpresaService;
import com.rjconsultores.ventaboletos.service.EmpresaSicfeConfigService;
import com.rjconsultores.ventaboletos.service.EstadoService;
import com.rjconsultores.ventaboletos.service.FormaPagoService;
import com.rjconsultores.ventaboletos.service.ImpresionLayoutConfigService;
import com.rjconsultores.ventaboletos.service.InstiFinanceiraService;
import com.rjconsultores.ventaboletos.service.OrgaoConcedenteService;
import com.rjconsultores.ventaboletos.service.TipoEventoExtraService;
import com.rjconsultores.ventaboletos.service.TipoVentaService;
import com.rjconsultores.ventaboletos.utilerias.ApplicationProperties;
import com.rjconsultores.ventaboletos.utilerias.CustomEnum;
import com.rjconsultores.ventaboletos.utilerias.RegistroConDependenciaException;
import com.rjconsultores.ventaboletos.utilerias.SendMail.AuthType;
import com.rjconsultores.ventaboletos.utilerias.UsuarioLogado;
import com.rjconsultores.ventaboletos.vo.mercadopago.PosVO;
import com.rjconsultores.ventaboletos.vo.mercadopago.RetornoPosVO;
import com.rjconsultores.ventaboletos.vo.mercadopago.RetornoStoreVO;
import com.rjconsultores.ventaboletos.vo.mercadopago.StoreVO;
import com.rjconsultores.ventaboletos.web.utilerias.MyCheckboxSiNo;
import com.rjconsultores.ventaboletos.web.utilerias.MyComboboxEstandar;
import com.rjconsultores.ventaboletos.web.utilerias.MyComboboxImpresionLayoutConfig;
import com.rjconsultores.ventaboletos.web.utilerias.MyComboboxParada;
import com.rjconsultores.ventaboletos.web.utilerias.MyGenericForwardComposer;
import com.rjconsultores.ventaboletos.web.utilerias.MyListbox;
import com.rjconsultores.ventaboletos.web.utilerias.MyTextbox;
import com.rjconsultores.ventaboletos.web.utilerias.render.RenderComEmpCategoria;
import com.rjconsultores.ventaboletos.web.utilerias.render.RenderComEmpFormapago;
import com.rjconsultores.ventaboletos.web.utilerias.render.RenderComEmpTipoEventoExtra;
import com.rjconsultores.ventaboletos.web.utilerias.render.RenderEmpresaContaBancaria;
import com.rjconsultores.ventaboletos.web.utilerias.render.RenderEmpresaEmpresaConfigLayout;
import com.rjconsultores.ventaboletos.web.utilerias.render.RenderEmpresaImposto;
import com.rjconsultores.ventaboletos.web.utilerias.render.RenderEmpresaInscricaoEstadual;
import com.rjconsultores.ventaboletos.web.utilerias.render.RenderEmpresaSicfeFormasPagamento;

/**
 *
 * @author Rafius
 */
@Controller("editarEmpresaController")
@Scope("prototype")
@SuppressWarnings({"unused", "rawtypes", "unchecked"})
public class EditarEmpresaController extends MyGenericForwardComposer {

	private static final String TITULO = "editarEmpresaController.window.title";
	private static final long serialVersionUID = 1L;
	private static Logger log = LogManager.getLogger(EditarEmpresaController.class);
	@Autowired
	private EmpresaService empresaService;
	@Autowired
	private EmpresaImpostoService empresaImpostoService;
	@Autowired
	private EstadoService estadoService;
	@Autowired
	private CiudadService ciudadService;
	@Autowired
	private InstiFinanceiraService instFinanceiraService;
	@Autowired
	private CategoriaService categoriaService;
	@Autowired
	private FormaPagoService formaPagoService;
	@Autowired
	private TipoEventoExtraService tipoEventoExtraService;
	@Autowired
	private EmpresaEmailService empresaEmailService;
	@Autowired
	private EmpresaEmailEComerceService empresaEmailEComerceService;
	@Autowired
	private EmpresaEmailConfigService empresaEmailConfigService;
	@Autowired
	private EmpresaEmailFlexBusService empresaEmailFlexBusService;
	@Autowired
	private EmpresaCieloLinkService empresaCieloLinkService;
	@Autowired
	private EmpresaIziPayService empresaIziPayService;
	@Autowired
	private EmpresaRecargaService empresaRecargaService;
	@Autowired
	private EmpresaSaferConfigService empresaSaferConfigService;
	@Autowired
	private EmpresaAdyenConfigService empresaAdyenConfigService;
	@Autowired
	private EmpresaMercadoPagoConfigService empresaMercadoPagoConfigService;
	@Autowired
	private EmpresaCertificadoConfigService empresaCertificadoConfigService;
	@Autowired
	private EmpresaSicfeConfigService empresaSicfeConfigService;
	@Autowired
	private EmpresaCrediBancoConfigService empresaCrediBancoConfigService;
	@Autowired
	private EmpresaNequiConfigService empresaNequiConfigService;
	@Autowired
	private EmpresaAsistenciaDeViajeConfigService empresaAsistenciaDeViajeConfigService;
	@Autowired
	private EmpresaComprovantePassagemConfigService empresaComprovantePassagemConfigService;
	
	@Autowired
	private EmpresaPMArtespConfigService empresaPMArtespConfigService;
	@Autowired
	private OrgaoConcedenteService orgaoConcedenteService;
	@Autowired
	private TipoVentaService tipoVentaService;
	private List<TipoVenta> lsTiposVenta;

	private Empresa empresa;
	private EmpresaEmail empresaEmail;
	private EmpresaEmailEComerce empresaEmailEComerce;
	private EmpresaEmailConfig empresaEmailConfig;
	private EmpresaEmailFlexBus empresaEmailFlexBus;
	private EmpresaCieloLinkConfig empresaCieloLinkConfig;
	private EmpresaIziPayConfig empresaIziPayConfig;
	private EmpresaRecargaConfig empresaRecargaConfig;
	private EmpresaSaferConfig empresaSaferConfig;
	private EmpresaAdyenConfig empresaAdyenConfig;
	private EmpresaMercadoPagoConfig empresaMercadoPagoConfig;
	private EmpresaCertificadoConfig empresaCertificadoConfigSaftao;
	private List<EmpresaSicfeConfig> empresaSicfeConfig;
	private List<EmpresaCrediBancoConfig> empresaCrediBancoConfig;
	private EmpresaNequiConfig empresaNequiConfig;
	private List<EmpresaAsistenciaDeViajeConfig> empresaAsistenciaDeViajeConfig;
	private List<EmpresaComprovantePassagemConfig> empresaComprovantePassagemConfig;
	private MyListbox empresaList;
	private MyTextbox txtNome;
	private MyTextbox txtCNPJ;
	private MyTextbox txtCodantt;
	private MyTextbox txtCodder;
	private Intbox txtCNAE;
	private Textbox txtTAR;
	private Textbox txtCNPJCampoAutorizadora;
	private Textbox textSenhaEmail;
	private Textbox textSMTPHost;
	private Textbox textSMTPPorta;
	private Textbox textEmailDe;
	private Textbox textDestinatario;
	private Textbox textEmailCopiaOculta;
	private Textbox textAssunto;
	private Textbox textAssuntoFiscal;
	private Textbox textEmail;
	private Checkbox chkAutenticacao;
	private MyTextbox txtCodContPrevidencia;
	private Textbox txtApiKeyAdyen;
	private Textbox txtMerchantAccountAdyen;
	private Radio indProducaoAdyenSim;
	private MyComboboxEstandar cmbTipoAutorizacao;

	//FlexBus
	private Checkbox chkAutenticacaoFlexBus;
	private Textbox textSenhaEmailFlexBus;
	private Textbox textSMTPHostFlexBus;
	private Textbox textSMTPPortaFlexBus;
	private Textbox textEmailDeFlexBus;
	private Textbox textDestinatarioFlexBus;
	private Textbox textEmailCopiaOcultaFlexBus;
	private Textbox textAssuntoFlexBus;
	private Textbox textAssuntoFiscalFlexBus;
	private Textbox textEmailFlexBus;
	private CKeditor messageConteudoEmailFlexBus;
	private CKeditor messageCupomEmbarqueFlexBus;
	private MyComboboxEstandar cmbTipoAutorizacaoFlexBus;
	
	//CieloLink
	private Textbox txtClientId;
	private Textbox txtMerchantId;
	private Textbox txtSecret;
	private Textbox txtMinutosCancela;
	private Textbox txtCieloUrl;
	
	//IziPay
	private Textbox txtIziPayClientId;
	private Textbox txtIziPaySecret;
	private Textbox txtIziPayMinutosCancela;
	private Textbox txtIziPayUrl;
	
	//Recarga Celular
	private Textbox txtRecargaClientId;		
	private Textbox txtRecargaSecret;
	
	//eRede
	private Checkbox chkRedeProducao;
	private Textbox txtFiliation;
	private Textbox txtToken;
	
	private Textbox textAssuntoECommerce;
	private Radio rdgFechaVenta;
	private Radio rdgFechaSalida;
	private Radio rdgRestringeZSim;
	private Radio utilizaProjetoFidelidadeSim;
	private MyListbox empresaImpostoList;
	private List<EmpresaImposto> lsEmpresaImposto;
	private Button btnApagar;
	private Button btnAdicionarEstadoImposto;
	private Button btnTestEmail;
	private Combobox cmbIndTipo;
	private Combobox cmbEstado;
	private Combobox cmbEstadoImposto;
	private Combobox cmbCidade;
	private Combobox cmbCRT;
	private List<Estado> lsEstados;
	private List<Estado> lsTodosEstados;
	private List<Ciudad> lsCidades;
	private MyTextbox numtelefono;
	private MyTextbox numTelSACDef;

	private Checkbox chkIndcarboletosdevolvidosconf;
	private Checkbox chkIndBoletoAgrupado;
	private Checkbox chkIndEnviarEmailComissao;
	private Checkbox chkIndnaopermiteconfsemmalote;
	private Checkbox chkIndValidaDescontoTarifa;
	private Checkbox chkIndBloqVdaImpPosterior;
	private Checkbox chkImprimirSegViaTransf;
	private Checkbox chkImprimirCupEmbVendaManual;
	private Checkbox chkPermiteVendaManualTodosEstados;
	private Checkbox chkImprimir2Vias;
	private Checkbox chkIndEmiteBpeVdaImpPosterior;
	private Checkbox chkIndCancelaBpeTrocaOrigDest;
	private Checkbox chkIndTransferenciaBpeMoviCaja;
	private Checkbox chkIndUsarAliasMapaViagemVenda;
	private Checkbox chkOutrasFPVdaCallCenter;
	private Checkbox chkEmiteDABpeVdaCallCenter;
	private Checkbox chkEmiteDABpeVdaInternet;
	private Checkbox chkEmiteDABpeVdaIntJ3;
	private Checkbox chkEmiteDABpeVdaFidelidade;
	private Checkbox chkExigeClienteCompradorVdaCallCenter;
	private Checkbox chkIndEmiteDeclaracaoCancelamentoBpeTrocaOrigDest;
	private Checkbox chkIndSubstituicaoIgualSefaz;
	private Checkbox chkIndReaproveitarNumBPeRejeitado;
	private Checkbox chkImprimeRelFechamentoViagemDetalhadoEmarcada;
	private Checkbox chkImprimeLogoBilheteVendaEmbarcada;
	private Checkbox chkIndCodBarCpEmbarque;
	private Checkbox chkIndEmiteComprovanteCancelamentoSitef;
	private Checkbox chkIndImprimirComprovantePagamentoSeguroOpcional;
	private Checkbox chkIndEncerraViagemFechorllegada;
	private Checkbox chkIndImprimirSeguroOpcionalEntregaVdaImpPosterior;
	private Checkbox chkIndTabelaPrecoEmbarcada;
	private Checkbox chkIndImpressaoCanhotoEmbarcada;
	private Checkbox chkIndImprimeQRCodeAdicional;
	private Checkbox chkIndAlteraPosicaoCamposDocCupomEmbarque;
	private Checkbox chkIndImprimeVoucherPersonalizado;
	private Checkbox chkIndImpComprovanteDeReserva;
	private Checkbox chkIndEnviaDadosAgenciaBpe;
	private Checkbox chkIndSegundaViaFechamentoCaixa;
	private Checkbox chkIndExigeBpeExcessoBagagem;
	private Checkbox chkIndAlertaVDAPosHorarioViagem;
	private Checkbox chkIndConfMovFPTrocaVlrDeposito;
	private Checkbox chkIndComTransfGeraCaja;
	private Checkbox chkIndPricingVendaAberto;
	private MyTextbox txtUrlBaseSeguro;
	private Checkbox chkIndNaoPermiteTrocaEntreEmpresa;
	private Checkbox chkIndHabilitarVendaAbertoMovimentoCaixa;
	private Checkbox cnhIndSeguroOpcionalW2Digital;
	private Checkbox chkIndLimitaCategoriaPorCorrida;
	private Checkbox chkIndHabilitaVendaDeBilheteSemelhante;
	private Checkbox chkIndHabilitaTaxaConvenienciaSomenteVenda;
	private Checkbox chkindImpressaoAposConfAberto;
	
	private Checkbox chkIndHabilitaHoraEmbarque;
	
	private Timebox horaInicioEmbarque;
	private Timebox horaFimEmbarque;
	
	private Checkbox chkIndNaoImprimeCupomEmbarqueVendaEmAberto;
	private Checkbox chkIndNaoImprimeCupomEmbarqueConfirmacaoDeAberto;
	
	private Image imgIndMantemVdaCajaVdaEmbarcada;
	private Checkbox chkIndMantemVdaCajaVdaEmbarcada;
	
	private Radio rdCst00;
	private Radio rdCst40;
	private Radio rdCst41;

	private MyListbox inscEstadualList;
	private MyTextbox txtNumInscricaoMunicipal;
	private Combobox cmbEstadoInscEstadual;
	private MyTextbox txtInscEstadual;
	private Button btnRemoverInscEstadual;
	private Button btnAdicionarInscEstadual;

	private List<InstiFinanceira> lsBanco;
	private Combobox cmbBanco;
	private MyListbox empresaContaBancariaList;
	private Textbox txtNumConta;
	private Textbox txtNumAgencia;
	private Textbox txtNumIntegracion;
	private List<EmpresaContaBancaria> lsEmpresaContaBancaria;
	private Textbox txtInscEstLogradouro;
	private Textbox txtInscEstNumero;
	private Textbox txtInscEstComplemento;
	private Textbox txtInscEstCEP;
	private Textbox txtInscEstBairro;
	private Combobox cmbInscEstCidade;
	private Textbox txtInscEstCNPJ;
	private Textbox txtEquivalenciaAG;
	private Checkbox chkBPe;
	private Checkbox chkFormaPagoOutrosSemDadosCartao;
	private Checkbox chkIndgennumfoliovtaintimpost;
	private Checkbox chkHabilitaIEDescentralizada;
	private Checkbox ckIsento;
	private MyComboboxParada cmbOrigemIEDescentralizada;

	private List<Categoria> lsCategorias;
	private List<FormaPago> lsFormaPagos;
	private List<TipoEventoExtra> lsTipoEventoExtras;

	private MyListbox comEmpCategoriaList;
	private MyListbox comEmpFormapagoList;
	private MyListbox comEmpTipoEventoExtraList;

	private MyComboboxEstandar cmbCategorias;
	private MyComboboxEstandar cmbFormaPagos;
	private MyComboboxEstandar cmbTipoEventoExtras;

	private ComEmpConferencia comEmpConferencia;
	private Checkbox chkIndbilhetemanual;
	private Checkbox chkIndbilhetevendido;
	private Checkbox chkIndbilhetecancelado;
	private Checkbox chkIndbilhetedevolvido;
	private Checkbox chkIndgapvendido;
	private Checkbox chkIndgapcancelado;
	private Checkbox chkIndgapdevolvido;
	private Checkbox chkIndeventosfinanceiros;
	private Checkbox chkIndocd;
	private Checkbox chkObrigarInfNomePassageiro;
	private Checkbox chkPermitirImpressaoGratuidade;
	private Checkbox chkIndBilheteDevDebitoDinheiro;
	private Checkbox chkIndBilheteDevPixDinheiro;
	private Checkbox chkIndCalcGratuiSobreDescTotais;
	private Checkbox chkIndQRCodeFormMarcoReg;
	private Textbox txtEmail;
	private Checkbox chkHabilitarFidelidade;
	private Checkbox chkHabilitarVendaEstudanteTotem;
	private Checkbox chkNaoAlterarDiagrama;
	private Intbox intPontuacaoFraudeIni;
	private Intbox intPontuacaoFraudeFim;
	private Checkbox chkIndEmiteCupomFiscalRemarcacao;

	private Radio rdgTipoDCNenhum;
	private Radio rdgTipoDCTodos;
	private Radio rdgTipoDCDebito;
	private Radio rdgTipoDCCredito;
	private Checkbox chkUtilizaResolucao;
	private Checkbox chkUtilizaFolioVendaPrepagoAberto;
	private Checkbox chkImprime2ViasImpreNaoFiscal;
	private Checkbox chkImprime2ViasDevolucao;
	private Checkbox chkExibeDiferencaMenorTrocaCupomEmbarqueEcf;
	private Checkbox chkPermiteTrocaVdaAberto;
	private Checkbox chkExibeComissaoZeradaAgencia;
	private Checkbox chkPermiteReativacaoPassagemBpeEstacaoNaoBpe;
	private Checkbox chkImprimirEmbarqueDesembarqCupom;
	private Checkbox chkIndSegundaViaSeguroOpcional;
	private Checkbox chkIndJurosCredito;

	private CKeditor messageConteudoEmail;
	private CKeditor messageConteudoEmailFiscal;
	private CKeditor messageCupomEmbarque;
	
	private CKeditor messageConteudoEmailECommerce;
	private CKeditor messageAnexo1Ecommerce;
	
	private CKeditor ckCampoCustomVoucher;
	private Row rowNumFolio;
	
	private Radio radAtivarRateioComissaoGrupoLinhaSim;
	private Radio radAtivarRateioComissaoGrupoLinhaNao;
	private Radio radGrupoLinhasLinhaOriginal;
	private Radio radGrupoLinhasAproveitamentoSeletivo;
	
	private MyTextbox txtCpfCnpj_AutorizadoDowload;
	
	private Decimalbox txtIrkPadrao;
	
	private Label lblCertificado;
	private Textbox txtSenhaCertificado;
	private Textbox txtPartnerId;
	private Textbox txtContractId;
	private byte[] certificado;
	private Tab tabSafer;
	private Checkbox chkIndCheckinBloqueadoNoshow;
	private Checkbox chkIndAgrupamentoLocalidadeConexao;
	
	private Combobox cmbTipoEmail;
	private Combobox cmbTipoOperacao;
	
	private Tabbox tabCallCenter;
	private Tabbox tabECommerce;
    private List<TipoEmail> lsTipoEmail;
    private List<TipoOperacaoECommerce> lsTipoOperacao;
    private Label lblTipoEmail;
    
    private Textbox txtUserIdMercadoPago;
    private Textbox txtTokenMercadoPago;
    private Combobox cmbStoreMercadoPago;
    private Combobox cmbPOSMercadoPago;
    private Textbox txtUrlApiMercadoPago;
 
    private List<StoreVO> lsStoreMercadoPago;
    private List<PosVO> lsPosMercadoPago;
    
    private Textbox txtNomeStore;
    private Textbox txtIdStoreMercadoPago;
    private Textbox txtNomePOS;
    private Textbox txtIdPOSMercadoPago;
    private Combobox cmbCategoriaMercadoPago;
    private Combobox cmbStoreCadastroMercadoPago;
    private Button btnCadastrarStoreMercadoPago;
    private Button btnCadastrarPOSMercadoPago;   
    
    private PosVO posVO;
    private StoreVO storeVO;
    
	private Textbox txtLatitudeLongitude;
	private Textbox txtLatitude;
	private Textbox txtLongitude;
	
	private Textbox txtTokenRJ;
	private Textbox txtLicenca;
	private Button btnDigitarLicenca;
	private Button btnValidarLicenca;
	private boolean cadastroEmpresaNova = false;
	
	private Checkbox chkIndntegracaoAGR;
	
	private Checkbox chkIndCupomEmbarqueSimplificado;
	
	//Integracao PM ARTESP
	private Checkbox chkAtivarIntegracaoPMARTESP;
	private Textbox txtUrlIntegracaoARTESP;
	private Textbox txtTokenIntegracaoARTESP;
	
	private Label lblCertificadoSaftao;
	private Checkbox chkIndSaftao;
	private byte[] certificadoSaftao;
	private Tab tabSaftao;
	
	private Groupbox gbHabilitaSicfe;
	private Checkbox chkIsSicfeHabilitado;
	private Textbox txtRUTSicfe;
	private Textbox txtSicfeTenant;
	private Textbox txtSicfeURL;
	private Textbox txtSicfeUSR;
	private Textbox txtSicfePassword;
	private Intbox txtSicfeFatura;
	private Intbox txtSicfeTicket;
	private Intbox txtSicfeNotaCreditoFatura;
	private Intbox txtSicfeNotaCreditoTicket;
	private Intbox txtSicfeFormaPagoContado;
	private Intbox txtSicfeFormaPagoCredito;
	private Intbox txtSicfeTipoDocRecepcao;
	private Textbox txtSicfePais;
	private Textbox txtSicfeMoeda;
	private Textbox txtSicfeCidade;
	private Textbox txtSicfeDepartamento;
	private Textbox txtSicfeEndereco;
	private Textbox txtSicfeRazaoSocial;
	private Textbox txtSicfeSucursal;
	
	private MyCheckboxSiNo chkSicfeUsaRUTCliente;
	private MyCheckboxSiNo chkSicfeUsaTermica;
	private MyCheckboxSiNo chkSicfeDesconto100Emite;
	private MyCheckboxSiNo chkSicfeCreditoOrdemServico;
	
	private MyListbox empresaFormasPagamentoSicfe;
	private MyListbox empresaFormasPagamentoSicfeSelecionado;
	
	private MyListbox empresaFormasPagamentoSicfeNaoEmite;
	private MyListbox empresaFormasPagamentoSicfeNaoEmiteSelecionado;
	
	private Checkbox chkIndProducaoCrediBanco;
	private Textbox txtUsuarioCrediBanco;
	private Textbox txtSenhaCrediBanco;
	private Textbox txtClientIdCrediBanco;
	private Textbox txtGrantTypeCrediBanco;
	private Textbox txtClientSecretCrediBanco;
	
	private Textbox txtURLAsistenciaViaje;
	private Textbox txtUsuarioAsistenciaViaje;
	private Textbox txtSenhaAsistenciaViaje;
	private Textbox txtClientIdAsistenciaViaje;
	private Textbox txtGrantTypeAsistenciaViaje;
	private Textbox txtClientSecretAsistenciaViaje;
	private MyComboboxEstandar cmbTipoEventoExtrasAsistenciaViaje;
	
	private MyComboboxEstandar cmbTipoDePassagem;
	private MyComboboxEstandar cmbOrgaoConcedente;
	
	private EmpresaPMArtespConfig empresaPMArtespConfig;
	private List<OrgaoConcedente> lsOrgaoConcedente;
	
	private List<EnumTipoIntegracao> lsTipoIntegracao;
	
	private Groupbox gbHabilitaImpressaoComprovante;
	private Checkbox chkIsImpressaoComprovanteHabilitado;
	
	private Groupbox gbHabilitaWhatsAppComprovante;
	private Checkbox chkIsWhatsAppComprovanteHabilitado;
	private Checkbox chkDefaultWhatsApp;
	private Combobox cmbTipoIntegracaoWhatsApp;
	private MyComboboxImpresionLayoutConfig cmbImpresionLayoutConfigWhatsApp;
	
	private Groupbox gbHabilitaSMSComprovante;
	private Checkbox chkIsSMSComprovanteHabilitado;
	private Checkbox chkDefaultSMS;
	private Combobox cmbTipoIntegracaoSMS;
	private MyComboboxImpresionLayoutConfig cmbImpresionLayoutConfigSMS;
	
	private Groupbox gbHabilitaEmailComprovante;
	private Checkbox chkIsEmailComprovanteHabilitado;
	private Checkbox chkDefaultEmail;
	private Combobox cmbTipoIntegracaoEmail;
	private MyComboboxImpresionLayoutConfig cmbImpresionLayoutConfigEmail;
	
	private ImpresionLayoutConfigService impresionLayoutConfigService;
	
	private Combobox cmbConfigLayoutTiposVenda;
	private MyComboboxImpresionLayoutConfig cmbImpresionLayoutConfig;
	private MyListbox empresaLayoutConfigList;
	private Checkbox chkindLayoutEmailConfig;
	private List<EmpresaConfigLayout> lsEmpresaConfigLayout;
	
	private Textbox txtClientIdNequi;
	private Textbox txtApiKeyNequi;
	private Textbox txtCodeEmpresaNequi;
	private Textbox txtUrlNequi;
	private Textbox txtHashNequi;
	
	@Autowired
	private EmpresaConfigLayoutService empresaConfigLayoutService;
	
	private Checkbox chkIndImprimeTaxaEmbarqueNoCupom;

	private static final String EMAIL_PATTERN = "^[_A-Za-z0-9-\\+]+(\\.[_A-Za-z0-9-]+)*@"
			+ "[A-Za-z0-9-]+(\\.[A-Za-z0-9]+)*(\\.[A-Za-z]{2,})$";

	private static final Pattern pattern = Pattern.compile(EditarEmpresaController.EMAIL_PATTERN, Pattern.CASE_INSENSITIVE);

	@Override
	public void doAfterCompose(Component comp) throws Exception {
		lsCategorias = categoriaService.obtenerTodasCategoriasVisibles();
		lsFormaPagos = formaPagoService.obtenerTodos();
		lsTipoEventoExtras = tipoEventoExtraService.obtenerTodos();
		lsOrgaoConcedente = orgaoConcedenteService.obtenerTodos();
		lsTipoIntegracao = Arrays.asList(EnumTipoIntegracao.values());
		
		empresa = (Empresa) Executions.getCurrent().getArg().get("empresa");
		empresaList = (MyListbox) Executions.getCurrent().getArg().get("empresaList");

		lsEstados = estadoService.buscarNotInEmpresaImposto(empresa);
		lsTodosEstados = estadoService.obtenerTodos();
		
		lsCidades = new ArrayList<Ciudad>();
		lsBanco = instFinanceiraService.obtenerTodos();	
		lsTiposVenta = tipoVentaService.obtenerTodos();	

		if (empresa != null && empresa.getEmpresaId() != null) {
			empresaEmail = empresaEmailService.buscarPorEmpresa(empresa);
			empresaEmailConfig = empresaEmailConfigService.buscarPorEmpresa(empresa);
			empresaSaferConfig = empresaSaferConfigService.buscarPorEmpresa(empresa);
			empresaAdyenConfig = empresaAdyenConfigService.buscarPorEmpresa(empresa);
			empresaMercadoPagoConfig = empresaMercadoPagoConfigService.buscarPorEmpresa(empresa);
			empresaCertificadoConfigSaftao = empresaCertificadoConfigService.buscarPorEmpresa(empresa, EnumTipoCertificado.SAFTAO);
			empresaSicfeConfig = empresaSicfeConfigService.buscarByEmpresa(empresa.getEmpresaId());
			empresaCrediBancoConfig = empresaCrediBancoConfigService.buscarByEmpresa(empresa.getEmpresaId());
			empresaNequiConfig = empresaNequiConfigService.buscarByEmpresa(empresa.getEmpresaId());
			empresaAsistenciaDeViajeConfig = empresaAsistenciaDeViajeConfigService.buscarByEmpresa(empresa.getEmpresaId());
			empresaComprovantePassagemConfig = empresaComprovantePassagemConfigService.buscarByEmpresa(empresa.getEmpresaId());
			empresaPMArtespConfig = empresaPMArtespConfigService.buscarPorEmpresa(empresa);
			lsEmpresaConfigLayout = empresaConfigLayoutService.buscarByEmpresa(empresa.getEmpresaId());
		}
		
		if (empresa != null && empresa.getEmpresaId() != null) {
			empresaEmailFlexBus = empresaEmailFlexBusService.buscarPorEmpresa(empresa);
			empresaCieloLinkConfig = empresaCieloLinkService.buscarPorEmpresa(empresa).orElse(null);
			empresaIziPayConfig = empresaIziPayService.buscarPorEmpresa(empresa).orElse(null);
			empresaRecargaConfig = empresaRecargaService.buscarPorEmpresa(empresa).orElse(null);
		}

		super.doAfterCompose(comp);
		
		popularCombobox();
		
		if (empresa != null && empresa.getEmpresaId() != null) {
			TipoOperacaoECommerce tipoOperacaoECommerce = TipoOperacaoECommerce.COMPRA_PASSAGEM;
			empresaEmailEComerce = empresaEmailEComerceService.buscarPorEmpresa(empresa, tipoOperacaoECommerce.getId().toString());
			cmbTipoOperacao.setValue(tipoOperacaoECommerce.getDescricao());
		}
		
		lsTipoEmail = Arrays.asList(TipoEmail.values());
		lsTipoOperacao = Arrays.asList(TipoOperacaoECommerce.values());
		
		this.imgIndMantemVdaCajaVdaEmbarcada.setTooltiptext(Labels.getLabel("editarEmpresaController.mantemVdaCajaVdaEmbarcada.ajuda", new Object[] {"\n"}));

		if (empresa.getEmpresaId() == null) {
			btnAdicionarEstadoImposto.setVisible(false);
			btnAdicionarInscEstadual.setVisible(false);
			
			cadastroEmpresaNova  = true;

		} else {
			btnAdicionarEstadoImposto.setVisible(true);
			btnAdicionarInscEstadual.setVisible(true);
		}
		
		if (empresaEmailConfig != null) {
			if(empresaEmailConfig.getIndAutenticacao()){
				chkAutenticacao.setChecked(true);
				
			}else{
				chkAutenticacao.setChecked(false);
				textEmail.setDisabled(true);
				textSenhaEmail.setDisabled(true);
			}
			
			if(empresaEmailConfig.getTipoAutorizacao() != null){
				cmbTipoAutorizacao.setText(empresaEmailConfig.getTipoAutorizacao());
			}
			
		} else {
			chkAutenticacao.setChecked(true);
		}
		if (empresaEmailFlexBus != null) {
			if(empresaEmailFlexBus.getIndAutenticacao()){
				chkAutenticacaoFlexBus.setChecked(true);
			}else{
				chkAutenticacaoFlexBus.setChecked(false);
				textEmailFlexBus.setDisabled(true);
				textSenhaEmailFlexBus.setDisabled(true);
			}
			if(empresaEmailFlexBus.getTipoAutorizacao() != null){
				cmbTipoAutorizacaoFlexBus.setText(empresaEmailFlexBus.getTipoAutorizacao());
			}
		} else {
			chkAutenticacaoFlexBus.setChecked(true);
		}
		
		if (empresaCieloLinkConfig != null) {
			txtClientId.setText(empresaCieloLinkConfig.getClientId());
			txtMerchantId.setText(empresaCieloLinkConfig.getMerchantId());
			txtSecret.setText(empresaCieloLinkConfig.getSecret());
			txtCieloUrl.setText(empresaCieloLinkConfig.getUrl());			
			txtMinutosCancela.setText(empresaCieloLinkConfig.getMinutosCancela().toString());			
		}
		
		if (empresaIziPayConfig != null) {
			txtIziPayClientId.setText(empresaIziPayConfig.getClientId());
			txtIziPaySecret.setText(empresaIziPayConfig.getSecret());
			txtIziPayUrl.setText(empresaIziPayConfig.getUrl());			
			txtIziPayMinutosCancela.setText(empresaIziPayConfig.getMinutosCancela().toString());			
		}
		
		if (empresaRecargaConfig != null) {
			txtRecargaClientId.setText(empresaRecargaConfig.getClientId());			
			txtRecargaSecret.setText(empresaRecargaConfig.getSecret());
		}
		
		if (empresaSaferConfig != null) {
			txtPartnerId.setText(empresaSaferConfig.getPartnerId());
			txtContractId.setText(empresaSaferConfig.getContractId());
			txtSenhaCertificado.setText(empresaSaferConfig.getSenha());
			certificado = empresaSaferConfig.getCertificado();
			if(certificado != null){
				InputStream certStream = new ByteArrayInputStream(certificado);
				if (certStream != null) {
					lblCertificado.setValue(getCerticateInfo(certStream));
				}
			}
		}
		
		if (empresaCertificadoConfigSaftao != null) {
			certificadoSaftao = empresaCertificadoConfigSaftao.getCertificado();
			if(certificadoSaftao != null){
				InputStream certStream = new ByteArrayInputStream(certificadoSaftao);
				if (certStream != null) {
					lblCertificadoSaftao.setValue(getCerticateInfoSaftao(certStream));
				}
			}
		}
		mostrarAbaSaftao();
		mostrarAbaSafer();
		
		if (empresaAdyenConfig != null) {
			txtApiKeyAdyen.setText(empresaAdyenConfig.getApiKey());
			txtMerchantAccountAdyen.setText(empresaAdyenConfig.getMerchantAccountAdyen());
			if (empresaAdyenConfig.getIndProducao() == null) {
				indProducaoAdyenSim.setChecked(Boolean.FALSE);
			} else if (empresaAdyenConfig.getIndProducao()) {
				indProducaoAdyenSim.setChecked(Boolean.TRUE);
			} else {
				indProducaoAdyenSim.setChecked(Boolean.FALSE);
			}
		}
		
		if (empresaMercadoPagoConfig != null) {
			txtUserIdMercadoPago.setText(empresaMercadoPagoConfig.getUserId());
			txtTokenMercadoPago.setText(empresaMercadoPagoConfig.getToken());
			txtUrlApiMercadoPago.setText(empresaMercadoPagoConfig.getUrlApi());
			carregarConfiguracaoMercadoPago();
		}
		
		if(empresaPMArtespConfig != null) {
			chkAtivarIntegracaoPMARTESP.setChecked(empresaPMArtespConfig.getValidacaoAtiva());
			
			txtUrlIntegracaoARTESP.setText(empresaPMArtespConfig.getUrlApi());
			txtTokenIntegracaoARTESP.setText(empresaPMArtespConfig.getApiKey());
			
			if(empresaPMArtespConfig.getOrgaoConcedente() != null) {
				cmbOrgaoConcedente.setText(empresaPMArtespConfig.getOrgaoConcedente().getDescOrgao());
			}
			
			if(empresaPMArtespConfig.getCategoria() != null) {
				cmbTipoDePassagem.setText(empresaPMArtespConfig.getCategoria().getDesccategoria());
			}
		}

		preencheInformacoesSicfe();
		preencheInformacoesCrediBanco();
		preencheInformacoesNequi();
		preencheInformacoesAsistenciaDeViaje();
		preencheInformacoesComprovantePassagem();
		
		if (empresa.getIndfechatarifa() == null) {
			rdgFechaSalida.setChecked(Boolean.TRUE);
		} else if (empresa.getIndfechatarifa()) {
			rdgFechaVenta.setChecked(Boolean.TRUE);
		} else {
			rdgFechaSalida.setChecked(Boolean.TRUE);
		}

		if (empresa.getIndvalidabloqueioecf() == null) {
			rdgRestringeZSim.setChecked(Boolean.FALSE);
		} else if (empresa.getIndvalidabloqueioecf()) {
			rdgRestringeZSim.setChecked(Boolean.TRUE);
		} else {
			rdgRestringeZSim.setChecked(Boolean.FALSE);
		}

		if (empresa.getIndUtilizaFidelidade() == null) {
			utilizaProjetoFidelidadeSim.setChecked(Boolean.FALSE);
		} else if (empresa.getIndUtilizaFidelidade()) {
			utilizaProjetoFidelidadeSim.setChecked(Boolean.TRUE);
		} else {
			utilizaProjetoFidelidadeSim.setChecked(Boolean.FALSE);
		}
		
		txtLatitudeLongitude.addEventListener("onChanging", new EventListener() {

			@Override
			public void onEvent(Event event) throws Exception {
				if (event instanceof InputEvent) {
					InputEvent inputEvent = (InputEvent) event;
					if (inputEvent.getValue() != null) {
						List<String> coordinates = Arrays.asList(inputEvent.getValue().split("\\s*,\\s*"));
						if (!coordinates.isEmpty() && coordinates.size() == 2) {
							Float latitude = new BigDecimal(coordinates.get(0)).floatValue();
							Float longitude = new BigDecimal(coordinates.get(1)).floatValue();
							txtLatitude.setValue(String.valueOf(latitude));
							txtLongitude.setValue(String.valueOf(longitude));
							txtLatitudeLongitude.setValue(null);
							txtLatitudeLongitude.setText(null);
							empresa.setLatitude(latitude);
							empresa.setLongitude(longitude);
							event.stopPropagation();
						}
					}
				}
			}

		});

		chkIndgennumfoliovtaintimpost.setChecked(BooleanUtils.toBoolean(empresa.getIndgennumfoliovtaintimpost()));
		chkHabilitarFidelidade.setChecked(BooleanUtils.toBoolean(empresa.getIndFidelidade()));
		chkHabilitarVendaEstudanteTotem.setChecked(BooleanUtils.toBoolean(empresa.getIndVendaEstudanteTotem()));
		chkIndBilheteDevDebitoDinheiro.setChecked(BooleanUtils.toBoolean(empresa.getIndBilheteDevDebitoDinheiro()));
		chkIndBilheteDevPixDinheiro.setChecked(BooleanUtils.toBoolean(empresa.getIndBilheteDevPixDinheiro()));
		chkIndCalcGratuiSobreDescTotais.setChecked(BooleanUtils.toBoolean(empresa.getIndCalcGratuiSobreDescTotais()));
		chkIndQRCodeFormMarcoReg.setChecked(BooleanUtils.toBoolean(empresa.getIndQRCodeFormMarcoReg()));
		chkNaoAlterarDiagrama.setChecked(BooleanUtils.toBoolean(empresa.getIndNaoAlterarDiagrama()));
		chkIndEmiteCupomFiscalRemarcacao.setChecked(BooleanUtils.toBoolean(empresa.getIndEmiteCupomFiscalRemarcacao()));
		chkIndEmiteBpeVdaImpPosterior.setChecked(BooleanUtils.toBoolean(empresa.getIndEmiteBpeVdaImpPosterior()));
		chkIndCancelaBpeTrocaOrigDest.setChecked(BooleanUtils.toBoolean(empresa.getIndCancelaBpeTrocaOrigDest()));
		chkIndTransferenciaBpeMoviCaja.setChecked(BooleanUtils.toBoolean(empresa.getIndTransferenciaBpeMoviCaja()));
		chkIndUsarAliasMapaViagemVenda.setChecked(BooleanUtils.toBoolean(empresa.getIndUsarAliasMapaViagem()));
		chkUtilizaResolucao.setChecked(BooleanUtils.toBoolean(empresa.getIndUtilizaResolucao()));
		chkUtilizaFolioVendaPrepagoAberto.setChecked(BooleanUtils.toBoolean(empresa.getIndUtiFolioLocaPrepagoAberto()));
		chkImprime2ViasImpreNaoFiscal.setChecked(BooleanUtils.toBoolean(empresa.getIndImprime2ViasImpreNaoFiscal()));
		chkImprime2ViasDevolucao.setChecked(BooleanUtils.toBoolean(empresa.getIndImprime2ViasDevolucao()));
		chkExibeDiferencaMenorTrocaCupomEmbarqueEcf.setChecked(BooleanUtils.toBoolean(empresa.getIndExibeDiferencaMenorTrocaCupomEmbarqueEcf()));
		chkPermiteTrocaVdaAberto.setChecked(BooleanUtils.toBoolean(empresa.getIndPermiteTrocaVdaAberto()));
		chkExibeComissaoZeradaAgencia.setChecked(BooleanUtils.toBoolean(empresa.getIndExibeComissaoZeradaAgencia()));
		chkPermiteReativacaoPassagemBpeEstacaoNaoBpe.setChecked(BooleanUtils.toBoolean(empresa.getIndPermiteReativacaoPassagemBpeEstacaoNaoBpe()));
		chkImprimirEmbarqueDesembarqCupom.setChecked(BooleanUtils.toBoolean(empresa.getIndImprimirEmbarqueDesembarqCupom()));
		chkEmiteDABpeVdaCallCenter.setChecked(BooleanUtils.toBoolean(empresa.getIndEmiteDABpeVdaCallCenter()));
		chkOutrasFPVdaCallCenter.setChecked(BooleanUtils.toBoolean(empresa.getIndOutrasFPVdaCallCenter()));
		chkEmiteDABpeVdaInternet.setChecked(BooleanUtils.toBoolean(empresa.getIndEmiteDABpeVdaInternet()));
		chkEmiteDABpeVdaIntJ3.setChecked(BooleanUtils.toBoolean(empresa.getIndEmiteDABpeVdaIntJ3()));
		chkEmiteDABpeVdaFidelidade.setChecked(BooleanUtils.toBoolean(empresa.getIndEmiteDABpeVdaFidelidade()));
		chkExigeClienteCompradorVdaCallCenter.setChecked(BooleanUtils.toBoolean(empresa.getIndExigeClienteCompradorVdaCallCenter()));
		chkIndEmiteDeclaracaoCancelamentoBpeTrocaOrigDest.setChecked(BooleanUtils.toBoolean(empresa.getIndEmiteDeclaracaoCancelaBpeTrocaOrigDest()));
		chkIndReaproveitarNumBPeRejeitado.setChecked(BooleanUtils.toBoolean(empresa.getIndReaproveitarNumBPeRejeitado()));
		chkIndSubstituicaoIgualSefaz.setChecked(BooleanUtils.toBoolean(empresa.getIndSubstituicaoIgualSefaz()));
		chkImprimeLogoBilheteVendaEmbarcada.setChecked(BooleanUtils.toBoolean(empresa.getIndImprimeLogoBilheteVendaEmbarcada()));
		chkImprimeRelFechamentoViagemDetalhadoEmarcada.setChecked(BooleanUtils.toBoolean(empresa.getIndImprimeRelFechamentoViagemDetalhadoEmarcada()));
		chkIndCodBarCpEmbarque.setChecked(empresa.getIndCodBarCpEmbarque() != null ? empresa.getIndCodBarCpEmbarque() : Boolean.TRUE);
		chkIndEmiteComprovanteCancelamentoSitef.setChecked(empresa.getIndEmiteComprovanteCancelamentoSitef() != null ? empresa.getIndEmiteComprovanteCancelamentoSitef() : Boolean.TRUE);
		chkIndImprimirComprovantePagamentoSeguroOpcional.setChecked(empresa.getIndImprimirComprovantePagamentoSeguroOpcional() != null ? empresa.getIndImprimirComprovantePagamentoSeguroOpcional() : Boolean.TRUE);
		chkIndEncerraViagemFechorllegada.setChecked(BooleanUtils.toBoolean(empresa.getIndEncerraViagemFechorllegada()));
		chkIndImprimirSeguroOpcionalEntregaVdaImpPosterior.setChecked(BooleanUtils.toBoolean(empresa.getIndImprimirSeguroOpcionalEntregaVdaImpPosterior()));
		chkIndTabelaPrecoEmbarcada.setChecked(BooleanUtils.toBoolean(empresa.getIndTabelaPrecoEmbarcada()));
		chkIndImpressaoCanhotoEmbarcada.setChecked(BooleanUtils.toBoolean(empresa.getIndImpressaoCanhotoEmbarcada()));
		chkIndImprimeQRCodeAdicional.setChecked(BooleanUtils.toBoolean(empresa.getIndImprimeQRCodeAdicional()));
		chkIndImprimeVoucherPersonalizado.setChecked(BooleanUtils.toBoolean(empresa.getIndImprimeVoucherPersonalizado()));
		chkIndImpComprovanteDeReserva.setChecked(BooleanUtils.toBoolean(empresa.getIndImpComprovanteReserva()));
		chkIndAlteraPosicaoCamposDocCupomEmbarque.setChecked(BooleanUtils.toBoolean(empresa.getIndAltPosicaoCamposCupom()));
		ckCampoCustomVoucher.setValue(empresa.getCampoCustomVoucher());
		chkIndEnviaDadosAgenciaBpe.setChecked(BooleanUtils.toBoolean(empresa.getIndEnviaDadosAgenciaBpe()));
		chkIndSegundaViaFechamentoCaixa.setChecked(BooleanUtils.toBoolean(empresa.getIndSegundaViaFechamentoCaixa()));
		chkIndExigeBpeExcessoBagagem.setChecked(BooleanUtils.toBoolean(empresa.getIndExigeBpeExcessoBagagem()));
		chkIndMantemVdaCajaVdaEmbarcada.setChecked(BooleanUtils.toBoolean(empresa.getIndMantemVdaCajaVdaEmbarcada()));
		chkIndAlertaVDAPosHorarioViagem.setChecked(BooleanUtils.toBoolean(empresa.getIndAlertaVDAPosHorarioViagem()));
		chkIndConfMovFPTrocaVlrDeposito.setChecked(BooleanUtils.toBoolean(empresa.getIndConfMovFPTrocaVlrDeposito()));
		chkIndComTransfGeraCaja.setChecked(BooleanUtils.toBoolean(empresa.getIndComTransfGeraCaja()));
		chkIndPricingVendaAberto.setChecked(BooleanUtils.toBoolean(empresa.getIndPricingVendaAberto()));
		chkIndNaoPermiteTrocaEntreEmpresa.setChecked(BooleanUtils.toBoolean(empresa.getIndNaoPermiteTrocaEntreEmpresa()));
		chkIndHabilitarVendaAbertoMovimentoCaixa.setChecked(BooleanUtils.toBoolean(empresa.getIndVendaAbertoMovimentaCaixa()));
		
		chkIndNaoImprimeCupomEmbarqueVendaEmAberto.setChecked(BooleanUtils.toBoolean(empresa.getIndNaoImprimeCupomEmbarqueVendaAberto()));
		chkIndNaoImprimeCupomEmbarqueConfirmacaoDeAberto.setChecked(BooleanUtils.toBoolean(empresa.getIndNaoImprimeCupomEmbarqueConfirmacaoAberto()));
		cnhIndSeguroOpcionalW2Digital.setChecked(BooleanUtils.toBoolean(empresa.getIndSeguroOpcionalW2Digital()));
		chkIndLimitaCategoriaPorCorrida.setChecked(BooleanUtils.toBoolean(empresa.getIndLimitaCategoriaPorCorrida()));
		chkIndCheckinBloqueadoNoshow.setChecked(BooleanUtils.toBoolean(empresa.getIndCheckinBloqueadoRemarcacao()));
		chkIndAgrupamentoLocalidadeConexao.setChecked(BooleanUtils.toBoolean(empresa.getIndAgrupLocConexao()));
		chkIndSegundaViaSeguroOpcional.setChecked(BooleanUtils.toBoolean(empresa.getIndSegundaViaSegOpcional()));
		chkIndJurosCredito.setChecked(BooleanUtils.toBoolean(empresa.getIndJurosCredito()));
		chkIndSaftao.setChecked(BooleanUtils.toBoolean(empresa.getIndSaftao()));
		
		chkIndHabilitaVendaDeBilheteSemelhante.setChecked(BooleanUtils.toBoolean(empresa.getIndVendeDeBilheteSemelhante()));
		chkIndHabilitaTaxaConvenienciaSomenteVenda.setChecked(BooleanUtils.toBoolean(empresa.getIndTaxaConvenienciaSoVenda()));
		chkIndHabilitaHoraEmbarque.setChecked(empresa.getHoraInicioEmbarque() != null && empresa.getHoraFimEmbarque() != null);
		chkIndntegracaoAGR.setChecked(empresa.getIndIntegracaoAGR());
		chkindImpressaoAposConfAberto.setChecked(BooleanUtils.toBoolean(empresa.getIndImpressaoAposConfAberto()));
		txtUrlBaseSeguro.setText(empresa.getUrlBaseEmpresaSeguro());
		chkIndCupomEmbarqueSimplificado.setChecked(BooleanUtils.toBoolean(empresa.getIndCupomEmbarqueSimplificado()));
		chkIndImprimeTaxaEmbarqueNoCupom.setChecked(BooleanUtils.toBoolean(empresa.getIndImprimeTaxaEmbarqueNoCupom()));
		
		lsEmpresaContaBancaria = new ArrayList<EmpresaContaBancaria>();
		empresaContaBancariaList.setItemRenderer(new RenderEmpresaContaBancaria());
		empresaContaBancariaList.addEventListener("onDoubleClick", new EventListener() {
			@Override
			public void onEvent(Event event) throws Exception {
				EmpresaContaBancaria empCB = (EmpresaContaBancaria) empresaContaBancariaList.getSelected();
				editContaBancaria(empCB);
			}
		});

		empresaImpostoList.setItemRenderer(new RenderEmpresaImposto());
		empresaImpostoList.addEventListener("onDoubleClick", new EventListener() {
			@Override
			public void onEvent(Event event) throws Exception {
				EmpresaImposto empresaImposto = (EmpresaImposto) empresaImpostoList.getSelected();
				abrirEmpresaImposto(empresaImposto);
			}
		});

		inscEstadualList.setItemRenderer(new RenderEmpresaInscricaoEstadual());
		inscEstadualList.addEventListener("onDoubleClick", new EventListener() {
			@Override
			public void onEvent(Event event) throws Exception {
				InscricaoEstadual inscricaoEstadual = (InscricaoEstadual) inscEstadualList.getSelected();
				abrirInscricaoEstadual(inscricaoEstadual);
			}
		});
		
		txtNumInscricaoMunicipal.setValue("ISENTO");
		txtNumInscricaoMunicipal.setDisabled(true);
		ckIsento.setChecked(true);
		
		empresaLayoutConfigList.setItemRenderer(new RenderEmpresaEmpresaConfigLayout());
		
		empresaFormasPagamentoSicfe.setItemRenderer(new RenderEmpresaSicfeFormasPagamento());
		empresaFormasPagamentoSicfeSelecionado.setItemRenderer(new RenderEmpresaSicfeFormasPagamento());
		empresaFormasPagamentoSicfe.addEventListener("onDrop", new _DragEvent());
		empresaFormasPagamentoSicfeSelecionado.addEventListener("onDrop", new _DragEvent());
		
		empresaFormasPagamentoSicfeNaoEmite.setItemRenderer(new RenderEmpresaSicfeFormasPagamento());
		empresaFormasPagamentoSicfeNaoEmiteSelecionado.setItemRenderer(new RenderEmpresaSicfeFormasPagamento());
		empresaFormasPagamentoSicfeNaoEmite.addEventListener("onDrop", new _DragEvent());
		empresaFormasPagamentoSicfeNaoEmiteSelecionado.addEventListener("onDrop", new _DragEvent());

		if (empresa.getEmpresaId() != null) {
			empresa = empresaService.obtenerID(empresa.getEmpresaId());
			lsEmpresaImposto = empresaImpostoService.buscarByEmpresa(empresa);
			empresaImpostoList.setData(lsEmpresaImposto);
			inscEstadualList.setData(empresa.getInscricoesEstaduaisActivas());

			// Contas Bancárias das Empresas
			lsEmpresaContaBancaria = empresa.getEmpresaContaBancaria();
			empresaContaBancariaList.setData(lsEmpresaContaBancaria);
			
			//retirar caracteres cnpj - mantis: 16363
			retirarCaracteresEspeciaisCNPJ();
			
			empresaLayoutConfigList.setData(lsEmpresaConfigLayout);
		}

		txtNome.focus();

		if (empresa.getEmpresaId() == null) {
			btnApagar.setVisible(Boolean.FALSE);
		} else {
			Ciudad cidade = empresa.getCidade();
			if (cidade != null) {
				cmbCidade.setText(cidade.getNombciudad());

				Estado estado = cidade.getEstado();
				if (estado != null) {
					cmbEstado.setText(estado.getNombestado());
				}
			}
		}


		comEmpCategoriaList.setItemRenderer(new RenderComEmpCategoria());
		if (empresa.getComEmpCategorias() != null) {
			comEmpCategoriaList.setData(empresa.getComEmpCategorias());
		}

		comEmpFormapagoList.setItemRenderer(new RenderComEmpFormapago());

		if (empresa.getComEmpFormapagos() != null) {
			comEmpFormapagoList.setData(empresa.getComEmpFormapagos());
		}

		comEmpTipoEventoExtraList.setItemRenderer(new RenderComEmpTipoEventoExtra());

		if (empresa.getComEmpTipoEventoExtras() != null) {
			comEmpTipoEventoExtraList.setData(empresa.getComEmpTipoEventoExtras());
		}

		if (empresa.getCrtBPe() == null) {
			empresa.setCrtBPe(3);
		}

		carrergarParametrosComissao();
		
		
		if (!getGeneraNumfoliosistemaVtaInternetImp()) {
			rowNumFolio.setVisible(false);
		}
		
		radAtivarRateioComissaoGrupoLinhaSim.setChecked(Boolean.TRUE.equals(empresa.getIndRateioComissaoGrupoLinha()));
		radAtivarRateioComissaoGrupoLinhaNao.setChecked(!Boolean.TRUE.equals(empresa.getIndRateioComissaoGrupoLinha()));
		radGrupoLinhasLinhaOriginal.setChecked(Boolean.TRUE.equals(empresa.getIndComissaoGrupoLinhaOriginal()));
		radGrupoLinhasAproveitamentoSeletivo.setChecked(!Boolean.TRUE.equals(empresa.getIndComissaoGrupoLinhaOriginal()));
		
		if(empresa.getCstGratuidade() != null) {
			if(TipoCstGratuidade.CST00.equals(empresa.getCstGratuidade())) {
				rdCst00.setChecked(true);
			} else if(TipoCstGratuidade.CST40.equals(empresa.getCstGratuidade())) {
				rdCst40.setChecked(true);
			} else if(TipoCstGratuidade.CST41.equals(empresa.getCstGratuidade())) {
				rdCst41.setChecked(true);
			}
		} else {
			rdCst00.setChecked(true);
		}
		
		ajustarRadioAbaRateioComissao();
	}
	
	public void onClick$btnDigitarLicenca(Event ev) {
		txtLicenca.setDisabled(false);
	}
	public void onClick$btnValidarLicenca(Event ev) throws InterruptedException {
		
		String tokenLicensa = empresaService.validarTokenLicensa(empresa,txtLicenca.getText());
		
		if (StringUtils.isNotBlank(tokenLicensa)){
			txtLicenca.setText(tokenLicensa);
			txtLicenca.setDisabled(true);
			btnValidarLicenca.setDisabled(true);
			btnDigitarLicenca.setDisabled(true);
			empresa.setLicenca(tokenLicensa);
			
			Messagebox.show(Labels.getLabel("editarEmpresaController.MSG.licencaOK"),
					Labels.getLabel(TITULO), Messagebox.OK, Messagebox.INFORMATION);
		}else{
			txtLicenca.setText("");
			Messagebox.show(Labels.getLabel("editarEmpresaController.MSG.licencaNOK"),
					Labels.getLabel(TITULO), Messagebox.OK, Messagebox.ERROR);
		}
	}

	public void onClick$chkAutenticacao(Event ev) {
		if(chkAutenticacao.isChecked()){
			textEmail.setDisabled(false);
			textSenhaEmail.setDisabled(false);			
		}else{
			textEmail.setDisabled(true);
			textSenhaEmail.setDisabled(true);
		}
		
	}

	private void carrergarParametrosComissao() {
		if (empresa.getComEmpConferencias() != null && !empresa.getComEmpConferencias().isEmpty()) {
			comEmpConferencia = empresa.getComEmpConferencias().iterator().next();
			chkIndbilhetemanual.setChecked(comEmpConferencia.getIndbilhetemanual());
			chkIndbilhetevendido.setChecked(comEmpConferencia.getIndbilhetevendido());
			chkIndbilhetecancelado.setChecked(comEmpConferencia.getIndbilhetecancelado());
			chkIndbilhetedevolvido.setChecked(comEmpConferencia.getIndbilhetedevolvido());
			chkIndgapvendido.setChecked(comEmpConferencia.getIndgapvendido());
			chkIndgapcancelado.setChecked(comEmpConferencia.getIndgapcancelado());
			chkIndgapdevolvido.setChecked(comEmpConferencia.getIndgapdevolvido());
			chkIndeventosfinanceiros.setChecked(comEmpConferencia.getIndeventosfinanceiros());
			chkIndocd.setChecked(comEmpConferencia.getIndocd());
			chkIndcarboletosdevolvidosconf.setChecked(empresa.getIndcarboletosdevolvidosconf() == null ? false : empresa.getIndcarboletosdevolvidosconf());
			chkIndBoletoAgrupado.setChecked(empresa.getIndBoletoAgrupado() == null ? false : empresa.getIndBoletoAgrupado());
			chkIndEnviarEmailComissao.setChecked(empresa.getIndenviaemailcomissao() == null ? false : empresa.getIndenviaemailcomissao());
			chkIndnaopermiteconfsemmalote.setChecked(empresa.getIndnaopermiteconfsemmalote() == null ? false : empresa.getIndnaopermiteconfsemmalote());
			chkIndValidaDescontoTarifa.setChecked(empresa.getIndValidaDescontoTarifa() == null ? false : empresa.getIndValidaDescontoTarifa());
			chkIndBloqVdaImpPosterior.setChecked(empresa.getIndBloqVdaImpPosterior() == null ? false : empresa.getIndBloqVdaImpPosterior());
			chkImprimirSegViaTransf.setChecked(empresa.getIndImprimeSegviaTransferencia() == null ? false : empresa.getIndImprimeSegviaTransferencia());
			chkImprimirCupEmbVendaManual.setChecked(empresa.getIndImprimirCupomEmbarqueVendaManual() == null ? false : empresa.getIndImprimirCupomEmbarqueVendaManual());
			chkPermiteVendaManualTodosEstados.setChecked(empresa.getIndPermiteVendaManualTodosEstados() == null ? false : empresa.getIndPermiteVendaManualTodosEstados());
			chkImprimir2Vias.setChecked(empresa.getIndImprime2Vias() == null ? false : empresa.getIndImprime2Vias());
			// chkIndEmiteBpeVdaImpPosterior.setChecked(empresa.getIndEmiteBpeVdaImpPosterior() == null ? false : empresa.getIndEmiteBpeVdaImpPosterior());
			chkObrigarInfNomePassageiro.setChecked(empresa.getIndobrigarinformarnomepassageiro() == null ? false : empresa.getIndobrigarinformarnomepassageiro());
			chkPermitirImpressaoGratuidade.setChecked(empresa.getIndImprimeGratuidade() == null ? false : empresa.getIndImprimeGratuidade());
			if (comEmpConferencia.getTipoDebitoCredito().equals(Integer.valueOf(0))) {
				rdgTipoDCNenhum.setSelected(Boolean.TRUE);
				rdgTipoDCTodos.setSelected(Boolean.FALSE);
				rdgTipoDCDebito.setSelected(Boolean.FALSE);
				rdgTipoDCCredito.setSelected(Boolean.FALSE);
			} else if (comEmpConferencia.getTipoDebitoCredito().equals(Integer.valueOf(1))) {
				rdgTipoDCNenhum.setSelected(Boolean.FALSE);
				rdgTipoDCTodos.setSelected(Boolean.TRUE);
				rdgTipoDCDebito.setSelected(Boolean.FALSE);
				rdgTipoDCCredito.setSelected(Boolean.FALSE);
			} else if (comEmpConferencia.getTipoDebitoCredito().equals(Integer.valueOf(2))) {
				rdgTipoDCNenhum.setSelected(Boolean.FALSE);
				rdgTipoDCTodos.setSelected(Boolean.FALSE);
				rdgTipoDCDebito.setSelected(Boolean.TRUE);
				rdgTipoDCCredito.setSelected(Boolean.FALSE);
			} else if (comEmpConferencia.getTipoDebitoCredito().equals(Integer.valueOf(3))) {
				rdgTipoDCNenhum.setSelected(Boolean.FALSE);
				rdgTipoDCTodos.setSelected(Boolean.FALSE);
				rdgTipoDCDebito.setSelected(Boolean.FALSE);
				rdgTipoDCCredito.setSelected(Boolean.TRUE);
			}
		} else {
			comEmpConferencia = new ComEmpConferencia();
		}
	}

	private void editContaBancaria(EmpresaContaBancaria empCB) {
		if (empCB == null) {
			return;
		}

		Map args = new HashMap();
		args.put("empresaContaBancaria", empCB);
		args.put("empresaContaBancariaList", empresaContaBancariaList);

		openWindow("/gui/catalogos/editarContaBancariaEmpresa.zul",
				Labels.getLabel("editarEmpresaController.contaBancaria.window.title"), args, MyGenericForwardComposer.MODAL);
	}
	
	public void onClick$btnGerarToken(Event ev) throws InterruptedException {
		txtTokenRJ.setText(empresaService.token(empresa));
	}
	
	public void onClick$btnSalvar(Event ev) throws InterruptedException {
		txtNome.getValue();
		cmbIndTipo.getValue();
		txtCNPJ.getValue();
		txtCodantt.getValue();
		txtCodder.getValue();
		txtCNAE.getValue();
		txtTAR.getValue();
		txtCNPJCampoAutorizadora.getValue();
		numtelefono.getValue();
		numTelSACDef.getValue();
		chkIndcarboletosdevolvidosconf.getValue();
		chkIndBoletoAgrupado.getValue();
		chkIndgennumfoliovtaintimpost.getValue();
		chkIndEmiteCupomFiscalRemarcacao.getValue();
		chkIndEmiteBpeVdaImpPosterior.getValue();
		chkIndCancelaBpeTrocaOrigDest.getValue();
		chkIndTransferenciaBpeMoviCaja.getValue();
		chkIndUsarAliasMapaViagemVenda.getValue();
		chkEmiteDABpeVdaCallCenter.getValue();
		chkEmiteDABpeVdaInternet.getValue();
		chkEmiteDABpeVdaIntJ3.getValue();
		chkEmiteDABpeVdaFidelidade.getValue();
		chkOutrasFPVdaCallCenter.getValue();
		chkExibeDiferencaMenorTrocaCupomEmbarqueEcf.getValue();
		chkPermiteTrocaVdaAberto.getValue();
		chkExibeComissaoZeradaAgencia.getValue();
		chkPermiteReativacaoPassagemBpeEstacaoNaoBpe.getValue();
		chkImprimirEmbarqueDesembarqCupom.getValue();
		chkExigeClienteCompradorVdaCallCenter.getValue();
		chkImprimeRelFechamentoViagemDetalhadoEmarcada.getValue();
		chkImprimeLogoBilheteVendaEmbarcada.getValue();
		chkIndCodBarCpEmbarque.getValue();
		chkIndEmiteComprovanteCancelamentoSitef.getValue();
		chkIndImprimirComprovantePagamentoSeguroOpcional.getValue();
		chkIndEncerraViagemFechorllegada.getValue();
		chkIndImprimirSeguroOpcionalEntregaVdaImpPosterior.getValue();
		chkIndTabelaPrecoEmbarcada.getValue();
		chkIndImpressaoCanhotoEmbarcada.getValue();
		chkIndImprimeQRCodeAdicional.getValue();
		chkIndImprimeVoucherPersonalizado.getValue();
		chkIndImpComprovanteDeReserva.getValue();
		chkIndEnviaDadosAgenciaBpe.getValue();
		chkIndAlteraPosicaoCamposDocCupomEmbarque.getValue();
		cmbCRT.getValue();
		chkIndSegundaViaFechamentoCaixa.getValue();
		chkIndExigeBpeExcessoBagagem.getValue();
		chkIndMantemVdaCajaVdaEmbarcada.getValue();
		txtCpfCnpj_AutorizadoDowload.getValue();
		chkIndAlertaVDAPosHorarioViagem.getValue();
		chkIndConfMovFPTrocaVlrDeposito.getValue();
		chkIndComTransfGeraCaja.getValue();
		chkIndPricingVendaAberto.getValue();
		chkIndNaoPermiteTrocaEntreEmpresa.getValue();
		chkIndHabilitarVendaAbertoMovimentoCaixa.getValue();
		chkIndNaoImprimeCupomEmbarqueVendaEmAberto.getValue();
		chkIndNaoImprimeCupomEmbarqueConfirmacaoDeAberto.getValue();
		cnhIndSeguroOpcionalW2Digital.getValue();
		chkIndLimitaCategoriaPorCorrida.getValue();
		chkIndCheckinBloqueadoNoshow.getValue();
		chkIndSegundaViaSeguroOpcional.getValue();
		chkIndJurosCredito.getValue();
		chkIndSaftao.getValue();
		chkIndHabilitaVendaDeBilheteSemelhante.getValue();
		chkIndHabilitaTaxaConvenienciaSomenteVenda.getValue();
		chkIndHabilitaHoraEmbarque.getValue();
		chkIndntegracaoAGR.getValue();
		chkindImpressaoAposConfAberto.getValue();
		
		txtIrkPadrao.getValue();
		rdCst00.getValue();
		rdCst40.getValue();
		rdCst41.getValue();

		if (!validarEmail()) {
			Messagebox.show(Labels.getLabel("editarTipoPuntoVentaController.MSG.emailInvalido"),
					Labels.getLabel(TITULO),
					Messagebox.OK, Messagebox.EXCLAMATION);
			txtEmail.focus();
			return;
		}
		
		if(!validarCPFCNPJ(txtCpfCnpj_AutorizadoDowload.getValue())) {
			txtCpfCnpj_AutorizadoDowload.focus();
			return;
		} else if(StringUtils.isBlank(txtCpfCnpj_AutorizadoDowload.getValue())) {
			empresa.setCpfCnpjAutDownload(null);
		}

		boolean isBPe = false;

		if (empresa.getInscricoesEstaduais() != null) {
			for (InscricaoEstadual ie : empresa.getInscricoesEstaduais()) {
				if (ie.getIsBPe() != null && ie.getIsBPe()) {
					isBPe = true;
					break;
				}
			}
		}

		if (isBPe) {
			if ((empresa.getCnae() == null || empresa.getCnae().isEmpty()) ||
					(empresa.getTarBPe() == null || empresa.getTarBPe().isEmpty()) ||
					(empresa.getCrtBPe() == null)) {
				Messagebox.show(Labels.getLabel("editarEmpresaController.MSG.InfoBPeInvalido"),
						Labels.getLabel(TITULO),
						Messagebox.OK, Messagebox.EXCLAMATION);
				txtEmail.focus();
				return;
			}
		}

		Comboitem cbiCidade = cmbCidade.getSelectedItem();
		if (cbiCidade != null) {
			Ciudad cidade = (Ciudad) cbiCidade.getValue();
			empresa.setCidade(cidade);
		}
		
		if(!isValidosCamposIntegracaoPMArtesp()) {
			return;
		}
		

		try {
			if (empresa.getIndExterna() == null) {
				empresa.setIndExterna(Boolean.FALSE);
			}

			empresa.setIndfechatarifa(rdgFechaVenta.isChecked());
			empresa.setIndvalidabloqueioecf(rdgRestringeZSim.isChecked());
			empresa.setIndUtilizaFidelidade(utilizaProjetoFidelidadeSim.isChecked());
			empresa.setIndcarboletosdevolvidosconf(chkIndcarboletosdevolvidosconf.isChecked());
			empresa.setIndgennumfoliovtaintimpost(chkIndgennumfoliovtaintimpost.isChecked());

			empresa.setIndBoletoAgrupado(chkIndBoletoAgrupado.isChecked());
			empresa.setIndenviaemailcomissao(chkIndEnviarEmailComissao.isChecked());
			empresa.setIndnaopermiteconfsemmalote(chkIndnaopermiteconfsemmalote.isChecked());
			empresa.setIndValidaDescontoTarifa(chkIndValidaDescontoTarifa.isChecked());
			empresa.setIndBloqVdaImpPosterior(chkIndBloqVdaImpPosterior.isChecked());
			empresa.setIndImprimeSegviaTransferencia(chkImprimirSegViaTransf.isChecked());
			empresa.setIndImprimirCupomEmbarqueVendaManual(chkImprimirCupEmbVendaManual.isChecked());
			empresa.setIndPermiteVendaManualTodosEstados(chkPermiteVendaManualTodosEstados.isChecked());
			empresa.setIndImprime2Vias(chkImprimir2Vias.isChecked());

			empresa.setIndobrigarinformarnomepassageiro(chkObrigarInfNomePassageiro.isChecked());
			empresa.setIndImprimeGratuidade(chkPermitirImpressaoGratuidade.isChecked());
			empresa.setIndFidelidade(chkHabilitarFidelidade.isChecked());
			empresa.setIndVendaEstudanteTotem(chkHabilitarVendaEstudanteTotem.isChecked());
			empresa.setIndBilheteDevDebitoDinheiro(chkIndBilheteDevDebitoDinheiro.isChecked());
			empresa.setIndBilheteDevPixDinheiro(chkIndBilheteDevPixDinheiro.isChecked());
			empresa.setIndCalcGratuiSobreDescTotais(chkIndCalcGratuiSobreDescTotais.isChecked());
			empresa.setIndQRCodeFormMarcoReg(chkIndQRCodeFormMarcoReg.isChecked());
			empresa.setIndNaoAlterarDiagrama(chkNaoAlterarDiagrama.isChecked());
			empresa.setIndEmiteCupomFiscalRemarcacao(chkIndEmiteCupomFiscalRemarcacao.isChecked());
			empresa.setIndEmiteBpeVdaImpPosterior(chkIndEmiteBpeVdaImpPosterior.isChecked());
			empresa.setIndCancelaBpeTrocaOrigDest(chkIndCancelaBpeTrocaOrigDest.isChecked());
			empresa.setIndTransferenciaBpeMoviCaja(chkIndTransferenciaBpeMoviCaja.isChecked());
			empresa.setIndUsarAliasMapaViagem(chkIndUsarAliasMapaViagemVenda.isChecked());
			empresa.setIndUtilizaResolucao(chkUtilizaResolucao.isChecked());
			empresa.setIndUtiFolioLocaPrepagoAberto(chkUtilizaFolioVendaPrepagoAberto.isChecked());
			empresa.setIndImprime2ViasImpreNaoFiscal(chkImprime2ViasImpreNaoFiscal.isChecked());
			empresa.setIndImprime2ViasDevolucao(chkImprime2ViasDevolucao.isChecked());
			empresa.setIndExibeDiferencaMenorTrocaCupomEmbarqueEcf(chkExibeDiferencaMenorTrocaCupomEmbarqueEcf.isChecked());
			empresa.setIndPermiteTrocaVdaAberto(chkPermiteTrocaVdaAberto.isChecked());
			empresa.setIndExibeComissaoZeradaAgencia(chkExibeComissaoZeradaAgencia.isChecked());
			empresa.setIndPermiteReativacaoPassagemBpeEstacaoNaoBpe(chkPermiteReativacaoPassagemBpeEstacaoNaoBpe.isChecked());
			empresa.setIndImprimirEmbarqueDesembarqCupom(chkImprimirEmbarqueDesembarqCupom.isChecked());
			empresa.setIndEmiteDABpeVdaCallCenter(chkEmiteDABpeVdaCallCenter.isChecked());
			empresa.setIndOutrasFPVdaCallCenter(chkOutrasFPVdaCallCenter.isChecked());
			empresa.setIndEmiteDABpeVdaInternet(chkEmiteDABpeVdaInternet.isChecked());
			empresa.setIndEmiteDABpeVdaIntJ3(chkEmiteDABpeVdaIntJ3.isChecked());
			empresa.setIndEmiteDABpeVdaFidelidade(chkEmiteDABpeVdaFidelidade.isChecked());
			empresa.setIndExigeClienteCompradorVdaCallCenter(chkExigeClienteCompradorVdaCallCenter.isChecked());
			empresa.setIndEmiteDeclaracaoCancelaBpeTrocaOrigDest(chkIndEmiteDeclaracaoCancelamentoBpeTrocaOrigDest.isChecked());
			empresa.setIndReaproveitarNumBPeRejeitado(chkIndReaproveitarNumBPeRejeitado.isChecked());
			empresa.setIndSubstituicaoIgualSefaz(chkIndSubstituicaoIgualSefaz.isChecked());
			empresa.setIndImprimeLogoBilheteVendaEmbarcada(chkImprimeLogoBilheteVendaEmbarcada.isChecked());
			empresa.setIndImprimeRelFechamentoViagemDetalhadoEmarcada(chkImprimeRelFechamentoViagemDetalhadoEmarcada.isChecked());
			empresa.setIndCodBarCpEmbarque(chkIndCodBarCpEmbarque.isChecked());
			empresa.setIndEmiteComprovanteCancelamentoSitef(chkIndEmiteComprovanteCancelamentoSitef.isChecked());
			empresa.setIndImprimirComprovantePagamentoSeguroOpcional(chkIndImprimirComprovantePagamentoSeguroOpcional.isChecked());
			empresa.setIndEncerraViagemFechorllegada(chkIndEncerraViagemFechorllegada.isChecked());
			empresa.setIndImprimirSeguroOpcionalEntregaVdaImpPosterior(chkIndImprimirSeguroOpcionalEntregaVdaImpPosterior.isChecked());
			empresa.setIndTabelaPrecoEmbarcada(chkIndTabelaPrecoEmbarcada.isChecked());
			empresa.setIndImpressaoCanhotoEmbarcada(chkIndImpressaoCanhotoEmbarcada.isChecked());
			empresa.setIndImprimeQRCodeAdicional(chkIndImprimeQRCodeAdicional.isChecked());
			empresa.setIndImprimeVoucherPersonalizado(chkIndImprimeVoucherPersonalizado.isChecked());
			empresa.setIndImpComprovanteReserva(chkIndImpComprovanteDeReserva.isChecked());
			empresa.setIndAltPosicaoCamposCupom(chkIndAlteraPosicaoCamposDocCupomEmbarque.isChecked());
			empresa.setCampoCustomVoucher(ckCampoCustomVoucher.getValue());
			empresa.setIndEnviaDadosAgenciaBpe(chkIndEnviaDadosAgenciaBpe.isChecked());
			empresa.setIndSegundaViaFechamentoCaixa(chkIndSegundaViaFechamentoCaixa.isChecked());
			empresa.setIndExigeBpeExcessoBagagem(chkIndExigeBpeExcessoBagagem.isChecked());
			empresa.setIndMantemVdaCajaVdaEmbarcada(chkIndMantemVdaCajaVdaEmbarcada.isChecked());
			empresa.setIndAlertaVDAPosHorarioViagem(chkIndAlertaVDAPosHorarioViagem.isChecked());
			empresa.setIndConfMovFPTrocaVlrDeposito(chkIndConfMovFPTrocaVlrDeposito.isChecked());
			empresa.setIndComTransfGeraCaja(chkIndComTransfGeraCaja.isChecked());
			empresa.setIndPricingVendaAberto(chkIndPricingVendaAberto.isChecked());
			empresa.setIndNaoPermiteTrocaEntreEmpresa(chkIndNaoPermiteTrocaEntreEmpresa.isChecked());
			empresa.setIndVendaAbertoMovimentaCaixa(chkIndHabilitarVendaAbertoMovimentoCaixa.isChecked());
			empresa.setIndiceIRK(txtIrkPadrao.getValue());
			
			empresa.setIndNaoImprimeCupomEmbarqueVendaAberto(chkIndNaoImprimeCupomEmbarqueVendaEmAberto.isChecked());
			empresa.setIndNaoImprimeCupomEmbarqueConfirmacaoAberto(chkIndNaoImprimeCupomEmbarqueConfirmacaoDeAberto.isChecked());
			empresa.setIndSeguroOpcionalW2Digital(cnhIndSeguroOpcionalW2Digital.isChecked());
			empresa.setIndLimitaCategoriaPorCorrida(chkIndLimitaCategoriaPorCorrida.isChecked());
			empresa.setIndCheckinBloqueadoRemarcacao(chkIndCheckinBloqueadoNoshow.isChecked());

			empresa.setIndAgrupLocConexao(chkIndAgrupamentoLocalidadeConexao.isChecked());
			empresa.setIndSegundaViaSegOpcional(chkIndSegundaViaSeguroOpcional.isChecked());
			empresa.setIndJurosCredito(chkIndJurosCredito.isChecked());
			empresa.setIndSaftao(chkIndSaftao.isChecked());
			empresa.setIndVendeDeBilheteSemelhante(chkIndHabilitaVendaDeBilheteSemelhante.isChecked());
			empresa.setIndTaxaConvenienciaSoVenda(chkIndHabilitaTaxaConvenienciaSomenteVenda.isChecked());
			empresa.setIndIntegracaoAGR(chkIndntegracaoAGR.isChecked());
			empresa.setIndImpressaoAposConfAberto(chkindImpressaoAposConfAberto.isChecked());
			empresa.setIndCupomEmbarqueSimplificado(chkIndCupomEmbarqueSimplificado.isChecked());
			empresa.setIndImprimeTaxaEmbarqueNoCupom(chkIndImprimeTaxaEmbarqueNoCupom.isChecked());
			
			//Se tiver marcado coloca a hora no embarque na empresa, se não, seta os valores como null
			if(chkIndHabilitaHoraEmbarque.isChecked()) {
				
				Date inicioEmbarque = horaInicioEmbarque.getValue();
				Date fimEmbarque = horaFimEmbarque.getValue();
				
				//Se tiver marcado é necessário preencher as duas datas
				if(inicioEmbarque == null || fimEmbarque == null) {
					Messagebox.show(Labels.getLabel("editarEmpresaController.indHabilitaHorarioEmbarque.erro"),
							Labels.getLabel(TITULO),
							Messagebox.OK, Messagebox.EXCLAMATION);
					return;
				}
				
				if(fimEmbarque.after(inicioEmbarque)) {
					Messagebox.show(Labels.getLabel("editarEmpresaController.indHabilitaHorarioEmbarque.erroInicioAntesDoFInal"),
							Labels.getLabel(TITULO),
							Messagebox.OK, Messagebox.EXCLAMATION);
					return;
				}
				
				empresa.setHoraInicioEmbarque(buscarHora(inicioEmbarque));
				empresa.setHoraFimEmbarque(buscarHora(fimEmbarque));
				
			} else {
				empresa.setHoraInicioEmbarque(null);
				empresa.setHoraFimEmbarque(null);
			}
			
			if(rdCst00.isChecked()) {
				empresa.setCstGratuidade(TipoCstGratuidade.CST00);
			} else if(rdCst40.isChecked()) {
				empresa.setCstGratuidade(TipoCstGratuidade.CST40);
			} else if(rdCst41.isChecked()) {
				empresa.setCstGratuidade(TipoCstGratuidade.CST41);
			}
			
			empresa.setIndRateioComissaoGrupoLinha(radAtivarRateioComissaoGrupoLinhaSim.isChecked());
			if (radGrupoLinhasLinhaOriginal.isDisabled()) {
				empresa.setIndComissaoGrupoLinhaOriginal(null);
			} else {
				empresa.setIndComissaoGrupoLinhaOriginal(radGrupoLinhasLinhaOriginal.isChecked());
			}
			
			carregarComEmpConferencia();
			
			empresaService.suscribirActualizacion(empresa);
			empresaList.updateItem(empresa);
			
			//TODO: Criar validacao se o Flexbus esta liberado para a empresa
			if (empresaEmailFlexBus == null) {
				empresaEmailFlexBus = new EmpresaEmailFlexBus();
				empresaEmailFlexBus.setEmpresa(empresa);
				preencheInformacoesEmpresaEmailFlexBus();
				empresaEmailFlexBus = empresaEmailFlexBusService.suscribir(empresaEmailFlexBus);
			} else {
				preencheInformacoesEmpresaEmailFlexBus();
				empresaEmailFlexBusService.actualizacion(empresaEmailFlexBus);
			}
			
			if (empresaCieloLinkConfig == null) {
				empresaCieloLinkConfig = new EmpresaCieloLinkConfig();
				empresaCieloLinkConfig.setEmpresa(empresa);
				preencheInformacoesCieloLinkConfig();
				empresaCieloLinkConfig = empresaCieloLinkService.suscribir(empresaCieloLinkConfig);
			} else {
				preencheInformacoesCieloLinkConfig();
				empresaCieloLinkService.actualizacion(empresaCieloLinkConfig);
			}
			
			if (empresaIziPayConfig == null) {
				empresaIziPayConfig = new EmpresaIziPayConfig();
				empresaIziPayConfig.setEmpresa(empresa);
				preencheInformacoesIziPayConfig();
				empresaIziPayConfig = empresaIziPayService.suscribir(empresaIziPayConfig);
			} else {
				preencheInformacoesIziPayConfig();
				empresaIziPayService.actualizacion(empresaIziPayConfig);
			}
			
			if (empresaRecargaConfig == null) {
				empresaRecargaConfig = new EmpresaRecargaConfig();
				empresaRecargaConfig.setEmpresa(empresa);
				preencheInformacoesRecargaConfig();
				empresaRecargaConfig = empresaRecargaService.suscribir(empresaRecargaConfig);
			} else {
				preencheInformacoesRecargaConfig();
				empresaRecargaService.actualizacion(empresaRecargaConfig);
			}

			if (empresaEmail == null) {
				empresaEmail = new EmpresaEmail();
				empresaEmail.setEmpresa(empresa);
				preencheInformacoesEmpresaEmail();
				empresaEmail = empresaEmailService.suscribir(empresaEmail);
			} else {
				preencheInformacoesEmpresaEmail();
				empresaEmailService.actualizacion(empresaEmail);
			}

			if (empresaEmailConfig == null) {
				empresaEmailConfig = new EmpresaEmailConfig();
				empresaEmailConfig.setEmpresa(empresa);
				preencheInformacoesEmpresaConfig();
				empresaEmailConfig = empresaEmailConfigService.suscribir(empresaEmailConfig);
			} else {
				preencheInformacoesEmpresaConfig();
				empresaEmailConfigService.actualizacion(empresaEmailConfig);
			}
			
			if (empresaSaferConfig == null) {
				empresaSaferConfig = new EmpresaSaferConfig();
				empresaSaferConfig.setEmpresa(empresa);
				preencheInformacoesSaferConfig();
				empresaSaferConfig = empresaSaferConfigService.suscribir(empresaSaferConfig);
			} else {
				preencheInformacoesSaferConfig();
				empresaSaferConfigService.actualizacion(empresaSaferConfig);
			}
			
			if (empresaEmailEComerce == null) {
				empresaEmailEComerce = new EmpresaEmailEComerce();
				empresaEmailEComerce.setEmpresa(empresa);
				preencheInformacoesEmpresaEmailECommerce();
				empresaEmailEComerce = empresaEmailEComerceService.suscribir(empresaEmailEComerce);
			} else {
				preencheInformacoesEmpresaEmailECommerce();
				empresaEmailEComerceService.actualizacion(empresaEmailEComerce);
			}
			
			if (empresaAdyenConfig == null) {
				empresaAdyenConfig = new EmpresaAdyenConfig();
				empresaAdyenConfig.setEmpresa(empresa);
				empresaAdyenConfig.setApiKey(txtApiKeyAdyen.getValue());
				empresaAdyenConfig.setMerchantAccountAdyen(txtMerchantAccountAdyen.getValue());
				empresaAdyenConfig.setIndProducao(indProducaoAdyenSim.isChecked());
				empresaAdyenConfig = empresaAdyenConfigService.suscribir(empresaAdyenConfig);
			} else {
				empresaAdyenConfig.setEmpresa(empresa);
				empresaAdyenConfig.setApiKey(txtApiKeyAdyen.getValue());
				empresaAdyenConfig.setMerchantAccountAdyen(txtMerchantAccountAdyen.getValue());
				empresaAdyenConfig.setIndProducao(indProducaoAdyenSim.isChecked());
				empresaAdyenConfigService.actualizacion(empresaAdyenConfig);
			}
				    
			if (empresaMercadoPagoConfig == null) {
				empresaMercadoPagoConfig = new EmpresaMercadoPagoConfig();
				empresaMercadoPagoConfig.setEmpresa(empresa);
				empresaMercadoPagoConfig.setUserId(txtUserIdMercadoPago.getValue());
				empresaMercadoPagoConfig.setToken(txtTokenMercadoPago.getValue());
				empresaMercadoPagoConfig.setUrlApi(txtUrlApiMercadoPago.getValue());
				
				if (cmbStoreMercadoPago.getSelectedItem() != null) {
					empresaMercadoPagoConfig.setStore(cmbStoreMercadoPago.getSelectedItem().getValue().toString());
				}
				
				if (cmbPOSMercadoPago.getSelectedItem() != null) {
					empresaMercadoPagoConfig.setPos(cmbPOSMercadoPago.getSelectedItem().getValue().toString());
				}
				
				empresaMercadoPagoConfig = empresaMercadoPagoConfigService.suscribir(empresaMercadoPagoConfig);
				
			} else {
				empresaMercadoPagoConfig.setEmpresa(empresa);
				empresaMercadoPagoConfig.setUserId(txtUserIdMercadoPago.getValue());
				empresaMercadoPagoConfig.setToken(txtTokenMercadoPago.getValue());
				empresaMercadoPagoConfig.setUrlApi(txtUrlApiMercadoPago.getValue());
				
				if (cmbStoreMercadoPago.getSelectedItem() != null) {
					empresaMercadoPagoConfig.setStore(cmbStoreMercadoPago.getSelectedItem().getValue().toString());
				}
				
				if (cmbPOSMercadoPago.getSelectedItem() != null) {
					empresaMercadoPagoConfig.setPos(cmbPOSMercadoPago.getSelectedItem().getValue().toString());
				}

				empresaMercadoPagoConfigService.actualizacion(empresaMercadoPagoConfig);
			}
			
			if (empresaNequiConfig == null) {
				empresaNequiConfig = new EmpresaNequiConfig();
				empresaNequiConfig.setEmpresa(empresa);
				empresaNequiConfig.setClienteIdNequi(txtClientIdNequi.getValue());
				empresaNequiConfig.setApiKey(txtApiKeyNequi.getValue());
				empresaNequiConfig.setCode(txtCodeEmpresaNequi.getValue());
				empresaNequiConfig.setHash(txtHashNequi.getValue());
				empresaNequiConfig.setUrl(txtUrlNequi.getValue());
					
				empresaNequiConfig = empresaNequiConfigService.suscribir(empresaNequiConfig);
			} else {
				empresaNequiConfig.setClienteIdNequi(txtClientIdNequi.getValue());
				empresaNequiConfig.setApiKey(txtApiKeyNequi.getValue());
				empresaNequiConfig.setCode(txtCodeEmpresaNequi.getValue());
				empresaNequiConfig.setHash(txtHashNequi.getValue());
				empresaNequiConfig.setUrl(txtUrlNequi.getValue());
				empresaNequiConfigService.actualizacion(empresaNequiConfig);
			}

					
			adicionaInformacoesSicfe();
			adicionaInformacoesCrediBanco();
			adicionaInformacoesAsistenciaDeViaje();
			adicionaInformacoesComprovantePassagem();
			
			salvarEmpresaConfigLayout();
			
			//INTEGRACAO TIPO DE PASSAGEM PM ARTESP
			salvarEmpresaPMArtespConfig();

			Messagebox.show(Labels.getLabel(MSG_OK),
					Labels.getLabel(TITULO),
					Messagebox.OK, Messagebox.INFORMATION);
			
			if (cadastroEmpresaNova){
				Messagebox.show(
						Labels.getLabel("editarEmpresaController.MSG.tokenNovaEmpresaOK", new String[] {empresa.getToken()}),
						Labels.getLabel(TITULO),
						Messagebox.OK, Messagebox.EXCLAMATION);
			}else{
				
				List<Empresa> lsEmpresa = Arrays.asList(empresa);	
					if (empresaService.filtrarApenasEmpresasLicencaValida(lsEmpresa).isEmpty()){
						Messagebox.show(
								Labels.getLabel("editarEmpresaController.MSG.licencaNOK"),
								Labels.getLabel(TITULO),
								Messagebox.OK, Messagebox.EXCLAMATION);
					}
				
			}

			closeWindow();

		} catch (Exception ex) {
			EditarEmpresaController.log.error("editarEmpresaController: ", ex);

			Messagebox.show(Labels.getLabel(ex.getMessage()),
					Labels.getLabel(TITULO), Messagebox.OK, Messagebox.ERROR);
		}
	}

	private boolean isValidosCamposIntegracaoPMArtesp() throws InterruptedException {
		if(chkAtivarIntegracaoPMARTESP.isChecked()) {

			if(cmbOrgaoConcedente.getSelectedItem() == null || cmbTipoDePassagem.getSelectedItem() == null ||
					txtTokenIntegracaoARTESP.getValue() == null || txtUrlIntegracaoARTESP.getValue() == null) {
				
				Messagebox.show(Labels.getLabel("editarEmpresaController.MSG.InfoCamposIntegracaoPMArtespInvalido"),
						Labels.getLabel(TITULO), Messagebox.OK, Messagebox.EXCLAMATION);
				return false;
			}
		}
		
		return true;
	}

	private void salvarEmpresaPMArtespConfig() {
		boolean atualizar = true;
		
		if(empresaPMArtespConfig == null) {
			empresaPMArtespConfig = new EmpresaPMArtespConfig();
			atualizar = false;
		} 

		empresaPMArtespConfig.setEmpresa(empresa);
		
		if(cmbOrgaoConcedente.getSelectedItem() != null) {
			OrgaoConcedente orgao = (OrgaoConcedente) cmbOrgaoConcedente.getSelectedItem().getValue();
			empresaPMArtespConfig.setOrgaoConcedente(orgao);
		}
		
		if(cmbTipoDePassagem.getSelectedItem() != null) {
			Categoria categoria = (Categoria) cmbTipoDePassagem.getSelectedItem().getValue();
			empresaPMArtespConfig.setCategoria(categoria);
		}
		
		empresaPMArtespConfig.setApiKey(txtTokenIntegracaoARTESP.getValue());
		empresaPMArtespConfig.setUrlApi(txtUrlIntegracaoARTESP.getValue());
		
		empresaPMArtespConfig.setValidacaoAtiva(chkAtivarIntegracaoPMARTESP.isChecked());
		
		if(atualizar) {
			empresaPMArtespConfig = empresaPMArtespConfigService.actualizacion(empresaPMArtespConfig);
		} else {
			empresaPMArtespConfig = empresaPMArtespConfigService.suscribir(empresaPMArtespConfig);
		}
	}

	private void salvarEmpresaConfigLayout() {

		for (EmpresaConfigLayout empresaEmpresaConfigLayoutInTheList : lsEmpresaConfigLayout) {

			if (empresaEmpresaConfigLayoutInTheList != null
					&& empresaEmpresaConfigLayoutInTheList.getEmpresaconfiglayoutId() != null) {
				if (empresaEmpresaConfigLayoutInTheList.getActivo()) {
					empresaConfigLayoutService.actualizacion(empresaEmpresaConfigLayoutInTheList);
				} else {
					empresaConfigLayoutService.borrar(empresaEmpresaConfigLayoutInTheList);
				}

			} else {
				empresaConfigLayoutService.suscribir(empresaEmpresaConfigLayoutInTheList);
			}

		}
	}

	private Date buscarHora(Date horaEmbarque) {
		if (horaEmbarque != null) {
			GregorianCalendar gHoraSalida = new GregorianCalendar();
			gHoraSalida.setTime(horaEmbarque);
			gHoraSalida.set(Calendar.SECOND, 0);
			gHoraSalida.set(Calendar.MILLISECOND, 0);
			gHoraSalida.set(Calendar.MONTH, 01);
			gHoraSalida.set(Calendar.DAY_OF_MONTH, 01);
			gHoraSalida.set(Calendar.YEAR, 1970);
			
			return  gHoraSalida.getTime();
		}
		
		return null;
	}

	private void preencheInformacoesEmpresaConfig() {
		empresaEmailConfig.setSmtpEmail(textEmail.getValue());
		empresaEmailConfig.setSenha(textSenhaEmail.getValue());
		empresaEmailConfig.setSmtp(textSMTPHost.getValue());
		empresaEmailConfig.setSmtpPorta(textSMTPPorta.getValue());
		empresaEmailConfig.setIndAutenticacao(chkAutenticacao.isChecked());
		empresaEmailConfig.setTipoAutorizacao(cmbTipoAutorizacao.getValue());
	}

	private void preencheInformacoesEmpresaEmail() {
		empresaEmail.setEmailDe(textEmailDe.getValue());
		empresaEmail.setDestinatario(textDestinatario.getValue());
		empresaEmail.setAssunto(textAssunto.getValue());
		empresaEmail.setAssuntoFiscal(textAssuntoFiscal.getValue());
		empresaEmail.setTextoCupomEmbarque(messageCupomEmbarque.getValue() != null ? messageCupomEmbarque.getValue() : "");
		empresaEmail.setTextoEmail(messageConteudoEmail.getValue());
		empresaEmail.setTextoEmailFiscal(messageConteudoEmailFiscal.getValue());
	}
	
	private void preencheInformacoesEmpresaEmailECommerce() {
		empresaEmailEComerce.setAssunto(textAssuntoECommerce.getValue());
		empresaEmailEComerce.setAnexo1(messageAnexo1Ecommerce.getValue() != null ? messageAnexo1Ecommerce.getValue() : "");
		empresaEmailEComerce.setTextoEmail(messageConteudoEmailECommerce.getValue());
		
		Comboitem cbiTipoOperacao = cmbTipoOperacao.getSelectedItem();
		if (cbiTipoOperacao != null) {
			TipoOperacaoECommerce tipoOperacao = (TipoOperacaoECommerce) cbiTipoOperacao.getValue();
			empresaEmailEComerce.setTipoOperacao(tipoOperacao.getId().toString());			
		}
		
	}

	private void preencheInformacoesEmpresaEmailFlexBus() {
		empresaEmailFlexBus.setEmailDe(textEmailDeFlexBus.getValue());
		empresaEmailFlexBus.setAssunto(textAssuntoFlexBus.getValue());
		empresaEmailFlexBus.setTextoEmail(messageConteudoEmailFlexBus.getValue());
		empresaEmailFlexBus.setSmtpEmail(textEmailFlexBus.getValue());
		empresaEmailFlexBus.setSenha(textSenhaEmailFlexBus.getValue());
		empresaEmailFlexBus.setSmtp(textSMTPHostFlexBus.getValue());
		empresaEmailFlexBus.setSmtpPorta(textSMTPPortaFlexBus.getValue());
		empresaEmailFlexBus.setIndAutenticacao(chkAutenticacaoFlexBus.isChecked());
		empresaEmailFlexBus.setTipoAutorizacao(cmbTipoAutorizacaoFlexBus.getValue());
	}

	private void preencheInformacoesSaferConfig() {
		empresaSaferConfig.setPartnerId(txtPartnerId.getValue());
		empresaSaferConfig.setContractId(txtContractId.getValue());
		empresaSaferConfig.setSenha(txtSenhaCertificado.getValue());
		empresaSaferConfig.setCertificado(certificado);
	}
	
	private void preencheInformacoesCieloLinkConfig() {
		empresaCieloLinkConfig.setClientId(txtClientId.getValue());
		empresaCieloLinkConfig.setMerchantId(txtMerchantId.getValue());
		empresaCieloLinkConfig.setSecret(txtSecret.getValue());
		empresaCieloLinkConfig.setUrl(txtCieloUrl.getValue());
		
		empresaCieloLinkConfig.setMinutosCancela(
				StringUtils.isEmpty(txtMinutosCancela.getValue())?
						180:
						Integer.parseInt(txtMinutosCancela.getValue())
		);
	}
	
	private void preencheInformacoesIziPayConfig() {
		empresaIziPayConfig.setClientId(txtIziPayClientId.getValue());
		empresaIziPayConfig.setSecret(txtIziPaySecret.getValue());
		empresaIziPayConfig.setUrl(txtIziPayUrl.getValue());
		
		empresaIziPayConfig.setMinutosCancela(
				StringUtils.isEmpty(txtIziPayMinutosCancela.getValue())?
						30:
						Integer.parseInt(txtIziPayMinutosCancela.getValue())
		);
	}
	
	private void preencheInformacoesRecargaConfig() {
		empresaRecargaConfig.setClientId(txtRecargaClientId.getValue());		
		empresaRecargaConfig.setSecret(txtRecargaSecret.getValue());
	}
	
	private void preencheInformacoesSicfe() {
		Map<String, String> mapConfigSicfe = retornaValoresSicfe();
		if (!mapConfigSicfe.isEmpty()) {
			gbHabilitaSicfe.setOpen(BooleanUtils.toBoolean(mapConfigSicfe.get("indHabilitado")));
			chkIsSicfeHabilitado.setChecked(BooleanUtils.toBoolean(mapConfigSicfe.get("indHabilitado")));
			txtRUTSicfe.setText(mapConfigSicfe.get("rut"));
			txtSicfeTenant.setText(mapConfigSicfe.get("tenant"));
			txtSicfeURL.setText(mapConfigSicfe.get("URL"));
			txtSicfeUSR.setText(mapConfigSicfe.get("USR"));
			txtSicfePassword.setText(mapConfigSicfe.get("password"));
			txtSicfeFatura.setText(mapConfigSicfe.get("fatura"));
			txtSicfeTicket.setText(mapConfigSicfe.get("ticket"));
			txtSicfeNotaCreditoFatura.setText(mapConfigSicfe.get("notaCreditoFatura"));
			txtSicfeNotaCreditoTicket.setText(mapConfigSicfe.get("notaCreditoTicket"));
			txtSicfeFormaPagoContado.setText(mapConfigSicfe.get("formaPagoContado"));
			txtSicfeFormaPagoCredito.setText(mapConfigSicfe.get("formaPagoCredito"));
			txtSicfeTipoDocRecepcao.setText(mapConfigSicfe.get("tipoDocRecepcao"));
			txtSicfePais.setText(mapConfigSicfe.get("pais"));
			txtSicfeMoeda.setText(mapConfigSicfe.get("moeda"));
			txtSicfeCidade.setText(mapConfigSicfe.get("cidade"));
			txtSicfeDepartamento.setText(mapConfigSicfe.get("departamento"));
			txtSicfeEndereco.setText(mapConfigSicfe.get("endereco"));
			txtSicfeRazaoSocial.setText(mapConfigSicfe.get("razaoSocial"));
			chkSicfeUsaRUTCliente.setChecked(BooleanUtils.toBoolean(mapConfigSicfe.get("indRUTCliente")));
			chkSicfeUsaTermica.setChecked(BooleanUtils.toBoolean(mapConfigSicfe.get("indUsaTermica")));
			chkSicfeDesconto100Emite.setChecked(BooleanUtils.toBoolean(mapConfigSicfe.get("indDesconto100Emite")));
			txtSicfeSucursal.setText(mapConfigSicfe.get("sucursal"));
		}
		
		String[] valorSelecionado = mapConfigSicfe.get("formasPagoOrdemServico") != null
				? mapConfigSicfe.get("formasPagoOrdemServico").toString().replace("[", "").replace("]", "")
						.replace(" ", "").trim().split(",")
				: null;

		int tamanhoSelecionado = valorSelecionado != null ? valorSelecionado.length : 0;

		Short[] selecionados = new Short[tamanhoSelecionado];

		for (int i = 0; i < tamanhoSelecionado; i++) {
			if (StringUtils.isNotBlank(valorSelecionado[i])) {
				selecionados[i] = Short.valueOf(valorSelecionado[i]);
			} else {
				selecionados[i] = -1;
			}
		}

		empresaFormasPagamentoSicfe.setData(formaPagoService.buscarNotIn(selecionados));

		if (selecionados.length > 0) {
			empresaFormasPagamentoSicfeSelecionado.setData(formaPagoService.buscarIn(selecionados));
		}
		
		String[] valorSelecionadoNaoEmite = mapConfigSicfe.get("formasPagoNaoEmite") != null
				? mapConfigSicfe.get("formasPagoNaoEmite").toString().replace("[", "").replace("]", "")
						.replace(" ", "").trim().split(",")
				: null;

		int tamanhoSelecionadoNaoEmite = valorSelecionadoNaoEmite != null ? valorSelecionadoNaoEmite.length : 0;

		Short[] selecionadosNaoEmite = new Short[tamanhoSelecionadoNaoEmite];

		for (int i = 0; i < tamanhoSelecionadoNaoEmite; i++) {
			if (StringUtils.isNotBlank(valorSelecionadoNaoEmite[i])) {
				selecionadosNaoEmite[i] = Short.valueOf(valorSelecionadoNaoEmite[i]);
			} else {
				selecionadosNaoEmite[i] = -1;
			}
		}

		empresaFormasPagamentoSicfeNaoEmite.setData(formaPagoService.buscarNotIn(selecionadosNaoEmite));

		if (selecionadosNaoEmite.length > 0) {
			empresaFormasPagamentoSicfeNaoEmiteSelecionado.setData(formaPagoService.buscarIn(selecionadosNaoEmite));
		}
	}

	private void adicionaInformacoesSicfe() {
		Map<String, String> mapConfigSicfe = retornaValoresSicfe();
		salvaValoresSicfe("indHabilitado", String.valueOf(chkIsSicfeHabilitado.isChecked()), mapConfigSicfe);
		salvaValoresSicfe("rut", txtRUTSicfe.getValue(), mapConfigSicfe);
		salvaValoresSicfe("tenant", txtSicfeTenant.getValue(), mapConfigSicfe);
		salvaValoresSicfe("URL", txtSicfeURL.getValue(), mapConfigSicfe);
		salvaValoresSicfe("USR", txtSicfeUSR.getValue(), mapConfigSicfe);
		salvaValoresSicfe("password", txtSicfePassword.getValue(), mapConfigSicfe);
		salvaValoresSicfe("fatura", txtSicfeFatura.getValue(), mapConfigSicfe);
		salvaValoresSicfe("ticket", txtSicfeTicket.getValue(), mapConfigSicfe);
		salvaValoresSicfe("notaCreditoFatura", txtSicfeNotaCreditoFatura.getValue(), mapConfigSicfe);
		salvaValoresSicfe("notaCreditoTicket", txtSicfeNotaCreditoTicket.getValue(), mapConfigSicfe);
		salvaValoresSicfe("formaPagoContado", txtSicfeFormaPagoContado.getValue(), mapConfigSicfe);
		salvaValoresSicfe("formaPagoCredito", txtSicfeFormaPagoCredito.getValue(), mapConfigSicfe);
		salvaValoresSicfe("tipoDocRecepcao", txtSicfeTipoDocRecepcao.getValue(), mapConfigSicfe);
		salvaValoresSicfe("pais", txtSicfePais.getValue(), mapConfigSicfe);
		salvaValoresSicfe("moeda", txtSicfeMoeda.getValue(), mapConfigSicfe);
		salvaValoresSicfe("cidade", txtSicfeCidade.getValue(), mapConfigSicfe);
		salvaValoresSicfe("departamento", txtSicfeDepartamento.getValue(), mapConfigSicfe);
		salvaValoresSicfe("endereco", txtSicfeEndereco.getValue(), mapConfigSicfe);
		salvaValoresSicfe("razaoSocial", txtSicfeRazaoSocial.getValue(), mapConfigSicfe);
		salvaValoresSicfe("indRUTCliente", String.valueOf(chkSicfeUsaRUTCliente.isChecked()), mapConfigSicfe);
		salvaValoresSicfe("indUsaTermica", String.valueOf(chkSicfeUsaTermica.isChecked()), mapConfigSicfe);
		salvaValoresSicfe("indDesconto100Emite", String.valueOf(chkSicfeDesconto100Emite.isChecked()), mapConfigSicfe);
		salvaValoresSicfe("formasPagoOrdemServico", Arrays.asList(retornaIdsFormaPagamento(empresaFormasPagamentoSicfeSelecionado.getListData())), mapConfigSicfe);
		salvaValoresSicfe("formasPagoNaoEmite", Arrays.asList(retornaIdsFormaPagamento(empresaFormasPagamentoSicfeNaoEmiteSelecionado.getListData())), mapConfigSicfe);
		salvaValoresSicfe("sucursal", txtSicfeSucursal.getValue(), mapConfigSicfe);
	}
	
	private Map<String, String> retornaValoresSicfe() {
		Map<String, String> map = new HashMap<String, String>();
		if (empresaSicfeConfig != null) {
			for (EmpresaSicfeConfig empresaSicfeConfig : empresaSicfeConfig) {
				map.put(empresaSicfeConfig.getChave(), empresaSicfeConfig.getValor());
			}
		}

		return map;
	}
	
	private void salvaValoresSicfe(String chave, Object valor, Map<String, String> mapConfigSicfe) {

		if (mapConfigSicfe.containsKey(chave)) {
			EmpresaSicfeConfig empresaSicfeConfig = empresaSicfeConfigService.buscarChave(chave,
					empresa.getEmpresaId());
			empresaSicfeConfig.setValor(valor != null ? valor.toString() : null);
			empresaSicfeConfigService.actualizacion(empresaSicfeConfig);
		} else {
			EmpresaSicfeConfig empresaSicfeConfig = new EmpresaSicfeConfig();
			empresaSicfeConfig.setEmpresa(empresa);
			empresaSicfeConfig.setChave(chave);
			empresaSicfeConfig.setValor(valor != null ? valor.toString() : null);
			empresaSicfeConfigService.suscribir(empresaSicfeConfig);
		}

	}
	
	private void preencheInformacoesCrediBanco() {
		Map<String, String> mapConfigCrediBanco = retornaValoresCrediBanco();
		if (!mapConfigCrediBanco.isEmpty()) {
			chkIndProducaoCrediBanco.setChecked(BooleanUtils.toBoolean(mapConfigCrediBanco.get("indProducao")));
			txtUsuarioCrediBanco.setText(mapConfigCrediBanco.get("usuario"));
			txtSenhaCrediBanco.setText(mapConfigCrediBanco.get("senha"));
			txtClientIdCrediBanco.setText(mapConfigCrediBanco.get("clientId"));
			txtGrantTypeCrediBanco.setText(mapConfigCrediBanco.get("grantType"));
			txtClientSecretCrediBanco.setText(mapConfigCrediBanco.get("clientSecret"));
		}
	}
	
	
	
	private void preencheInformacoesNequi() {
		if(empresaNequiConfig!=null) {
			txtClientIdNequi.setValue(empresaNequiConfig.getClienteIdNequi());
			txtApiKeyNequi.setValue(empresaNequiConfig.getApiKey());
			txtCodeEmpresaNequi.setValue(empresaNequiConfig.getCode());
			txtHashNequi.setValue(empresaNequiConfig.getHash());
			txtUrlNequi.setValue(empresaNequiConfig.getUrl());
		}
	}


	private void adicionaInformacoesCrediBanco() {
		Map<String, String> mapConfiCrediBanco = retornaValoresCrediBanco();
		salvaValoresCrediBanco("indProducao", String.valueOf(chkIndProducaoCrediBanco.isChecked()), mapConfiCrediBanco);
		salvaValoresCrediBanco("usuario", txtUsuarioCrediBanco.getValue(), mapConfiCrediBanco);
		salvaValoresCrediBanco("senha", txtSenhaCrediBanco.getValue(), mapConfiCrediBanco);
		salvaValoresCrediBanco("clientId", txtClientIdCrediBanco.getValue(), mapConfiCrediBanco);
		salvaValoresCrediBanco("grantType", txtGrantTypeCrediBanco.getValue(), mapConfiCrediBanco);
		salvaValoresCrediBanco("clientSecret", txtClientSecretCrediBanco.getValue(), mapConfiCrediBanco);
	}
	
	private Map<String, String> retornaValoresCrediBanco() {
		Map<String, String> map = new HashMap<String, String>();
		if (empresaCrediBancoConfig != null) {
			for (EmpresaCrediBancoConfig empresaCrediBancoConfig : empresaCrediBancoConfig) {
				map.put(empresaCrediBancoConfig.getChave(), empresaCrediBancoConfig.getValor());
			}
		}

		return map;
	}

	
	private void salvaValoresCrediBanco(String chave, Object valor, Map<String, String> mapConfigCrediBanco) {

		if (mapConfigCrediBanco.containsKey(chave)) {
			EmpresaCrediBancoConfig empresaCrediBancoConfig = empresaCrediBancoConfigService.buscarChave(chave,
					empresa.getEmpresaId());
			empresaCrediBancoConfig.setValor(valor != null ? valor.toString() : null);
			empresaCrediBancoConfigService.actualizacion(empresaCrediBancoConfig);
		} else {
			EmpresaCrediBancoConfig empresaCrediBancoConfig = new EmpresaCrediBancoConfig();
			empresaCrediBancoConfig.setEmpresa(empresa);
			empresaCrediBancoConfig.setChave(chave);
			empresaCrediBancoConfig.setValor(valor != null ? valor.toString() : null);
			empresaCrediBancoConfigService.suscribir(empresaCrediBancoConfig);
		}

	}
	
	private void preencheInformacoesAsistenciaDeViaje() {
		Map<String, String> mapConfigAsistenciaDeViaje = retornaValoresAsistenciaDeViaje();
		if (!mapConfigAsistenciaDeViaje.isEmpty()) {
			txtURLAsistenciaViaje.setText(mapConfigAsistenciaDeViaje.get("url"));
			txtUsuarioAsistenciaViaje.setText(mapConfigAsistenciaDeViaje.get("usuario"));
			txtSenhaAsistenciaViaje.setText(mapConfigAsistenciaDeViaje.get("senha"));
			txtClientIdAsistenciaViaje.setText(mapConfigAsistenciaDeViaje.get("clientId"));
			txtGrantTypeAsistenciaViaje.setText(mapConfigAsistenciaDeViaje.get("grantType"));
			txtClientSecretAsistenciaViaje.setText(mapConfigAsistenciaDeViaje.get("clientSecret"));
			TipoEventoExtra tipoEventoExtra = mapConfigAsistenciaDeViaje.get("tipoEventoExtra") != null
					? tipoEventoExtraService
							.obtenerID(Integer.valueOf(mapConfigAsistenciaDeViaje.get("tipoEventoExtra")))
					: null;
			if (tipoEventoExtra != null) {
				cmbTipoEventoExtrasAsistenciaViaje.setText(tipoEventoExtra.getDescTipoEvento());
			}
		}
	}

	private void adicionaInformacoesAsistenciaDeViaje() {
		Map<String, String> mapConfiAsistenciaDeViaje = retornaValoresAsistenciaDeViaje();
		salvaValoresAsistenciaDeViaje("url", txtURLAsistenciaViaje.getValue(), mapConfiAsistenciaDeViaje);
		salvaValoresAsistenciaDeViaje("usuario", txtUsuarioAsistenciaViaje.getValue(), mapConfiAsistenciaDeViaje);
		salvaValoresAsistenciaDeViaje("senha", txtSenhaAsistenciaViaje.getValue(), mapConfiAsistenciaDeViaje);
		salvaValoresAsistenciaDeViaje("clientId", txtClientIdAsistenciaViaje.getValue(), mapConfiAsistenciaDeViaje);
		salvaValoresAsistenciaDeViaje("grantType", txtGrantTypeAsistenciaViaje.getValue(), mapConfiAsistenciaDeViaje);
		salvaValoresAsistenciaDeViaje("clientSecret", txtClientSecretAsistenciaViaje.getValue(), mapConfiAsistenciaDeViaje);
		Comboitem selectedItem = cmbTipoEventoExtrasAsistenciaViaje.getSelectedItem();
		if (selectedItem != null) {
			TipoEventoExtra tipoEventoExtra = (TipoEventoExtra) selectedItem.getValue();
			salvaValoresAsistenciaDeViaje("tipoEventoExtra", tipoEventoExtra.getTipoeventoextraId(),
					mapConfiAsistenciaDeViaje);
		} else {
			salvaValoresAsistenciaDeViaje("tipoEventoExtra", null, mapConfiAsistenciaDeViaje);
		}
	}
	
	private Map<String, String> retornaValoresAsistenciaDeViaje() {
		Map<String, String> map = new HashMap<String, String>();
		if (empresaAsistenciaDeViajeConfig != null) {
			for (EmpresaAsistenciaDeViajeConfig empresaAsistenciaDeViajeConfig : empresaAsistenciaDeViajeConfig) {
				map.put(empresaAsistenciaDeViajeConfig.getChave(), empresaAsistenciaDeViajeConfig.getValor());
			}
		}

		return map;
	}
	
	private void salvaValoresAsistenciaDeViaje(String chave, Object valor, Map<String, String> mapConfigAsistenciaDeViaje) {

		if (mapConfigAsistenciaDeViaje.containsKey(chave)) {
			EmpresaAsistenciaDeViajeConfig empresaAsistenciaDeViajeConfig = empresaAsistenciaDeViajeConfigService.buscarChave(chave,
					empresa.getEmpresaId());
			empresaAsistenciaDeViajeConfig.setValor(valor != null ? valor.toString() : null);
			empresaAsistenciaDeViajeConfigService.actualizacion(empresaAsistenciaDeViajeConfig);
		} else {
			EmpresaAsistenciaDeViajeConfig empresaAsistenciaDeViajeConfig = new EmpresaAsistenciaDeViajeConfig();
			empresaAsistenciaDeViajeConfig.setEmpresa(empresa);
			empresaAsistenciaDeViajeConfig.setChave(chave);
			empresaAsistenciaDeViajeConfig.setValor(valor != null ? valor.toString() : null);
			empresaAsistenciaDeViajeConfigService.suscribir(empresaAsistenciaDeViajeConfig);
		}

	}
	
	private void preencheInformacoesComprovantePassagem() {
		Map<String, String> mapConfigComprovantePassagem = retornaValoresComprovantePassagem();
		if (!mapConfigComprovantePassagem.isEmpty()) {

			gbHabilitaWhatsAppComprovante
					.setOpen(BooleanUtils.toBoolean(mapConfigComprovantePassagem.get("indHabilitadoWhatsApp")));
			chkIsWhatsAppComprovanteHabilitado
					.setChecked(BooleanUtils.toBoolean(mapConfigComprovantePassagem.get("indHabilitadoWhatsApp")));
			chkDefaultWhatsApp.setChecked(BooleanUtils.toBoolean(mapConfigComprovantePassagem.get("defaultWhatsApp")));
			if (mapConfigComprovantePassagem.get("tipoIntegracaoWhatsApp") != null) {
				cmbTipoIntegracaoWhatsApp.setText(mapConfigComprovantePassagem.get("tipoIntegracaoWhatsApp"));
			}
			ImpresionLayoutConfig impresionLayoutConfigWhatsApp = mapConfigComprovantePassagem.get("layoutWhatsApp") != null
					? impresionLayoutConfigService
							.obtenerID(Integer.valueOf(mapConfigComprovantePassagem.get("layoutWhatsApp")))
					: null;
			if (impresionLayoutConfigWhatsApp != null) {
				cmbImpresionLayoutConfigWhatsApp.setInitialValue(impresionLayoutConfigWhatsApp);
				cmbImpresionLayoutConfigWhatsApp.setText(impresionLayoutConfigWhatsApp.toString());
			}
			
			gbHabilitaSMSComprovante
					.setOpen(BooleanUtils.toBoolean(mapConfigComprovantePassagem.get("indHabilitadoSMS")));
			chkIsSMSComprovanteHabilitado
					.setChecked(BooleanUtils.toBoolean(mapConfigComprovantePassagem.get("indHabilitadoSMS")));
			chkDefaultSMS.setChecked(BooleanUtils.toBoolean(mapConfigComprovantePassagem.get("defaultSMS")));
			if (mapConfigComprovantePassagem.get("tipoIntegracaoSMS") != null) {
				cmbTipoIntegracaoSMS.setText(mapConfigComprovantePassagem.get("tipoIntegracaoSMS"));
			}
			ImpresionLayoutConfig impresionLayoutConfigSMS = mapConfigComprovantePassagem.get("layoutSMS") != null
					? impresionLayoutConfigService
							.obtenerID(Integer.valueOf(mapConfigComprovantePassagem.get("layoutSMS")))
					: null;
			if (impresionLayoutConfigSMS != null) {
				cmbImpresionLayoutConfigSMS.setInitialValue(impresionLayoutConfigSMS);
				cmbImpresionLayoutConfigSMS.setText(impresionLayoutConfigSMS.toString());
			}

			gbHabilitaEmailComprovante
					.setOpen(BooleanUtils.toBoolean(mapConfigComprovantePassagem.get("indHabilitadoEmail")));
			chkIsEmailComprovanteHabilitado
					.setChecked(BooleanUtils.toBoolean(mapConfigComprovantePassagem.get("indHabilitadoEmail")));
			chkDefaultEmail.setChecked(BooleanUtils.toBoolean(mapConfigComprovantePassagem.get("defaultEmail")));
			if (mapConfigComprovantePassagem.get("tipoIntegracaoEmail") != null) {
				cmbTipoIntegracaoEmail.setText(mapConfigComprovantePassagem.get("tipoIntegracaoEmail"));
			}
			ImpresionLayoutConfig impresionLayoutConfigEmail = mapConfigComprovantePassagem.get("layoutEmail") != null
					? impresionLayoutConfigService
							.obtenerID(Integer.valueOf(mapConfigComprovantePassagem.get("layoutEmail")))
					: null;
			if (impresionLayoutConfigEmail != null) {
				cmbImpresionLayoutConfigEmail.setInitialValue(impresionLayoutConfigEmail);
				cmbImpresionLayoutConfigEmail.setText(impresionLayoutConfigEmail.toString());
			}

		}
	}

	private void adicionaInformacoesComprovantePassagem() {
		Map<String, String> mapConfigComprovantePassagem = retornaValoresComprovantePassagem();
		
		salvaValoresComprovantePassagem("indHabilitadoWhatsApp", String.valueOf(chkIsWhatsAppComprovanteHabilitado.isChecked()), mapConfigComprovantePassagem);
		salvaValoresComprovantePassagem("defaultWhatsApp", String.valueOf(chkDefaultWhatsApp.isChecked()), mapConfigComprovantePassagem);
		salvaValoresComprovantePassagem("tipoIntegracaoWhatsApp", cmbTipoIntegracaoWhatsApp.getText(), mapConfigComprovantePassagem);
		
		Comboitem selectedItemWhatsApp = cmbImpresionLayoutConfigWhatsApp.getSelectedItem();
		if (selectedItemWhatsApp != null) {
			ImpresionLayoutConfig impresionLayoutConfig = (ImpresionLayoutConfig) selectedItemWhatsApp.getValue();
			salvaValoresComprovantePassagem("layoutWhatsApp", impresionLayoutConfig.getImpresionLayoutConfigId(),
					mapConfigComprovantePassagem);
		} else {
			salvaValoresComprovantePassagem("layoutWhatsApp", null, mapConfigComprovantePassagem);
		}
		
		salvaValoresComprovantePassagem("indHabilitadoSMS", String.valueOf(chkIsSMSComprovanteHabilitado.isChecked()), mapConfigComprovantePassagem);
		salvaValoresComprovantePassagem("defaultSMS", String.valueOf(chkDefaultSMS.isChecked()), mapConfigComprovantePassagem);
		salvaValoresComprovantePassagem("tipoIntegracaoSMS", cmbTipoIntegracaoSMS.getText(), mapConfigComprovantePassagem);
		
		Comboitem selectedItemSMS = cmbImpresionLayoutConfigSMS.getSelectedItem();
		if (selectedItemSMS != null) {
			ImpresionLayoutConfig impresionLayoutConfig = (ImpresionLayoutConfig) selectedItemSMS.getValue();
			salvaValoresComprovantePassagem("layoutSMS", impresionLayoutConfig.getImpresionLayoutConfigId(),
					mapConfigComprovantePassagem);
		} else {
			salvaValoresComprovantePassagem("layoutSMS", null, mapConfigComprovantePassagem);
		}
		
		salvaValoresComprovantePassagem("indHabilitadoEmail", String.valueOf(chkIsEmailComprovanteHabilitado.isChecked()), mapConfigComprovantePassagem);
		salvaValoresComprovantePassagem("defaultEmail", String.valueOf(chkDefaultEmail.isChecked()), mapConfigComprovantePassagem);
		salvaValoresComprovantePassagem("tipoIntegracaoEmail", cmbTipoIntegracaoEmail.getText(), mapConfigComprovantePassagem);
		
		Comboitem selectedItemEmail = cmbImpresionLayoutConfigEmail.getSelectedItem();
		if (selectedItemEmail != null) {
			ImpresionLayoutConfig impresionLayoutConfig = (ImpresionLayoutConfig) selectedItemEmail.getValue();
			salvaValoresComprovantePassagem("layoutEmail", impresionLayoutConfig.getImpresionLayoutConfigId(),
					mapConfigComprovantePassagem);
		} else {
			salvaValoresComprovantePassagem("layoutEmail", null, mapConfigComprovantePassagem);
		}
		
	}
	
	private Map<String, String> retornaValoresComprovantePassagem() {
		Map<String, String> map = new HashMap<String, String>();
		if (empresaComprovantePassagemConfig != null) {
			for (EmpresaComprovantePassagemConfig empresaComprovantePassagemConfig : empresaComprovantePassagemConfig) {
				map.put(empresaComprovantePassagemConfig.getChave(), empresaComprovantePassagemConfig.getValor());
			}
		}

		return map;
	}
	
	private void salvaValoresComprovantePassagem(String chave, Object valor, Map<String, String> mapConfigComprovantePassagem) {

		if (mapConfigComprovantePassagem.containsKey(chave)) {
			EmpresaComprovantePassagemConfig empresaComprovantePassagemConfig = empresaComprovantePassagemConfigService.buscarChave(chave,
					empresa.getEmpresaId());
			empresaComprovantePassagemConfig.setValor(valor != null ? valor.toString() : null);
			empresaComprovantePassagemConfigService.actualizacion(empresaComprovantePassagemConfig);
		} else {
			EmpresaComprovantePassagemConfig empresaComprovantePassagemConfig = new EmpresaComprovantePassagemConfig();
			empresaComprovantePassagemConfig.setEmpresa(empresa);
			empresaComprovantePassagemConfig.setChave(chave);
			empresaComprovantePassagemConfig.setValor(valor != null ? valor.toString() : null);
			empresaComprovantePassagemConfigService.suscribir(empresaComprovantePassagemConfig);
		}

	}
	

	private boolean validarEmail() {
		if (txtEmail.getText() == null || txtEmail.getText().isEmpty()) {
			return true;
		}
		for (String email : txtEmail.getText().split(";")) {
			Matcher matcher = EditarEmpresaController.pattern.matcher(email);
			if (!matcher.matches()) {
				return false;
			}
		}
		return true;
	}

	private void carregarComEmpConferencia() {
		getComEmpConferencia().setIndbilhetemanual(chkIndbilhetemanual.isChecked());
		getComEmpConferencia().setIndbilhetevendido(chkIndbilhetevendido.isChecked());
		getComEmpConferencia().setIndbilhetecancelado(chkIndbilhetecancelado.isChecked());
		getComEmpConferencia().setIndbilhetedevolvido(chkIndbilhetedevolvido.isChecked());
		getComEmpConferencia().setIndgapvendido(chkIndgapvendido.isChecked());
		getComEmpConferencia().setIndgapcancelado(chkIndgapcancelado.isChecked());
		getComEmpConferencia().setIndgapdevolvido(chkIndgapdevolvido.isChecked());
		getComEmpConferencia().setIndeventosfinanceiros(chkIndeventosfinanceiros.isChecked());
		getComEmpConferencia().setIndocd(chkIndocd.isChecked());

		int tipoDebitoCredito = 0;

		if (rdgTipoDCTodos.isChecked()) {
			tipoDebitoCredito = 1;
		} else if (rdgTipoDCDebito.isChecked()) {
			tipoDebitoCredito = 2;
		} else if (rdgTipoDCCredito.isChecked()) {
			tipoDebitoCredito = 3;
		}

		getComEmpConferencia().setTipoDebitoCredito(tipoDebitoCredito);

		empresa.setComEmpConferencias(new ArrayList<ComEmpConferencia>());
		empresa.getComEmpConferencias().add(getComEmpConferencia());
	}

	public String replaceTextbox(Textbox textbox) {
		String getString = textbox.getValue();
		getString = getString.replace("(", "");
		getString = getString.replaceAll("_", "");
		getString = getString.replace(")", "");
		getString = getString.replace("-", "");

		return getString;
	}

	public void onClick$btnApagar(Event ev) throws InterruptedException {

		int resp = Messagebox.show(
				Labels.getLabel("editarEmpresaController.MSG.borrarPergunta"),
				Labels.getLabel(TITULO),
				Messagebox.YES | Messagebox.NO, Messagebox.QUESTION);

		if (resp == Messagebox.YES) {

			try {
				empresaService.borrar(empresa);
			} catch (RegistroConDependenciaException e) {
				Messagebox.show(
						Labels.getLabel("editarEmpresaController.MSG.noPuedeBorrar"),
						Labels.getLabel(TITULO),
						Messagebox.OK, Messagebox.INFORMATION);
				return;

			}

			Messagebox.show(
					Labels.getLabel("editarEmpresaController.MSG.borrarOK"),
					Labels.getLabel(TITULO),
					Messagebox.OK, Messagebox.INFORMATION);

			empresaList.removeItem(empresa);

			closeWindow();
		}
	}
	
	public void onClick$btnTestEmail(Event ev) throws InterruptedException {
		
		Map args = new HashMap();
		args.put("empresa", empresa);
		args.put("isAutenticacao", chkAutenticacao.isChecked());
		args.put("emailSMTP", textEmail.getValue());
		args.put("senhaEmail", textSenhaEmail.getValue());
		args.put("SMTPHost", textSMTPHost.getValue());
		args.put("SMTPPorta", textSMTPPorta.getValue());
		args.put("emailDe", textEmailDe.getValue());
		args.put("emailCopiaOculta", textEmailCopiaOculta.getValue());
		args.put("destinatario", textDestinatario.getValue());
		args.put("tipoAutorizacao", cmbTipoAutorizacao.getValue());

		openWindow("/gui/catalogos/viewTestEmail.zul",
				Labels.getLabel("viewTestEmailController.window.title"), args, MODAL);

	}
	
public void onClick$btnTestEmailFlexBus(Event ev) throws InterruptedException {
		Map args = new HashMap();
		args.put("empresa", empresa);
		args.put("isAutenticacao", chkAutenticacaoFlexBus.isChecked());
		args.put("emailSMTP", textEmailFlexBus.getValue());
		args.put("senhaEmail", textSenhaEmailFlexBus.getValue());
		args.put("SMTPHost", textSMTPHostFlexBus.getValue());
		args.put("SMTPPorta", textSMTPPortaFlexBus.getValue());
		args.put("emailDe", textEmailDeFlexBus.getValue());
		args.put("emailCopiaOculta", textEmailCopiaOcultaFlexBus.getValue());
		args.put("destinatario", textDestinatario.getValue());
		args.put("tipoAutorizacao", cmbTipoAutorizacaoFlexBus.getValue());

		openWindow("/gui/catalogos/viewTestEmail.zul",
				Labels.getLabel("viewTestEmailController.window.title"), args, MODAL);
	}

	public void onChange$cmbEstado(Event ev) {
		Comboitem cbiEstado = cmbEstado.getSelectedItem();
		if (cbiEstado != null) {
			Estado estado = (Estado) cbiEstado.getValue();

			lsCidades.addAll(ciudadService.buscarPorEstado(estado));
			BindingListModel listModelCiudad = new BindingListModelList(lsCidades, true);
			cmbCidade.setModel(listModelCiudad);
		}
	}

	public void onChange$cmbEstadoInscEstadual(Event ev) {
		Comboitem cbiEstado = cmbEstadoInscEstadual.getSelectedItem();
		if (cbiEstado != null) {
			Estado estado = (Estado) cbiEstado.getValue();
			lsCidades = new ArrayList<Ciudad>();
			lsCidades.addAll(ciudadService.buscarPorEstado(estado));
			BindingListModel listModelCiudad = new BindingListModelList(lsCidades, true);
			cmbInscEstCidade.setModel(listModelCiudad);
		}
	}

	public void onClick$btnAdicionarEstadoImposto(Event ev) throws InterruptedException {
		if (cmbEstadoImposto.getSelectedItem() == null) {
			Messagebox.show(
					Labels.getLabel("MSG.Error.combobox"),
					Labels.getLabel("editarPricingController.windowMarca.title"),
					Messagebox.OK, Messagebox.EXCLAMATION);
			return;
		}
		Estado estado = (Estado) cmbEstadoImposto.getSelectedItem().getValue();

		EmpresaImposto empresaImposto = new EmpresaImposto();

		empresaImposto.setEstado(estado);
		empresaImposto.setEmpresa(empresa);

		empresaImpostoService.suscribir(empresaImposto);

		lsEmpresaImposto.add(empresaImposto);

		List<EmpresaImposto> lsEmpresaImpostoAtivo = new ArrayList<EmpresaImposto>();
		for (EmpresaImposto rc : lsEmpresaImposto) {
			if (rc.getActivo()) {
				lsEmpresaImpostoAtivo.add(rc);
			}
		}
		empresaImpostoList.setData(lsEmpresaImpostoAtivo);

		cmbEstadoImposto.getSelectedItem().setVisible(false);
		cmbEstadoImposto.setSelectedIndex(-1);

		this.abrirEmpresaImposto(empresaImposto);

	}

	public void abrirEmpresaImposto(EmpresaImposto empresaImposto) {
		Map args = new HashMap();
		args.put("empresaImposto", empresaImposto);
		args.put("empresaImpostoList", empresaImpostoList);

		openWindow("/gui/catalogos/editarEmpresaImposto.zul",
				Labels.getLabel("editarEmpresaImpostoController.window.title"), args, MyGenericForwardComposer.MODAL);

	}

	public void abrirInscricaoEstadual(InscricaoEstadual inscricaoEstadual) {
		if (inscricaoEstadual == null) {
			return;
		}
		Map args = new HashMap();
		args.put("inscricaoEstadual", inscricaoEstadual);
		args.put("inscEstadualList", inscEstadualList);
		args.put("empresa", empresa);

		openWindow("/gui/catalogos/editarEmpresaInscricaoEstadual.zul",
				Labels.getLabel("editarEmpresaInscricaoEstadualController.window.title"), args, MyGenericForwardComposer.MODAL);

	}

	public MyListbox getInscEstadualList() {
		return inscEstadualList;
	}

	public void setInscEstadualList(MyListbox inscEstadualList) {
		this.inscEstadualList = inscEstadualList;
	}

	public void onClick$btnAdicionarInscEstadual(Event ev) throws InterruptedException {
		Estado estado = (Estado) cmbEstadoInscEstadual.getSelectedItem().getValue();
		String inscEstadual = txtInscEstadual.getValue();

		String inscEstLogradouro = txtInscEstLogradouro.getValue();
		String inscEstNumero = txtInscEstNumero.getValue();
		String inscEstComplemento = txtInscEstComplemento.getValue();
		String inscEstCEP = txtInscEstCEP.getValue();
		String inscEstBairro = txtInscEstBairro.getValue();
		Ciudad ciudad = (Ciudad) cmbInscEstCidade.getSelectedItem().getValue();
		String inscEstCNPJ = txtInscEstCNPJ.getValue();
		String equivalenciaAG = txtEquivalenciaAG.getValue();
		Boolean isBPe = chkBPe.isChecked();
		final Boolean isFormaPagoOutrosSemDadosCartao = chkFormaPagoOutrosSemDadosCartao.isChecked();
		Boolean isHabilitaIEDescentralizada = chkHabilitaIEDescentralizada.isChecked();
		Parada origemIEDescentralizada = cmbOrigemIEDescentralizada.getSelectedObject();
		String inscricaoMunicipal=StringUtils.isBlank((txtNumInscricaoMunicipal.getValue()))?"ISENTO":txtNumInscricaoMunicipal.getValue();
		
		if(!validarCamposIEDescentralizada()) {
			return;
		}

		for (int i = 0; i < inscEstadualList.getModel().getSize(); i++) {
			
			InscricaoEstadual inscricaoEstadual = (InscricaoEstadual) inscEstadualList.getModel().getElementAt(i);
			if(isHabilitaIEDescentralizada) {
				if (inscricaoEstadual.getEstado().equals(estado) && origemIEDescentralizada.equals(inscricaoEstadual.getOrigemIEDescentralizada())) {
					Messagebox.show(
							Labels.getLabel("editarEmpresaController.MSG.origemIEDescentralizadaJaInformada", new String[] {origemIEDescentralizada.getDescparada(), inscricaoEstadual.getEstado().getNombestado()}),
							Labels.getLabel("editarPricingController.windowMarca.title"),
							Messagebox.OK, Messagebox.EXCLAMATION);
					return;
				}
			} else {
				if (inscricaoEstadual.getEstado().equals(estado)) {
					Messagebox.show(
							Labels.getLabel("editarEmpresaController.MSG.insEstadualCadastrada"),
							Labels.getLabel("editarPricingController.windowMarca.title"),
							Messagebox.OK, Messagebox.EXCLAMATION);
					return;
				}
			}
		}

		InscricaoEstadual nuevaInscEstadual = new InscricaoEstadual(inscEstadual, empresa, estado, UsuarioLogado.getUsuarioLogado().getUsuarioId(),
				inscEstLogradouro, inscEstNumero, inscEstComplemento, inscEstCEP, inscEstBairro, ciudad, inscEstCNPJ,inscricaoMunicipal);
		nuevaInscEstadual.setEquivalenciaAG(equivalenciaAG);
		nuevaInscEstadual.setIsBPe(isBPe);
		nuevaInscEstadual.setIndFormaPagoOutrosSemCartao(isFormaPagoOutrosSemDadosCartao);
		
		nuevaInscEstadual.setIndHabilitaIEDescentralizada(isHabilitaIEDescentralizada);
		if(isHabilitaIEDescentralizada) {
			nuevaInscEstadual.setOrigemIEDescentralizada(origemIEDescentralizada);
		} else {
			nuevaInscEstadual.setOrigemIEDescentralizada(null);
		}
		
		empresaService.actualizaInscEstadual(nuevaInscEstadual);
		empresa.getInscricoesEstaduais().add(nuevaInscEstadual);

		inscEstadualList.setData(empresa.getInscricoesEstaduaisActivas());

		cmbEstadoInscEstadual.setSelectedItem(null);
		txtInscEstadual.setText(null);
		txtInscEstLogradouro.setText(null);
		txtInscEstNumero.setText(null);
		txtInscEstComplemento.setText(null);
		txtInscEstCEP.setText(null);
		txtInscEstBairro.setText(null);
		cmbInscEstCidade.setSelectedItem(null);
		txtInscEstCNPJ.setText(null);
		txtNumInscricaoMunicipal.setValue("ISENTO");
		txtNumInscricaoMunicipal.setDisabled(true);
		ckIsento.setChecked(true);
	}
	
	public void onClick$ckIsento(Event ev) {
		if (ckIsento.isChecked()) {			
			txtNumInscricaoMunicipal.setValue("ISENTO");
			txtNumInscricaoMunicipal.setDisabled(true);
		} else {			
			txtNumInscricaoMunicipal.setValue("");
			txtNumInscricaoMunicipal.setDisabled(false);
		}
	}

	private boolean validarCamposIEDescentralizada() throws InterruptedException {
		Boolean isHabilitaIEDescentralizada = chkHabilitaIEDescentralizada.isChecked();
		if(!isHabilitaIEDescentralizada) {
			return true;
		}
		
		Parada origemIEDescentralizada = cmbOrigemIEDescentralizada.getSelectedObject();
		if(origemIEDescentralizada == null) {
			Messagebox.show(
					Labels.getLabel("editarEmpresaController.MSG.origemIEDescentralizadaNaoInformada"),
					Labels.getLabel("editarPricingController.windowMarca.title"),
					Messagebox.OK, Messagebox.EXCLAMATION);			
			return false;
		}
		
		Estado estado = (Estado) cmbEstadoInscEstadual.getSelectedItem().getValue();
		if(origemIEDescentralizada.getCiudad() == null ||
		   !origemIEDescentralizada.getCiudad().getEstado().equals(estado)) {
			Messagebox.show(
					Labels.getLabel("editarEmpresaController.MSG.origemIEDescentralizadaUFIncompativel"),
					Labels.getLabel("editarPricingController.windowMarca.title"),
					Messagebox.OK, Messagebox.EXCLAMATION);			
			return false;
		}
		
		return true;
	}

	public void onClick$btnRemoverInscEstadual(Event ev) throws InterruptedException {
		InscricaoEstadual inscEstadual = (InscricaoEstadual) inscEstadualList.getSelected();

		if (inscEstadual != null) {
			if (inscEstadual.getInscricaoestadualId() != null) {
				inscEstadual.setActivo(Boolean.FALSE);
				inscEstadual.setFecmodif(Calendar.getInstance().getTime());
				inscEstadual.setUsuarioId(UsuarioLogado.getUsuarioLogado().getUsuarioId());

				empresaService.actualizaInscEstadual(inscEstadual);
			}

			inscEstadualList.setData(empresa.getInscricoesEstaduaisActivas());
		}
	}

	public void onClick$btnAdicionarComissaoCategoria(Event ev) throws InterruptedException {
		try {

			Categoria categoria = (Categoria) cmbCategorias.getSelectedItem().getValue();

			if (categoria != null) {

				for (ComEmpCategoria c : empresa.getComEmpCategorias()) {
					if (c.getCategoria().getCategoriaId().equals(categoria.getCategoriaId())) {
						return;
					}
				}

				ComEmpCategoria comEmpCategoria = new ComEmpCategoria();
				comEmpCategoria.setCategoria(categoria);
				comEmpCategoria.setEmpresa(getEmpresa());

				comEmpCategoria = empresaService.adicionarComissaoCategoria(comEmpCategoria);

				comEmpCategoriaList.updateItem(comEmpCategoria);
				empresa.getComEmpCategorias().add(comEmpCategoria);

				Messagebox.show(Labels.getLabel("editarEmpresaController.msg.adicionarComissaoCategoria"),
						Labels.getLabel(TITULO),
						Messagebox.OK, Messagebox.INFORMATION);

			}

		} catch (Exception e) {
			EditarEmpresaController.log.error(e.getMessage(), e);
			Messagebox.show(Labels.getLabel("MSG.Error"),
					Labels.getLabel(TITULO),
					Messagebox.OK, Messagebox.ERROR);
		}
	}

	public void onClick$btnRemoverComissaoCategoria(Event ev) throws InterruptedException {
		try {
			if (comEmpCategoriaList.getSelected() != null) {
				int resp = Messagebox.show(
						Labels.getLabel("editarEmpresaController.MSG.borrarComissaoCategoriaPergunta"),
						Labels.getLabel(TITULO),
						Messagebox.YES | Messagebox.NO, Messagebox.QUESTION);

				if (resp == Messagebox.YES) {
					ComEmpCategoria comEmpCategoria = (ComEmpCategoria) comEmpCategoriaList.getSelected();
					empresaService.removerComissaoCategoria(comEmpCategoria);
					comEmpCategoriaList.removeItem(comEmpCategoria);
					empresa.getComEmpCategorias().remove(comEmpCategoria);

					Messagebox.show(Labels.getLabel("editarEmpresaController.msg.removerComissaoCategoria"),
							Labels.getLabel(TITULO),
							Messagebox.OK, Messagebox.INFORMATION);
				}
			}

		} catch (Exception e) {
			EditarEmpresaController.log.error(e.getMessage(), e);
			Messagebox.show(Labels.getLabel("MSG.Error"),
					Labels.getLabel(TITULO),
					Messagebox.OK, Messagebox.ERROR);
		}
	}

	public void onClick$btnAdicionarComissaoFormapago(Event ev) throws InterruptedException {
		try {

			FormaPago formapago = (FormaPago) cmbFormaPagos.getSelectedItem().getValue();

			if (formapago != null) {

				for (ComEmpFormapago f : empresa.getComEmpFormapagos()) {
					if (f.getFormaPago().getFormapagoId().equals(formapago.getFormapagoId())) {
						return;
					}
				}

				ComEmpFormapago comEmpFormapago = new ComEmpFormapago();
				comEmpFormapago.setFormaPago(formapago);
				comEmpFormapago.setEmpresa(getEmpresa());

				comEmpFormapago = empresaService.adicionarComissaoFormapago(comEmpFormapago);

				comEmpFormapagoList.updateItem(comEmpFormapago);
				empresa.getComEmpFormapagos().add(comEmpFormapago);

				Messagebox.show(Labels.getLabel("editarEmpresaController.msg.adicionarComissaoFormapago"),
						Labels.getLabel(TITULO),
						Messagebox.OK, Messagebox.INFORMATION);

			}

		} catch (Exception e) {
			EditarEmpresaController.log.error(e.getMessage(), e);
			Messagebox.show(Labels.getLabel("MSG.Error"),
					Labels.getLabel(TITULO),
					Messagebox.OK, Messagebox.ERROR);
		}
	}

	public void onClick$btnRemoverComissaoFormapago(Event ev) throws InterruptedException {
		try {
			if (comEmpFormapagoList.getSelected() != null) {
				int resp = Messagebox.show(
						Labels.getLabel("editarEmpresaController.MSG.borrarComissaoFormapagoPergunta"),
						Labels.getLabel(TITULO),
						Messagebox.YES | Messagebox.NO, Messagebox.QUESTION);

				if (resp == Messagebox.YES) {
					ComEmpFormapago comEmpFormapago = (ComEmpFormapago) comEmpFormapagoList.getSelected();
					empresaService.removerComissaoFormapago(comEmpFormapago);
					comEmpFormapagoList.removeItem(comEmpFormapago);
					empresa.getComEmpFormapagos().remove(comEmpFormapago);

					Messagebox.show(Labels.getLabel("editarEmpresaController.msg.removerComissaoFormapago"),
							Labels.getLabel(TITULO),
							Messagebox.OK, Messagebox.INFORMATION);
				}
			}

		} catch (Exception e) {
			EditarEmpresaController.log.error(e.getMessage(), e);
			Messagebox.show(Labels.getLabel("MSG.Error"),
					Labels.getLabel(TITULO),
					Messagebox.OK, Messagebox.ERROR);
		}
	}

	public void onClick$btnAdicionarComissaoTipoEventoExtra(Event ev) throws InterruptedException {
		try {

			Comboitem selectedItem = cmbTipoEventoExtras.getSelectedItem();
			if (selectedItem == null) {
				return;
			}

			TipoEventoExtra tipoEventoExtra = (TipoEventoExtra) selectedItem.getValue();

			if (tipoEventoExtra != null) {

				for (ComEmpTipoEventoExtra e : empresa.getComEmpTipoEventoExtras()) {
					if (e.getTipoEventoExtra().getTipoeventoextraId().equals(tipoEventoExtra.getTipoeventoextraId())) {
						return;
					}
				}

				ComEmpTipoEventoExtra comEmpTipoEventoExtra = new ComEmpTipoEventoExtra();
				comEmpTipoEventoExtra.setTipoEventoExtra(tipoEventoExtra);
				comEmpTipoEventoExtra.setEmpresa(getEmpresa());

				comEmpTipoEventoExtra = empresaService.adicionarComissaoTipoEventoExtra(comEmpTipoEventoExtra);

				comEmpTipoEventoExtraList.updateItem(comEmpTipoEventoExtra);
				empresa.getComEmpTipoEventoExtras().add(comEmpTipoEventoExtra);

				Messagebox.show(Labels.getLabel("editarEmpresaController.msg.adicionarComissaoTipoEventoExtra"),
						Labels.getLabel(TITULO),
						Messagebox.OK, Messagebox.INFORMATION);

			}

		} catch (Exception e) {
			EditarEmpresaController.log.error(e.getMessage(), e);
			Messagebox.show(Labels.getLabel("MSG.Error"),
					Labels.getLabel(TITULO),
					Messagebox.OK, Messagebox.ERROR);
		}
	}

	public void onClick$btnRemoverComissaoTipoEventoExtra(Event ev) throws InterruptedException {
		try {
			if (comEmpTipoEventoExtraList.getSelected() != null) {
				int resp = Messagebox.show(
						Labels.getLabel("editarEmpresaController.MSG.borrarComissaoTipoEventoExtraPergunta"),
						Labels.getLabel(TITULO),
						Messagebox.YES | Messagebox.NO, Messagebox.QUESTION);

				if (resp == Messagebox.YES) {
					ComEmpTipoEventoExtra comEmpTipoEventoExtra = (ComEmpTipoEventoExtra) comEmpTipoEventoExtraList.getSelected();
					empresa.getComEmpTipoEventoExtras().remove(comEmpTipoEventoExtra);
					empresaService.removerComissaoTipoEventoExtra(comEmpTipoEventoExtra);
					comEmpTipoEventoExtraList.removeItem(comEmpTipoEventoExtra);

					Messagebox.show(Labels.getLabel("editarEmpresaController.msg.removerComissaoTipoEventoExtra"),
							Labels.getLabel(TITULO),
							Messagebox.OK, Messagebox.INFORMATION);
				}
			}

		} catch (Exception e) {
			EditarEmpresaController.log.error(e.getMessage(), e);
			Messagebox.show(Labels.getLabel("MSG.Error"),
					Labels.getLabel(TITULO),
					Messagebox.OK, Messagebox.ERROR);
		}
	}
	
	public void onClick$btnCadastrarStoreMercadoPago(Event ev) throws InterruptedException {
		Object storeVO = MercadoPagoService.getInstance().cadastrarStoreMercadoPago(empresa, txtNomeStore.getValue(),
				txtIdStoreMercadoPago.getValue(), txtUserIdMercadoPago.getValue(), txtUrlApiMercadoPago.getValue(),
				txtTokenMercadoPago.getValue());

		if (storeVO != null && storeVO instanceof StoreVO) {
			RetornoStoreVO retornoStoreVO = MercadoPagoService.getInstance().retornarStoreMercadoPago(
					txtUserIdMercadoPago.getValue(), txtUrlApiMercadoPago.getValue(), txtTokenMercadoPago.getValue());
			
			boolean processing = true;
			while (processing) {
				for (StoreVO vo : retornoStoreVO.getResults()) {
					if (storeVO.toString().equals(vo.toString())) {
						processing = false;
						break;
					}
				}
				retornoStoreVO = MercadoPagoService.getInstance().retornarStoreMercadoPago(
						txtUserIdMercadoPago.getValue(), txtUrlApiMercadoPago.getValue(),
						txtTokenMercadoPago.getValue());
			}
			lsStoreMercadoPago.clear();
			for (StoreVO vo : retornoStoreVO.getResults()) {
				lsStoreMercadoPago.add(vo);
			}
			BindingListModel listModel = new BindingListModelList(lsStoreMercadoPago, true);
			cmbStoreMercadoPago.setModel(listModel);
			cmbStoreCadastroMercadoPago.setModel(listModel);
			if (this.storeVO != null) {
				cmbStoreMercadoPago.setSelectedIndex(lsStoreMercadoPago.indexOf(this.storeVO));
			}
			
			Messagebox.show(Labels.getLabel("editarEmpresaController.lblMsgCadastrarStoreMercadoPago.value"),
					Labels.getLabel(TITULO),
					Messagebox.OK, Messagebox.INFORMATION);
		} else {
			Messagebox.show(storeVO.toString(), Labels.getLabel(TITULO),
					Messagebox.OK, Messagebox.ERROR);
		}

	}

	public void onClick$btnCadastrarPOSMercadoPago(Event ev) throws InterruptedException {
				
		Object posVO = MercadoPagoService.getInstance().cadastrarPOSMercadoPago(txtNomePOS.getValue(),
				cmbStoreCadastroMercadoPago.getSelectedItem() != null
						? (StoreVO) cmbStoreCadastroMercadoPago.getSelectedItem().getValue()
						: null,
				txtIdPOSMercadoPago.getValue(), txtUrlApiMercadoPago.getValue(), txtTokenMercadoPago.getValue());

		if (posVO != null && posVO instanceof PosVO) {
			RetornoPosVO retornoPosVO = MercadoPagoService.getInstance()
					.retornarPosMercadoPago(txtUrlApiMercadoPago.getValue(), txtTokenMercadoPago.getValue());
			
			boolean processing = true;
			while (processing) {
				for (PosVO vo : retornoPosVO.getResults()) {
					if (posVO.toString().equals(vo.toString())) {
						processing = false;
						break;
					}

				}
				retornoPosVO = MercadoPagoService.getInstance().retornarPosMercadoPago(txtUrlApiMercadoPago.getValue(),
						txtTokenMercadoPago.getValue());
			}
			
			lsPosMercadoPago.clear();
			for (PosVO vo : retornoPosVO.getResults()) {
				lsPosMercadoPago.add(vo);
			}
			BindingListModel listModel = new BindingListModelList(lsPosMercadoPago, true);
			cmbPOSMercadoPago.setModel(listModel);
			if (this.posVO != null) {
				cmbPOSMercadoPago.setSelectedIndex(lsPosMercadoPago.indexOf(this.posVO));
			}
			
			Messagebox.show(Labels.getLabel("editarEmpresaController.lblMsgCadastrarPOSMercadoPago.value"),
					Labels.getLabel(TITULO),
					Messagebox.OK, Messagebox.INFORMATION);
		} else {
			Messagebox.show(storeVO.toString(), Labels.getLabel(TITULO),
					Messagebox.OK, Messagebox.ERROR);
		}
	}
	
	private void carregarConfiguracaoMercadoPago() {

		String store = empresaMercadoPagoConfig.getStore();
		String pos = empresaMercadoPagoConfig.getPos();
		
		lsStoreMercadoPago = new ArrayList<StoreVO>();
		lsPosMercadoPago = new ArrayList<PosVO>();

		if (StringUtils.isNotBlank(txtUserIdMercadoPago.getValue())
				&& StringUtils.isNotBlank(txtUrlApiMercadoPago.getValue())
				&& StringUtils.isNotBlank(txtTokenMercadoPago.getValue())) {
			RetornoStoreVO retornoStoreVO = MercadoPagoService.getInstance().retornarStoreMercadoPago(
					txtUserIdMercadoPago.getValue(), txtUrlApiMercadoPago.getValue(), txtTokenMercadoPago.getValue());

			if (retornoStoreVO != null) {
				for (StoreVO vo : retornoStoreVO.getResults()) {
					if (store != null && vo.toString().equals(store)) {
						this.storeVO = vo;
					}
					lsStoreMercadoPago.add(vo);
				}
			}
		}
		
		if (StringUtils.isNotBlank(txtUrlApiMercadoPago.getValue())
				&& StringUtils.isNotBlank(txtTokenMercadoPago.getValue())) {

			RetornoPosVO retornoPosVO = MercadoPagoService.getInstance()
					.retornarPosMercadoPago(txtUrlApiMercadoPago.getValue(), txtTokenMercadoPago.getValue());

			if (retornoPosVO != null) {
				for (PosVO vo : retornoPosVO.getResults()) {
					if (pos != null && vo.toString().equals(pos)) {
						this.posVO = vo;
					}
					lsPosMercadoPago.add(vo);
				}
			}
		}
		
	}

	public Combobox getCmbEstadoInscEstadual() {
		return cmbEstadoInscEstadual;
	}

	public void setCmbEstadoInscEstadual(Combobox cmbEstadoInscEstadual) {
		this.cmbEstadoInscEstadual = cmbEstadoInscEstadual;
	}

	public MyTextbox getTxtInscEstadual() {
		return txtInscEstadual;
	}

	public void setTxtInscEstadual(MyTextbox txtInscEstadual) {
		this.txtInscEstadual = txtInscEstadual;
	}

	public Button getBtnRemoverInscEstadual() {
		return btnRemoverInscEstadual;
	}

	public void setBtnRemoverInscEstadual(Button btnRemoverInscEstadual) {
		this.btnRemoverInscEstadual = btnRemoverInscEstadual;
	}

	public List<InstiFinanceira> getLsBanco() {
		return lsBanco;
	}

	public void setLsBanco(List<InstiFinanceira> lsBanco) {
		this.lsBanco = lsBanco;
	}

	public Combobox getCmbBanco() {
		return cmbBanco;
	}

	public void setCmbBanco(Combobox cmbBanco) {
		this.cmbBanco = cmbBanco;
	}

	public MyListbox getEmpresaContaBancariaList() {
		return empresaContaBancariaList;
	}

	public void setEmpresaContaBancariaList(MyListbox empresaContaBancariaList) {
		this.empresaContaBancariaList = empresaContaBancariaList;
	}

	public Textbox getTxtNumConta() {
		return txtNumConta;
	}

	public void setTxtNumConta(Textbox txtNumConta) {
		this.txtNumConta = txtNumConta;
	}

	public Textbox getTxtNumAgencia() {
		return txtNumAgencia;
	}

	public void setTxtNumAgencia(Textbox txtNumAgencia) {
		this.txtNumAgencia = txtNumAgencia;
	}

	public Combobox getCmbInscEstCidade() {
		return cmbInscEstCidade;
	}

	public void setCmbInscEstCidade(Combobox cmbInscEstCidade) {
		this.cmbInscEstCidade = cmbInscEstCidade;
	}

	public Textbox getTxtInscEstLogradouro() {
		return txtInscEstLogradouro;
	}

	public void setTxtInscEstLogradouro(Textbox txtInscEstLogradouro) {
		this.txtInscEstLogradouro = txtInscEstLogradouro;
	}

	public Textbox getTxtInscEstNumero() {
		return txtInscEstNumero;
	}

	public void setTxtInscEstNumero(Textbox txtInscEstNumero) {
		this.txtInscEstNumero = txtInscEstNumero;
	}

	public Textbox getTxtInscEstComplemento() {
		return txtInscEstComplemento;
	}

	public void setTxtInscEstComplemento(Textbox txtInscEstComplemento) {
		this.txtInscEstComplemento = txtInscEstComplemento;
	}

	public Textbox getTxtInscEstCEP() {
		return txtInscEstCEP;
	}

	public void setTxtInscEstCEP(Textbox txtInscEstCEP) {
		this.txtInscEstCEP = txtInscEstCEP;
	}

	public Textbox getTxtInscEstBairro() {
		return txtInscEstBairro;
	}

	public void setTxtInscEstBairro(Textbox txtInscEstBairro) {
		this.txtInscEstBairro = txtInscEstBairro;
	}

	public Textbox getTxtInscEstCNPJ() {
		return txtInscEstCNPJ;
	}

	public void setTxtInscEstCNPJ(Textbox txtInscEstCNPJ) {
		this.txtInscEstCNPJ = txtInscEstCNPJ;
	}

	public void onClick$btnRemoverContaBancaria(Event ev) {

		EmpresaContaBancaria empresaToRemove = (EmpresaContaBancaria) empresaContaBancariaList.getSelected();

		if (empresaToRemove != null) {
			lsEmpresaContaBancaria.remove(empresaToRemove);
			empresaToRemove.setFecmodif(Calendar.getInstance().getTime());
			empresaToRemove.setActivo(Boolean.FALSE);
			empresaToRemove.setUsuarioId(UsuarioLogado.getUsuarioLogado().getUsuarioId());
			lsEmpresaContaBancaria.add(empresaToRemove);
			empresaContaBancariaList.updateItem(empresaToRemove);
			empresaContaBancariaList.removeItem(empresaToRemove);
			empresa.setEmpresaContaBancaria(lsEmpresaContaBancaria);
		} else {
			try {
				Messagebox.show(
						Labels.getLabel("editarEmpresaController.MSG.selecioneUmItem"),
						Labels.getLabel("editarEmpresaController.contaBancaria.label"),
						Messagebox.OK, Messagebox.EXCLAMATION);
			} catch (InterruptedException e) {
				EditarEmpresaController.log.error("editarEmpresaController: " + e);
			}
		}
	}

	public void onClick$btnAdicionarContaBancaria(Event ev) throws InterruptedException {

		if (infoContaBancariaValida()) {
			InstiFinanceira instiFinanceira = (InstiFinanceira) cmbBanco.getSelectedItem().getValue();
			String numConta = txtNumConta.getValue();
			String numAgencia = txtNumAgencia.getValue();
			String numIntegracion = txtNumIntegracion.getValue();

			EmpresaContaBancaria empresaContaBancariaToAdd = new EmpresaContaBancaria();
			empresaContaBancariaToAdd.setActivo(Boolean.TRUE);
			empresaContaBancariaToAdd.setUsuarioId(UsuarioLogado.getUsuarioLogado().getUsuarioId());
			empresaContaBancariaToAdd.setFecmodif(Calendar.getInstance().getTime());
			empresaContaBancariaToAdd.setEmpresa(empresa);
			empresaContaBancariaToAdd.setInstituicaoFinandeira(instiFinanceira);
			empresaContaBancariaToAdd.setNumAgencia(numAgencia);
			empresaContaBancariaToAdd.setNumIntegracion(numIntegracion);
			empresaContaBancariaToAdd.setNumConta(numConta);

			boolean achou = Boolean.FALSE;
			for (EmpresaContaBancaria empresaContaBancariaInTheList : lsEmpresaContaBancaria) {
				if (empresaContaBancariaInTheList.equals(empresaContaBancariaToAdd)) {
					achou = Boolean.TRUE;
				}
			}

			if (!achou) {
				lsEmpresaContaBancaria.add(empresaContaBancariaToAdd);
				empresa.setEmpresaContaBancaria(lsEmpresaContaBancaria);

				List<EmpresaContaBancaria> tempList = new ArrayList<EmpresaContaBancaria>();
				if (lsEmpresaContaBancaria != null) {
					for (EmpresaContaBancaria empresaContaBancaria : lsEmpresaContaBancaria) {
						if (empresaContaBancaria.getActivo()) {
							tempList.add(empresaContaBancaria);
						}
					}
				}

				empresaContaBancariaList.setData(tempList);

			} else {
				Messagebox.show(
						Labels.getLabel("editarEmpresaController.MSG.jaExisteContaComAsMesmasInfoCadastradas"),
						Labels.getLabel("editarEmpresaController.contaBancaria.label"),
						Messagebox.OK, Messagebox.EXCLAMATION);
			}

			clearContaBancaria();
		}
	}

	private void clearContaBancaria() {
		cmbBanco.setSelectedItem(null);
		txtNumAgencia.setValue(null);
		txtNumConta.setValue(null);
	}

	private boolean infoContaBancariaValida() throws InterruptedException {

		if (cmbBanco.getSelectedItem().getValue() == null) {
			Messagebox.show(
					Labels.getLabel("editarEmpresaController.MSG.informeBanco"),
					Labels.getLabel("editarEmpresaController.contaBancaria.label"),
					Messagebox.OK, Messagebox.EXCLAMATION);
			return false;
		}

		if (txtNumConta.getValue() == null) {
			Messagebox.show(
					Labels.getLabel("editarEmpresaController.MSG.informeConta"),
					Labels.getLabel("editarEmpresaController.contaBancaria.label"),
					Messagebox.OK, Messagebox.EXCLAMATION);
			return false;
		}

		if (txtNumAgencia.getValue() == null) {
			Messagebox.show(
					Labels.getLabel("editarEmpresaController.MSG.informeAgencia"),
					Labels.getLabel("editarEmpresaController.contaBancaria.label"),
					Messagebox.OK, Messagebox.EXCLAMATION);
			return false;
		}

		return true;
	}

	public void onClick$btnAdicionarConfigLayout(Event ev) throws InterruptedException {
		
		if (cmbConfigLayoutTiposVenda.getSelectedItem() == null || cmbImpresionLayoutConfig.getSelectedItem() == null) {
			return;
		}
		
		TipoVenta tipoVenta = (TipoVenta) cmbConfigLayoutTiposVenda.getSelectedItem().getValue();
		ImpresionLayoutConfig impresionLayoutConfig = (ImpresionLayoutConfig) cmbImpresionLayoutConfig.getSelectedItem()
				.getValue();

		EmpresaConfigLayout empresaConfigLayoutToAdd = new EmpresaConfigLayout();
		empresaConfigLayoutToAdd.setActivo(Boolean.TRUE);
		empresaConfigLayoutToAdd.setUsuarioId(UsuarioLogado.getUsuarioLogado().getUsuarioId());
		empresaConfigLayoutToAdd.setFecmodif(Calendar.getInstance().getTime());
		empresaConfigLayoutToAdd.setEmpresa(empresa);
		empresaConfigLayoutToAdd.setTipoVenta(tipoVenta);
		empresaConfigLayoutToAdd.setImpresionlayoutconfigId(impresionLayoutConfig);
		empresaConfigLayoutToAdd.setIndEmail(chkindLayoutEmailConfig.isChecked());

		boolean achou = Boolean.FALSE;
		for (EmpresaConfigLayout empresaEmpresaConfigLayoutInTheList : lsEmpresaConfigLayout) {
			if (empresaEmpresaConfigLayoutInTheList != null && empresaEmpresaConfigLayoutInTheList.getActivo()
					&& empresaConfigLayoutToAdd.getTipoVenta()
							.equals(empresaEmpresaConfigLayoutInTheList.getTipoVenta())
					&& empresaConfigLayoutToAdd.getImpresionlayoutconfigId()
							.equals(empresaEmpresaConfigLayoutInTheList.getImpresionlayoutconfigId())
					&& empresaConfigLayoutToAdd.getIndEmail()
							.equals(empresaEmpresaConfigLayoutInTheList.getIndEmail())) {
				achou = Boolean.TRUE;
			}
		}

		if (!achou) {
			lsEmpresaConfigLayout.add(empresaConfigLayoutToAdd);

			List<EmpresaConfigLayout> tempList = new ArrayList<EmpresaConfigLayout>();
			if (lsEmpresaContaBancaria != null) {
				for (EmpresaConfigLayout empresaConfigLayout : lsEmpresaConfigLayout) {
					if (empresaConfigLayout.getActivo()) {
						tempList.add(empresaConfigLayout);
					}
				}
			}

			empresaLayoutConfigList.setData(tempList);

		} else {
			Messagebox.show(Labels.getLabel("editarEmpresaController.MSG.jaExisteConfigLayoutComAsMesmasInfoCadastradas"),
					Labels.getLabel("editarEmpresaController.tabConfiguracaoLayout.value"), Messagebox.OK,
					Messagebox.EXCLAMATION);
		}


	}

	public void onClick$btnRemoverConfigLayout(Event ev) {

		EmpresaConfigLayout empresaToRemove = (EmpresaConfigLayout) empresaLayoutConfigList.getSelected();

		if (empresaToRemove != null) {
			lsEmpresaConfigLayout.remove(empresaToRemove);
			empresaToRemove.setFecmodif(Calendar.getInstance().getTime());
			empresaToRemove.setActivo(Boolean.FALSE);
			empresaToRemove.setUsuarioId(UsuarioLogado.getUsuarioLogado().getUsuarioId());
			lsEmpresaConfigLayout.add(empresaToRemove);
			empresaLayoutConfigList.updateItem(empresaToRemove);
			empresaLayoutConfigList.removeItem(empresaToRemove);
		} else {
			try {
				Messagebox.show(Labels.getLabel("editarEmpresaController.MSG.selecioneUmItemConfigLayout"),
						Labels.getLabel("editarEmpresaController.tabConfiguracaoLayout.value"), Messagebox.OK,
						Messagebox.EXCLAMATION);
			} catch (InterruptedException e) {
				EditarEmpresaController.log.error("editarEmpresaController: " + e);
			}
		}
	}

	private void retirarCaracteresEspeciaisCNPJ() {
		if(empresa != null && empresa.getCnpj() != null && empresa.getCnpj().contains("-") 
				|| empresa.getCnpj().contains(".") || empresa.getCnpj().contains("/")) {
			empresa.setCnpj(empresa.getCnpj().replaceAll("[^\\d ]", ""));
			try {
				empresaService.suscribirActualizacion(empresa);
			} catch (BusinessException e) {
				log.error("Ocorreu um erro ao retirar os caracteres especiais do cnpj e atualizar o objeto empresa");
				e.printStackTrace();
			}
		}
	}
	
	public List<Categoria> getLsCategorias() {
		return lsCategorias;
	}

	public void setLsCategorias(List<Categoria> lsCategorias) {
		this.lsCategorias = lsCategorias;
	}

	public List<FormaPago> getLsFormaPagos() {
		return lsFormaPagos;
	}

	public void setLsFormaPagos(List<FormaPago> lsFormaPagos) {
		this.lsFormaPagos = lsFormaPagos;
	}

	public List<TipoEventoExtra> getLsTipoEventoExtras() {
		return lsTipoEventoExtras;
	}

	public void setLsTipoEventoExtras(List<TipoEventoExtra> lsTipoEventoExtras) {
		this.lsTipoEventoExtras = lsTipoEventoExtras;
	}

	public MyListbox getComEmpCategoriaList() {
		return comEmpCategoriaList;
	}

	public void setComEmpCategoriaList(MyListbox comEmpCategoriaList) {
		this.comEmpCategoriaList = comEmpCategoriaList;
	}

	public ComEmpConferencia getComEmpConferencia() {
		return comEmpConferencia;
	}

	public void setComEmpConferencia(ComEmpConferencia comEmpConferencia) {
		this.comEmpConferencia = comEmpConferencia;
	}

	public Boolean getGeneraNumfoliosistemaVtaInternetImp() {
		return UsuarioLogado.getUsuarioLogado().isPermisoClave(ConstantesFuncionSistema.CLAVE_GENERA_FOLIOSISTEMA_VTA_INT_IMP_POSTERIOR);
	}
	
	public Boolean desabilitarEquivalencia() {
		return !ApplicationProperties.getInstance().isCustomHabilitado(CustomEnum.MOSTRAR_EQUIVALENCIA.getDescricao());
	}

	public Checkbox getChkHabilitarFidelidade() {
		return chkHabilitarFidelidade;
	}

	public void setChkHabilitarFidelidade(Checkbox chkHabilitarFidelidade) {
		this.chkHabilitarFidelidade = chkHabilitarFidelidade;
	}

	public Intbox getIntPontuacaoFraudeIni() {
		return intPontuacaoFraudeIni;
	}

	public void setIntPontuacaoFraudeIni(Intbox intPontuacaoFraudeIni) {
		this.intPontuacaoFraudeIni = intPontuacaoFraudeIni;
	}

	public Intbox getIntPontuacaoFraudeFim() {
		return intPontuacaoFraudeFim;
	}

	public void setIntPontuacaoFraudeFim(Intbox intPontuacaoFraudeFim) {
		this.intPontuacaoFraudeFim = intPontuacaoFraudeFim;
	}

	public void onClick$chkIndEnviarEmailComissao() {
		if (chkIndEnviarEmailComissao.isChecked()) {
			txtEmail.setDisabled(false);
		} else {
			txtEmail.setText("");
			txtEmail.setDisabled(true);
			empresa.setEmail("");
		}
	}

	public Boolean isPermissaoVendaSemReducaoZ() {
		return !UsuarioLogado.getUsuarioLogado().isPermisoClave(ConstantesFuncionSistema.CLAVE_EDITAR_VENDA_SEM_REDUCAO_Z);
	}

	public Radio getUtilizaProjetoFidelidadeSim() {
		return utilizaProjetoFidelidadeSim;
	}

	public void setUtilizaProjetoFidelidadeSim(Radio utilizaProjetoFidelidadeSim) {
		this.utilizaProjetoFidelidadeSim = utilizaProjetoFidelidadeSim;
	}

	public Checkbox getChkBPe() {
		return chkBPe;
	}

	public void setChkBPe(Checkbox chkBPe) {
		this.chkBPe = chkBPe;
	}

	public Checkbox getChkUtilizaResolMonitriip() {
		return chkUtilizaResolucao;
	}

	public void setChkUtilizaResolMonitriip(Checkbox chkUtilizaResolMonitriip) {
		this.chkUtilizaResolucao = chkUtilizaResolMonitriip;
	}

	public Checkbox getChkUtilizaFolioVendaPrepagoAberto() {
		return chkUtilizaFolioVendaPrepagoAberto;
	}

	public void setChkUtilizaFolioVendaPrepagoAberto(Checkbox chkUtilizaFolioVendaPrepagoAberto) {
		this.chkUtilizaFolioVendaPrepagoAberto = chkUtilizaFolioVendaPrepagoAberto;
	}

	public EmpresaEmailService getEmpresaEmailService() {
		return empresaEmailService;
	}

	public void setEmpresaEmailService(EmpresaEmailService empresaEmailService) {
		this.empresaEmailService = empresaEmailService;
	}

	public EmpresaEmailConfigService getEmpresaEmailConfigService() {
		return empresaEmailConfigService;
	}

	public void setEmpresaEmailConfigService(EmpresaEmailConfigService empresaEmailConfigService) {
		this.empresaEmailConfigService = empresaEmailConfigService;
	}

	public EmpresaEmail getEmpresaEmail() {
		return empresaEmail;
	}

	public void setEmpresaEmail(EmpresaEmail empresaEmail) {
		this.empresaEmail = empresaEmail;
	}

	public EmpresaEmailConfig getEmpresaEmailConfig() {
		return empresaEmailConfig;
	}

	public void setEmpresaEmailConfig(EmpresaEmailConfig empresaEmailConfig) {
		this.empresaEmailConfig = empresaEmailConfig;
	}

	public Empresa getEmpresa() {
		return empresa;
	}

	public void setEmpresa(Empresa empresa) {
		this.empresa = empresa;
	}

	public List<Estado> getLsEstados() {
		return lsEstados;
	}

	public void setLsEstados(List<Estado> lsEstados) {
		this.lsEstados = lsEstados;
	}

	/**
	 * @return the lsTodosEstados
	 */
	public List<Estado> getLsTodosEstados() {
		return lsTodosEstados;
	}

	/**
	 * @param lsTodosEstados
	 *            the lsTodosEstados to set
	 */
	public void setLsTodosEstados(List<Estado> lsTodosEstados) {
		this.lsTodosEstados = lsTodosEstados;
	}

	public List<Ciudad> getLsCidades() {
		return lsCidades;
	}

	public void setLsCidades(List<Ciudad> lsCidades) {
		this.lsCidades = lsCidades;
	}

	public Checkbox getChkHabilitarVendaEstudanteTotem() {
		return chkHabilitarVendaEstudanteTotem;
	}

	public void setChkHabilitarVendaEstudanteTotem(Checkbox chkHabilitarVendaEstudanteTotem) {
		this.chkHabilitarVendaEstudanteTotem = chkHabilitarVendaEstudanteTotem;
	}
	
	public Boolean getHabilitaIEDescentralizada() {
		return ApplicationProperties.getInstance().isCustomHabilitado(CustomEnum.IS_HABILITA_IE_DESCENTRALIZADA.getDescricao());
	}
	
	private void ajustarRadioAbaRateioComissao() {
		radAtivarRateioComissaoGrupoLinhaSim.setChecked(!radAtivarRateioComissaoGrupoLinhaNao.isChecked());
		radAtivarRateioComissaoGrupoLinhaNao.setChecked(!radAtivarRateioComissaoGrupoLinhaSim.isChecked());
		radGrupoLinhasLinhaOriginal.setChecked(radAtivarRateioComissaoGrupoLinhaSim.isChecked() && !radGrupoLinhasAproveitamentoSeletivo.isChecked());
		radGrupoLinhasLinhaOriginal.setDisabled(radAtivarRateioComissaoGrupoLinhaNao.isChecked());
		radGrupoLinhasAproveitamentoSeletivo.setChecked(radAtivarRateioComissaoGrupoLinhaSim.isChecked() && !radGrupoLinhasLinhaOriginal.isChecked());
		radGrupoLinhasAproveitamentoSeletivo.setDisabled(radAtivarRateioComissaoGrupoLinhaNao.isChecked());
	}
	
	public void onCheck$radAtivarRateioComissaoGrupoLinhaSim(Event event) {
		ajustarRadioAbaRateioComissao();
	}
	
	public void onCheck$radAtivarRateioComissaoGrupoLinhaNao(Event event) {
		ajustarRadioAbaRateioComissao();
	}
	
	public void onCheck$radGrupoLinhasLinhaOriginal(Event event) {
		ajustarRadioAbaRateioComissao();
	}
	
	public void onCheck$radGrupoLinhasAproveitamentoSeletivo(Event event) {
		ajustarRadioAbaRateioComissao();
	}
	
	public void onClick$chkIndMantemVdaCajaVdaEmbarcada() throws InterruptedException {
		boolean statusAtual = chkIndMantemVdaCajaVdaEmbarcada.isChecked();
		chkIndMantemVdaCajaVdaEmbarcada.setChecked(!statusAtual);
		
		int resp = Messagebox.show(
				Labels.getLabel("editarEmpresaController.mantemVdaCajaVdaEmbarcada.pergunta", new Object[] {"\n"}),
				Labels.getLabel(TITULO),
				Messagebox.YES | Messagebox.NO, Messagebox.QUESTION);
		
		if(resp == Messagebox.NO) {
			chkIndMantemVdaCajaVdaEmbarcada.setChecked(!statusAtual);
		} else {
			chkIndMantemVdaCajaVdaEmbarcada.setChecked(statusAtual);
		}
		
	}

	public void onChange$cmbTipoEmail(Event ev) {
		Comboitem cbiEmail = cmbTipoEmail.getSelectedItem();
		if (cbiEmail != null) {
			TipoEmail tipoEmail = (TipoEmail) cbiEmail.getValue();

			switch (tipoEmail) {
			case CALL_CENTER:
				tabCallCenter.setVisible(true);
				tabECommerce.setVisible(false);
				cmbTipoOperacao.setVisible(false);
				lblTipoEmail.setVisible(false);
				break;
			case ECOMMERCE:
				tabCallCenter.setVisible(false);
				tabECommerce.setVisible(true);
				cmbTipoOperacao.setVisible(true);
				lblTipoEmail.setVisible(true);
				break;
			default:
				tabCallCenter.setVisible(false);
				tabECommerce.setVisible(false);
				cmbTipoOperacao.setVisible(false);
				lblTipoEmail.setVisible(false);
				break;
			}

		}
	}
	
	public void onChange$cmbTipoOperacao(Event ev) {
		Comboitem cbiTipoOperacao = cmbTipoOperacao.getSelectedItem();
		if (cbiTipoOperacao != null) {
			TipoOperacaoECommerce tipoOperacao = (TipoOperacaoECommerce) cbiTipoOperacao.getValue();
			empresaEmailEComerce = empresaEmailEComerceService.buscarPorEmpresa(empresa, tipoOperacao.getId().toString());
			if(empresaEmailEComerce != null) {
				textAssuntoECommerce.setValue(empresaEmailEComerce.getAssunto());
				messageAnexo1Ecommerce.setValue(empresaEmailEComerce.getAnexo1());
				messageConteudoEmailECommerce.setValue(empresaEmailEComerce.getTextoEmail());
			}else {
				textAssuntoECommerce.setValue("");
				messageAnexo1Ecommerce.setValue("");
				messageConteudoEmailECommerce.setValue("");
			}
		}
	}

	public void onBlur$txtCpfCnpj_AutorizadoDowload(Event event) {
		String numDoc = txtCpfCnpj_AutorizadoDowload.getValue();
		
		validarCPFCNPJ(numDoc);
	}
	
	private class _DragEvent implements EventListener {
		@Override
		public void onEvent(Event event) throws Exception {

			MyListbox droppedListbox = (MyListbox) (((DropEvent) event).getTarget());
			Listitem draggedListitem = (Listitem) ((DropEvent) event).getDragged();
			MyListbox draggedListBox = (MyListbox) draggedListitem.getParent();

			if (draggedListitem instanceof Listitem) {

				if (!droppedListbox.equals(draggedListBox)) {
					if (draggedListitem.getIndex() >= 0) {
						droppedListbox
								.addItemNovo(draggedListBox.getListModel().getElementAt(draggedListitem.getIndex()));
						draggedListBox
								.removeItem(draggedListBox.getListModel().getElementAt(draggedListitem.getIndex()));

					}
				}

			} else {
				droppedListbox.appendChild(draggedListitem);
			}
		}
	}
	
	private Short[] retornaIdsFormaPagamento(List<FormaPago> idFormasPagos) {
		Short[] retorno = new Short[idFormasPagos.size()];
		for (int i = 0; i < idFormasPagos.size(); i++) {
			retorno[i] = idFormasPagos.get(i).getFormapagoId();
		}
		return retorno;
	}

	public void uploadFile(UploadEvent event) {
		org.zkoss.util.media.Media media = event.getMedia();

		try {
			String info = getCerticateInfo(media.getStreamData());

			if (info != null) {
				certificado = media.getByteData();
				lblCertificado.setValue(info);
			} else {
				Messagebox.show(
						Labels.getLabel("editarMarcaController.MSG.errorIMG") + " " + media,
						Labels.getLabel(TITULO),
						Messagebox.OK, Messagebox.ERROR);
			}

		} catch (Exception ex) {
			log.error(ex);
			throw UiException.Aide.wrap(ex);
		}
	}
	
	private String getCerticateInfo(InputStream cerFileStream) throws IOException, KeyStoreException, CertificateException, NoSuchAlgorithmException, UnrecoverableEntryException, InvalidKeyException, SignatureException {

		Certificate certificate = null;
		PrivateKey pvtkey = null;
		Enumeration<String> aliasList;
		String alias;

		String certPassword = txtSenhaCertificado.getValue();

		KeyStore keyStore = KeyStore.getInstance("PKCS12");
		keyStore.load(cerFileStream, certPassword.toCharArray());
		aliasList = keyStore.aliases();
		while (aliasList.hasMoreElements()) {
			alias = aliasList.nextElement();
			KeyStore.ProtectionParameter entryPassword = new KeyStore.PasswordProtection(certPassword.toCharArray());
			KeyStore.PrivateKeyEntry privateKeyEntry = (KeyStore.PrivateKeyEntry) keyStore.getEntry(alias, entryPassword);
			pvtkey = privateKeyEntry.getPrivateKey();
			X509Certificate c = (X509Certificate) keyStore.getCertificate(alias);
			PrivateKey privKey = pvtkey;
			Signature sign = Signature.getInstance("SHA256withRSA");
			sign.initSign(privKey);
			byte[] bytes = "TestSign".getBytes();
			sign.update(bytes);
			byte[] signature = sign.sign();
			PublicKey pubKey = c.getPublicKey();
			Signature verify = Signature.getInstance("SHA256withRSA");
			verify.initVerify(pubKey);
			verify.update(bytes);

			boolean signatureVerified = verify.verify(signature);
			if (signatureVerified) {
				SimpleDateFormat fmt = new SimpleDateFormat("dd/MM/yyyy HH:mm:ss");
				String dadosCertificado = "Certificado: OK" + "\n"
						+ "Validade: " + fmt.format(c.getNotBefore()) + " até " + fmt.format(c.getNotAfter()) + 
						"\n" + "Tipo: " + c.getVersion() + "\n" +
						c.getSubjectDN().getName();
				return dadosCertificado;
			}
		}
		return null;
	}
	
	private void mostrarAbaSafer() {
		if (ApplicationProperties.getInstance().isCustomHabilitado(CustomEnum.INTEGRACION_SAFER.getDescricao())) {
			tabSafer.setVisible(true);
		}
	}
	
	private void mostrarAbaSaftao() {
		if (ApplicationProperties.getInstance().isCustomHabilitado(CustomEnum.IS_VENDA_SAFTAO.getDescricao(), true)) {
			tabSaftao.setVisible(true);
		}
	}
	
	private void popularCombobox() {
		for (AuthType tipoAutorizacao : AuthType.values()) {
			Comboitem comboItem = new Comboitem(tipoAutorizacao.toString());
			comboItem.setValue(tipoAutorizacao);
			comboItem.setParent(cmbTipoAutorizacao);
		}
		for (AuthType tipoAutorizacao : AuthType.values()) {
			Comboitem comboItem = new Comboitem(tipoAutorizacao.toString());
			comboItem.setValue(tipoAutorizacao);
			comboItem.setParent(cmbTipoAutorizacaoFlexBus);
		}

	}
	
	private boolean validarCPFCNPJ(String numDoc) {
		try {
			if(numDoc == null) {
				return true;
			}
			
			numDoc = numDoc.trim();
			
			String msg = "";
			
			if(StringUtils.isNotBlank(numDoc)) {
				Boolean documentoValido = false;
				if(numDoc.length() == 11) {
					if(!isCPFValido(numDoc)) {
						msg = "editarEmpresaController.cpfCnpjAutorizadoDownload.CPFincorreto";
					}
				} else if(numDoc.length() == 14) {
					if(!isCNPJValido(numDoc)) {
						msg = "editarEmpresaController.cpfCnpjAutorizadoDownload.CNPJincorreto";
					}
				} else { //Se o tamanho estiver errado
					msg = "editarEmpresaController.cpfCnpjAutorizadoDownload.CPFCNPJincorreto";
				}
			}
			
			if(StringUtils.isNotBlank(msg)) {
				Messagebox.show(Labels.getLabel(msg), Labels.getLabel(TITULO),
						Messagebox.OK, Messagebox.EXCLAMATION);			
				return false;
			}
			
			return true;
		} catch (Exception e) {
			log.error("Erro ao validar CPF/CNPJ: ", e);
			return false;
		}
	}
	
	private Boolean isCPFValido(String numDoc) {
		try {
			// O Validador não pegava os CPFs com todos os numeros iguais
			if (numDoc.length() != 11 || numDoc.equals("00000000000") || numDoc.equals("11111111111") || numDoc.equals("22222222222") || 
				numDoc.equals("33333333333") || numDoc.equals("44444444444") || numDoc.equals("55555555555") || 
				numDoc.equals("66666666666") || numDoc.equals("77777777777") || numDoc.equals("88888888888") || 
				numDoc.equals("99999999999")) {
				return false;				
			}
						
			Cpf cpf = new Cpf(numDoc);					
			if(!cpf.isValid()) {
				return false;						
			}
		} catch (ValidationException e) {
			return false;		
		}
		
		return true;
	}
	
	private Boolean isCNPJValido(String numDoc) {
		try {
			Cnpj cnpj = new Cnpj(numDoc);					
			if(!cnpj.isValid()) {
				return false;						
			}
		} catch (ValidationException e) {
			return false;		
		}
		
		return true;
	}
	
	public void uploadFileSaftao(UploadEvent event) {
		org.zkoss.util.media.Media media = event.getMedia();

		try {
			String info = getCerticateInfoSaftao(media.getStreamData());

			if (info != null) {
				certificadoSaftao = media.getByteData();
				lblCertificadoSaftao.setValue(info);
			} else {
				Messagebox.show(
						Labels.getLabel("editarMarcaController.MSG.errorIMG") + " " + media,
						Labels.getLabel(TITULO),
						Messagebox.OK, Messagebox.ERROR);
			}

		} catch (Exception ex) {
			log.error(ex);
			throw UiException.Aide.wrap(ex);
		}
	}
	
	private String getCerticateInfoSaftao(InputStream cerFileStream) throws IOException, Exception {

		StringWriter writer = new StringWriter();
		IOUtils.copy(cerFileStream, writer, "UTF-8");

		String privateKeyContent = writer != null ? writer.toString() : null;

		if (privateKeyContent == null) {
			return null;
		}

		privateKeyContent = privateKeyContent.replaceAll("-----END PRIVATE KEY-----", "")
				.replaceAll("-----BEGIN PRIVATE KEY-----", "").replaceAll("-----BEGIN RSA PRIVATE KEY-----", "")
				.replaceAll("-----END RSA PRIVATE KEY-----", "").replaceAll("\r\n", "").replaceAll("\n", "");

		KeyFactory kf = KeyFactory.getInstance("RSA");

		PKCS8EncodedKeySpec keySpecPKCS8 = new PKCS8EncodedKeySpec(Base64.decodeBase64(privateKeyContent));

		PrivateKey privKey = kf.generatePrivate(keySpecPKCS8);

		return privKey.toString();
	}

	public EmpresaEmailFlexBusService getEmpresaEmailFlexBusService() {
		return empresaEmailFlexBusService;
	}

	public void setEmpresaEmailFlexBusService(EmpresaEmailFlexBusService empresaEmailFlexBusService) {
		this.empresaEmailFlexBusService = empresaEmailFlexBusService;
	}

	public EmpresaEmailFlexBus getEmpresaEmailFlexBus() {
		return empresaEmailFlexBus;
	}

	public void setEmpresaEmailFlexBus(EmpresaEmailFlexBus empresaEmailFlexBus) {
		this.empresaEmailFlexBus = empresaEmailFlexBus;
	}
	
	public Decimalbox getTxtIrkPadrao() {
		return txtIrkPadrao;
	}

	public void setTxtIrkPadrao(Decimalbox txtIrkPadrao) {
		this.txtIrkPadrao = txtIrkPadrao;
	}

	public List<TipoEmail> getLsTipoEmail() {
		return lsTipoEmail;
	}

	public void setLsTipoEmail(List<TipoEmail> lsTipoEmail) {
		this.lsTipoEmail = lsTipoEmail;
	}

	public Tabbox getTabCallCenter() {
		return tabCallCenter;
	}

	public void setTabCallCenter(Tabbox tabCallCenter) {
		this.tabCallCenter = tabCallCenter;
	}

	public Tabbox getTabECommerce() {
		return tabECommerce;
	}

	public void setTabECommerce(Tabbox tabECommerce) {
		this.tabECommerce = tabECommerce;
	}

	public Combobox getCmbTipoEmail() {
		return cmbTipoEmail;
	}

	public void setCmbTipoEmail(Combobox cmbTipoEmail) {
		this.cmbTipoEmail = cmbTipoEmail;
	}

	public EmpresaEmailEComerce getEmpresaEmailEComerce() {
		return empresaEmailEComerce;
	}

	public void setEmpresaEmailEComerce(EmpresaEmailEComerce empresaEmailEComerce) {
		this.empresaEmailEComerce = empresaEmailEComerce;
	}

	public List<TipoOperacaoECommerce> getLsTipoOperacao() {
		return lsTipoOperacao;
	}

	public void setLsTipoOperacao(List<TipoOperacaoECommerce> lsTipoOperacao) {
		this.lsTipoOperacao = lsTipoOperacao;
	}

	public Label getLblTipoEmail() {
		return lblTipoEmail;
	}

	public void setLblTipoEmail(Label lblTipoEmail) {
		this.lblTipoEmail = lblTipoEmail;
	}

	public List<StoreVO> getLsStoreMercadoPago() {
		return lsStoreMercadoPago;
	}

	public void setLsStoreMercadoPago(List<StoreVO> lsStoreMercadoPago) {
		this.lsStoreMercadoPago = lsStoreMercadoPago;
	}
	
	public List<PosVO> getLsPosMercadoPago() {
		return lsPosMercadoPago;
	}

	public void setLsPosMercadoPago(List<PosVO> lsPosMercadoPago) {
		this.lsPosMercadoPago = lsPosMercadoPago;
	}

	public EmpresaMercadoPagoConfig getEmpresaMercadoPagoConfig() {
		return empresaMercadoPagoConfig;
	}

	public void setEmpresaMercadoPagoConfig(EmpresaMercadoPagoConfig empresaMercadoPagoConfig) {
		this.empresaMercadoPagoConfig = empresaMercadoPagoConfig;
	}

	public PosVO getPosVO() {
		return posVO;
	}

	public void setPosVO(PosVO posVO) {
		this.posVO = posVO;
	}

	public StoreVO getStoreVO() {
		return storeVO;
	}

	public void setStoreVO(StoreVO storeVO) {
		this.storeVO = storeVO;
	}

	public EmpresaAdyenConfigService getEmpresaAdyenConfigService() {
		return empresaAdyenConfigService;
	}

	public void setEmpresaAdyenConfigService(EmpresaAdyenConfigService empresaAdyenConfigService) {
		this.empresaAdyenConfigService = empresaAdyenConfigService;
	}

	public EmpresaAdyenConfig getEmpresaAdyenConfig() {
		return empresaAdyenConfig;
	}

	public void setEmpresaAdyenConfig(EmpresaAdyenConfig empresaAdyenConfig) {
		this.empresaAdyenConfig = empresaAdyenConfig;
	}

	public Timebox getHoraInicioEmbarque() {
		return horaInicioEmbarque;
	}

	public void setHoraInicioEmbarque(Timebox horaInicioEmbarque) {
		this.horaInicioEmbarque = horaInicioEmbarque;
	}

	public Timebox getHoraFimEmbarque() {
		return horaFimEmbarque;
	}

	public void setHoraFimEmbarque(Timebox horaFimEmbarque) {
		this.horaFimEmbarque = horaFimEmbarque;
	}

	public boolean isExibeDadosTokenLicenca() {
		return !cadastroEmpresaNova;
	}

	public MyComboboxEstandar getCmbTipoDePassagem() {
		return cmbTipoDePassagem;
	}

	public void setCmbTipoDePassagem(MyComboboxEstandar cmbTipoDePassagem) {
		this.cmbTipoDePassagem = cmbTipoDePassagem;
	}

	public EmpresaPMArtespConfig getEmpresaPMArtespConfig() {
		return empresaPMArtespConfig;
	}

	public void setEmpresaPMArtespConfig(EmpresaPMArtespConfig empresaPMArtespConfig) {
		this.empresaPMArtespConfig = empresaPMArtespConfig;
	}

	public MyComboboxEstandar getCmbOrgaoConcedente() {
		return cmbOrgaoConcedente;
	}

	public void setCmbOrgaoConcedente(MyComboboxEstandar cmbOrgaoConcedente) {
		this.cmbOrgaoConcedente = cmbOrgaoConcedente;
	}

	public List<OrgaoConcedente> getLsOrgaoConcedente() {
		return lsOrgaoConcedente;
	}

	public void setLsOrgaoConcedente(List<OrgaoConcedente> lsOrgaoConcedente) {
		this.lsOrgaoConcedente = lsOrgaoConcedente;
	}

	public List<EnumTipoIntegracao> getLsTipoIntegracao() {
		return lsTipoIntegracao;
	}

	public void setLsTipoIntegracao(List<EnumTipoIntegracao> lsTipoIntegracao) {
		this.lsTipoIntegracao = lsTipoIntegracao;
	}

	public List<TipoVenta> getLsTiposVenta() {
		return lsTiposVenta;
	}

	public void setLsTiposVenta(List<TipoVenta> lsTiposVenta) {
		this.lsTiposVenta = lsTiposVenta;
	}

	public List<EmpresaConfigLayout> getLsEmpresaConfigLayout() {
		return lsEmpresaConfigLayout;
	}

	public void setLsEmpresaConfigLayout(List<EmpresaConfigLayout> lsEmpresaConfigLayout) {
		this.lsEmpresaConfigLayout = lsEmpresaConfigLayout;
	}

	public MyListbox getEmpresaLayoutConfigList() {
		return empresaLayoutConfigList;
	}

	public void setEmpresaLayoutConfigList(MyListbox empresaLayoutConfigList) {
		this.empresaLayoutConfigList = empresaLayoutConfigList;
	}

	public MyListbox getEmpresaFormasPagamentoSicfe() {
		return empresaFormasPagamentoSicfe;
	}

	public void setEmpresaFormasPagamentoSicfe(MyListbox empresaFormasPagamentoSicfe) {
		this.empresaFormasPagamentoSicfe = empresaFormasPagamentoSicfe;
	}

	public MyListbox getEmpresaFormasPagamentoSicfeSelecionado() {
		return empresaFormasPagamentoSicfeSelecionado;
	}

	public void setEmpresaFormasPagamentoSicfeSelecionado(MyListbox empresaFormasPagamentoSicfeSelecionado) {
		this.empresaFormasPagamentoSicfeSelecionado = empresaFormasPagamentoSicfeSelecionado;
	}

	public MyListbox getEmpresaFormasPagamentoSicfeNaoEmite() {
		return empresaFormasPagamentoSicfeNaoEmite;
	}

	public void setEmpresaFormasPagamentoSicfeNaoEmite(MyListbox empresaFormasPagamentoSicfeNaoEmite) {
		this.empresaFormasPagamentoSicfeNaoEmite = empresaFormasPagamentoSicfeNaoEmite;
	}

	public MyListbox getEmpresaFormasPagamentoSicfeNaoEmiteSelecionado() {
		return empresaFormasPagamentoSicfeNaoEmiteSelecionado;
	}

	public void setEmpresaFormasPagamentoSicfeNaoEmiteSelecionado(
			MyListbox empresaFormasPagamentoSicfeNaoEmiteSelecionado) {
		this.empresaFormasPagamentoSicfeNaoEmiteSelecionado = empresaFormasPagamentoSicfeNaoEmiteSelecionado;
	}

}
