/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package com.rjconsultores.ventaboletos.web.gui.controladores.configuracioneccomerciales;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Calendar;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.apache.commons.lang.StringUtils;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
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.zhtml.Messagebox;
import org.zkoss.zk.ui.Component;
import org.zkoss.zk.ui.Executions;
import org.zkoss.zk.ui.WrongValueException;
import org.zkoss.zk.ui.event.Event;
import org.zkoss.zk.ui.event.EventListener;
import org.zkoss.zk.ui.util.Clients;
import org.zkoss.zul.Checkbox;
import org.zkoss.zul.Combobox;
import org.zkoss.zul.Comboitem;
import org.zkoss.zul.Decimalbox;
import org.zkoss.zul.Intbox;
import org.zkoss.zul.Label;
import org.zkoss.zul.Radio;
import org.zkoss.zul.Row;
import org.zkoss.zul.Spinner;
import org.zkoss.zul.Tab;
import org.zkoss.zul.Textbox;
import org.zkoss.zul.api.Timebox;

import com.rjconsultores.ventaboletos.constantes.Constantes;
import com.rjconsultores.ventaboletos.constantes.ConstantesFuncionSistema;
import com.rjconsultores.ventaboletos.dao.ConstanteDAO;
import com.rjconsultores.ventaboletos.entidad.Categoria;
import com.rjconsultores.ventaboletos.entidad.CategoriaClase;
import com.rjconsultores.ventaboletos.entidad.CategoriaCorrida;
import com.rjconsultores.ventaboletos.entidad.CategoriaCtrl;
import com.rjconsultores.ventaboletos.entidad.CategoriaDescuento;
import com.rjconsultores.ventaboletos.entidad.CategoriaDescuento.TipoDescontoComponentePreco;
import com.rjconsultores.ventaboletos.entidad.CategoriaMarca;
import com.rjconsultores.ventaboletos.entidad.CategoriaMercado;
import com.rjconsultores.ventaboletos.entidad.CategoriaOrgao;
import com.rjconsultores.ventaboletos.entidad.CategoriaPeriodo;
import com.rjconsultores.ventaboletos.entidad.CategoriaRuta;
import com.rjconsultores.ventaboletos.entidad.CategoriaRutaExcecao;
import com.rjconsultores.ventaboletos.entidad.ClaseServicio;
import com.rjconsultores.ventaboletos.entidad.Constante;
import com.rjconsultores.ventaboletos.entidad.Corrida;
import com.rjconsultores.ventaboletos.entidad.CorridaCtrl;
import com.rjconsultores.ventaboletos.entidad.Empresa;
import com.rjconsultores.ventaboletos.entidad.Marca;
import com.rjconsultores.ventaboletos.entidad.OrgaoConcedente;
import com.rjconsultores.ventaboletos.entidad.Parada;
import com.rjconsultores.ventaboletos.entidad.Ruta;
import com.rjconsultores.ventaboletos.entidad.TipoOcupacion;
import com.rjconsultores.ventaboletos.enums.HorarioLiberacaoVendaPassagem;
import com.rjconsultores.ventaboletos.enums.TipoPassagemCores;
import com.rjconsultores.ventaboletos.service.CategoriaClaseService;
import com.rjconsultores.ventaboletos.service.CategoriaCorridaService;
import com.rjconsultores.ventaboletos.service.CategoriaCtrlService;
import com.rjconsultores.ventaboletos.service.CategoriaMarcaService;
import com.rjconsultores.ventaboletos.service.CategoriaMercadoService;
import com.rjconsultores.ventaboletos.service.CategoriaOrgaoService;
import com.rjconsultores.ventaboletos.service.CategoriaPeriodoService;
import com.rjconsultores.ventaboletos.service.CategoriaRutaExcecaoService;
import com.rjconsultores.ventaboletos.service.CategoriaRutaService;
import com.rjconsultores.ventaboletos.service.CategoriaService;
import com.rjconsultores.ventaboletos.service.ClaseServicioService;
import com.rjconsultores.ventaboletos.service.ConstanteService;
import com.rjconsultores.ventaboletos.service.CorridaCtrlService;
import com.rjconsultores.ventaboletos.service.MarcaService;
import com.rjconsultores.ventaboletos.service.OrgaoConcedenteService;
import com.rjconsultores.ventaboletos.service.RutaService;
import com.rjconsultores.ventaboletos.service.TipoOcupacionService;
import com.rjconsultores.ventaboletos.service.impl.CategoriaCtrlServiceImpl;
import com.rjconsultores.ventaboletos.utilerias.DateUtil;
import com.rjconsultores.ventaboletos.utilerias.UsuarioLogado;
import com.rjconsultores.ventaboletos.web.utilerias.MyComboboxRuta;
import com.rjconsultores.ventaboletos.web.utilerias.MyGenericForwardComposer;
import com.rjconsultores.ventaboletos.web.utilerias.MyListbox;
import com.rjconsultores.ventaboletos.web.utilerias.render.RenderConfiguracionCategoriaClase;
import com.rjconsultores.ventaboletos.web.utilerias.render.RenderConfiguracionCategoriaCorrida;
import com.rjconsultores.ventaboletos.web.utilerias.render.RenderConfiguracionCategoriaDecuento;
import com.rjconsultores.ventaboletos.web.utilerias.render.RenderConfiguracionCategoriaMarca;
import com.rjconsultores.ventaboletos.web.utilerias.render.RenderConfiguracionCategoriaMercado;
import com.rjconsultores.ventaboletos.web.utilerias.render.RenderConfiguracionCategoriaOrgao;
import com.rjconsultores.ventaboletos.web.utilerias.render.RenderConfiguracionCategoriaRuta;
import com.rjconsultores.ventaboletos.web.utilerias.render.RenderConfiguracionCategoriaRutaExcecao;

/**
 *
 * @author rodrigo
 */
@Controller("editarConfiguracionCategoriaController")
@Scope("prototype")
public class EditarConfiguracionCategoriaController extends MyGenericForwardComposer {

	private static final long serialVersionUID = 1L;
	private static Logger log = LogManager.getLogger(EditarConfiguracionCategoriaController.class);
	@Autowired
	private MarcaService marcaService;
	@Autowired
	private ClaseServicioService claseServicioService;
	@Autowired
	private CorridaCtrlService corridaCtrlService;
	@Autowired
	private CategoriaService categoriaService;
	@Autowired
	private CategoriaCorridaService categoriaCorridaService;
	@Autowired
	private CategoriaCtrlService categoriaCtrlService;
	@Autowired
	private CategoriaOrgaoService categoriaOrgaoService;
	@Autowired
	private CategoriaClaseService categoriaClaseService;
	@Autowired
	private CategoriaPeriodoService categoriaPeriodoService;
	@Autowired
	private CategoriaMarcaService categoriaMarcaService;
	@Autowired
	private OrgaoConcedenteService orgaoService;
	@Autowired
	private RutaService rutaService;
	@Autowired
	private ConstanteService constanteService;
	@Autowired
	private CategoriaRutaService categoriaRutaService;
	@Autowired
	private CategoriaRutaExcecaoService categoriaRutaExcecaoService;
	@Autowired
	private CategoriaMercadoService categoriaMercadoService;
	
	private List<Marca> lsMarcas;
	private List<ClaseServicio> lsClaseServicio;
	private List<Empresa> lsEmpresas;
	private List<Corrida> lsCorridas;
	private List<Categoria> lsCategorias;
	private List<OrgaoConcedente> lsOrgao;
	private List<Ruta> lsRuta;
	private List<Ruta> lsRutaSemTodas;
	private CategoriaMercado categoriaMercado;
	private CategoriaMarca categoriaMarca;
	private CategoriaDescuento categoriaDescuento;
	private CategoriaCtrl categoriaCtrl;
	private CategoriaCorrida categoriaCorrida;
	private CategoriaClase categoriaClase;
	private CategoriaOrgao categoriaOrgao;
	private CategoriaRuta categoriaRuta;
	private MyListbox categoriaCtrlList;
	private MyListbox categoriaClaseList;
	private MyListbox categoriaCorridaList;
	private MyListbox categoriaDescuentoList;
	private MyListbox categoriaMarcaList;
	private MyListbox categoriaMercadoList;
	private MyListbox categoriaOrgaoList;
	private MyListbox categoriaRutaList;
	private MyListbox categoriaRutaExcecaoList;
	private List<CategoriaClase> lsCategoriaClase;
	private List<CategoriaClase> lsCategoriaClaseTemp;
	private List<CategoriaDescuento> lsCategoriaDescuento;
	private List<CategoriaMarca> lsCategoriaMarca;
	private List<CategoriaMarca> lsCategoriaMarcaTemp;
	private List<CategoriaMercado> lsCategoriaMercado;
	private List<CategoriaMercado> lsCategoriaMercadoTemp;
	private List<CategoriaCorrida> lsCategoriaCorrida;
	private List<CategoriaCorrida> lsCategoriaCorridaTemp;
	private List<CategoriaOrgao> lsCategoriaOrgao;
	private List<CategoriaOrgao> lsCategoriaOrgaoTemp;
	private List<CategoriaRuta> lsCategoriaRuta;
	private List<CategoriaRuta> lsCategoriaRutaTemp;
	private List<CategoriaRutaExcecao> lsCategoriaRutaExcecao;
	private List<CategoriaRutaExcecao> lsCategoriaRutaExcecaoTemp;
	private boolean clone = false;
	private Combobox cmbCategorias;
	private Combobox cmbEmpresas;
	private Combobox cmbMarca;
	private Combobox cmbClase;
	private Combobox cmbParadaOrigem;
	private Combobox cmbParadaDestino;
	private Combobox cmbOrgao;
	private MyComboboxRuta cmbRuta;
	private Combobox cmbCategoriaRutaExcecao;
	private Combobox cmbIndGeneraFeriado;
	private Decimalbox descuentoImporte;
	private Decimalbox descuentoPorc;
	private Intbox idCorrida;
	private Intbox cantAutorizada;
	private Radio radioImp;
	private Radio radioImprimePassagem;
	private Radio rdCuotaSi;
	private Radio radioNaoImprimePassagem;
	private Radio rdVendaAntecipadaSi;
	private Radio rdVendaAntecipadaNo;
	private Radio rdVendeAbertoSim;
	private Row rowTrecho;
	private Row rowTiempo;
	private Radio rdTrecho;
	private Radio rdNuncaLiberar;
	private Timebox timeTempoPermitir;
	private Tab tabEmpresa;
	private Tab tabDesconto;
	private Tab tabMarca;
	private Tab tabMercado;
	private Tab tabClasse;
	private Checkbox chkPrecoTxEmbarque;
	private Checkbox chkPrecoPedagio;
	private Checkbox chkPrecoSeguro;
	private Checkbox chkPrecoOutros;
	private Checkbox chkPrecoSeguroOpcional;
	private Label lblMsgTiempo;
	private Spinner spnHora;
	private Spinner spnMinuto;
	private Checkbox chkLiberacionSolamenteEnvasado;
	private Textbox asientosReservados;
	private Row linhaLiberarPoltronasQuandoOnibus;
	private Row linhaAssentosReservados;
	private Checkbox chkExigenombpasajero;
	private Checkbox chkExigedocpasajero;
	private Checkbox chkExigetelefonopasajero;
	private Checkbox chkExigefecnacimientopasajero;
	private Checkbox chkExigedoc2pasajero;
	private Checkbox chkExigeEnderecopasajero;
	private Checkbox chkExigeEmailpasajero;
	private Checkbox chkSegunda;
	private Checkbox chkTerca;
	private Checkbox chkQuarta;
	private Checkbox chkQuinta;
	private Checkbox chkSexta;
	private Checkbox chkSabado;
	private Checkbox chkDomingo;
	private Checkbox chkIndnaopermitevdamesmodocviagem;
	private Checkbox chkIndnaopermiteVendaDuasGratuidades;
	private Checkbox chkIndnaoaplicatarifaminima;
	private Checkbox chkIndtipoocupacao;

	private Radio radioCorLaranja;
	private Radio radioCorVerde;
	private Radio radioCorVerdeMusgo;
	private Radio radioCorAzul;
	private Radio radioCorAzulMarinho;
	private Radio radioCorAzulPiscina;
	private Radio radioCorBege;
	private Radio radioCorLilas;
	private Radio radioCorMarrom;
	private Radio radioCorRosa;
	private Radio radioCorRosaChoque;
	private Radio radioCorRoxo;

	private Radio radioHorarioLiberacaoVendaOrigem;
	private Radio radioHorarioLiberacaoVendaTrecho;

	private Checkbox radioCompPrecoImp;
	private Checkbox radioCompPrecoPor;
	private Decimalbox desccomppreco;
	private Textbox txtDescricao;
	private CorridaCtrl corrida;
	private CategoriaCtrl nuevo;

	private Checkbox chkIndEmiteSomenteCupomEmbarque;
	private Intbox qtdeViasCupomEmbarque;
	
	private Radio rdVendaAntecipadaKMSi;
	
	private Row rowVendaAntecipada;
	private Row rowKMVendaAntecipada;
	private Row rowTempoKMVendaAntecipada;
	private Row rowTiempoVendaAntecipada;
	
	private Timebox tbTempoAteKM;
	private Timebox tbTempoMaiorKM;
	
	private Spinner spnKM;
	
	private Checkbox chkIndClientePcd;
	private Intbox qtdeLimiteNaoEmbarque;
	private Intbox cantMaximaVendaMes;
	
	private Row rowComportamentoVendaAberto;
	
	//Opcoes de venda em aberto
	private Checkbox chkPermiteTroca;
	private Checkbox chkPermiteTransferencia;
	
	private Checkbox chkCancelaEmAberto;
	private Checkbox chkDevolveEmAberto;
	private Checkbox chkCancelaEmergencialEmAberto;
	private Checkbox chkTrocaEmAberto;
	private Checkbox chkTrocaTiturlidadeEmAberto;
	
	private Checkbox chkCancela;
	private Checkbox chkDevolve;
	private Checkbox chkCancelaEmergencial;
	private Checkbox chkTrocaTiturlidade;
	private Checkbox chkReativa;
	private Radio radioCheckinSim;
	private Radio radioCheckinNao;
	/**
	 * Desconto por Valor pela linha(Ruta)
	 */
	private Decimalbox descontoValorLinha;
	/**
	 * Desconto Porcentagem pela linha(Ruta)
	 */
	private Decimalbox descontoPorcentagemLinha;
	/**
	 * Qtade poltronas autorizadas pela Linha(Ruta)
	 */
	private Intbox qtdAutorizadaLinha;
	private List<Intbox> lsIntBox;
	private List<Decimalbox> lsValorDecimalBox;
	private List<Decimalbox> lsPorcentagemDecimalBox;
	
	private Combobox cmbCategoriasInteragem;
	private Row rowIdTipoCategoriaInteragem;
	private Checkbox chkTipoCategoriaInteragem;
	private Checkbox chkExigeNumeroFidelidade;
	
	private CKeditor ckCustomizaRodapeCupomEmbarque;	
	private Checkbox chkIndCustomizaRodapeCupomEmbarque;	
	private Row rowCustomizaRodapeCupomEmbarque;
	
	private List<TipoOcupacion> lsTipoOcupacion;
	
	@Autowired
	private TipoOcupacionService tipoOcupacionService;
	
	private Combobox cmbOcupacion;
	private Row rowIdTipoOcupacao;
	
	@Autowired
	private ConstanteDAO constanteDAO;

	public Checkbox getChkTipoCategoriaIntegarem() {
		return chkTipoCategoriaInteragem;
	}

	public void setChkTipoCategoriaIntegarem(Checkbox chkTipoCategoriaInteragem) {
		this.chkTipoCategoriaInteragem = chkTipoCategoriaInteragem;
	}

	public Checkbox getChkExigeNumeroFidelidade() {
		return chkExigeNumeroFidelidade;
	}

	public void setChkExigeNumeroFidelidade(Checkbox chkExigeNumeroFidelidade) {
		this.chkExigeNumeroFidelidade = chkExigeNumeroFidelidade;
	}

	public Row getRowIdTipoCategoriaIntegarem() {
		return rowIdTipoCategoriaInteragem;
	}

	public void setRowIdTipoCategoriaIntegarem(Row rowIdTipoCategoriaIntegarem) {
		this.rowIdTipoCategoriaInteragem = rowIdTipoCategoriaIntegarem;
	}

	public List<Categoria> getLsCategorias() {
		return lsCategorias;
	}

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

	public List<ClaseServicio> getLsClaseServicio() {
		return lsClaseServicio;
	}

	public void setLsClaseServicio(List<ClaseServicio> lsClaseServicio) {
		this.lsClaseServicio = lsClaseServicio;
	}

	public List<Corrida> getLsCorridas() {
		return lsCorridas;
	}

	public void setLsCorridas(List<Corrida> lsCorridas) {
		this.lsCorridas = lsCorridas;
	}

	public List<Empresa> getLsEmpresas() {
		return lsEmpresas;
	}

	public void setLsEmpresas(List<Empresa> lsEmpresas) {
		this.lsEmpresas = lsEmpresas;
	}

	public List<Marca> getLsMarcas() {
		return lsMarcas;
	}

	public void setLsMarcas(List<Marca> lsMarcas) {
		this.lsMarcas = lsMarcas;
	}

	public List<OrgaoConcedente> getLsOrgao() {
		return lsOrgao;
	}

	public void setLsOrgao(List<OrgaoConcedente> lsOrgao) {
		this.lsOrgao = lsOrgao;
	}

	public CategoriaCtrl getCategoriaCTRL() {
		return categoriaCtrl;
	}

	public void setCategoriaCTRL(CategoriaCtrl categoriaCTRL) {
		this.categoriaCtrl = categoriaCTRL;
	}

	public CategoriaClase getCategoriaClase() {
		return categoriaClase;
	}

	public void setCategoriaClase(CategoriaClase categoriaClase) {
		this.categoriaClase = categoriaClase;
	}

	public CategoriaCorrida getCategoriaCorrida() {
		return categoriaCorrida;
	}

	public void setCategoriaCorrida(CategoriaCorrida categoriaCorrida) {
		this.categoriaCorrida = categoriaCorrida;
	}

	public CategoriaOrgao getCategoriaOrgao() {
		return categoriaOrgao;
	}

	public void setCategoriaOrgao(CategoriaOrgao categoriaOrgao) {
		this.categoriaOrgao = categoriaOrgao;
	}

	public List<CategoriaOrgao> getLsCategoriaOrgao() {
		return lsCategoriaOrgao;
	}

	public void setLsCategoriaOrgao(List<CategoriaOrgao> lsCategoriaOrgao) {
		this.lsCategoriaOrgao = lsCategoriaOrgao;
	}

	public CategoriaCtrlService getCategoriaCtrlService() {
		return categoriaCtrlService;
	}

	public void setCategoriaCtrlService(CategoriaCtrlService categoriaCtrlService) {
		this.categoriaCtrlService = categoriaCtrlService;
	}

	public CategoriaDescuento getCategoriaDescuento() {
		return categoriaDescuento;
	}

	public void setCategoriaDescuento(CategoriaDescuento categoriaDescuento) {
		this.categoriaDescuento = categoriaDescuento;
	}

	public CategoriaMarca getCategoriaMarca() {
		return categoriaMarca;
	}

	public void setCategoriaMarca(CategoriaMarca categoriaMarca) {
		this.categoriaMarca = categoriaMarca;
	}

	public CategoriaMercado getCategoriaMercado() {
		return categoriaMercado;
	}

	public void setCategoriaMercado(CategoriaMercado categoriaMercado) {
		this.categoriaMercado = categoriaMercado;
	}

	public List<CategoriaClase> getLsCategoriaClase() {
		return lsCategoriaClase;
	}

	public void setLsCategoriaClase(List<CategoriaClase> lsCategoriaClase) {
		this.lsCategoriaClase = lsCategoriaClase;
	}

	public List<CategoriaDescuento> getLsCategoriaDescuento() {
		return lsCategoriaDescuento;
	}

	public void setLsCategoriaDescuento(List<CategoriaDescuento> lsCategoriaDescuento) {
		this.lsCategoriaDescuento = lsCategoriaDescuento;
	}

	public List<CategoriaMarca> getLsCategoriaMarca() {
		return lsCategoriaMarca;
	}

	public void setLsCategoriaMarca(List<CategoriaMarca> lsCategoriaMarca) {
		this.lsCategoriaMarca = lsCategoriaMarca;
	}

	public List<CategoriaMercado> getLsCategoriaMercado() {
		return lsCategoriaMercado;
	}

	public void setLsCategoriaMercado(List<CategoriaMercado> lsCategoriaMercado) {
		this.lsCategoriaMercado = lsCategoriaMercado;
	}

	public List<CategoriaCorrida> getLsCategoriaCorrida() {
		return lsCategoriaCorrida;
	}

	public void setLsCategoriaCorrida(List<CategoriaCorrida> lsCategoriaCorrida) {
		this.lsCategoriaCorrida = lsCategoriaCorrida;
	}

	public List<Ruta> getLsRuta() {
		return lsRuta;
	}

	public void setLsRuta(List<Ruta> lsRuta) {
		this.lsRuta = lsRuta;
	}

	public List<Ruta> getLsRutaSemTodas() {
		return lsRutaSemTodas;
	}

	public void setLsRutaSemTodas(List<Ruta> lsRutaSemTodas) {
		this.lsRutaSemTodas = lsRutaSemTodas;
	}

	public CategoriaRuta getCategoriaRuta() {
		return categoriaRuta;
	}

	public void setCategoriaRuta(CategoriaRuta categoriaRuta) {
		this.categoriaRuta = categoriaRuta;
	}

	public MyListbox getCategoriaRutaList() {
		return categoriaRutaList;
	}

	public void setCategoriaRutaList(MyListbox categoriaRutaList) {
		this.categoriaRutaList = categoriaRutaList;
	}

	public List<CategoriaRuta> getLsCategoriaRuta() {
		return lsCategoriaRuta;
	}

	public void setLsCategoriaRuta(List<CategoriaRuta> lsCategoriaRuta) {
		this.lsCategoriaRuta = lsCategoriaRuta;
	}

	public Combobox getCmbRuta() {
		return cmbRuta;
	}

	public void setCmbRuta(MyComboboxRuta cmbRuta) {
		this.cmbRuta = cmbRuta;
	}

	public void clearCombobox(Combobox combobox) {
		int size = combobox.getItemCount();

		for (int i = size - 1; i >= 0; i--) {
			combobox.removeItemAt(i);
		}
	}

	public void popularCombobox(Combobox cmb) throws Exception {
		clearCombobox(cmb);
		for (CategoriaDescuento.DisponibilidadeFeriado p : CategoriaDescuento.DisponibilidadeFeriado.values()) {
			Comboitem comboItem = new Comboitem(p.descricao());
			comboItem.setValue(p.valor());
			comboItem.setParent(cmb);
		}

		cmb.setSelectedIndex(0);
	}

	@Override
	public void doAfterCompose(Component comp) throws Exception {
		lsCategorias = categoriaService.obtenerTodos();
		lsClaseServicio = claseServicioService.obtenerTodos();
		lsEmpresas = UsuarioLogado.getUsuarioLogado().getEmpresa();
		lsMarcas = marcaService.buscarMarcaPorEmpresa(UsuarioLogado.getUsuarioLogado().getEmpresa());
		lsOrgao = orgaoService.obtenerTodos();
		lsRuta = rutaService.obtenerTodos();
		lsRutaSemTodas = restringirOpcaoTodasLinhas(lsRuta);
		lsTipoOcupacion = tipoOcupacionService.obtenerTodos();
		
		super.doAfterCompose(comp);
		
		idCorrida.setMaxlength(Boolean.valueOf(constanteDAO.buscarPorNomeConstante(Constantes.NUM_VIAJE_9_DIGITOS).getValorconstante()) ? 9 : 7);
		

		popularCombobox(cmbIndGeneraFeriado);

		categoriaCtrlList = (MyListbox) Executions.getCurrent().getArg().get("categoriaCtrlList");
		categoriaCtrl = (CategoriaCtrl) Executions.getCurrent().getArg().get("categoriaCtrl");

		if (categoriaCtrl == null) {
			categoriaCtrl = new CategoriaCtrl();
		}

		// Desconto
		categoriaDescuentoList.setItemRenderer(new RenderConfiguracionCategoriaDecuento());

		lsCategoriaDescuento = new ArrayList<CategoriaDescuento>();
		// Clase
		categoriaClaseList.setItemRenderer(new RenderConfiguracionCategoriaClase());
		lsCategoriaClase = new ArrayList<CategoriaClase>();
		lsCategoriaClaseTemp = new ArrayList<CategoriaClase>();
		// Marca
		categoriaMarcaList.setItemRenderer(new RenderConfiguracionCategoriaMarca());
		lsCategoriaMarca = new ArrayList<CategoriaMarca>();
		lsCategoriaMarcaTemp = new ArrayList<CategoriaMarca>();
		// Mercado
		categoriaMercadoList.setItemRenderer(new RenderConfiguracionCategoriaMercado());
		lsCategoriaMercado = new ArrayList<CategoriaMercado>();
		lsCategoriaMercadoTemp = new ArrayList<CategoriaMercado>();
		// Corrida
		categoriaCorridaList.setItemRenderer(new RenderConfiguracionCategoriaCorrida());
		lsCategoriaCorrida = new ArrayList<CategoriaCorrida>();
		lsCategoriaCorridaTemp = new ArrayList<CategoriaCorrida>();
		// Orgao
		categoriaOrgaoList.setItemRenderer(new RenderConfiguracionCategoriaOrgao());
		lsCategoriaOrgao = new ArrayList<CategoriaOrgao>();
		lsCategoriaOrgaoTemp = new ArrayList<CategoriaOrgao>();
		// Ruta
		lsCategoriaRuta = new ArrayList<CategoriaRuta>();
		lsCategoriaRutaTemp = new ArrayList<CategoriaRuta>();
		// Ruta Excecao
		categoriaRutaExcecaoList.setItemRenderer(new RenderConfiguracionCategoriaRutaExcecao());
		lsCategoriaRutaExcecao = new ArrayList<CategoriaRutaExcecao>();
		lsCategoriaRutaExcecaoTemp = new ArrayList<CategoriaRutaExcecao>();

		// Recarrega Listas
		if (categoriaCtrl.getCategoriactrlId() != null) {
			categoriaCtrl = categoriaCtrlService.obtenerID(categoriaCtrl.getCategoriactrlId());

			lsCategoriaDescuento = categoriaCtrl.getCategoriaDescuentoList();
			categoriaDescuentoList.setData(lsCategoriaDescuento);

			lsCategoriaClase = categoriaCtrl.getCategoriaClaseList();
			categoriaClaseList.setData(lsCategoriaClase);
			lsCategoriaClaseTemp.addAll(lsCategoriaClase);

			lsCategoriaMarca = categoriaCtrl.getCategoriaMarcaList();
			categoriaMarcaList.setData(lsCategoriaMarca);
			lsCategoriaMarcaTemp.addAll(lsCategoriaMarca);

			lsCategoriaOrgao = categoriaCtrl.getCategoriaOrgaoList();
			categoriaOrgaoList.setData(lsCategoriaOrgao);
			lsCategoriaOrgaoTemp.addAll(lsCategoriaOrgao);

			lsCategoriaRuta = categoriaCtrl.getCategoriaRutaList();
			lsCategoriaRutaTemp.addAll(lsCategoriaRuta);
			//categoriaRutaList.setData(lsCategoriaRuta);

			lsCategoriaMercado = categoriaCtrl.getCategoriaMercadoList();
			lsCategoriaMercadoTemp = categoriaCtrl.getCategoriaMercadoList();
			categoriaMercadoList.setData(lsCategoriaMercado);

			lsCategoriaCorrida = categoriaCtrl.getCategoriaCorridaList();
			categoriaCorridaList.setData(lsCategoriaCorrida);
			lsCategoriaCorridaTemp.addAll(lsCategoriaCorrida);
			
			lsCategoriaRutaExcecao = categoriaCtrl.getCategoriaRutaExcecaoList();
			lsCategoriaRutaExcecaoTemp = categoriaCtrl.getCategoriaRutaExcecaoList();
			categoriaRutaExcecaoList.setData(lsCategoriaRutaExcecao);
			
			try {
				categoriaCtrl.clonar();
			} catch (Exception e) {
				log.error(e.getMessage(), e);
			}
		}
		
		//Inicializa Intbox
		iniciaIntBoxesQtdeAutorizada(lsCategoriaRuta);
		inicialDecimalBoxesValor(lsCategoriaRuta);
		inicialDecimalBoxesPorcentagem(lsCategoriaRuta);
		categoriaRutaList.setItemRenderer(new RenderConfiguracionCategoriaRuta(lsIntBox, lsValorDecimalBox, lsPorcentagemDecimalBox ));
		categoriaRutaList.setData(lsCategoriaRuta);
		
		descuentoImporte.setValue(BigDecimal.ZERO);
		descuentoPorc.setValue(BigDecimal.ZERO);

		descuentoImporte.setDisabled(true);
		descuentoPorc.setDisabled(true);

		radioImp.setChecked(true);
		onClick$radioImp(null);
		cmbEmpresas.focus();
		linhaLiberarPoltronasQuandoOnibus.setVisible(false);
		linhaAssentosReservados.setVisible(false);
		txtDescricao.setValue(categoriaCtrl.getDescricao());
		radioCheckinNao.setChecked(Boolean.TRUE);
		rowIdTipoCategoriaInteragem.setVisible(false);
		rowIdTipoOcupacao.setVisible(false);

	}

	@SuppressWarnings({ "rawtypes", "unchecked" })
	public void onClick$btnEditarDatosCategoria(Event e) throws InterruptedException {
		CategoriaDescuento cd = (CategoriaDescuento) categoriaDescuentoList.getSelected();
		if (cd == null) {
			Messagebox.show(
					Labels.getLabel("editarConfiguracionCategoriaController.MSG.selectDescuento"),
					Labels.getLabel("editarConfiguracionCategoriaController.window.title"),
					Messagebox.OK, Messagebox.EXCLAMATION);
			return;
		}

		Map args = new HashMap();
		args.put("categoriaDescuento", cd);
		args.put("categoriaDescuentoList", categoriaDescuentoList);
		args.put("lsTipoOcupacion", lsTipoOcupacion);

		openWindow("/gui/configuraciones_comerciales/editarConfiguracionCategoriasDatosCategoria.zul",
				Labels.getLabel("editarConfiguracionCategoriaDatosCategoriaController.title"), args, MODAL);
	}

	@SuppressWarnings({ "rawtypes", "unchecked" })
	private void verPeriodoDesconto(CategoriaDescuento cd) throws InterruptedException {
		if (cd == null) {
			return;
		}

		/*
		 * Nao deixa editar periodos para novos tipo de pasajero Desa forma nao traslapa os periodos.
		 */
		if (categoriaCtrl.getCategoriactrlId() == null || (nuevo != null ? (nuevo.getCategoriactrlId() == null ? true : false) : false)) {
			Messagebox.show(Labels.getLabel("editarConfiguracionCategoriaController.MSG.editarPeriodo"),
					Labels.getLabel("editarConfiguracionCategoriaController.window.title"),
					Messagebox.OK, Messagebox.EXCLAMATION);
			return;
		}
		if (cd.getCategoria().getCategoriaId().equals(CategoriaCtrlServiceImpl.CATEGORIA_ADULTO)) {
			Messagebox.show(Labels.getLabel("editarConfiguracionCategoriaController.MSG.categoriaNormal"),
					Labels.getLabel("editarConfiguracionCategoriaController.window.title"),
					Messagebox.OK, Messagebox.EXCLAMATION);
			return;
		}

		Map args = new HashMap();
		args.put("categoriaDescuento", cd);
		args.put("categoriaDescuentoList", categoriaDescuentoList);

		openWindow("/gui/configuraciones_comerciales/editarConfiguracionCategoriasPeriodo.zul",
				Labels.getLabel("editarConfiguracionCategoriaControllerPeriodo.window.title"), args, MODAL);
	}

	public boolean validaObligatorios() throws InterruptedException {
		if (categoriaDescuentoList.getData().length == 0) {
			Messagebox.show(
					Labels.getLabel("editarConfiguracionCategoriaController.MSG.necesitaDescuento"),
					Labels.getLabel("editarConfiguracionCategoriaController.window.title"),
					Messagebox.OK, Messagebox.INFORMATION);
			tabDesconto.setSelected(Boolean.TRUE);
			return false;
		}
		if (categoriaMarcaList.getData().length == 0) {
			Messagebox.show(
					Labels.getLabel("editarConfiguracionCategoriaController.MSG.necesitaMarca"),
					Labels.getLabel("editarConfiguracionCategoriaController.window.title"),
					Messagebox.OK, Messagebox.INFORMATION);
			tabMarca.setSelected(Boolean.TRUE);
			return false;
		}
		if (categoriaMercadoList.getData().length == 0) {
			Messagebox.show(
					Labels.getLabel("editarConfiguracionCategoriaController.MSG.necesitaMercado"),
					Labels.getLabel("editarConfiguracionCategoriaController.window.title"),
					Messagebox.OK, Messagebox.INFORMATION);
			tabMercado.setSelected(Boolean.TRUE);
			return false;
		}
		if (categoriaClaseList.getData().length == 0) {
			Messagebox.show(
					Labels.getLabel("editarConfiguracionCategoriaController.MSG.necesitaClase"),
					Labels.getLabel("editarConfiguracionCategoriaController.window.title"),
					Messagebox.OK, Messagebox.INFORMATION);
			tabClasse.setSelected(Boolean.TRUE);
			return false;
		}
		if (categoriaRutaList.getData().length == 0) {
			Messagebox.show(
					Labels.getLabel("editarConfiguracionCategoriaController.MSG.necesitaRuta"),
					Labels.getLabel("editarConfiguracionCategoriaController.window.title"),
					Messagebox.OK, Messagebox.INFORMATION);
			tabClasse.setSelected(Boolean.TRUE);
			return false;
		}
		return true;
	}

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

		tabEmpresa.setSelected(Boolean.TRUE);
		cmbEmpresas.getValue();
		txtDescricao.getValue();

		if (!validaObligatorios()) {
			return;
		}
		if(!validarExisteExcecaoLinha()) {
				int resp = Messagebox.show(
						Labels.getLabel("editarConfiguracionCategoriaController.MSG.validarTodasComboLinhaSalvar"),
						Labels.getLabel("editarConfiguracionCategoriaController.window.title"), Messagebox.OK | Messagebox.CANCEL,
						Messagebox.QUESTION);
				if (!(resp == Messagebox.OK)) {
					return;
				}
			 inativarExcecoesLinha();		 
		}

		if (categoriaCtrl.getCategoriactrlId() != null) {
			for (CategoriaDescuento cd : lsCategoriaDescuento) {
				if ((cd.getCategoriadescuentoId() != null) && (cd.getActivo())) {
					List<CategoriaPeriodo> obtenerPorCategoriaDescuento = categoriaPeriodoService.obtenerPorCategoriaDescuento(cd);
					if (obtenerPorCategoriaDescuento.isEmpty()) {
						int resp = Messagebox.show(
								Labels.getLabel("editarConfiguracionCategoriaController.MSG.categoriaPeriodoObligatorio"),
								Labels.getLabel("editarConfiguracionCategoriaController.window.title"), Messagebox.OK | Messagebox.CANCEL,
								Messagebox.QUESTION);
						if (!(resp == Messagebox.OK)) {
							return;
						}
					}
				}
			}
		}
		try {
			categoriaCtrl.setActivo(true);
			categoriaCtrl.setFecmodif(Calendar.getInstance().getTime());
			categoriaCtrl.setUsuarioId(UsuarioLogado.getUsuarioLogado().getUsuarioId());
			categoriaCtrl.setCategoriaorgaoList(lsCategoriaOrgaoTemp);
			categoriaCtrl.setCategoriaMarcaList(lsCategoriaMarcaTemp);
			categoriaCtrl.setCategoriaCorridaList(lsCategoriaCorridaTemp);
			categoriaCtrl.setCategoriaClaseList(lsCategoriaClaseTemp);
			categoriaCtrl.setCategoriarutaList(lsCategoriaRutaTemp);
			categoriaCtrl.setCategoriarutaExcecaoList(lsCategoriaRutaExcecaoTemp);
			categoriaCtrl.setCategoriaMercadoList(lsCategoriaMercadoTemp);

			if (categoriaCtrl.getCategoriactrlId() == null) {
				categoriaCtrlService.suscribir(categoriaCtrl);
				categoriaCtrlList.addItemNovo(categoriaCtrl);

				Messagebox.show(
						Labels.getLabel("editarConfiguracionCategoriaController.MSG.suscribirOK"),
						Labels.getLabel("editarConfiguracionCategoriaController.window.title"),
						Messagebox.OK, Messagebox.INFORMATION);
			} else {
				// Recarrega os periodos alterados
				List<CategoriaDescuento> lsCategoriaDescuentoNova = new ArrayList<CategoriaDescuento>();

				for (CategoriaDescuento cd : lsCategoriaDescuento) {
					if (!cd.getActivo()) {
						lsCategoriaDescuentoNova.add(cd);
						continue;
					}
					if (cd.getCategoriaPeriodoList() == null || cd.getCategoriaPeriodoList().isEmpty()) {
						cd.setCategoriaPeriodoList(new ArrayList<CategoriaPeriodo>());
						List<CategoriaPeriodo> listCategoriaPeriodo = categoriaPeriodoService.obtenerPorCategoriaDescuento(categoriaDescuento);
						cd.setCategoriaPeriodoList(listCategoriaPeriodo);
					}
					lsCategoriaDescuentoNova.add(cd);

				}
				categoriaCtrl.setCategoriaDescuentoList(lsCategoriaDescuentoNova);
				categoriaCtrl.setDescricao(txtDescricao.getValue());

				if (clone) {
					setValores();
					categoriaCtrlService.suscribir(nuevo);
					categoriaCtrlList.addItemNovo(nuevo);
				} else {
					categoriaOrgaoService.actualizacionAuditagem(lsCategoriaOrgao);
					categoriaMarcaService.actualizacionAuditagem(lsCategoriaMarca);
					categoriaClaseService.actualizacionAuditagem(lsCategoriaClase);
					categoriaRutaService.actualizacionAuditagem(lsCategoriaRuta);
					categoriaRutaExcecaoService.actualizacionAuditagem(lsCategoriaRutaExcecao);
					categoriaMercadoService.actualizacionAuditagem(lsCategoriaMercado);
					categoriaCtrlService.actualizacion(categoriaCtrl);
					categoriaCtrlList.updateItem(categoriaCtrl);
				}

				Messagebox.show(
						Labels.getLabel("editarConfiguracionCategoriaController.MSG.suscribirOK"),
						Labels.getLabel("editarConfiguracionCategoriaController.window.title"),
						Messagebox.OK, Messagebox.INFORMATION);

				closeWindow();
			}
		} catch (Exception ex) {
			log.error("", ex);
			Clients.alert(
					Labels.getLabel("MSG.Error"),
					Labels.getLabel("editarConfiguracionCategoriaController.window.title"),
					Messagebox.ERROR);
		}
	}

	@SuppressWarnings("unchecked")
	private void setValores() {

		nuevo.setDescricao(txtDescricao.getValue());

		List<CategoriaMarca> lsCategoriaMarca = nuevo.addNuevoCloneCategoriaMarca((List<CategoriaMarca>) categoriaMarcaList.getListData(), nuevo);
		nuevo.setCategoriaMarcaList(lsCategoriaMarca);

		List<CategoriaOrgao> lsCategoriaOrgao = nuevo.addNuevoCloneCategoriaOrgao((List<CategoriaOrgao>) categoriaOrgaoList.getListData(), nuevo);
		nuevo.setCategoriaorgaoList(lsCategoriaOrgao);

		List<CategoriaRuta> lsCategoriaRuta = nuevo.addNuevoCloneCategoriaRuta((List<CategoriaRuta>) categoriaRutaList.getListData(), nuevo);
		nuevo.setCategoriarutaList(lsCategoriaRuta);
		
		List<CategoriaRutaExcecao> lsCategoriaRutaExcecao = nuevo.addNuevoCloneCategoriaRutaExcecao((List<CategoriaRutaExcecao>) categoriaRutaExcecaoList.getListData(), nuevo);
		nuevo.setCategoriarutaExcecaoList(lsCategoriaRutaExcecao);

		List<CategoriaCorrida> lsCategoriaCorrida = nuevo.addNuevoCloneCategoriaCorrida((List<CategoriaCorrida>) categoriaCorridaList.getListData(), nuevo);
		nuevo.setCategoriaCorridaList(lsCategoriaCorrida);

		List<CategoriaClase> lsCategoriaClasse = nuevo.addNuevoCloneCategoriaClase((List<CategoriaClase>) categoriaClaseList.getListData(), nuevo);
		nuevo.setCategoriaClaseList(lsCategoriaClasse);

		List<CategoriaDescuento> lsCategoriaDescuento = nuevo.addNuevoCloneCategoriaDescuento((List<CategoriaDescuento>) categoriaDescuentoList.getListData(), nuevo);
		nuevo.setCategoriaDescuentoList(lsCategoriaDescuento);

		List<CategoriaMercado> lsCategoriaMercado = nuevo.addNuevoCloneCategoriaMercado((List<CategoriaMercado>) categoriaMercadoList.getListData(), nuevo);
		nuevo.setCategoriaMercadoList(lsCategoriaMercado);

	}

	public void onClick$btnCopiar(Event ev) throws CloneNotSupportedException, InterruptedException {
		if (!clone) {

			if (txtDescricao.getValue().isEmpty()) {
				txtDescricao.setConstraint("no empty");
			}
			for (CategoriaDescuento categoriaDescuento : lsCategoriaDescuento) {
				if (categoriaDescuento.getCategoria().getCategoriaId().intValue() != 1) {
					categoriaDescuento.setCategoriaPeriodoList(new ArrayList<CategoriaPeriodo>());
				}
				for (CategoriaPeriodo tempRef : categoriaDescuento.getCategoriaPeriodoList()) {
					tempRef.setCategoriaperiodoId(null);
				}
			}
			categoriaDescuentoList.setData(lsCategoriaDescuento);
		}
		nuevo = (CategoriaCtrl) categoriaCtrl.clone();
		nuevo.setCategoriactrlId(null);
		clone = true;
		Messagebox.show(Labels.getLabel("editarConfiguracionCategoriaController.MSG.cloneOK.value"),
				Labels.getLabel("editarConfiguracionCategoriaController.window.title"),
				Messagebox.OK, Messagebox.INFORMATION);

	}

	public void onClick$btnApagar(Event ev) {
		try {
			int resp = Messagebox.show(
					Labels.getLabel("editarConfiguracionCategoriaController.MSG.borrarPergunta"),
					Labels.getLabel("editarConfiguracionCategoriaController.window.title"),
					Messagebox.YES | Messagebox.NO, Messagebox.QUESTION);

			if (resp == Messagebox.YES) {
				categoriaCtrlService.borrar(categoriaCtrl);
				categoriaCtrlList.removeItem(categoriaCtrl);

				Messagebox.show(
						Labels.getLabel("editarConfiguracionCategoriaController.MSG.borrarOK"),
						Labels.getLabel("editarConfiguracionCategoriaController.window.title"),
						Messagebox.OK, Messagebox.INFORMATION);

				closeWindow();
			}
		} catch (Exception ex) {
			log.error("", ex);
			Clients.alert(
					Labels.getLabel("MSG.Error"),
					Labels.getLabel("editarConfiguracionCategoriaController.window.title"),
					Messagebox.ERROR);
		}
	}

	private Boolean validarCampoAssentosReservados() throws InterruptedException {

		// Verifica se o campo possui n<EFBFBD>meros separados por ponto e v<EFBFBD>rgula.
		// N<EFBFBD>o permite que outros caracteres sejam digitados.
		if (!asientosReservados.getValue().equals("") && !asientosReservados.getValue().toString().matches("(([1-9]([0-9])+;)|([1-9]([0-9])+)|([1-9];)|([1-9][1-9][1-9])|[1-9])+")) {
			Messagebox.show(
					Labels.getLabel("editarConfiguracionCategoriaController.msg.validacaoAssentosReservadosPontoeVirgula"),
					Labels.getLabel("editarConfiguracionCategoriaController.window.title"),
					Messagebox.OK, Messagebox.ERROR);
			return false;
		}
		// Verifica se a quantidade de assentos reservados <EFBFBD> menor que a quantidade de assentos autorizados.
		String assentosReservados[] = asientosReservados.getValue().toString().split(";");
		if (assentosReservados.length > cantAutorizada.getValue()) {
			Messagebox.show(
					Labels.getLabel("editarConfiguracionCategoriaController.msg.validacaoAssentosReservados"),
					Labels.getLabel("editarConfiguracionCategoriaController.window.title"),
					Messagebox.OK, Messagebox.ERROR);
			return false;
		}

		// Retira poss<EFBFBD>veis assentos em duplicidade utilizando Set
		if (!asientosReservados.getValue().equals("") && assentosReservados.length > 0) {
			Set<String> assentosSemDuplicacao = new HashSet<String>();
			StringBuilder assentos = new StringBuilder();
			assentosSemDuplicacao.addAll(Arrays.asList(assentosReservados));
			assentosReservados = assentosSemDuplicacao.toArray(new String[assentosSemDuplicacao.size()]);
			for (String assento : assentosReservados) {
				assentos.append(assento.trim()).append(";");
			}
			assentos.replace(assentos.length() - 1, assentos.length(), "");
			asientosReservados.setValue(assentos.toString());
		}

		return true;
	}

	public void onClick$btnAdicionarDesconto(Event ev) throws InterruptedException {
		if (cmbCategorias.getSelectedItem() == null) {
			Messagebox.show(
					Labels.getLabel("editarConfiguracionCategoriaController.msg.validacaoCategoria"),
					Labels.getLabel("editarConfiguracionCategoriaController.window.title"),
					Messagebox.OK, Messagebox.EXCLAMATION);

			cmbCategorias.focus();
			return;
		}

		if (!categoriaCtrlService.validaCategoriaProgramaFidelidade((Categoria) cmbCategorias.getSelectedItem().getValue())) {
			Messagebox.show(
					Labels.getLabel("editarConfiguracionCategoriaController.msg.modoFidelidadeNaoCinfigurado"),
					Labels.getLabel("editarConfiguracionCategoriaController.window.title"),
					Messagebox.OK, Messagebox.EXCLAMATION);

			cmbCategorias.focus();
			return;
		}
		
		if(rdVendaAntecipadaKMSi.isChecked()) {
			spnKM.getValue();
			tbTempoAteKM.getValue();
			tbTempoMaiorKM.getValue();
		} else if (rdVendaAntecipadaSi.isChecked()) {
			int hora = (spnHora.getValue() == null) ? 0 : spnHora.getValue();
			int minuto = (spnMinuto.getValue() == null) ? 0 : spnMinuto.getValue();
			if ((hora + minuto) == 0) {
				Messagebox.show(
						Labels.getLabel("editarConfiguracionCategoriaController.msg.validacaoVentaAntecipada"),
						Labels.getLabel("editarConfiguracionCategoriaController.window.title"),
						Messagebox.OK, Messagebox.EXCLAMATION);

				spnHora.focus();

				return;
			}
		}
		if (!((Categoria) cmbCategorias.getSelectedItem().getValue()).getCategoriaId().equals(CategoriaCtrlServiceImpl.CATEGORIA_ADULTO)) {
			cmbCategorias.getValue();
			cantAutorizada.getValue();
			descuentoPorc.getValue();
			descuentoImporte.getValue();
			asientosReservados.getValue();
		}

		boolean existe = false;
		for (CategoriaDescuento cd : lsCategoriaDescuento) {
			if (cd.getActivo() && cd.getCategoria().equals(cmbCategorias.getSelectedItem().getValue())) {
				existe = true;
			}
		}

		if (!existe) {
			if (((Categoria) cmbCategorias.getSelectedItem().getValue()).getCategoriaId().equals(CategoriaCtrlServiceImpl.CATEGORIA_ADULTO)) {
				categoriaCtrl = categoriaCtrlService.checarCategoriaAdulto(categoriaCtrl, rdVendeAbertoSim.isSelected(), 
						chkCancelaEmAberto.isChecked(), chkDevolveEmAberto.isChecked(), chkCancelaEmergencialEmAberto.isChecked(), chkTrocaTiturlidadeEmAberto.isChecked(), chkTrocaEmAberto.isChecked());
				List<CategoriaDescuento> aux = lsCategoriaDescuento;
				lsCategoriaDescuento = categoriaCtrl.getCategoriaDescuentoList();
				categoriaDescuentoList.setData(lsCategoriaDescuento);
				lsCategoriaDescuento.addAll(aux);
			} else if (validarCampoAssentosReservados()) {
				CategoriaDescuento cDescuento = new CategoriaDescuento();
				cDescuento.setCategoriaCtrl(categoriaCtrl);
				cDescuento.setActivo(Boolean.TRUE);
				cDescuento.setFecmodif(Calendar.getInstance().getTime());
				cDescuento.setUsuarioId(UsuarioLogado.getUsuarioLogado().getUsuarioId());
				cDescuento.setCategoria((Categoria) cmbCategorias.getSelectedItem().getValue());
				cDescuento.setCantautorizada(cantAutorizada.getValue());
				cDescuento.setDescuentoimporte(descuentoImporte.getValue());
				cDescuento.setDescuentoporc(descuentoPorc.getValue());
				cDescuento.setIndImporteOutros(chkPrecoOutros.isChecked());
				cDescuento.setIndImportePedagio(chkPrecoPedagio.isChecked());
				cDescuento.setIndImporteSeguro(chkPrecoSeguro.isChecked());
				cDescuento.setIndImporteTxEmbarque(chkPrecoTxEmbarque.isChecked());
				cDescuento.setIndVentaAbierto(rdVendeAbertoSim.isSelected());
				cDescuento.setIndImporteSeguroOpcional(chkPrecoSeguroOpcional.isChecked());
				
				if(rdVendeAbertoSim.isSelected()) {
					//Aberto Vendido
					cDescuento.setIndCancelaEmAberto(chkCancelaEmAberto.isChecked());
					cDescuento.setIndDevolveEmAberto(chkDevolveEmAberto.isChecked());
					cDescuento.setIndCancelaEmergencialEmAberto(chkCancelaEmergencialEmAberto.isChecked());
					cDescuento.setIndTrocaTitularidadeEmAberto(chkTrocaTiturlidadeEmAberto.isChecked());
					cDescuento.setIndTrocaEmAberto(chkTrocaEmAberto.isChecked());
				} else {
					cDescuento.setIndCancelaEmAberto(false);
					cDescuento.setIndDevolveEmAberto(false);
					cDescuento.setIndCancelaEmergencialEmAberto(false);
					cDescuento.setIndTrocaTitularidadeEmAberto(false);
					cDescuento.setIndTrocaEmAberto(false);
				}
				
				cDescuento.setIndLiberacionSolamenteEnvasado(chkLiberacionSolamenteEnvasado.isChecked());
				cDescuento.setAsientosReservados(asientosReservados.getValue());
				cDescuento.setIndexigedocpasajero(chkExigedocpasajero.isChecked());
				cDescuento.setIndexigefecnacimientopasajero(chkExigefecnacimientopasajero.isChecked());
				cDescuento.setIndExigeDoc2Passageiro(chkExigedoc2pasajero.isChecked());
				cDescuento.setIndexigenombpasajero(chkExigenombpasajero.isChecked());
				cDescuento.setIndexigetelefonopasajero(chkExigetelefonopasajero.isChecked());
				cDescuento.setIndSegunda(chkSegunda.isChecked());
				cDescuento.setIndTerca(chkTerca.isChecked());
				cDescuento.setIndQuarta(chkQuarta.isChecked());
				cDescuento.setIndQuinta(chkQuinta.isChecked());
				cDescuento.setIndSexta(chkSexta.isChecked());
				cDescuento.setIndSabado(chkSabado.isChecked());
				cDescuento.setIndDomingo(chkDomingo.isChecked());
				cDescuento.setIndnaopermitevdamesmodocviagem(chkIndnaopermitevdamesmodocviagem.isChecked());
				cDescuento.setIndNaoPermiteVendaDuasGrat(chkIndnaopermiteVendaDuasGratuidades.isChecked());	
				cDescuento.setCantMaxVendaMes(cantMaximaVendaMes.getValue());	
				cDescuento.setIndnaoaplicatarifaminima(chkIndnaoaplicatarifaminima.isChecked());
				cDescuento.setIndExigeEmailPassageiro(chkExigeEmailpasajero.isChecked());
				cDescuento.setIndExigeEnderecoPassageiro(chkExigeEnderecopasajero.isChecked());
				cDescuento.setIndtipoocupacao(chkIndtipoocupacao.isChecked());
				cDescuento.setIndEmiteSomenteCupomEmbarque(chkIndEmiteSomenteCupomEmbarque.isChecked());
				cDescuento.setQtdeViasCupomEmbarque(qtdeViasCupomEmbarque.getValue());
				cDescuento.setIndClientePcd(chkIndClientePcd.isChecked());
				cDescuento.setQtdeLimiteNaoEmbarque(qtdeLimiteNaoEmbarque.getValue());
				cDescuento.setIndCheckinAutomatico(radioCheckinSim.isSelected() ? Boolean.TRUE : Boolean.FALSE );

				if (radioHorarioLiberacaoVendaOrigem.isChecked()) {
					cDescuento.setHorarioLiberacaoVendaPassagem(HorarioLiberacaoVendaPassagem.HORARIO_LIBERACAO_VENDA_ORIGEM);
				} else if (radioHorarioLiberacaoVendaTrecho.isChecked()) {
					cDescuento.setHorarioLiberacaoVendaPassagem(HorarioLiberacaoVendaPassagem.HORARIO_LIBERACAO_VENDA_TRECHO);
				}

				
				if(rdVendaAntecipadaKMSi.isChecked()) {
					cDescuento.setIndVendaAntecipadaPorKM(true);
					cDescuento.setKmVendaAntecipada(spnKM.getValue());
					cDescuento.setTempoLiberacaoAteKM(tbTempoAteKM.getValue());
					cDescuento.setTempoLiberacaoDepoisKM(tbTempoMaiorKM.getValue());
				} else if (rdVendaAntecipadaSi.isChecked()) {
					cDescuento.setTiempoDesactivar(spnHora.getValue(), spnMinuto.getValue());
				} else {
					cDescuento.setTiempoActivar(spnHora.getValue(), spnMinuto.getValue());
				}

				if (cmbIndGeneraFeriado.getSelectedItem() != null) {
					cDescuento.setIndAplicaFeriado((String) cmbIndGeneraFeriado.getSelectedItem().getValue());
				}

				if (radioImprimePassagem.isSelected()) {
					cDescuento.setIndImprimeBoleto(Boolean.TRUE);
				} else if (radioNaoImprimePassagem.isSelected()) {
					cDescuento.setIndImprimeBoleto(Boolean.FALSE);
				}

				cDescuento.setIndCuota(false);
				cDescuento.setIndCuotaTramo(false);

				if (rdCuotaSi.isChecked()) {
					if (timeTempoPermitir.getValue() == null) {
						throw new WrongValueException(timeTempoPermitir, Labels.getLabel("MSG.CONSTRAINT.CONSTRAINTNUMBERBDOBLIGATORIO"));
					}

					cDescuento.setIndCuota(true);
					cDescuento.setIndCuotaTramo(rdTrecho.isChecked());
					cDescuento.setTiempoCuota(timeTempoPermitir.getValue());
					
					boolean isNuncaLiberarCota = rdNuncaLiberar.isChecked();
					cDescuento.setIndCuotaNuncaLiberar(isNuncaLiberarCota);
					if (isNuncaLiberarCota) {
						String assentosReservados = asientosReservados.getValue();
						if (StringUtils.isBlank(assentosReservados)) {
							Messagebox.show(
									Labels.getLabel("editarConfiguracionCategoriaController.msg.nuncaLiberarAssentosReservados"),
									Labels.getLabel("editarConfiguracionCategoriaController.window.title"),
									Messagebox.OK, Messagebox.ERROR);
							return;
						}
					}
				}

				if (radioCompPrecoImp.isChecked()) {
					cDescuento.setTipodesccomppreco(TipoDescontoComponentePreco.DESCONTO_COMPONENTE_PRECO_VALOR.getValor());
				} else if (radioCompPrecoPor.isChecked()) {
					cDescuento.setTipodesccomppreco(TipoDescontoComponentePreco.DESCONTO_COMPONENTE_PRECO_PERC.getValor());
				}

				if (radioCorLaranja.isChecked()) {
					cDescuento.setCorpoltrona(TipoPassagemCores.LARANJA);
				} else if (radioCorVerde.isChecked()) {
					cDescuento.setCorpoltrona(TipoPassagemCores.VERDE);
				} else if (radioCorVerdeMusgo.isChecked()) {
					cDescuento.setCorpoltrona(TipoPassagemCores.VERDE_MUSGO);
				} else if (radioCorAzul.isChecked()) {
					cDescuento.setCorpoltrona(TipoPassagemCores.AZUL);
				} else if (radioCorAzulMarinho.isChecked()) {
					cDescuento.setCorpoltrona(TipoPassagemCores.AZUL_MARINHO);
				}  else if (radioCorAzulPiscina.isChecked()) {
					cDescuento.setCorpoltrona(TipoPassagemCores.AZUL_PISCINA);
				}  else if (radioCorBege.isChecked()) {
					cDescuento.setCorpoltrona(TipoPassagemCores.BEGE);
				} else if (radioCorLilas.isChecked()) {
					cDescuento.setCorpoltrona(TipoPassagemCores.LILAS);
				} else if (radioCorMarrom.isChecked()) {
					cDescuento.setCorpoltrona(TipoPassagemCores.MARROM);
				} else if (radioCorRosa.isChecked()) {
					cDescuento.setCorpoltrona(TipoPassagemCores.ROSA);
				} else if (radioCorRosaChoque.isChecked()) {
					cDescuento.setCorpoltrona(TipoPassagemCores.ROSA_CHOQUE);
				}  else if (radioCorRoxo.isChecked()) {
					cDescuento.setCorpoltrona(TipoPassagemCores.ROXO);
				} else {
					cDescuento.setCorpoltrona(null);
				}

				cDescuento.setDesccomppreco(desccomppreco.getValue());
				cDescuento.setIndPermiteTroca(chkPermiteTroca.isChecked());
				cDescuento.setIndPermiteTransferencia(chkPermiteTransferencia.isChecked());
				
				
				cDescuento.setIndPermiteCancelar(chkCancela.isChecked());
				cDescuento.setIndPermiteCancelarEmergencial(chkCancelaEmergencial.isChecked());
				cDescuento.setIndPermiteDevolver(chkDevolve.isChecked());
				cDescuento.setIndPermiteReativar(chkReativa.isChecked());
				cDescuento.setIndPermiteTrocaTitularidade(chkTrocaTiturlidade.isChecked());
				
				cDescuento.setIndExigeNumFidelidade(chkExigeNumeroFidelidade.isChecked());
				
				if(chkTipoCategoriaInteragem.isChecked()) {
					if(cmbCategoriasInteragem.getSelectedItem() != null && cmbCategoriasInteragem.getSelectedItem().getValue()!=null) {
						cDescuento.setCategoriaInterage((Categoria) cmbCategoriasInteragem.getSelectedItem().getValue());
					}else {
						cDescuento.setCategoriaInterage(null);
					}
				}else {
					cDescuento.setCategoriaInterage(null);
				}
				
				
				if(chkExigeNumeroFidelidade.isChecked()) {
					if(cmbOcupacion.getSelectedItem() != null && cmbOcupacion.getSelectedItem().getValue() != null) {
						cDescuento.setTipoOcupacion((TipoOcupacion) cmbOcupacion.getSelectedItem().getValue());
					}else {
						cDescuento.setTipoOcupacion(null);
					}
				}else {
					cDescuento.setTipoOcupacion(null);
				}
				if(chkIndCustomizaRodapeCupomEmbarque.isChecked()){
				cDescuento.setCustomizaRodapeCumpomEmbarque(ckCustomizaRodapeCupomEmbarque.getValue());
				}else {
					cDescuento.setCustomizaRodapeCumpomEmbarque(null);
				}
				lsCategoriaDescuento.add(cDescuento);
				categoriaDescuentoList.addItemNovo(cDescuento);
				categoriaCtrl.setCategoriaDescuentoList(lsCategoriaDescuento);

				cmbCategorias.setSelectedItem(null);
				cantAutorizada.setRawValue(null);
				if (radioImp.isChecked()) {
					onClick$radioImp(null);
				} else {
					onClick$radioPor(null);
				}
				onClick$rdVendaAntecipadaNo(null);
				rdVendaAntecipadaNo.setChecked(true);
			}
		} else {
			Messagebox.show(
					Labels.getLabel("MSG.Registro.Existe"),
					Labels.getLabel("editarConfiguracionCategoriaController.window.title"),
					Messagebox.OK, Messagebox.EXCLAMATION);
		}
	}

	public void onClick$btnRemoverDesconto(Event ev) {
		try {
			CategoriaDescuento cDescuento = (CategoriaDescuento) categoriaDescuentoList.getSelected();
			if (cDescuento != null) {
				lsCategoriaDescuento.remove(cDescuento);
				cDescuento.setFecmodif(Calendar.getInstance().getTime());
				cDescuento.setActivo(Boolean.FALSE);
				cDescuento.setUsuarioId(UsuarioLogado.getUsuarioLogado().getUsuarioId());
				categoriaDescuentoList.removeItem(cDescuento);
				lsCategoriaDescuento.add(cDescuento);
			} else {
				Messagebox.show(
						Labels.getLabel("editarConfiguracionCategoriaController.MSG.selectItem"),
						Labels.getLabel("editarConfiguracionCategoriaController.window.title"),
						Messagebox.OK, Messagebox.EXCLAMATION);
			}
		} catch (Exception ex) {
			log.error("", ex);
			Clients.alert(
					Labels.getLabel("MSG.Error"),
					Labels.getLabel("editarConfiguracionCategoriaController.window.title"),
					Messagebox.ERROR);
		}
	}

	public void onClick$btnAdicionarMarca(Event ev) throws InterruptedException {
		if (cmbMarca.getSelectedItem() == null) {
			Messagebox.show(
					Labels.getLabel("MSG.Error.combobox"),
					Labels.getLabel("editarConfiguracionCategoriaController.window.title"),
					Messagebox.OK, Messagebox.EXCLAMATION);

			cmbMarca.focus();
			return;
		}

		if (((Marca) cmbMarca.getSelectedItem().getValue()).getMarcaId().equals((short) -1)) {
			if (categoriaMarcaList.getData().length != 0) {
				Messagebox.show(
						Labels.getLabel("editarConfiguracionCategoriaController.MSG.noEsPermitidoTodosMarca"),
						Labels.getLabel("editarConfiguracionCategoriaController.window.title"),
						Messagebox.OK, Messagebox.EXCLAMATION);

				return;
			}
		}
		if (lsCategoriaMarca != null) {
			for (CategoriaMarca cm : lsCategoriaMarca) {
				if (!cm.getActivo()) {
					continue;
				}
				if (cm.getMarca().getMarcaId().equals((short) -1)) {
					Messagebox.show(
							Labels.getLabel("editarConfiguracionCategoriaController.MSG.noEsPermitidoMarcaTodosExiste"),
							Labels.getLabel("editarConfiguracionCategoriaController.window.title"),
							Messagebox.OK, Messagebox.EXCLAMATION);

					return;
				}
			}
		}
		try {
			boolean existe = false;
			for (CategoriaMarca cm : lsCategoriaMarca) {
				Marca categoriaMarcaTeste = (Marca) cmbMarca.getSelectedItem().getValue();
				if (cm.getActivo() && cm.getMarca().getMarcaId().equals(categoriaMarcaTeste.getMarcaId())) {
					existe = true;
				}
			}

			if (!existe) {
				
				CategoriaMarca cMarca = new CategoriaMarca();
				cMarca.setCategoriaCtrl(categoriaCtrl);
				cMarca.setActivo(Boolean.TRUE);
				cMarca.setMarca((Marca) cmbMarca.getSelectedItem().getValue());
				cMarca.setFecmodif(Calendar.getInstance().getTime());
				cMarca.setUsuarioId(UsuarioLogado.getUsuarioLogado().getUsuarioId());
				lsCategoriaMarca.add(cMarca);
				lsCategoriaMarcaTemp.add(cMarca);
				categoriaMarcaList.addItemNovo(cMarca);
				categoriaCtrl.setCategoriaMarcaList(lsCategoriaMarca);


			} else {
				Messagebox.show(
						Labels.getLabel("MSG.Registro.Existe"),
						Labels.getLabel("editarConfiguracionCategoriaController.window.title"),
						Messagebox.OK, Messagebox.EXCLAMATION);
			}
		} catch (Exception ex) {
			log.error("", ex);
			Clients.alert(
					Labels.getLabel("MSG.Error"),
					Labels.getLabel("editarConfiguracionCategoriaController.window.title"),
					Messagebox.ERROR);
		}
	}

	public void onClick$btnRemoverMarca(Event ev) {
		try {
			CategoriaMarca cMarca = (CategoriaMarca) categoriaMarcaList.getSelected();
			if (cMarca != null) {
				// removo o antigo
				
				lsCategoriaMarca.remove(cMarca);
				cMarca.setFecmodif(Calendar.getInstance().getTime());
				cMarca.setActivo(Boolean.FALSE);
				cMarca.setUsuarioId(UsuarioLogado.getUsuarioLogado().getUsuarioId());
				lsCategoriaMarcaTemp.remove(cMarca);
				lsCategoriaMarca.add(cMarca);
				categoriaCtrl.setCategoriaMarcaList(lsCategoriaMarca);
				categoriaMarcaList.removeItem(cMarca);
				
			} else {
				Messagebox.show(
						Labels.getLabel("editarConfiguracionCategoriaController.MSG.selectItem"),
						Labels.getLabel("editarConfiguracionCategoriaController.window.title"),
						Messagebox.OK, Messagebox.EXCLAMATION);
			}
		} catch (Exception ex) {
			log.error("", ex);
			Clients.alert(
					Labels.getLabel("MSG.Error"),
					Labels.getLabel("editarConfiguracionCategoriaController.window.title"),
					Messagebox.ERROR);
		}
	}

	public void onClick$btnAdicionarRuta(Event ev) throws InterruptedException {
		if (cmbRuta.getSelectedItem() == null) {
			Messagebox.show(
					Labels.getLabel("MSG.Error.combobox"),
					Labels.getLabel("editarConfiguracionCategoriaController.window.title"),
					Messagebox.OK, Messagebox.EXCLAMATION);

			cmbRuta.focus();
			return;
		}

		try {
			boolean existe = false;
			for (CategoriaRuta cm : lsCategoriaRuta) {
				Ruta categoriaRutaTeste = (Ruta) cmbRuta.getSelectedItem().getValue();
				if (cm.getActivo() && cm.getRuta().getRutaId().equals(categoriaRutaTeste.getRutaId())) {
					existe = true;
				}
			}

			if (!existe) {
				CategoriaRuta cRuta = new CategoriaRuta();
				cRuta.setCategoriaCtrl(categoriaCtrl);
				cRuta.setActivo(Boolean.TRUE);
				cRuta.setQtdPoltronasAutorizadas(qtdAutorizadaLinha.getValue()!=null ? qtdAutorizadaLinha.getValue() : null);
				cRuta.setPorcentagemDesconto(descontoPorcentagemLinha.getValue());
				cRuta.setValorDesconto(descontoValorLinha.getValue());
				cRuta.setRuta((Ruta) cmbRuta.getSelectedItem().getValue());
				cRuta.setFecmodif(Calendar.getInstance().getTime());
				cRuta.setUsuarioId(UsuarioLogado.getUsuarioLogado().getUsuarioId());			
				lsCategoriaRuta.add(cRuta);
				lsCategoriaRutaTemp.add(cRuta);
				categoriaRutaList.addItemNovo(cRuta);
				categoriaCtrl.setCategoriarutaList(lsCategoriaRuta);
				addIntBox();
				addPorcentagemDecimalBox();
				addValorDecimalBox();
			} else {
				Messagebox.show(
						Labels.getLabel("MSG.Registro.Existe"),
						Labels.getLabel("editarConfiguracionCategoriaController.window.title"),
						Messagebox.OK, Messagebox.EXCLAMATION);
			}
		} catch (Exception ex) {
			log.error("", ex);
			Clients.alert(
					Labels.getLabel("MSG.Error"),
					Labels.getLabel("editarConfiguracionCategoriaController.window.title"),
					Messagebox.ERROR);
		}

	}

	public void onClick$btnRemoverRuta(Event ev) {
		try {
			CategoriaRuta cRuta = (CategoriaRuta) categoriaRutaList.getSelected();
			int resp = Messagebox.show(
					Labels.getLabel("editarConfiguracionCategoriaController.MSG.borrarPergunta"),
					Labels.getLabel("editarConfiguracionCategoriaController.window.title"),
					Messagebox.YES | Messagebox.NO, Messagebox.QUESTION);
			if (resp == Messagebox.YES) {
				if (cRuta != null) {
					// removo o antigo
					lsCategoriaRuta.remove(cRuta);
					cRuta.setFecmodif(Calendar.getInstance().getTime());
					cRuta.setActivo(Boolean.FALSE);
					cRuta.setUsuarioId(UsuarioLogado.getUsuarioLogado().getUsuarioId());
					lsCategoriaRutaTemp.remove(cRuta);
					lsCategoriaRuta.add(cRuta);
					categoriaCtrl.setCategoriarutaList(lsCategoriaRuta);
					categoriaRutaList.removeItem(cRuta);
				} else {
					Messagebox.show(
							Labels.getLabel("editarConfiguracionCategoriaController.MSG.selectItem"),
							Labels.getLabel("editarConfiguracionCategoriaController.window.title"),
							Messagebox.OK, Messagebox.EXCLAMATION);
				}
			}
		} catch (Exception ex) {
			log.error("", ex);
			Clients.alert(
					Labels.getLabel("MSG.Error"),
					Labels.getLabel("editarConfiguracionCategoriaController.window.title"),
					Messagebox.ERROR);
		}
	}
	
	public void onClick$btnAdicionarRutaExcecao(Event ev) throws InterruptedException {
		if (cmbCategoriaRutaExcecao.getSelectedItem() == null) {
			Messagebox.show(
					Labels.getLabel("MSG.Error.combobox"),
					Labels.getLabel("editarConfiguracionCategoriaController.window.title"),
					Messagebox.OK, Messagebox.EXCLAMATION);

			cmbCategoriaRutaExcecao.focus();
			return;
		}
		if(!validarOpcaoTodasComboLinhas()) {
			Messagebox.show(
					Labels.getLabel("editarConfiguracionCategoriaController.validarOpcaoTodasComboLinha"),
					Labels.getLabel("MSG.Error.combobox"),
					
					Messagebox.OK, Messagebox.EXCLAMATION);

			cmbCategoriaRutaExcecao.focus();
			return;
		}

		try {
			boolean existe = false;
			for (CategoriaRutaExcecao cm : lsCategoriaRutaExcecao) {
				Ruta categoriaRutaTeste = (Ruta) cmbCategoriaRutaExcecao.getSelectedItem().getValue();
				if (cm.getActivo() && cm.getRuta().getRutaId().equals(categoriaRutaTeste.getRutaId())) {
					existe = true;
				}
			}

			if (!existe) {
				CategoriaRutaExcecao cRutaExcecao = new CategoriaRutaExcecao();
				cRutaExcecao.setCategoriaCtrl(categoriaCtrl);
				cRutaExcecao.setActivo(Boolean.TRUE);
				cRutaExcecao.setRuta((Ruta) cmbCategoriaRutaExcecao.getSelectedItem().getValue());
				cRutaExcecao.setFecmodif(Calendar.getInstance().getTime());
				cRutaExcecao.setUsuarioId(UsuarioLogado.getUsuarioLogado().getUsuarioId());
				lsCategoriaRutaExcecao.add(cRutaExcecao);
				lsCategoriaRutaExcecaoTemp.add(cRutaExcecao);
				categoriaRutaExcecaoList.addItemNovo(cRutaExcecao);
				categoriaCtrl.setCategoriarutaExcecaoList(lsCategoriaRutaExcecao);
			} else {
				Messagebox.show(
						Labels.getLabel("MSG.Registro.Existe"),
						Labels.getLabel("editarConfiguracionCategoriaController.window.title"),
						Messagebox.OK, Messagebox.EXCLAMATION);
			}
		} catch (Exception ex) {
			log.error("", ex);
			Clients.alert(
					Labels.getLabel("MSG.Error"),
					Labels.getLabel("editarConfiguracionCategoriaController.window.title"),
					Messagebox.ERROR);
		}

	}

	public void onClick$btnRemoverCategoriaRutaExcecao(Event ev) {
		try {
			CategoriaRutaExcecao cRutaExcecao = (CategoriaRutaExcecao) categoriaRutaExcecaoList.getSelected();
			int resp = Messagebox.show(
					Labels.getLabel("editarConfiguracionCategoriaController.MSG.borrarPergunta"),
					Labels.getLabel("editarConfiguracionCategoriaController.window.title"),
					Messagebox.YES | Messagebox.NO, Messagebox.QUESTION);
			if (resp == Messagebox.YES) {
				if (cRutaExcecao != null) {
					// removo o antigo
					lsCategoriaRutaExcecao.remove(cRutaExcecao);
					cRutaExcecao.setFecmodif(Calendar.getInstance().getTime());
					cRutaExcecao.setActivo(Boolean.FALSE);
					cRutaExcecao.setUsuarioId(UsuarioLogado.getUsuarioLogado().getUsuarioId());
					lsCategoriaRutaExcecaoTemp.remove(cRutaExcecao);
					lsCategoriaRutaExcecao.add(cRutaExcecao);
					categoriaCtrl.setCategoriarutaExcecaoList(lsCategoriaRutaExcecao);
					categoriaRutaExcecaoList.removeItem(cRutaExcecao);
				} else {
					Messagebox.show(
							Labels.getLabel("editarConfiguracionCategoriaController.MSG.selectItem"),
							Labels.getLabel("editarConfiguracionCategoriaController.window.title"),
							Messagebox.OK, Messagebox.EXCLAMATION);
				}
			}
		} catch (Exception ex) {
			log.error("", ex);
			Clients.alert(
					Labels.getLabel("MSG.Error"),
					Labels.getLabel("editarConfiguracionCategoriaController.window.title"),
					Messagebox.ERROR);
		}
	}

	public void onClick$btnAdicionarOrgao(Event ev) throws InterruptedException {
		if (cmbOrgao.getSelectedItem() == null) {
			Messagebox.show(
					Labels.getLabel("MSG.Error.combobox"),
					Labels.getLabel("editarConfiguracionCategoriaController.window.title"),
					Messagebox.OK, Messagebox.EXCLAMATION);

			cmbOrgao.focus();
			return;
		}

		if (((OrgaoConcedente) cmbOrgao.getSelectedItem().getValue()).getOrgaoConcedenteId().equals((short) -1)) {
			if (categoriaOrgaoList.getData().length != 0) {
				Messagebox.show(
						Labels.getLabel("editarConfiguracionCategoriaController.MSG.noEsPermitidoTodosOrgao"),
						Labels.getLabel("editarConfiguracionCategoriaController.window.title"),
						Messagebox.OK, Messagebox.EXCLAMATION);

				return;
			}
		}
		if (lsCategoriaOrgao != null) {
			for (CategoriaOrgao cm : lsCategoriaOrgao) {
				if (!cm.getActivo()) {
					continue;
				}
				if (cm.getOrgao().equals((short) -1)) {
					Messagebox.show(
							Labels.getLabel("editarConfiguracionCategoriaController.MSG.noEsPermitidoMarcaTodosExiste"),
							Labels.getLabel("editarConfiguracionCategoriaController.window.title"),
							Messagebox.OK, Messagebox.EXCLAMATION);

					return;
				}
			}
		}
		try {
			boolean existe = false;
			for (CategoriaOrgao cm : lsCategoriaOrgao) {
				OrgaoConcedente categoriaOrgaoTeste = (OrgaoConcedente) cmbOrgao.getSelectedItem().getValue();
				if (cm.getActivo() && cm.getOrgao().getOrgaoConcedenteId().equals(categoriaOrgaoTeste.getOrgaoConcedenteId())) {
					existe = true;
				}
			}

			if (!existe) {
				CategoriaOrgao cOrgao = new CategoriaOrgao();
				cOrgao.setCategoriaCtrl(categoriaCtrl);
				cOrgao.setActivo(Boolean.TRUE);
				cOrgao.setOrgao((OrgaoConcedente) cmbOrgao.getSelectedItem().getValue());
				cOrgao.setFecmodif(Calendar.getInstance().getTime());
				cOrgao.setUsuarioId(UsuarioLogado.getUsuarioLogado().getUsuarioId());
				lsCategoriaOrgao.add(cOrgao);
				lsCategoriaOrgaoTemp.add(cOrgao);
				categoriaOrgaoList.addItemNovo(cOrgao);
				categoriaCtrl.setCategoriaorgaoList(lsCategoriaOrgao);
			} else {
				Messagebox.show(
						Labels.getLabel("MSG.Registro.Existe"),
						Labels.getLabel("editarConfiguracionCategoriaController.window.title"),
						Messagebox.OK, Messagebox.EXCLAMATION);
			}
		} catch (Exception ex) {
			log.error("", ex);
			Clients.alert(
					Labels.getLabel("MSG.Error"),
					Labels.getLabel("editarConfiguracionCategoriaController.window.title"),
					Messagebox.ERROR);
		}
	}

	public void onClick$btnRemoverOrgao(Event ev) {
		try {
			CategoriaOrgao cOrgao = (CategoriaOrgao) categoriaOrgaoList.getSelected();
			int resp = Messagebox.show(
					Labels.getLabel("editarConfiguracionCategoriaController.MSG.borrarPergunta"),
					Labels.getLabel("editarConfiguracionCategoriaController.window.title"),
					Messagebox.YES | Messagebox.NO, Messagebox.QUESTION);
			if (resp == Messagebox.YES) {
				if (cOrgao != null) {
					// removo o antigo
					lsCategoriaOrgao.remove(cOrgao);
					cOrgao.setFecmodif(Calendar.getInstance().getTime());
					cOrgao.setActivo(Boolean.FALSE);
					cOrgao.setUsuarioId(UsuarioLogado.getUsuarioLogado().getUsuarioId());
					lsCategoriaOrgaoTemp.remove(cOrgao);
					lsCategoriaOrgao.add(cOrgao);
					categoriaCtrl.setCategoriaorgaoList(lsCategoriaOrgao);
					categoriaOrgaoList.removeItem(cOrgao);
				} else {
					Messagebox.show(
							Labels.getLabel("editarConfiguracionCategoriaController.MSG.selectItem"),
							Labels.getLabel("editarConfiguracionCategoriaController.window.title"),
							Messagebox.OK, Messagebox.EXCLAMATION);
				}
			}
		} catch (Exception ex) {
			log.error("", ex);
			Clients.alert(
					Labels.getLabel("MSG.Error"),
					Labels.getLabel("editarConfiguracionCategoriaController.window.title"),
					Messagebox.ERROR);
		}
	}

	public void onClick$btnAdicionarCorrida(Event ev) {
		idCorrida.getValue();

		corrida = corridaCtrlService.obtenerID(idCorrida.getValue());
		try {
			if (corrida == null) {
				Messagebox.show(
						Labels.getLabel("editarConfiguracionCategoriaController.MSG.corrida"),
						Labels.getLabel("editarConfiguracionCategoriaController.window.title"),
						Messagebox.OK, Messagebox.EXCLAMATION);
			} else {
				boolean existe = false;
				for (CategoriaCorrida cc : lsCategoriaCorrida) {
					if (cc.getActivo() && cc.getCorridaCtrl().equals(corrida)) {
						existe = true;
					}
				}
				if (!existe) {

					CategoriaCorrida cc = new CategoriaCorrida();
					cc.setCategoriaCtrl(categoriaCtrl);
					cc.setActivo(Boolean.TRUE);
					cc.setFecmodif(Calendar.getInstance().getTime());
					cc.setUsuarioId(UsuarioLogado.getUsuarioLogado().getUsuarioId());
					cc.setCorridaCtrl(corrida);
					lsCategoriaCorrida.add(cc);
					lsCategoriaCorridaTemp.add(cc);
					categoriaCorridaList.addItemNovo(cc);
					categoriaCtrl.setCategoriaCorridaList(lsCategoriaCorrida);
				} else {
					Messagebox.show(
							Labels.getLabel("MSG.Registro.Existe"),
							Labels.getLabel("editarConfiguracionCategoriaController.window.title"),
							Messagebox.OK, Messagebox.EXCLAMATION);
				}
			}
		} catch (Exception ex) {
			log.error("", ex);
			Clients.alert(
					Labels.getLabel("MSG.Error"),
					Labels.getLabel("editarConfiguracionCategoriaController.window.title"),
					Messagebox.ERROR);
		}
	}

	public void onClick$btnRemoverCorrida(Event ev) {
		try {
			CategoriaCorrida cCorrida = (CategoriaCorrida) categoriaCorridaList.getSelected();
			if (cCorrida != null) {
				lsCategoriaCorrida.remove(cCorrida);
				cCorrida.setFecmodif(Calendar.getInstance().getTime());
				cCorrida.setActivo(Boolean.FALSE);
				cCorrida.setUsuarioId(UsuarioLogado.getUsuarioLogado().getUsuarioId());
				categoriaCorridaList.removeItem(cCorrida);
				categoriaCorridaService.borrar(cCorrida);
			} else {
				Messagebox.show(
						Labels.getLabel("editarConfiguracionCategoriaController.MSG.selectItem"),
						Labels.getLabel("editarConfiguracionCategoriaController.window.title"),
						Messagebox.OK, Messagebox.EXCLAMATION);
			}
		} catch (Exception ex) {
			log.error("", ex);
			Clients.alert(
					Labels.getLabel("MSG.Error"),
					Labels.getLabel("editarConfiguracionCategoriaController.window.title"),
					Messagebox.ERROR);
		}
	}

	public void onClick$btnAdicionarMercado(Event ev) throws InterruptedException {
		if (cmbParadaOrigem.getSelectedItem() == null) {
			Messagebox.show(
					Labels.getLabel("MSG.Error.combobox"),
					Labels.getLabel("editarConfiguracionCategoriaController.window.title"),
					Messagebox.OK, Messagebox.EXCLAMATION);

			cmbParadaOrigem.focus();
			return;
		}
		if (cmbParadaDestino.getSelectedItem() == null) {
			Messagebox.show(
					Labels.getLabel("MSG.Error.combobox"),
					Labels.getLabel("editarConfiguracionCategoriaController.window.title"),
					Messagebox.OK, Messagebox.EXCLAMATION);

			cmbParadaDestino.focus();
			return;
		}
		cmbParadaOrigem.getSelectedItem().getValue();
		cmbParadaDestino.getSelectedItem().getValue();
		try {
			if (cmbParadaOrigem.getSelectedItem().getValue() != cmbParadaDestino.getSelectedItem().getValue()) {

				CategoriaMercado cMercado = new CategoriaMercado();
				cMercado.setCategoriaCtrl(categoriaCtrl);
				cMercado.setActivo(Boolean.TRUE);
				cMercado.setOrigem((Parada) cmbParadaOrigem.getSelectedItem().getValue());
				cMercado.setDestino((Parada) cmbParadaDestino.getSelectedItem().getValue());
				cMercado.setFecmodif(Calendar.getInstance().getTime());
				cMercado.setUsuarioId(UsuarioLogado.getUsuarioLogado().getUsuarioId());
				boolean existe = false;
				for (CategoriaMercado cc : lsCategoriaMercado) {
					if (cc.getActivo() && cc.getOrigem().equals(cMercado.getOrigem()) && cc.getDestino().equals(cMercado.getDestino())) {
						existe = true;
					}
				}
				if (!existe) {
					lsCategoriaMercado.add(cMercado);
					lsCategoriaMercadoTemp.add(cMercado);
					categoriaMercadoList.addItemNovo(cMercado);
					categoriaCtrl.setCategoriaMercadoList(lsCategoriaMercado);
				} else {
					Messagebox.show(
							Labels.getLabel("MSG.Registro.Existe"),
							Labels.getLabel("editarConfiguracionCategoriaController.window.title"),
							Messagebox.OK, Messagebox.EXCLAMATION);
				}
			} else {
				Messagebox.show(
						Labels.getLabel("editarConfiguracionCategoriaController.MSG.selectItemDiferente"),
						Labels.getLabel("editarConfiguracionCategoriaController.window.title"),
						Messagebox.OK, Messagebox.EXCLAMATION);
			}
		} catch (Exception ex) {
			log.error("", ex);
			Clients.alert(
					Labels.getLabel("MSG.Error"),
					Labels.getLabel("editarConfiguracionCategoriaController.window.title"),
					Messagebox.ERROR);
		}
	}

	public void onClick$btnRemoverMercado(Event ev) {
		try {
			CategoriaMercado cMercado = (CategoriaMercado) categoriaMercadoList.getSelected();
			if (cMercado != null) {
				// removo o antigo
				lsCategoriaMercado.remove(cMercado);
				cMercado.setFecmodif(Calendar.getInstance().getTime());
				cMercado.setActivo(Boolean.FALSE);
				cMercado.setUsuarioId(UsuarioLogado.getUsuarioLogado().getUsuarioId());
				lsCategoriaMercadoTemp.remove(cMercado);
				lsCategoriaMercado.add(cMercado);
				categoriaCtrl.setCategoriaMercadoList(lsCategoriaMercado);
				categoriaMercadoList.removeItem(cMercado);
			} else {
				Messagebox.show(
						Labels.getLabel("editarConfiguracionCategoriaController.MSG.selectItem"),
						Labels.getLabel("editarConfiguracionCategoriaController.window.title"),
						Messagebox.OK, Messagebox.EXCLAMATION);
			}
		} catch (Exception ex) {
			log.error("", ex);
			Clients.alert(
					Labels.getLabel("MSG.Error"),
					Labels.getLabel("editarConfiguracionCategoriaController.window.title"),
					Messagebox.ERROR);
		}
	}

	public void onClick$btnAdicionarClase(Event ev) throws InterruptedException {
		if (cmbClase.getSelectedItem() == null) {
			Messagebox.show(
					Labels.getLabel("MSG.Error.combobox"),
					Labels.getLabel("editarConfiguracionCategoriaController.window.title"),
					Messagebox.OK, Messagebox.EXCLAMATION);

			cmbClase.focus();
			return;
		}
		cmbClase.getSelectedItem().getValue();
		try {
			boolean existe = false;
			for (CategoriaClase cc : lsCategoriaClase) {
				if (cc.getActivo() && cc.getClaseServicio().equals(cmbClase.getSelectedItem().getValue())) {
					existe = true;
				}
			}
			if (!existe) {
				CategoriaClase cClase = new CategoriaClase();
				cClase.setCategoriaCtrl(categoriaCtrl);
				cClase.setActivo(Boolean.TRUE);
				cClase.setClaseServicio((ClaseServicio) cmbClase.getSelectedItem().getValue());
				cClase.setFecmodif(Calendar.getInstance().getTime());
				cClase.setUsuarioId(UsuarioLogado.getUsuarioLogado().getUsuarioId());
				lsCategoriaClase.add(cClase);
				lsCategoriaClaseTemp.add(cClase);
				categoriaClaseList.addItemNovo(cClase);
				categoriaCtrl.setCategoriaClaseList(lsCategoriaClase);
			} else {
				Messagebox.show(
						Labels.getLabel("MSG.Registro.Existe"),
						Labels.getLabel("editarConfiguracionCategoriaController.window.title"),
						Messagebox.OK, Messagebox.EXCLAMATION);
			}
		} catch (Exception ex) {
			log.error("", ex);
			Clients.alert(
					Labels.getLabel("MSG.Error"),
					Labels.getLabel("editarConfiguracionCategoriaController.window.title"),
					Messagebox.ERROR);
		}
	}
	
	private void iniciaIntBoxesQtdeAutorizada(List<CategoriaRuta> lsCategoriaRuta) {
		lsIntBox = new ArrayList<Intbox>();
		for (int i = 0; i < lsCategoriaRuta.size(); i++) {
			addIntBox();
		}
	}
	
	private void inicialDecimalBoxesValor(List<CategoriaRuta> lsCategoriaRuta) {
		lsValorDecimalBox = new ArrayList<Decimalbox>();
		for (int i = 0; i < lsCategoriaRuta.size(); i++) {
			addValorDecimalBox();
		}
	}
	
	private void inicialDecimalBoxesPorcentagem(List<CategoriaRuta> lsCategoriaRuta) {
		lsPorcentagemDecimalBox = new ArrayList<Decimalbox>();
		for (int i = 0; i < lsCategoriaRuta.size(); i++) {
			addPorcentagemDecimalBox();
		}
	}

	
	private void addIntBox() {
		final Intbox intbox = new Intbox();
		intbox.setStyle("border:0;");

		intbox.addEventListener("onClick", new EventListener() {
			@Override
			public void onEvent(Event arg0) throws Exception {
				Integer position = lsIntBox.indexOf(intbox);
				categoriaRutaList.setSelectedIndex(position);
			}
		});

		intbox.addEventListener("onBlur", new EventListener() {

			@Override
			public void onEvent(Event arg0) throws Exception {
				Integer position = lsIntBox.indexOf(intbox);
				Integer qtdAutorizada = intbox.getText().isEmpty() ? null :  new Integer(intbox.getText());
				((CategoriaRuta) categoriaRutaList.getModel().getElementAt(position))
						.setQtdPoltronasAutorizadas(qtdAutorizada);
			}
		});
		lsIntBox.add(intbox);
	}
	
	private void addValorDecimalBox() {
		final Decimalbox decimalbox = new Decimalbox();
		decimalbox.setStyle("border:0;");

		decimalbox.addEventListener("onClick", new EventListener() {
			@Override
			public void onEvent(Event arg0) throws Exception {
				Integer position = lsValorDecimalBox.indexOf(decimalbox);
				categoriaRutaList.setSelectedIndex(position);
			}
		});

		decimalbox.addEventListener("onBlur", new EventListener() {

			@Override
			public void onEvent(Event arg0) throws Exception {
				Integer position = lsValorDecimalBox.indexOf(decimalbox);
				BigDecimal valor = decimalbox.getText().isEmpty() ? null : new BigDecimal( decimalbox.getText());
				((CategoriaRuta) categoriaRutaList.getModel().getElementAt(position))
						.setValorDesconto(valor);
			}
		});
		lsValorDecimalBox.add(decimalbox);
	}
	
	private void addPorcentagemDecimalBox() {
		final Decimalbox decimalbox = new Decimalbox();
		decimalbox.setStyle("border:0;");

		decimalbox.addEventListener("onClick", new EventListener() {
			@Override
			public void onEvent(Event arg0) throws Exception {
				Integer position = lsPorcentagemDecimalBox.indexOf(decimalbox);
				categoriaRutaList.setSelectedIndex(position);
			}
		});

		decimalbox.addEventListener("onBlur", new EventListener() {

			@Override
			public void onEvent(Event arg0) throws Exception {
				Integer position = lsPorcentagemDecimalBox.indexOf(decimalbox);
				BigDecimal porcentagem =  decimalbox.getText().isEmpty() ? null : new BigDecimal(decimalbox.getText());
				((CategoriaRuta) categoriaRutaList.getModel().getElementAt(position))
						.setPorcentagemDesconto(porcentagem);
			}
		});
		lsPorcentagemDecimalBox.add(decimalbox);
	}

	public void onClick$btnRemoverClase(Event ev) {
		try {
			CategoriaClase cClase = (CategoriaClase) categoriaClaseList.getSelected();
			if (cClase != null) {	
				// removo o antigo
				lsCategoriaClase.remove(cClase);
				cClase.setFecmodif(Calendar.getInstance().getTime());
				cClase.setActivo(Boolean.FALSE);
				cClase.setUsuarioId(UsuarioLogado.getUsuarioLogado().getUsuarioId());
				lsCategoriaClaseTemp.remove(cClase);
				lsCategoriaClase.add(cClase);
				categoriaCtrl.setCategoriaClaseList(lsCategoriaClase);
				categoriaClaseList.removeItem(cClase);
				
			} else {
				Messagebox.show(
						Labels.getLabel("editarConfiguracionCategoriaController.MSG.selectItem"),
						Labels.getLabel("editarConfiguracionCategoriaController.window.title"),
						Messagebox.OK, Messagebox.EXCLAMATION);
			}
		} catch (Exception ex) {
			log.error("", ex);
			Clients.alert(
					Labels.getLabel("MSG.Error"),
					Labels.getLabel("editarConfiguracionCategoriaController.window.title"),
					Messagebox.ERROR);
		}
	}

	public void onClick$btnAdicionarPeriodo(Event ev) {
		try {
			if (categoriaDescuentoList.getSelectedCount() > 0) {
				CategoriaDescuento cd = (CategoriaDescuento) categoriaDescuentoList.getSelected();
				verPeriodoDesconto(cd);
			} else {
				Messagebox.show(
						Labels.getLabel("editarConfiguracionCategoriaController.MSG.selectDescuento"),
						Labels.getLabel("editarConfiguracionCategoriaController.window.title"),
						Messagebox.OK, Messagebox.EXCLAMATION);
			}
		} catch (Exception ex) {
			log.error("", ex);
			Clients.alert(
					Labels.getLabel("MSG.Error"),
					Labels.getLabel("editarConfiguracionCategoriaController.window.title"),
					Messagebox.ERROR);
		}
	}

	public void onClick$radioImp(Event ev) {
		descuentoPorc.setDisabled(true);
		descuentoImporte.setDisabled(false);

		descuentoPorc.setConstraint("");
		descuentoPorc.setValue(BigDecimal.ZERO);
		descuentoImporte.setConstraint("");
		descuentoImporte.setValue(BigDecimal.ZERO);
		descuentoImporte.setConstraint("no empty, no negative");
	}

	public void onClick$radioPor(Event ev) {
		descuentoImporte.setDisabled(true);
		descuentoPorc.setDisabled(false);

		descuentoImporte.setConstraint("");
		descuentoImporte.setValue(BigDecimal.ZERO);
		descuentoPorc.setConstraint("");
		descuentoPorc.setValue(BigDecimal.ZERO);
		descuentoPorc.setConstraint("no empty, no zero, no negative");
	}

	public void onClick$rdVendaAntecipadaKMSi(Event ev) {
		rowVendaAntecipada.setVisible(false);
		rowTiempoVendaAntecipada.setVisible(false);
		rowKMVendaAntecipada.setVisible(true);
		rowTempoKMVendaAntecipada.setVisible(true);
	}

	public void onClick$rdVendaAntecipadaKMNo(Event ev) {
		rowVendaAntecipada.setVisible(true);
		rowTiempoVendaAntecipada.setVisible(true);
		rowKMVendaAntecipada.setVisible(false);
		spnKM.setValue(0);
		rowTempoKMVendaAntecipada.setVisible(false);
		tbTempoAteKM.setValue(DateUtil.getFecInicio().getTime());
		tbTempoMaiorKM.setValue(DateUtil.getFecInicio().getTime());
	}
	
	
	public void onClick$rdVendaAntecipadaSi(Event ev) {
		spnHora.setValue(0);
		spnMinuto.setValue(0);
		lblMsgTiempo.setValue(Labels.getLabel("editarConfiguracionCategoriaController.lblVentaAntecipadaTempoDesactivar.value"));
	}

	public void onClick$rdVendaAntecipadaNo(Event ev) {
		spnHora.setValue(0);
		spnMinuto.setValue(0);
		lblMsgTiempo.setValue(Labels.getLabel("editarConfiguracionCategoriaController.lblVentaAntecipadaTempoActivar.value"));
	}

	public void onClick$rdCuotaSi(Event ev) {
		mudarCamposCuota(true);
	}

	private void mudarCamposCuota(boolean visible) {
		rowTrecho.setVisible(visible);
		rowTiempo.setVisible(visible);
		linhaLiberarPoltronasQuandoOnibus.setVisible(visible);
		linhaAssentosReservados.setVisible(visible);
		timeTempoPermitir.setValue(null);
	}

	public void onClick$rdCuotaNo(Event ev) {
		mudarCamposCuota(false);
	}

	public Row getLinhaLiberarPoltronasQuandoOnibus() {
		return linhaLiberarPoltronasQuandoOnibus;
	}

	public void setLinhaLiberarPoltronasQuandoOnibus(Row linhaLiberarPoltronasQuandoOnibus) {
		this.linhaLiberarPoltronasQuandoOnibus = linhaLiberarPoltronasQuandoOnibus;
	}

	public Row getLinhaAssentosReservados() {
		return linhaAssentosReservados;
	}

	public void setLinhaAssentosReservados(Row linhaAssentosReservados) {
		this.linhaAssentosReservados = linhaAssentosReservados;
	}

	public Boolean isDescontoComponentePreco() {
		Constante constante = constanteService.buscarPorNomeConstante(Constantes.DESCONTO_COMPONENTE_PRECO);
		if (constante != null) {
			return Boolean.valueOf(constante.getValorconstante());
		}
		return false;
	}
		
	public void onClick$rdVendeAbertoSim(Event ev) {
		rowComportamentoVendaAberto.setVisible(rdVendeAbertoSim.isChecked());
	}
	
	public void onClick$rdVendaAbertoNao(Event ev) {
		rowComportamentoVendaAberto.setVisible(rdVendeAbertoSim.isChecked());
	}
	
	public void onClick$chkTipoCategoriaInteragem(Event event) {
		rowIdTipoCategoriaInteragem.setVisible(chkTipoCategoriaInteragem.isChecked());
	}
	
	public void onClick$chkExigeNumeroFidelidade(Event event) {
		rowIdTipoOcupacao.setVisible(chkExigeNumeroFidelidade.isChecked());
	}
	
	public void onClick$chkIndCustomizaRodapeCupomEmbarque(Event ev) {
		rowCustomizaRodapeCupomEmbarque.setVisible(chkIndCustomizaRodapeCupomEmbarque.isChecked());
	}


	public String getCorLaranja() {
		return TipoPassagemCores.LARANJA.getUrl();
	}

	public String getCorVerde() {
		return TipoPassagemCores.VERDE.getUrl();
	}
	
	public String getCorVerdeMusgo() {
		return TipoPassagemCores.VERDE_MUSGO.getUrl();
	}
	
	public String getCorAzul() {
		return TipoPassagemCores.AZUL.getUrl();
	}
	
	public String getCorAzulMarinho() {
		return TipoPassagemCores.AZUL_MARINHO.getUrl();
	}
	
	public String getCorAzulPiscina() {
		return TipoPassagemCores.AZUL_PISCINA.getUrl();
	}
	
	public String getCorBege() {
		return TipoPassagemCores.BEGE.getUrl();
	}
	
	public String getCorLilas() {
		return TipoPassagemCores.LILAS.getUrl();
	}
	
	public String getCorMarrom() {
		return TipoPassagemCores.MARROM.getUrl();
	}
	
	public String getCorRosa() {
		return TipoPassagemCores.ROSA.getUrl();
	}
	
	public String getCorRosaChoque() {
		return TipoPassagemCores.ROSA_CHOQUE.getUrl();
	}
	
	public String getCorRoxo() {
		return TipoPassagemCores.ROXO.getUrl();
	}

	public Checkbox getChkExigeEnderecopasajero() {
		return chkExigeEnderecopasajero;
	}

	public void setChkExigeEnderecopasajero(Checkbox chkExigeEnderecopasajero) {
		this.chkExigeEnderecopasajero = chkExigeEnderecopasajero;
	}

	public Checkbox getChkExigeEmailpasajero() {
		return chkExigeEmailpasajero;
	}

	public void setChkExigeEmailpasajero(Checkbox chkExigeEmailpasajero) {
		this.chkExigeEmailpasajero = chkExigeEmailpasajero;
	}
	
	public Boolean getConfigEmiteSomenteCupomEmbarque() {
		return UsuarioLogado.getUsuarioLogado().isPermisoClave(ConstantesFuncionSistema.CLAVE_CONFIG_EMITE_SOMENTE_CUPOM_EMBARQUE);
	}

	public Checkbox getChkPermiteTroca() {
		return chkPermiteTroca;
	}

	public void setChkPermiteTroca(Checkbox chkPermiteTroca) {
		this.chkPermiteTroca = chkPermiteTroca;
	}

	public Checkbox getChkPermiteTransferencia() {
		return chkPermiteTransferencia;
	}

	public void setChkPermiteTransferencia(Checkbox chkPermiteTransferencia) {
		this.chkPermiteTransferencia = chkPermiteTransferencia;
	}

	private List<Ruta> restringirOpcaoTodasLinhas(List<Ruta> lsRuta) {
		List<Ruta> lsRutaSemOpcaoTodas = new ArrayList<Ruta>();
		for (Ruta ruta : lsRuta) {
			if(!ruta.getRutaId().equals(-1)) {
				lsRutaSemOpcaoTodas.add(ruta);
			}
		}
		return lsRutaSemOpcaoTodas;
	}
	
	@SuppressWarnings("unchecked")
	private boolean validarOpcaoTodasComboLinhas() {
		
		List<CategoriaRuta> ls = categoriaRutaList.getListData();
		boolean contem = false;
		for (CategoriaRuta ruta : ls) {
			if(ruta.getRuta().getRutaId().equals(-1)) {
				return true;
			}
		}		
		return contem;		
	}
	
	@SuppressWarnings("unchecked")
	private boolean validarExisteExcecaoLinha() {
		
		boolean contem = false;
		List<CategoriaRuta> ls = categoriaRutaList.getListData();
		if(categoriaRutaExcecaoList.getListData().isEmpty()) {
			return true;
		}
		
		if(!categoriaRutaExcecaoList.getListData().isEmpty()) {
			for (CategoriaRuta ruta : ls) {
				if(ruta.getRuta().getRutaId().equals(-1)) {
					return true;
				}
			}
		}
		return contem;
	}
	
	@SuppressWarnings("unchecked")
	private void inativarExcecoesLinha() {
		
		List<CategoriaRutaExcecao> ls = categoriaRutaExcecaoList.getListData();

			for (CategoriaRutaExcecao ruta : ls) {
				ruta.setActivo(Boolean.FALSE);
			}
		
	}
	
	public Checkbox getChkCancelaEmAberto() {
		return chkCancelaEmAberto;
	}

	public void setChkCancelaEmAberto(Checkbox chkCancelaEmAberto) {
		this.chkCancelaEmAberto = chkCancelaEmAberto;
	}

	public Checkbox getChkDevolveEmAberto() {
		return chkDevolveEmAberto;
	}

	public void setChkDevolveEmAberto(Checkbox chkDevolveEmAberto) {
		this.chkDevolveEmAberto = chkDevolveEmAberto;
	}

	public Checkbox getChkCancelaEmergencialEmAberto() {
		return chkCancelaEmergencialEmAberto;
	}

	public void setChkCancelaEmergencialEmAberto(Checkbox chkCancelaEmergencialEmAberto) {
		this.chkCancelaEmergencialEmAberto = chkCancelaEmergencialEmAberto;
	}

	public Checkbox getChkTrocaEmAberto() {
		return chkTrocaEmAberto;
	}

	public void setChkTrocaEmAberto(Checkbox chkTrocaEmAberto) {
		this.chkTrocaEmAberto = chkTrocaEmAberto;
	}

	public Checkbox getChkTrocaTiturlidadeEmAberto() {
		return chkTrocaTiturlidadeEmAberto;
	}

	public void setChkTrocaTiturlidadeEmAberto(Checkbox chkTrocaTiturlidadeEmAberto) {
		this.chkTrocaTiturlidadeEmAberto = chkTrocaTiturlidadeEmAberto;
	}
	
	public Combobox getCmbCategoriasInteragem() {
		return cmbCategoriasInteragem;
	}

	public void setCmbCategoriasInteragem(Combobox cmbCategoriasInteragem) {
		this.cmbCategoriasInteragem = cmbCategoriasInteragem;
	}

	public Combobox getCmbOcupacion() {
		return cmbOcupacion;
	}

	public void setCmbOcupacion(Combobox cmbOcupacion) {
		this.cmbOcupacion = cmbOcupacion;
	}

	public List<TipoOcupacion> getLsTipoOcupacion() {
		return lsTipoOcupacion;
	}

	public void setLsTipoOcupacion(List<TipoOcupacion> lsTipoOcupacion) {
		this.lsTipoOcupacion = lsTipoOcupacion;
	}

	public Row getRowIdTipoOcupacao() {
		return rowIdTipoOcupacao;
	}

	public void setRowIdTipoOcupacao(Row rowIdTipoOcupacao) {
		this.rowIdTipoOcupacao = rowIdTipoOcupacao;
	}
	
	
}