Example #1
0
        } // fim de UltimaAcaoIgualCancelar

        /// <summary>
        /// Checa os ingressos de um item de venda
        /// </summary>
        /// <returns></returns>
        public override bool ChecarIngressoStatusCancelar()
        {
            Ingresso ingresso       = new Ingresso();
            bool     statusCancelar = true;

            try
            {
                // Obtendo dados atravehs de SQL
                string sql =
                    "SELECT     tIngressoLog.IngressoID, tIngressoLog.VendaBilheteriaItemID " +
                    "FROM       tIngressoLog INNER JOIN " +
                    "tIngresso ON tIngressoLog.IngressoID = tIngresso.ID INNER JOIN " +
                    "tVendaBilheteriaItem ON tIngressoLog.VendaBilheteriaItemID = tVendaBilheteriaItem.ID " +
                    "WHERE     (tIngressoLog.VendaBilheteriaItemID = " + this.Control.ID + ")";
                bd.Consulta(sql);
                while (bd.Consulta().Read() && statusCancelar)
                {
                    ingresso.Ler(bd.LerInt("IngressoID"));
                    statusCancelar = ingresso.ChecarStatusCancelar();
                }
                bd.Fechar();
                return(statusCancelar);
            }
            catch (Exception erro)
            {
                throw erro;
            }
        } // fim de ChecarIngressoStatusCancelar
Example #2
0
        }         // fim de InserirVenda

        public int IngressoID(int apresentacaoID, int setorID, string codigo)
        {
            Ingresso ingresso = new Ingresso();

            ingresso.Codigo.Valor = codigo;
            ingresso.Identifica(apresentacaoID, setorID);
            return(ingresso.Control.ID);
        }
Example #3
0
        } // fim de IngressoIDsPorAcao

        /// <summary>
        /// Alimenta esse IngressoLog de acordo com o Ingresso passado como parametro
        /// </summary>
        public override void Ingresso(Ingresso ingresso)
        {
            this.IngressoID.Valor = ingresso.Control.ID;
            this.UsuarioID.Valor  = ingresso.UsuarioID.Valor;
            this.BloqueioID.Valor = ingresso.BloqueioID.Valor;
            this.CortesiaID.Valor = ingresso.CortesiaID.Valor;
            this.PrecoID.Valor    = ingresso.PrecoID.Valor;
            this.TimeStamp.Valor  = System.DateTime.Now;
        }
        public DataTable PesquisarCodigoBarras(string codigoBarra)
        {
            BD        bd     = null;
            DataTable tabela = EstruturaHistorico();
            int       ingressoID;

            try
            {
                bd         = new BD();
                ingressoID = 0;

                using (IDataReader oDataReader = bd.Consulta("" +
                                                             "SELECT " +
                                                             "   tIngresso.ID " +
                                                             "FROM " +
                                                             "   tIngresso (NOLOCK) " +
                                                             "WHERE " +
                                                             "   (CodigoBarra = '" + codigoBarra + "' OR CodigoBarraCliente='" + codigoBarra + "') " +
                                                             "ORDER BY " +
                                                             "   tIngresso.ID"))
                {
                    if (!oDataReader.Read())
                    {
                        throw new ApplicationException("Código de Barras não encontrado!");
                    }

                    ingressoID = bd.LerInt("ID");

                    if (ingressoID < 1)
                    {
                        throw new ApplicationException("Código de Barras não encontrado!");
                    }

                    Ingresso ingresso = new Ingresso();
                    ingresso.Control.ID = ingressoID;

                    tabela = ingresso.Historico();
                }

                return(AssinaturaBancoIngresso.VerificarSeExisteBancoIngresso(ingressoID, tabela));
            }
            finally
            {
                if (bd != null)
                {
                    bd.Fechar();
                }
            }
        }
Example #5
0
        /// <summary>
        /// Vai inserir os ingressos on demand, este método só é utilizado em caso de compras para cinema!!!
        /// Não gerará código sequencial nem código do lugar!
        /// </summary>
        /// <param name="estruturaReserva"></param>
        /// <param name="apresentacaoSetorID"></param>
        /// <param name="eventoID"></param>
        /// <param name="apresentacaoID"></param>
        /// <param name="setorID"></param>
        /// <param name="ingressosRetorno"></param>
        /// <param name="listaPreco"></param>
        /// <returns></returns>
        private List <Ingresso> NovoNaoMarcadoOnDemand(EstruturaReservaInternet estruturaReserva, int apresentacaoSetorID, int eventoID, int apresentacaoID, int setorID, List <Ingresso> ingressosRetorno, List <EstruturaPrecoReservaSite> listaPreco)
        {
            BD bd = new BD();

            try
            {
                List <int> ids   = this.NovoNaoMarcadoOnDemand(bd, eventoID, apresentacaoID, apresentacaoSetorID, setorID, listaPreco.Count - ingressosRetorno.Count);
                int        atual = ingressosRetorno.Count;

                for (int i = atual; i < listaPreco.Count; i++)
                {
                    var ingresso = new Ingresso();
                    ingresso.Control.ID             = ids[0];
                    ingresso.PrecoID.Valor          = listaPreco[atual].ID;
                    ingresso.UsuarioID.Valor        = estruturaReserva.UsuarioID;
                    ingresso.LojaID.Valor           = estruturaReserva.LojaID;
                    ingresso.ClienteID.Valor        = estruturaReserva.ClienteID;
                    ingresso.SessionID.Valor        = estruturaReserva.SessionID;
                    ingresso.TimeStampReserva.Valor = DateTime.Now;
                    ingresso.TxConv           = new BilheteriaParalela().TaxaConveniencia(eventoID, listaPreco[atual].ID, estruturaReserva.CanalID);;
                    ingresso.CotaItemID       = listaPreco[atual].CotaItemID;
                    ingresso.CotaItemIDAPS    = listaPreco[atual].CotaItemIDAPS;
                    ingresso.SerieID.Valor    = 0;
                    ingresso.CompraGUID.Valor = estruturaReserva.GUID;
                    ingressosRetorno.Add(ingresso);
                }

                return(ingressosRetorno);
            }
            catch (Exception ex)
            {
                bd.DesfazerTransacao();
                throw ex;
            }
            finally
            {
                bd.Fechar();
            }
        }
Example #6
0
        public DataTable DetalhesItem(int VendaBilheteriaItemID)
        {
            DataTable tabela = new DataTable("DetalhesItem");

            try
            {
                tabela.Columns.Add("PacoteNome", typeof(string));
                tabela.Columns.Add("LocalNome", typeof(string));
                tabela.Columns.Add("EventoNome", typeof(string));
                tabela.Columns.Add("Horario", typeof(string));
                tabela.Columns.Add("SetorNome", typeof(string));
                tabela.Columns.Add("PrecoNome", typeof(string));
                tabela.Columns.Add("PrecoValor", typeof(decimal));
                tabela.Columns.Add("Status", typeof(string));
                tabela.Columns.Add("Codigo", typeof(string));

                bd.Consulta("" +
                            "SELECT " +
                            "	tPacote.Nome AS PacoteNome, "+
                            "	tLocal.Nome AS LocalNome, "+
                            "	tEvento.Nome AS EventoNome, "+
                            "	tApresentacao.Horario, "+
                            "	tSetor.Nome AS SetorNome, "+
                            "	tPreco.Nome AS PrecoNome, "+
                            "	tPreco.Valor AS PrecoValor, "+
                            "	tIngresso.Status, "+
                            "	tIngresso.Codigo "+
                            "FROM " +
                            "	tVendaBilheteriaItem "+
                            "INNER JOIN " +
                            "	tIngressoLog ON tIngressoLog.VendaBilheteriaItemID = tVendaBilheteriaItem.ID "+
                            "INNER JOIN " +
                            "	tIngresso ON tIngresso.ID = tIngressoLog.IngressoID "+
                            "INNER JOIN " +
                            "	tLocal ON tLocal.ID = tIngresso.LocalID "+
                            "INNER JOIN " +
                            "	tEvento ON tEvento.ID = tIngresso.EventoID "+
                            "INNER JOIN " +
                            "	tApresentacao ON tApresentacao.ID = tIngresso.ApresentacaoID "+
                            "INNER JOIN " +
                            "	tSetor ON tSetor.ID = tIngresso.SetorID "+
                            "INNER JOIN " +
                            "	tPreco ON tPreco.ID = tIngresso.PrecoID "+
                            "LEFT OUTER JOIN " +
                            "	tPacote ON tPacote.ID = tIngresso.PacoteID "+
                            "WHERE " +
                            "	tVendaBilheteriaItem.ID = "+ VendaBilheteriaItemID + " " +
                            "");

                while (bd.Consulta().Read())
                {
                    DataRow linha = tabela.NewRow();
                    linha["PacoteNome"] = bd.LerString("PacoteNome");
                    linha["LocalNome"]  = bd.LerString("LocalNome");
                    linha["EventoNome"] = bd.LerString("EventoNome");
                    linha["Horario"]    = bd.LerDateTime("Horario");
                    linha["SetorNome"]  = bd.LerString("SetorNome");
                    linha["PrecoNome"]  = bd.LerString("PrecoNome");
                    linha["PrecoValor"] = bd.LerDecimal("PrecoValor");
                    linha["Status"]     = Ingresso.StatusDescritivo(bd.LerString("Status"));
                    linha["Codigo"]     = bd.LerString("Codigo");
                    tabela.Rows.Add(linha);
                }
                bd.Fechar();
            }
            catch (Exception ex)
            {
                throw ex;
            }

            return(tabela);
        }
        public string TrocarPreco(Dictionary <int, int> ingressoXpreco, decimal valorPagar,
                                  decimal valorCancelar, int clienteID, int caixaID, int canalID,
                                  int empresaID, int lojaID, string motivoTroca, int usuarioID,
                                  int BIN, int codigoAutorizacaoCartao, int indiceInstituicaoTransacao,
                                  int indiceTipoCartao, int modalidadePagamentoCodigo,
                                  string modalidadePagamentoTexto, string notaFiscalCliente,
                                  string notaFiscalEstabelecimento, int NSUHost, int NSUSitef,
                                  int formaPagamentoEscolhida)
        {
            BD bd = new BD();

            try
            {
                bd.IniciarTransacao();

                /*
                 * VB
                 * VBI
                 * VBFP
                 * Log
                 * tIngressO
                 */

                #region Cancelamento
                VendaBilheteria vbCancelamento = new VendaBilheteria();
                vbCancelamento.CaixaID.Valor   = caixaID;
                vbCancelamento.ClienteID.Valor = clienteID;
                vbCancelamento.DataVenda.Valor = DateTime.Now;
                vbCancelamento.Obs.Valor       = motivoTroca;
                vbCancelamento.Status.Valor    = VendaBilheteria.CANCELADO;
                vbCancelamento.TaxaConvenienciaValorTotal.Valor = 0;
                vbCancelamento.TaxaEntregaID.Valor       = 0;
                vbCancelamento.TaxaEntregaValor.Valor    = 0;
                vbCancelamento.ValorTotal.Valor          = valorCancelar;
                vbCancelamento.PagamentoProcessado.Valor = true;
                string sql     = vbCancelamento.StringInserir();
                object retorno = bd.ConsultaValor(sql);
                int    vendaBilheteriaIDCancelamento = Convert.ToInt32(retorno);
                if (vendaBilheteriaIDCancelamento == 0)
                {
                    throw new Exception("Não foi possível inserir o cancelamento na VendaBilheteria");
                }

                VendaBilheteriaFormaPagamento vbfpCancelamento = new VendaBilheteriaFormaPagamento();
                vbfpCancelamento.FormaPagamentoID.Valor  = formaPagamentoEscolhida;
                vbfpCancelamento.Porcentagem.Valor       = 100;
                vbfpCancelamento.Valor.Valor             = valorCancelar;
                vbfpCancelamento.VendaBilheteriaID.Valor = vendaBilheteriaIDCancelamento;

                sql     = vbfpCancelamento.StringInserir();
                retorno = bd.ConsultaValor(sql);
                int vendaBilheteriaFormaPagamentoIDCancelamento = Convert.ToInt32(retorno);

                if (vendaBilheteriaFormaPagamentoIDCancelamento == 0)
                {
                    throw new Exception("Não foi possível inserir o cancelamento na VendaBilheteriaFormaPagamento");
                }

                foreach (KeyValuePair <int, int> iXp in ingressoXpreco)
                {
                    int ingressoID          = iXp.Key;
                    VendaBilheteriaItem vbi = new VendaBilheteriaItem();
                    vbi.Acao.Valor                  = VendaBilheteriaItem.CANCELAMENTO;
                    vbi.PacoteID.Valor              = 0;
                    vbi.TaxaConveniencia.Valor      = 0;
                    vbi.TaxaConvenienciaValor.Valor = 0;
                    vbi.VendaBilheteriaID.Valor     = vendaBilheteriaIDCancelamento;

                    sql     = vbi.StringInserir();
                    retorno = bd.ConsultaValor(sql);
                    int vendaBilheteriaItemIDCancelamento = Convert.ToInt32(retorno);
                    if (vendaBilheteriaItemIDCancelamento == 0)
                    {
                        throw new Exception("Não foi possível inserir o cancelamento na VendaBilheteriaItem");
                    }


                    Ingresso ingresso = new Ingresso();
                    ingresso.Ler(ingressoID);
                    IngressoLog oIngressoLog = new IngressoLog();
                    oIngressoLog.Acao.Valor                  = IngressoLog.CANCELAR;
                    oIngressoLog.BloqueioID.Valor            = 0;
                    oIngressoLog.CaixaID.Valor               = caixaID;
                    oIngressoLog.CanalID.Valor               = canalID;
                    oIngressoLog.ClienteID.Valor             = ingresso.ClienteID.Valor;
                    oIngressoLog.CortesiaID.Valor            = 0;
                    oIngressoLog.EmpresaID.Valor             = empresaID;
                    oIngressoLog.IngressoID.Valor            = ingressoID;
                    oIngressoLog.LojaID.Valor                = lojaID;
                    oIngressoLog.Obs.Valor                   = motivoTroca;
                    oIngressoLog.PrecoID.Valor               = ingresso.PrecoID.Valor;
                    oIngressoLog.TimeStamp.Valor             = DateTime.Now;
                    oIngressoLog.UsuarioID.Valor             = usuarioID;
                    oIngressoLog.VendaBilheteriaID.Valor     = vendaBilheteriaIDCancelamento;
                    oIngressoLog.VendaBilheteriaItemID.Valor = vendaBilheteriaItemIDCancelamento;

                    sql     = oIngressoLog.StringInserir();
                    retorno = bd.ConsultaValor(sql);
                }
                #endregion

                #region Nova Venda
                VendaBilheteria vbVenda = new VendaBilheteria();
                vbVenda.BIN.Valor       = BIN;
                vbVenda.CaixaID.Valor   = caixaID;
                vbVenda.ClienteID.Valor = clienteID;
                vbVenda.CodigoAutorizacaoCredito.Valor = codigoAutorizacaoCartao;
                vbVenda.DataVenda.Valor = DateTime.Now;
                vbVenda.IndiceInstituicaoTransacao.Valor = indiceInstituicaoTransacao;
                vbVenda.IndiceTipoCartao.Valor           = indiceTipoCartao;
                vbVenda.ModalidadePagamentoCodigo.Valor  = modalidadePagamentoCodigo;
                vbVenda.ModalidadePagamentoTexto.Valor   = modalidadePagamentoTexto;
                vbVenda.NotaFiscalCliente.Valor          = notaFiscalCliente;
                vbVenda.NotaFiscalEstabelecimento.Valor  = notaFiscalEstabelecimento;
                vbVenda.NSUHost.Valor  = NSUHost;
                vbVenda.NSUSitef.Valor = NSUSitef;
                vbVenda.Obs.Valor      = string.Empty;
                vbVenda.Status.Valor   = VendaBilheteria.PAGO;
                vbVenda.TaxaConvenienciaValorTotal.Valor = 0;
                vbVenda.TaxaEntregaID.Valor       = 0;
                vbVenda.TaxaEntregaValor.Valor    = 0;
                vbVenda.ValorTotal.Valor          = valorPagar;
                vbVenda.PagamentoProcessado.Valor = true;
                sql     = vbVenda.StringInserir();
                retorno = bd.ConsultaValor(sql);
                int vendaBilheteriaID = Convert.ToInt32(retorno);
                if (vendaBilheteriaID == 0)
                {
                    throw new Exception("Não foi possível inserir a venda na VendaBilheteria");
                }

                VendaBilheteriaFormaPagamento vbfpVenda = new VendaBilheteriaFormaPagamento();
                vbfpVenda.FormaPagamentoID.Valor  = formaPagamentoEscolhida;
                vbfpVenda.Porcentagem.Valor       = 100;
                vbfpVenda.Valor.Valor             = valorPagar;
                vbfpVenda.VendaBilheteriaID.Valor = vendaBilheteriaID;

                sql     = vbfpVenda.StringInserir();
                retorno = bd.ConsultaValor(sql);
                int vendaBilheteriaFormaPagamentoID = Convert.ToInt32(retorno);
                if (vendaBilheteriaFormaPagamentoID == 0)
                {
                    throw new Exception("Não foi possível inserir a venda na VendaBilheteriaFormaPagamento");
                }

                foreach (KeyValuePair <int, int> iXp in ingressoXpreco)
                {
                    int ingressoID          = iXp.Key;
                    VendaBilheteriaItem vbi = new VendaBilheteriaItem();
                    vbi.Acao.Valor                  = VendaBilheteriaItem.VENDA;
                    vbi.PacoteID.Valor              = 0;
                    vbi.TaxaConveniencia.Valor      = 0;
                    vbi.TaxaConvenienciaValor.Valor = 0;
                    vbi.VendaBilheteriaID.Valor     = vendaBilheteriaID;

                    sql     = vbi.StringInserir();
                    retorno = bd.ConsultaValor(sql);
                    int vendaBilheteriaItemID = Convert.ToInt32(retorno);
                    if (vendaBilheteriaItemID == 0)
                    {
                        throw new Exception("Não foi possível inserir a venda na VendaBilheteriaItem");
                    }


                    Ingresso ingresso = new Ingresso();
                    ingresso.Ler(ingressoID);
                    IngressoLog oIngressoLog = new IngressoLog();
                    oIngressoLog.Acao.Valor       = IngressoLog.VENDER;
                    oIngressoLog.BloqueioID.Valor = 0;
                    oIngressoLog.CaixaID.Valor    = caixaID;
                    oIngressoLog.CanalID.Valor    = canalID;
                    oIngressoLog.ClienteID.Valor  = ingresso.ClienteID.Valor;
                    oIngressoLog.CortesiaID.Valor = 0;
                    oIngressoLog.EmpresaID.Valor  = empresaID;
                    oIngressoLog.IngressoID.Valor = ingressoID;
                    oIngressoLog.LojaID.Valor     = lojaID;
                    oIngressoLog.Obs.Valor        = string.Empty;
                    int precoID = 0;
                    ingressoXpreco.TryGetValue(ingressoID, out precoID);
                    if (precoID == 0)
                    {
                        throw new Exception("Não existe preço definido para um dos ingressos!");
                    }
                    oIngressoLog.PrecoID.Valor               = precoID;
                    oIngressoLog.TimeStamp.Valor             = DateTime.Now;
                    oIngressoLog.UsuarioID.Valor             = usuarioID;
                    oIngressoLog.VendaBilheteriaID.Valor     = vendaBilheteriaID;
                    oIngressoLog.VendaBilheteriaItemID.Valor = vendaBilheteriaItemID;
                    sql = oIngressoLog.StringInserir();
                    bd.ConsultaValor(sql);

                    //ingresso.CodigoBarra.Valor = new CodigoBarra().GerarCodigoBarra(precoID, ingresso.EventoID.Valor);
                    ingresso.Status.Valor            = Ingresso.VENDIDO;
                    ingresso.VendaBilheteriaID.Valor = vendaBilheteriaID;
                    ingresso.UsuarioID.Valor         = usuarioID;
                    ingresso.LojaID.Valor            = lojaID;
                    ingresso.PrecoID.Valor           = precoID;

                    if (!ingresso.Atualizar(bd))
                    {
                        throw new Exception("Ingresso não pôde ser atualizado!");
                    }
                }
                #endregion
                bd.FinalizarTransacao();
                retorno = bd.ConsultaValor("SELECT Senha FROM tVendaBilheteria WHERE ID = " + vendaBilheteriaID);
                if (retorno is string)
                {
                    return((string)retorno);
                }
                else
                {
                    return(string.Empty);
                }
            }
            catch
            {
                bd.DesfazerTransacao();
            }
            return(null);
        }
Example #8
0
        }         // fim de GravarComanda

        /// <summary>
        /// Gravar informações de Comanda e seus itens, antes de imprimir Comanda no Bar
        /// </summary>
        /// <returns></returns>
        public string GravarComanda(
            out int vendaID,
            bool trabalharComIngresso,
            int caixaID,
            int apresentacaoID,
            int setorID,
            string codigo,
            int garconID,
            DataTable comandaItemTabelaMemoria)
        {
            int     comandaID;
            Comanda comanda = new Comanda(usuarioID);

            try{
                vendaID = 0;
                // Gravar na tabela Comanda
                comanda.CaixaID.Valor = caixaID;
                comanda.VendaID.Valor = 0;
                Ingresso ingresso = new Ingresso();
                if (trabalharComIngresso)
                {
                    comanda.IngressoID.Valor = IngressoID(apresentacaoID, setorID, codigo);
                    comanda.GarconID.Valor   = garconID;
                }
                else
                {
                    comanda.IngressoID.Valor = 0;
                    comanda.GarconID.Valor   = 0;
                }
                int incremento = comanda.Ultima() + 1;
                comanda.Ordem.Valor = incremento.ToString();
                comanda.Inserir();                      // *****
                comandaID = comanda.Control.ID;         // retornar ID da Comanda
                foreach (DataRow linha in comandaItemTabelaMemoria.Rows)
                {
                    // Gravar os itens
                    ComandaItem comandaItem = new ComandaItem(usuarioID);
                    comandaItem.ComandaID.Valor  = comandaID;
                    comandaItem.ProdutoID.Valor  = Convert.ToInt32(linha["ProdutoID"]);
                    comandaItem.Quantidade.Valor = Convert.ToInt32(linha["Quantidade"]);
                    // Pesquisar PrecoVenda
                    Produto produto = new Produto();
                    produto.Ler(Convert.ToInt32(linha["ProdutoID"]));
                    comandaItem.PrecoVenda.Valor = produto.PrecoVenda.Valor;
                    // Inserir o item de comanda
                    comandaItem.Inserir();
                    // Atualizar quantidade no estoque para cada item de venda
                    Caixa caixa = new Caixa(usuarioID);
                    caixa.Ler(caixaID);
                    Loja loja = new Loja(usuarioID);
                    loja.Ler(caixa.LojaID.Valor);
                    EstoqueItem estoqueItem = new EstoqueItem(usuarioID);
                    estoqueItem.ProdutoID.Valor = Convert.ToInt32(linha["ProdutoID"]);
                    estoqueItem.EstoqueID.Valor = loja.EstoqueID.Valor;
                    estoqueItem.DefinirID();
                    estoqueItem.AtualizarSaldo(-1 * Convert.ToInt32(linha["Quantidade"]));
                }
                // Em sistema de Ticket, assim que imprimiu a comanda, salva a venda
                if (!trabalharComIngresso)
                {
                    // Chame um mehtodo que cria um registro de Venda e atualiza VendaID nesta Comanda
                    vendaID = InserirVenda(caixaID, comanda.IngressoID.Valor, comandaID);
                }
            }catch (Exception erro) {
                throw erro;
            }
            return(comanda.Ordem.Valor);
        }         // fim de GravarComanda
Example #9
0
        }         // fim de GravarComandaPagamento

        /// <summary>
        /// Gravar informações de Comanda e seus itens, antes de imprimir Comanda no Bar
        /// Usa como parâmetro Matriz em vez de DataTable
        /// </summary>
        /// <returns></returns>
        public string GravarComanda(
            out int vendaID,
            bool trabalharComIngresso,
            int caixaID,
            int apresentacaoID,
            int setorID,
            string codigo,
            int garconID,
            int [,] comandaItemMatrizMemoria)
        {
            //

            int     comandaID;
            Comanda comanda = new Comanda(usuarioID);

            try{
                vendaID = 0;
                // Gravar na tabela Comanda
                comanda.CaixaID.Valor = caixaID;
                comanda.VendaID.Valor = 0;
                Ingresso ingresso = new Ingresso();
                if (trabalharComIngresso)
                {
                    comanda.IngressoID.Valor = IngressoID(apresentacaoID, setorID, codigo);
                    comanda.GarconID.Valor   = garconID;
                }
                else
                {
                    comanda.IngressoID.Valor = 0;
                    comanda.GarconID.Valor   = 0;
                }
                int incremento = comanda.Ultima() + 1;
                comanda.Ordem.Valor = incremento.ToString();
                comanda.Inserir();                                      // *****
                comandaID = comanda.Control.ID;                         // retornar ID da Comanda
                int tamanho = (int)comandaItemMatrizMemoria.Length / 2; // 2 colunas
                for (int conta = 0; conta < tamanho; conta++)
                {
                    // Gravar os itens
                    int         produtoID   = Convert.ToInt32(comandaItemMatrizMemoria[conta, 0]);
                    int         quantidade  = Convert.ToInt32(comandaItemMatrizMemoria[conta, 1]);
                    ComandaItem comandaItem = new ComandaItem(usuarioID);
                    comandaItem.ComandaID.Valor  = comandaID;
                    comandaItem.ProdutoID.Valor  = produtoID;
                    comandaItem.Quantidade.Valor = quantidade;
                    // Pesquisar PrecoVenda
                    Produto produto = new Produto();
                    produto.Ler(produtoID);                     // *****
                    comandaItem.PrecoVenda.Valor = produto.PrecoVenda.Valor;
                    // Inserir o item de comanda
                    comandaItem.Inserir();                      // *****
                    // Atualizar quantidade no estoque para cada item de venda
                    Caixa caixa = new Caixa(usuarioID);
                    caixa.Ler(caixaID);                         // *****
                    Loja loja = new Loja(usuarioID);
                    loja.Ler(caixa.LojaID.Valor);
                    EstoqueItem estoqueItem = new EstoqueItem(usuarioID);
                    estoqueItem.ProdutoID.Valor = produtoID;
                    estoqueItem.EstoqueID.Valor = loja.EstoqueID.Valor;
                    estoqueItem.DefinirID();                            // *****
                    estoqueItem.AtualizarSaldo(-1 * quantidade);        // *****
                }
                // Em sistema de Ticket, assim que imprimiu a comanda, salva a venda
                if (!trabalharComIngresso)
                {
                    // Chame um mehtodo que cria um registro de Venda e atualiza VendaID nesta Comanda
                    vendaID = InserirVenda(caixaID, comanda.IngressoID.Valor, comandaID);                       // *****
                }
            }catch (Exception erro) {
                throw erro;
            }
            return(comanda.Ordem.Valor);
        }         // fim de GravarComanda
Example #10
0
        /// <summary>
        /// Método para retornar os ingressos (para reserva) dos melhores lugares de mesa fechada.
        /// kim
        /// </summary>
        /// <param name="usuarioID"></param>
        /// <param name="lojaID"></param>
        /// <param name="sessionID"></param>
        /// <param name="clienteID"></param>
        /// <param name="eventoID"></param>
        /// <param name="apresentacaoSetorID"></param>
        /// <param name="precos"></param>
        /// <param name="preReserva"></param>
        /// <returns></returns>
        public List <Ingresso> MelhoresIngressos(int usuarioID, int lojaID, string sessionID, int clienteID, int eventoID,
                                                 int apresentacaoID, int apresentacaoSetorID, int setorID, List <EstruturaPrecoReservaSite> precos,
                                                 Setor.enumLugarMarcado tipoSetor, EstruturaCotasInfo cotaInfo, int serieID, EstruturaReservaInternet estruturaReserva)
        {
            BD                 bd          = new BD(ConfigurationManager.AppSettings["ConexaoReadOnly"]);
            BD                 bdReserva   = new BD();
            Ingresso           oIngresso   = new Ingresso();
            BilheteriaParalela oBilheteria = new BilheteriaParalela();
            Cota               oCota       = new Cota();
            CotaItem           oCotaItem   = new CotaItem();
            Lugar              oLugar      = new Lugar(); //usado para a busca de melhores lugares.
            List <Ingresso>    ingressosRetorno;
            decimal            precoValor;
            int                p;
            decimal            valorConv          = 0;
            decimal            valorProcessamento = 0;
            //decimal valor;
            Cortesia oCortesia        = new Cortesia();
            int      CortesiaPadraoID = 0;

            DateTime timeStamp = DateTime.Now.AddMinutes(new ConfigGerenciadorParalela().getValorTempoReserva());

            try
            {
                int qtdPrecos = 0;
                //Essa variavel duplica o preço e o valor pela quantidade de para reservar.
                //Dessa forma é possível reservar os lugares com os preços corretos. kim
                List <EstruturaPrecoReservaSite> precoPorLugar = new List <EstruturaPrecoReservaSite>();
                List <EstruturaPrecoReservaSite> listaPreco    = new List <EstruturaPrecoReservaSite>();
                EstruturaPrecoReservaSite        itemPreco;

                List <EstruturaCotaItemReserva> listaCotaItem = new List <EstruturaCotaItemReserva>();
                if (cotaInfo.CotaID_Apresentacao != 0 || cotaInfo.CotaID_ApresentacaoSetor != 0)
                {
                    listaCotaItem = oCotaItem.getListaCotaItemReserva(cotaInfo.CotaID_Apresentacao, cotaInfo.CotaID_ApresentacaoSetor);
                }

                cotaInfo.ApresentacaoID      = apresentacaoID;
                cotaInfo.ApresentacaoSetorID = apresentacaoSetorID;
                List <int> retornoCotaItens = new List <int>(2);

                foreach (EstruturaPrecoReservaSite preco in precos)
                {
                    //Verifica se é possivel reservar o ingresso apartir das cotas geradas p/ a apresentacao/setor

                    //Dispara Exception e nao deixa reservar
                    if (listaCotaItem.Count != 0)
                    {
                        retornoCotaItens = oCotaItem.getQuantidadeQPodeReservarCota(listaCotaItem, preco, cotaInfo);
                        //cotaItemID = oCotaItem.getQuantidadeQPodeReservarCota(-2, -1, listaCotaItem, preco, cotaInfo);

                        if (retornoCotaItens.Count > 0 && (retornoCotaItens[0].Equals(-1) || retornoCotaItens[1].Equals(-1)))
                        {
                            throw new BilheteriaException("Infelizmente não será possível comprar o preço \"" + preco.PrecoNome + "\", pois o limite de venda foi excedido. <br /> Escolha um novo preço.", BilheteriaParalela.CodMensagemReserva.PrecoIndisponivel);
                        }
                    }

                    precoValor = 0;
                    // Verifica se existe quantidade do PrecoID disponivel para venda e retorna via referencia o valor do preço
                    if (preco.Quantidade != oBilheteria.GetIngressosQPodeReservar(clienteID, sessionID, preco.ID, preco.Quantidade, ref precoValor, false, serieID, estruturaReserva))
                    {
                        throw new BilheteriaException("A Quantidade disponível para o preço \"" + preco.PrecoNome.ToString() + "\" foi excedida.", BilheteriaParalela.CodMensagemReserva.PrecoIndisponivel);
                    }
                    //incrementa a quantidade
                    qtdPrecos += preco.Quantidade;
                    //só utiliza os preços duplicados caso seja lugar marcado
                    while (retornoCotaItens.Count < 2)
                    {
                        retornoCotaItens.Add(0);
                    }

                    if (tipoSetor != IRLib.Paralela.Setor.enumLugarMarcado.Pista)
                    {
                        //duplica os registros para serem usados mais tarde na hora da reserva de lugares marcados
                        for (int x = 0; x < preco.Quantidade; x++)
                        {
                            itemPreco    = new EstruturaPrecoReservaSite();
                            itemPreco.ID = preco.ID;
                            itemPreco.GerenciamentoIngressosID = preco.GerenciamentoIngressosID;
                            itemPreco.Valor             = precoValor;
                            itemPreco.Quantidade        = preco.Quantidade;
                            itemPreco.CotaItemID        = retornoCotaItens[0];
                            itemPreco.CotaItemIDAPS     = retornoCotaItens[1];
                            itemPreco.CodigoCinema      = preco.CodigoCinema;
                            itemPreco.CodigoProgramacao = preco.CodigoProgramacao;
                            precoPorLugar.Add(itemPreco);
                        }
                    }
                    else
                    {
                        //gera novos registros para adicionar a cotaItemID do contrario não ha como verificar a multipla selecao de precos
                        itemPreco    = new EstruturaPrecoReservaSite();
                        itemPreco.ID = preco.ID;
                        itemPreco.GerenciamentoIngressosID = preco.GerenciamentoIngressosID;
                        itemPreco.PrecoNome         = preco.PrecoNome;
                        itemPreco.Quantidade        = preco.Quantidade;
                        itemPreco.Valor             = preco.Valor;
                        itemPreco.CotaItemID        = retornoCotaItens[0];
                        itemPreco.CotaItemIDAPS     = retornoCotaItens[1];
                        itemPreco.CodigoCinema      = preco.CodigoCinema;
                        itemPreco.CodigoProgramacao = preco.CodigoProgramacao;
                        listaPreco.Add(itemPreco);
                    }
                }
                //Lugares marcados. Precisa achar os melhores lugares.
                if (tipoSetor != IRLib.Paralela.Setor.enumLugarMarcado.Pista)
                {
                    #region Busca Ingresso de Lugar Marcado
                    // Busca a lista dos Melhores Lugares
                    List <Lugar> lugares = oLugar.MelhorLugarMarcado(qtdPrecos, apresentacaoSetorID, tipoSetor);

                    //Verifica se os ingressos estão juntos
                    if (tipoSetor == IRLib.Paralela.Setor.enumLugarMarcado.MesaFechada)
                    {
                        if (lugares.Count == 0)
                        {
                            throw new Exception("Não foi possível efetuar todas as reserva.");
                        }

                        if (lugares.Count != qtdPrecos)
                        {
                            throw new Exception("Não existem mesas com a capacidade de acomodar todas as pessoas juntas");
                        }
                    }
                    int  quantidadeMesaAberta = 0;
                    bool mesaAberta           = (tipoSetor == IRLib.Paralela.Setor.enumLugarMarcado.MesaAberta);
                    // Se for mesa aberta o total da de ingressos é a soma de todas as quantidades na listagem.
                    if (mesaAberta)
                    {
                        foreach (Lugar itemLugar in lugares)
                        {
                            quantidadeMesaAberta += itemLugar.Quantidade.Valor;
                        }
                        if (quantidadeMesaAberta != qtdPrecos) // Não encontrou a qtd suficiente?!
                        {
                            lugares.Clear();                   // Limpa os ingressos e passa para a próxima.
                        }
                    }
                    else
                    {
                        if (lugares.Count != qtdPrecos) // Não encontrou a qtd suficiente?!
                        {
                            lugares.Clear();            // Limpa os ingressos e passa para a próxima.
                        }
                    }

                    ingressosRetorno = new List <Ingresso>();
                    p = 0;                   //variavel de controle para os preços
                    int controlePrecoID = 0; //variavel de controle para saber se mudou o precoID e trazer a nova taxa de entrega
                    //Busca os ingressos para os melhores lugares encontrados
                    foreach (Lugar l in lugares)
                    {
                        try
                        {
                            //Só faz a select com base na quantidade caso seja mesa aberta.
                            string top = mesaAberta ? "TOP " + l.Quantidade.Valor : "";

                            string sql = "SELECT " + top + " ID, Codigo,EmpresaID FROM tIngresso(NOLOCK) " +
                                         "WHERE ApresentacaoSetorID = " + apresentacaoSetorID + " AND Status = '" + Ingresso.DISPONIVEL + "' " +
                                         "AND LugarID = " + l.Control.ID;

                            bd.Consulta(sql);


                            while (bd.Consulta().Read())
                            {
                                if (precoPorLugar[p].ID != controlePrecoID)
                                {
                                    valorConv = oBilheteria.TaxaConveniencia(eventoID, precoPorLugar[p].ID, estruturaReserva.CanalID);

                                    //Se não tem conveniencia, não deve contar que possui taxa de processamento, ignora a busca
                                    if (valorConv > 0)
                                    {
                                        valorProcessamento = oBilheteria.ValorTaxaProcessamento(eventoID);
                                    }

                                    controlePrecoID = precoPorLugar[p].ID;
                                }

                                //popula o objeto ingresso
                                oIngresso                        = new Ingresso();
                                oIngresso.Control.ID             = bd.LerInt("ID");
                                oIngresso.PrecoID.Valor          = precoPorLugar[p].ID;
                                oIngresso.UsuarioID.Valor        = usuarioID;
                                oIngresso.Codigo.Valor           = bd.LerString("Codigo");
                                oIngresso.LojaID.Valor           = lojaID;
                                oIngresso.ClienteID.Valor        = clienteID;
                                oIngresso.SessionID.Valor        = sessionID;
                                oIngresso.TimeStampReserva.Valor = timeStamp;
                                oIngresso.LugarID.Valor          = l.Control.ID;
                                oIngresso.TxConv                 = valorProcessamento > 0 ? 0 : valorConv;
                                oIngresso.TaxaProcessamentoValor = valorProcessamento;
                                oIngresso.Grupo.Valor            = l.Grupo.Valor;
                                oIngresso.Classificacao.Valor    = l.Classificacao.Valor;
                                oIngresso.CotaItemID             = precoPorLugar[p].CotaItemID;
                                oIngresso.CotaItemIDAPS          = precoPorLugar[p].CotaItemIDAPS;
                                oIngresso.EmpresaID.Valor        = bd.LerInt("EmpresaID");
                                oIngresso.SerieID.Valor          = serieID;

                                ////se não tiver valor e não tiver conveniencia não deve reservar
                                if (precoPorLugar[p].Valor == 0 && oIngresso.TxConv == 0 && oIngresso.TaxaProcessamentoValor == 0)
                                {
                                    // Atribui a Cortesia Padrão do Evento/Local - INICIO
                                    if (CortesiaPadraoID == 0)
                                    {
                                        CortesiaPadraoID = oCortesia.CortesiaPadraoEvento(eventoID);
                                    }

                                    if (CortesiaPadraoID <= 0)
                                    {
                                        throw new Exception("Falha ao reservar os ingressos. Não existe cortesia associada a este evento.");
                                    }

                                    oIngresso.CortesiaID.Valor = CortesiaPadraoID;
                                    //    // Atribui a Cortesia Padrão do Evento/Local - FIM

                                    //    oIngresso.Status.Valor = Ingresso.CORTESIA_SEM_CONVENIENCIA;
                                    ingressosRetorno.Add(oIngresso);
                                    //    break;//break para inserir somente um registro. esse registro de ingresso vai ser utilizado
                                    //    //como base de info para deletar o preço inválido do banco de dados do site.
                                }
                                else
                                {
                                    ingressosRetorno.Add(oIngresso);
                                }

                                if (tipoSetor != IRLib.Paralela.Setor.enumLugarMarcado.MesaFechada)
                                {
                                    p++;
                                }
                            }
                            if (tipoSetor == IRLib.Paralela.Setor.enumLugarMarcado.MesaFechada)
                            {
                                p++;
                            }
                        }
                        catch
                        {
                            throw;
                        }
                    }

                    #endregion
                }

                else //Ingressos de pista
                {
                    #region Busca Ingressos de Pista
                    Ingresso ing;
                    ingressosRetorno = new List <Ingresso>();
                    ArrayList ingressosIDInseridos = new ArrayList(); //lista de ingressos ID para não buscar os mesmos ingressos.
                    string    evitaDuplicidades    = "";              //monta a string para a sql
                    foreach (EstruturaPrecoReservaSite preco in listaPreco)
                    {
                        if (ingressosRetorno.Count > 0)
                        {
                            //Monta a query que evita duplicidade de ingressos na hora de reservar.
                            foreach (Ingresso item in ingressosRetorno)
                            {
                                ingressosIDInseridos.Add(item.Control.ID);
                            }

                            evitaDuplicidades = "AND ID NOT IN ( " + Utilitario.ArrayToString(ingressosIDInseridos) + ") ";
                        }
                        //Busca os ingressos de pista.
                        bd.FecharConsulta();

                        var bdBusca = new BD(ConfigurationManager.AppSettings["ConexaoReadOnly"]);

                        bdBusca.Consulta(string.Format("SELECT TOP {0} ID, Codigo, LugarID FROM tIngresso(NOLOCK) WHERE ApresentacaoSetorID = {1} AND Status = '{2}' {3} ORDER BY newid()", preco.Quantidade, apresentacaoSetorID, Ingresso.DISPONIVEL, evitaDuplicidades));

                        while (bdBusca.Consulta().Read())
                        {
                            valorConv = oBilheteria.TaxaConveniencia(eventoID, preco.ID, estruturaReserva.CanalID);
                            //Se não tem conveniencia, não deve contar que possui taxa de processamento, ignora a busca
                            if (valorConv > 0)
                            {
                                valorProcessamento = oBilheteria.ValorTaxaProcessamento(eventoID);
                            }
                            else
                            {
                                valorProcessamento = 0;
                            }

                            //Popula o objeto ingresso e adiciona a lista de retorno
                            ing               = new Ingresso();
                            ing.Control.ID    = bdBusca.LerInt("ID");
                            ing.PrecoID.Valor = preco.ID;
                            ing.GerenciamentoIngressosID.Valor = preco.GerenciamentoIngressosID;
                            ing.UsuarioID.Valor        = estruturaReserva.UsuarioID;
                            ing.Codigo.Valor           = bdBusca.LerString("Codigo");
                            ing.LojaID.Valor           = estruturaReserva.LojaID;
                            ing.ClienteID.Valor        = clienteID;
                            ing.SessionID.Valor        = sessionID;
                            ing.TimeStampReserva.Valor = timeStamp;
                            ing.LugarID.Valor          = bdBusca.LerInt("LugarID");
                            ing.TxConv = valorProcessamento > 0 ? 0 : valorConv;
                            ing.TaxaProcessamentoValor = valorProcessamento;
                            ing.CotaItemID             = preco.CotaItemID;
                            ing.CotaItemIDAPS          = preco.CotaItemIDAPS;
                            ing.SerieID.Valor          = serieID;
                            ing.CompraGUID.Valor       = estruturaReserva.GUID;
                            //se não tiver valor e não tiver conveniencia não deve reservar
                            if (preco.Valor == 0 && ing.TxConv == 0 && ing.TaxaProcessamentoValor == 0)
                            {
                                // Atribui a Cortesia Padrão do Evento/Local - INICIO
                                if (CortesiaPadraoID == 0)
                                {
                                    CortesiaPadraoID = oCortesia.CortesiaPadraoEvento(eventoID);
                                }

                                if (CortesiaPadraoID <= 0)
                                {
                                    throw new Exception("Não foi possível reservar o ingresso. Por favor, tente novamente mais tarde.");
                                }

                                ing.CortesiaID.Valor = CortesiaPadraoID;
                                // Atribui a Cortesia Padrão do Evento/Local - FIM

                                //ing.Status.Valor = Ingresso.CORTESIA_SEM_CONVENIENCIA;
                                ingressosRetorno.Add(ing);
                                //break;//break para inserir somente um registro. esse registro de ingresso vai ser utilizado
                                ////como base de info para deletar o preço inválido do banco de dados do site.
                            }
                            else
                            {
                                ingressosRetorno.Add(ing);
                            }
                        }//fim while consulta banco

                        bdBusca.Fechar();
                    }//fim foreach precos

                    //Ingressos para cinema, deve utilizar on demand!
                    if (listaPreco.Any(c => !string.IsNullOrEmpty(c.CodigoCinema)))
                    {
                        ingressosRetorno = this.NovoNaoMarcadoOnDemand(estruturaReserva, apresentacaoSetorID, eventoID, apresentacaoID, setorID, ingressosRetorno, listaPreco);
                    }


                    #endregion
                }

                return(ingressosRetorno);
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                bdReserva.Fechar();
                bd.Fechar();
            }
        }
        public DataTable PesquisarSenha(string senha)
        {
            DataTable tabela               = EstruturaHistorico();
            BD        bd                   = new BD();
            string    strStatus            = "";
            bool      pagamentoProcessado  = false;
            int       intVendaBilheteriaID = 0;

            try
            {
                using (IDataReader oDataReader = bd.Consulta("" +
                                                             "SELECT " +
                                                             "   tVendaBilheteria.ID, " +
                                                             "   tVendaBilheteria.Status, " +
                                                             "   tVendaBilheteria.PagamentoProcessado " +
                                                             "FROM " +
                                                             "  tVendaBilheteria (NOLOCK) " +
                                                             "WHERE " +
                                                             "  (Senha = '" + senha + "')"

                                                             ))
                {
                    if (!oDataReader.Read())
                    {
                        throw new ApplicationException("Venda não encontrada!");
                    }

                    if (bd.LerInt("ID") < 1)
                    {
                        throw new ApplicationException("Venda não encontrada!");
                    }

                    intVendaBilheteriaID = bd.LerInt("ID");

                    strStatus           = bd.LerString("Status");
                    pagamentoProcessado = bd.LerBoolean("PagamentoProcessado");
                }

                bd.Fechar();

                StringBuilder strSql = new StringBuilder();

                strSql.Append(" SELECT ");
                strSql.Append("( ");
                strSql.Append(" SELECT  ");
                strSql.Append(" COUNT(tIngressoLog.ID) ");
                strSql.Append(" FROM ");
                strSql.Append(" tIngressoLog (NOLOCK) ");
                strSql.Append(" WHERE ");
                strSql.Append(" (tIngressoLog.VendaBilheteriaID = " + intVendaBilheteriaID + ") ");
                strSql.Append(" ) AS TotIngressos, ");
                strSql.Append(" i.ID AS IngressoID, ");
                strSql.Append(" il.VendaBilheteriaID, ");
                strSql.Append(" i.Codigo, ");
                strSql.Append(" il.IngressoID, ");
                strSql.Append(" ev.ID EventoID, ");
                strSql.Append(" ev.Nome Evento, ");
                strSql.Append(" il.ID, ");
                strSql.Append(" il.[TimeStamp], ");
                strSql.Append(" il.Acao, ");
                strSql.Append(" il.Obs, ");
                strSql.Append(" p.Nome AS Preco, ");
                strSql.Append(" p.Valor, ");
                strSql.Append(" b.Nome AS Bloqueio, ");
                strSql.Append(" c.Nome AS Cortesia, ");
                strSql.Append(" lo.Nome AS Loja, ");
                strSql.Append(" i.Status, ");
                strSql.Append(" p.ID AS PrecoID, ");
                strSql.Append(" u.Nome AS Usuario, ");
                strSql.Append(" ci.Nome AS Cliente, ");
                strSql.Append(" vb.NotaFiscalEstabelecimento, ");
                strSql.Append(" vb.Senha, ");
                strSql.Append(" l.Nome AS Local, ");
                strSql.Append(" a.Horario AS Apresentacao, ");
                strSql.Append(" a.ID AS ApresentacaoID, ");
                strSql.Append(" s.Nome AS Setor, ");
                strSql.Append(" il.CodigoBarra, ");
                strSql.Append(" en.Tipo AS TaxaEntregaTipo, ");
                strSql.Append(" IsNull(us.Nome, ' - ') as  Supervisor, ");
                strSql.Append(" ep.Nome AS PeriodoAgenda ,");
                strSql.Append(" en.Nome AS EntregaNome ,");
                strSql.Append(" ea.Data AS DataAgenda ,");
                strSql.Append(" ear.Nome AS AreaEntrega ,");
                strSql.Append(" ISNULL(vb.ClienteEnderecoID,0) AS EnderecoEntrega , ");
                strSql.Append(" pdv.Nome as PDVEntrega, ");
                strSql.Append(" ev.TipoCodigoBarra, i.ApresentacaoSetorID ");
                strSql.Append(" ,ci.Email ");
                strSql.Append(" ,cl.Nome AS Canal ");
                strSql.Append(" ,en.ID AS EntregaID ");
                strSql.Append(" FROM tIngressoLog il (NOLOCK) ");
                strSql.Append(" LEFT JOIN tVendaBilheteria vb (NOLOCK) ON vb.ID = il.VendaBilheteriaID  ");
                strSql.Append(" INNER JOIN tUsuario u (NOLOCK) ON u.ID = il.UsuarioID ");
                strSql.Append(" LEFT JOIN tUsuario us (NOLOCK) ON us.ID = il.SupervisorID ");
                strSql.Append(" LEFT OUTER JOIN tPreco p (NOLOCK) ON p.ID = il.PrecoID ");
                strSql.Append(" INNER JOIN tIngresso i (NOLOCK) ON i.ID = IngressoID ");
                strSql.Append(" INNER JOIN tEvento ev (NOLOCK) ON ev.ID = i.EventoID ");
                strSql.Append(" INNER JOIN tLocal l (NOLOCK) ON l.ID = i.LocalID ");
                strSql.Append(" INNER JOIN tSetor s (NOLOCK) ON s.ID = i.SetorID ");
                strSql.Append(" INNER JOIN tApresentacao a (NOLOCK) ON a.ID = i.ApresentacaoID ");
                strSql.Append(" LEFT JOIN tLoja lo (NOLOCK) ON lo.ID = il.LojaID ");
                strSql.Append(" LEFT JOIN tCanal cl (NOLOCK) ON cl.ID = il.CanalID  ");
                strSql.Append(" LEFT JOIN tCliente ci (NOLOCK) ON ci.ID = vb.ClienteID ");
                strSql.Append(" LEFT JOIN tCortesia c (NOLOCK) ON c.ID = il.CortesiaID ");
                strSql.Append(" LEFT JOIN tBloqueio b (NOLOCK) ON b.ID = il.BloqueioID ");
                strSql.Append(" LEFT JOIN tEntregaControle ec (NOLOCK) ON vb.EntregaControleID = ec.ID ");
                strSql.Append(" LEFT JOIN tEntrega en (NOLOCK) ON ec.EntregaID = en.ID ");
                strSql.Append(" LEFT JOIN tEntregaPeriodo ep (NOLOCK) ON ec.PeriodoID = ep.ID ");
                strSql.Append(" LEFT JOIN tEntregaArea ear (NOLOCK) ON ec.EntregaAreaID = ear.ID ");
                strSql.Append(" LEFT JOIN tEntregaAgenda ea (NOLOCK) ON vb.EntregaAgendaID = ea.ID ");
                strSql.Append(" LEFT JOIN tPontoVenda pdv (NOLOCK) ON vb.PdvID = pdv.ID ");
                strSql.Append(" WHERE ");
                strSql.Append(" ( ");
                strSql.Append(" il.IngressoID IN ( ");
                strSql.Append(" SELECT ");
                strSql.Append(" IngressoID ");
                strSql.Append(" FROM  ");
                strSql.Append(" tIngressoLog (NOLOCK) ");
                strSql.Append(" WHERE ");
                strSql.Append(" (VendaBilheteriaID = " + intVendaBilheteriaID + ") ");
                strSql.Append(" ) ");
                strSql.Append(" ) ");
                strSql.Append(" ORDER BY ");
                strSql.Append(" il.IngressoID, ");
                strSql.Append(" il.ID ");

                using (IDataReader oDataReader = bd.Consulta(strSql.ToString()))
                {
                    int     ingressoID      = 0;
                    bool    blnInserirDados = false;
                    string  strSenhaVenda   = "";
                    DataRow linha           = null;

                    while (oDataReader.Read())
                    {
                        if (ingressoID != bd.LerInt("IngressoID"))
                        {
                            ingressoID      = bd.LerInt("IngressoID");
                            blnInserirDados = false;
                            strSenhaVenda   = "";
                        }

                        if (bd.LerString("Acao") == IngressoLog.VENDER)
                        {
                            strSenhaVenda = bd.LerString("Senha");
                        }

                        // Se a operação for venda, Liga o Flag de Inserir Dados
                        if (((bd.LerString("Acao") == IngressoLog.VENDER || bd.LerString("Acao") == IngressoLog.PRE_RESERVA) && strStatus != VendaBilheteria.CANCELADO && bd.LerInt("VendaBilheteriaID") == intVendaBilheteriaID) || (bd.LerString("Acao") == IngressoLog.CANCELAR && strStatus == VendaBilheteria.CANCELADO && bd.LerInt("VendaBilheteriaID") == intVendaBilheteriaID))
                        {
                            blnInserirDados = true;
                        }

                        // Insere as Informações dos Ingressos
                        if (blnInserirDados)
                        {
                            if (strSenhaVenda == "")
                            {
                                if (strStatus == VendaBilheteria.PRE_RESERVADO)
                                {
                                    strSenhaVenda = "-";
                                }
                                else
                                {
                                    strSenhaVenda = bd.LerString("Senha");
                                }
                            }

                            linha = tabela.NewRow();
                            linha["IngressoID"]          = bd.LerInt("IngressoID");
                            linha["IngressoLogID"]       = bd.LerInt("ID");
                            linha["Codigo"]              = bd.LerString("Codigo");
                            linha["Data"]                = bd.LerStringFormatoDataHora("TimeStamp");
                            linha["Cliente"]             = bd.LerString("Cliente");
                            linha["Evento"]              = bd.LerString("Evento");
                            linha["EventoID"]            = bd.LerString("EventoID");
                            linha["ApresentacaoID"]      = bd.LerString("ApresentacaoID");
                            linha["ApresentacaoSetorID"] = bd.LerInt("ApresentacaoSetorID");
                            linha["TipoCodigoBarra"]     = bd.LerString("TipoCodigoBarra");
                            // Se for uma senha de cancelamento alimentar a Senha de Venda e Senha de Cancelamento
                            if (strStatus == VendaBilheteria.CANCELADO)
                            {
                                linha["Senha"]             = strSenhaVenda;
                                linha["SenhaCancelamento"] = bd.LerString("Senha");
                            }
                            else
                            {
                                // Se for uma senha de venda, armazenar senha de venda, e somente a senha de cancalemento se for uma ação cancelar
                                linha["Senha"] = strSenhaVenda;

                                if (bd.LerString("Acao") == IngressoLog.CANCELAR)
                                {
                                    linha["SenhaCancelamento"] = bd.LerString("Senha");
                                }
                                else
                                {
                                    linha["SenhaCancelamento"] = " - ";
                                }
                            }

                            linha["Ação"]                = IngressoLog.AcaoDescritiva(bd.LerString("Acao"));
                            linha["Status"]              = Ingresso.StatusDescritivo(bd.LerString("Status"));
                            linha["StatusDetalhado"]     = Ingresso.StatusDetalhado(bd.LerString("Status"), bd.LerString("TaxaEntregaTipo"));
                            linha["PrecoID"]             = bd.LerInt("PrecoID");
                            linha["Preço"]               = bd.LerString("Preco");
                            linha["Loja"]                = bd.LerString("Loja");
                            linha["PagamentoProcessado"] = pagamentoProcessado;
                            linha["VendaBilheteriaID"]   = bd.LerString("VendaBilheteriaID");
                            linha["EntregaID"]           = bd.LerInt("EntregaID");
                            linha["Entrega"]             = bd.LerString("EntregaNome");
                            linha["Periodo"]             = bd.LerString("PeriodoAgenda");
                            linha["DataAgenda"]          = bd.LerDateTime("DataAgenda");
                            linha["AreaEntrega"]         = bd.LerString("AreaEntrega");
                            linha["EnderecoEntrega"]     = bd.LerInt("EnderecoEntrega");
                            linha["PDVEntrega"]          = bd.LerString("PDVEntrega");

                            if (bd.LerString("Acao") == IngressoLog.VENDER || bd.LerString("Acao") == IngressoLog.CANCELAR)
                            {
                                linha["Valor"] = bd.LerDecimal("Valor");
                            }

                            if (bd.LerString("Cortesia") != "")
                            {
                                linha["Cortesia"] = bd.LerString("Cortesia");
                            }
                            if (bd.LerString("Bloqueio") != "")
                            {
                                linha["Bloqueio"] = bd.LerString("Bloqueio");
                            }
                            linha["Usuario"] = bd.LerString("Usuario");
                            linha["Obs"]     = bd.LerString("Obs");

                            linha["Local"]        = bd.LerString("Local");
                            linha["Apresentacao"] = bd.LerStringFormatoDataHora("Apresentacao");
                            linha["Setor"]        = bd.LerString("Setor");
                            linha["CodigoBarra"]  = bd.LerString("CodigoBarra");
                            linha["Supervisor"]   = bd.LerString("Supervisor");
                            linha["Email"]        = bd.LerString("Email");
                            linha["Canal"]        = bd.LerString("Canal");

                            tabela.Rows.Add(linha);
                        }

                        // Caso a operação inserida for Cancelar, Desligar a Flag de Inserir Dados
                        if (bd.LerString("Acao") == IngressoLog.CANCELAR)
                        {
                            blnInserirDados = false;
                        }
                    }
                }
            }
            catch (SqlException ex)
            {
                throw new ApplicationException("Problemas ao acessar o banco de dados: " + ex.Message);
            }
            catch
            {
                throw;
            }
            finally
            {
                bd.Fechar();
            }

            return(tabela);
        }
        public DataTable PesquisarCodigoIngresso(int apresentacaoSetorID, string codigo)
        {
            BD        bd     = null;
            DataTable tabela = EstruturaHistorico();
            int       ingressoID;

            try
            {
                bd         = new BD();
                ingressoID = 0;

                using (IDataReader oDataReader = bd.Consulta("" +
                                                             "SELECT " +
                                                             "   tIngresso.ID " +
                                                             "FROM " +
                                                             "   tIngresso (NOLOCK) " +
                                                             "WHERE " +
                                                             "   (tIngresso.ApresentacaoSetorID = " + apresentacaoSetorID + ") " +
                                                             "AND " +
                                                             "   (tIngresso.Codigo = '" + codigo + "') " +
                                                             "ORDER BY " +
                                                             "   tIngresso.ID"))
                {
                    if (!oDataReader.Read())
                    {
                        throw new ApplicationException("Código do Ingresso não encontrado!");
                    }

                    ingressoID = bd.LerInt("ID");

                    if (ingressoID < 1)
                    {
                        throw new ApplicationException("Código do Ingresso não encontrado!");
                    }

                    int contadorIngressos = 1;

                    while (oDataReader.Read())
                    {
                        contadorIngressos++;
                    }

                    if (contadorIngressos > 1)
                    {
                        throw new IngressoHistoricoGerenciadorException("Apresentação possui mais de 1 lugar com código " + codigo);
                    }

                    Ingresso ingresso = new Ingresso();
                    ingresso.Control.ID = ingressoID;

                    tabela = ingresso.Historico();
                }

                return(AssinaturaBancoIngresso.VerificarSeExisteBancoIngresso(ingressoID, tabela));
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                if (bd != null)
                {
                    bd.Fechar();
                }
            }
        }