Beispiel #1
0
 public decimal ValorTotalVIRsFixo(List <int> valeIngressoIds)
 {
     try
     {
         string Ids = string.Empty;
         if (valeIngressoIds.Count > 0)
         {
             Ids = Utilitario.ArrayToString(valeIngressoIds.ToArray());
             StringBuilder stbSQL = new StringBuilder();
             stbSQL.Append("SELECT SUM(vip.Valor) FROM tValeIngresso (NOLOCK) ");
             stbSQL.Append("INNER JOIN tValeIngressoTipo vip (NOLOCK) ON ");
             stbSQL.Append("tValeIngresso.ValeIngressoTipoID = vip.ID ");
             stbSQL.Append("WHERE tValeIngresso.ID IN (" + Ids + ") ");
             return(Convert.ToDecimal(bd.ConsultaValor(stbSQL.ToString())));
         }
         else
         {
             return(0);
         }
     }
     catch (Exception ex)
     {
         throw ex;
     }
     finally
     {
         bd.Fechar();
     }
 }
Beispiel #2
0
        public int[] RemoverMulti(int eventoID, int apresentacaoID, int setorID, int precoID, int todosID, string precoNome)
        {
            try
            {
                DataTable tabelaPrecosAlteraveis = precosAlteraveis(eventoID, apresentacaoID, setorID, precoID, todosID, precoNome);

                Array precosIDs = Array.CreateInstance(typeof(DataRow), tabelaPrecosAlteraveis.Rows.Count);

                tabelaPrecosAlteraveis.Rows.CopyTo(precosIDs, 0);

                string precos = Utilitario.ArrayToString(precosIDs);

                bd.IniciarTransacao();

                //deletar todos os canais do preço
                string sql = "DELETE FROM tCanalPreco WHERE PrecoID in (" + precos + ") AND CanalID=" + this.CanalID.Valor;
                int    x   = bd.Executar(sql);

                bd.FinalizarTransacao();
                int[] retorno = new int[2];
                retorno[0] = tabelaPrecosAlteraveis.Rows.Count;
                retorno[1] = x;
                return(retorno);
            }
            catch (Exception ex)
            {
                bd.DesfazerTransacao();
                throw ex;
                //} finally {
                //    bd.Fechar();
                //    bd.Cnn.Dispose();
            }
        }
Beispiel #3
0
        public DataTable QuantidadePorBloqueioID(int[] ids, int apresentacaoSetorID)
        {
            BD bd = new BD();

            bd.Consulta(@"SELECT BloqueioID, COUNT(ID) Qtd
                        FROM tIngresso (NOLOCK) 
                        WHERE BloqueioID IN(" + Utilitario.ArrayToString(ids) + @") AND ApresentacaoSetorID = " + apresentacaoSetorID +
                        @"AND Status = 'B'
                        GROUP BY BloqueioID");
            DataTable retorno = new DataTable("Bloqueios");

            retorno.Columns.Add("BloqueioID", typeof(int));
            retorno.Columns.Add("Qtd", typeof(int));

            DataRow novalinha;

            while (bd.Consulta().Read())
            {
                novalinha = retorno.NewRow();
                novalinha["BloqueioID"] = bd.LerInt("BloqueioID");
                novalinha["Qtd"]        = bd.LerInt("Qtd");
                retorno.Rows.Add(novalinha);
            }

            return(retorno);
        }
Beispiel #4
0
        /// <summary>
        /// Obtem todas as cortesias
        /// </summary>
        /// <returns></returns>
        public DataTable Todas(ArrayList locaisIDs)
        {
            try
            {
                DataTable tabela = new DataTable("Cortesia");

                tabela.Columns.Add("ID", typeof(int));
                tabela.Columns.Add("Nome", typeof(string));
                tabela.Columns.Add("LocalID", typeof(int));

                string sql = "SELECT ID,Nome,LocalID " +
                             "FROM tCortesia " +
                             "WHERE LocalID in (" + Utilitario.ArrayToString(locaisIDs) + ") " +
                             "ORDER BY LocalID,Nome";

                bd.Consulta(sql);

                while (bd.Consulta().Read())
                {
                    DataRow linha = tabela.NewRow();
                    linha["ID"]      = bd.LerInt("ID");
                    linha["Nome"]    = bd.LerString("Nome");
                    linha["LocalID"] = bd.LerInt("LocalID");
                    tabela.Rows.Add(linha);
                }

                bd.Fechar();

                return(tabela);
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
Beispiel #5
0
        public bool CancelarReservas(int[] valeIngressoIDs)
        {
            try
            {
                string        IDs    = Utilitario.ArrayToString(valeIngressoIDs);
                StringBuilder stbSQL = new StringBuilder();
                stbSQL.Append("UPDATE tValeIngresso SET ");
                stbSQL.Append("ClienteID = 0, SessionID = 0, UsuarioID=0, LojaID=0, CanalID=0, ");
                stbSQL.Append("Status = '" + (char)ValeIngresso.enumStatus.Disponivel + "' ");
                stbSQL.Append("WHERE ID IN (" + IDs + ") AND ");
                stbSQL.Append("Status = '" + (char)ValeIngresso.enumStatus.Reservado + "'");

                bool ok = Convert.ToBoolean(bd.Executar(stbSQL.ToString()));

                return(ok);
            }
            catch (Exception)
            {
                throw;
            }
            finally
            {
                bd.Fechar();
            }
        }
Beispiel #6
0
        public DataTable EstadosComPDV(List <int> listaEventoID)
        {
            if (listaEventoID.Count == 0)
            {
                return(this.EstadosComPDV());
            }

            try
            {
                DataTable tabela = new DataTable("Estado");
                tabela.Columns.Add("ID", typeof(int));
                tabela.Columns.Add("Sigla", typeof(string));


                string sql =
                    string.Format(@"
                        SELECT 
		                    DISTINCT e.ID, e.Sigla, 
							                    (COUNT(DISTINCT epv.EventoID) + 
							                    CASE WHEN ev.HabilitarRetiradaTodosPDV = 'T'
								                    THEN 1
								                    ELSE 0
							                    END) AS Disponivel
			                    INTO #tmp
			                    FROM tPontoVenda pv (NOLOCK)
			                    INNER JOIN tEstado e (NOLOCK) ON e.Sigla = pv.Estado
	                            LEFT JOIN tEventoPontoDeVenda epv (NOLOCK) ON pv.ID = epv.PontoDeVendaID AND epv.EventoID IN ({0})
	                            LEFT JOIN tEvento ev (NOLOCK) ON ev.ID IN ({0})
	                            WHERE pv.PermiteRetirada = 'T' AND (epv.ID IS NOT NULL OR ev.HabilitarRetiradaTodosPDV = 'T')
	                            GROUP BY e.ID, e.Sigla, ev.HabilitarRetiradaTodosPDV--, ev.ID
                                
	                     SELECT 
		                    ID, Sigla
	                    FROM #tmp
	                    GROUP BY ID, Sigla
	                    HAVING SUM(Disponivel) = {1}
                        ORDER BY Sigla
                               
	                    DROP TABLE #tmp
                        ", Utilitario.ArrayToString(listaEventoID.ToArray()), listaEventoID.Count);

                bd.Consulta(sql);

                while (bd.Consulta().Read())
                {
                    DataRow linha = tabela.NewRow();
                    linha["ID"]    = bd.LerInt("ID");
                    linha["Sigla"] = bd.LerString("Sigla");
                    tabela.Rows.Add(linha);
                }

                return(tabela);
            }
            finally
            {
                bd.Fechar();
            }
        }
Beispiel #7
0
        public DataTable TabelaPorEstadocomSiglaComPDV(int estadoID, List <int> listaEventoID)
        {
            if (listaEventoID.Count == 0)
            {
                return(this.TabelaPorEstadocomSiglaComPDV(estadoID));
            }

            try
            {
                string sql =
                    string.Format(@"
                        SELECT 
		                    DISTINCT c.ID, c.Nome, c.EstadoSigla,
							                    (COUNT(DISTINCT epv.EventoID) + 
							                    CASE WHEN ev.HabilitarRetiradaTodosPDV = 'T'
								                    THEN 1
								                    ELSE 0
							                    END) AS Disponivel
			                    INTO #tmp
			                    FROM tPontoVenda pv (NOLOCK)
			                    INNER JOIN tCidade c (NOLOCK) ON c.Nome = pv.Cidade
	                            LEFT JOIN tEventoPontoDeVenda epv (NOLOCK) ON pv.ID = epv.PontoDeVendaID AND epv.EventoID IN ({0})
	                            LEFT JOIN tEvento ev (NOLOCK) ON ev.ID IN ({0})
	                            WHERE EstadoID = {1} AND pv.PermiteRetirada = 'T' AND (epv.ID IS NOT NULL OR ev.HabilitarRetiradaTodosPDV = 'T')
	                            GROUP BY c.ID, c.Nome, c.EstadoSigla, ev.HabilitarRetiradaTodosPDV--, ev.ID
                                
	                    SELECT 
		                    ID, Nome, EstadoSigla 
	                    FROM #tmp
	                    GROUP BY ID,Nome, EstadoSigla 
	                    HAVING SUM(Disponivel) = {2}
                        ORDER BY Nome
	                    DROP TABLE #tmp
                        ", Utilitario.ArrayToString(listaEventoID.ToArray()), estadoID, listaEventoID.Count);

                bd.Consulta(sql);
                DataTable dtt = this.EstruturaTabela();
                while (bd.Consulta().Read())
                {
                    DataRow linha = dtt.NewRow();
                    linha["ID"]          = bd.LerInt("ID");
                    linha["Nome"]        = bd.LerString("Nome");
                    linha["EstadoID"]    = estadoID;
                    linha["EstadoSigla"] = bd.LerString("EstadoSigla");;
                    dtt.Rows.Add(linha);
                }

                return(dtt);
            }
            finally
            {
                bd.Fechar();
            }
        }
Beispiel #8
0
        public List <PeridoAgenda> CarregarAgendaAindaNaoCriada(int EntregaID, string CEP, List <PeridoAgenda> naoEncontradas, List <int> eventosID, DateTime dataEventoMaisProximo)
        {
            try
            {
                List <int> DiasDaSemana = new List <int>();


                List <string> PeriodosDistintos = naoEncontradas.Select(c => c.Periodo).Distinct().ToList();

                bd.Consulta(string.Format(@"
                                SELECT DiaDaSemana, ec.ID AS EntregaControleID
                                FROM tEntrega e (NOLOCK)
                                INNER JOIN tEntregaControle ec (NOLOCK) ON ec.EntregaID = e.ID
                                INNER JOIN tEventoEntregaControle eec (NOLOCK) ON eec.EntregaControleID = ec.ID
                                INNER JOIN tDiasSemana s (NOLOCK) ON s.ControleEntregaID = ec.ID
                                INNER JOIN tEntregaAreaCep tac (NOLOCK)  ON ec.EntregaAreaID = tac.EntregaAreaID
                                WHERE e.ID = {0} AND tac.CepInicial <= '{1}' AND tac.CepFinal >= '{1}' AND eec.EventoID IN ({2})
                                GROUP BY DiaDaSemana, ec.ID
                                HAVING COUNT(DISTINCT eec.EventoID) = {3}
                                ORDER BY  EntregaControleID, DiaDaSemana 
                            ", EntregaID, CEP, Utilitario.ArrayToString(eventosID.ToArray()), eventosID.Count));

                while (bd.Consulta().Read())
                {
                    var datas = naoEncontradas
                                .Where(c => c.EntregaControleID == bd.LerInt("EntregaControleID") &&
                                       (Convert.ToInt32(c.Data.DayOfWeek) == bd.LerInt("DiaDaSemana") ||
                                        (Convert.ToInt32(c.Data.DayOfWeek) == 0 && bd.LerInt("DiaDaSemana") == 7))).ToList();

                    if (datas == null)
                    {
                        continue;
                    }

                    foreach (var data in datas.Where(c => c.Data.Date < dataEventoMaisProximo.Date))
                    {
                        data.Disponivel = true;
                    }
                }

                return(naoEncontradas);
            }
            finally
            {
                bd.Fechar();
            }
        }
Beispiel #9
0
        /// <summary>
        /// Atualiza a cor dos preços com o mesmo nome no evento e retorna os PrecoIDs
        /// </summary>
        /// <returns></returns>
        public int[] AtualizarCor(int apresentacaoSetorID, string nome, int corID)
        {
            BD bd = new BD();

            try
            {
                string sqlApresentacaoID = "SELECT ApresentacaoID FROM tApresentacaoSetor WHERE ID=" + apresentacaoSetorID;
                object ret            = bd.ConsultaValor(sqlApresentacaoID);
                int    apresentacaoID = (ret != null) ? Convert.ToInt32(ret) : 0;

                string sqlEventoID = "SELECT EventoID FROM tApresentacao WHERE ID=" + apresentacaoID;
                ret = bd.ConsultaValor(sqlEventoID);
                int eventoID = (ret != null) ? Convert.ToInt32(ret) : 0;

                string sql = "SELECT tPreco.ID AS PrecoID " +
                             "FROM tPreco (NOLOCK) " +
                             "INNER JOIN tApresentacaoSetor ON tApresentacaoSetor.ID = tPreco.ApresentacaoSetorID " +
                             "INNER JOIN tApresentacao ON tApresentacao.ID = tApresentacaoSetor.ApresentacaoID " +
                             "WHERE tApresentacao.EventoID=" + eventoID + " AND tPreco.Nome='" + nome + "'";
                bd.Consulta(sql);

                ArrayList precosIDs = new ArrayList();

                while (bd.Consulta().Read())
                {
                    precosIDs.Add(bd.LerInt("PrecoID"));
                }
                bd.Consulta().Close();

                precosIDs.TrimToSize();

                string sqlUpdate = "UPDATE tPreco SET CorID=" + corID + " " +
                                   "WHERE ID in (" + Utilitario.ArrayToString(precosIDs) + ")";
                bd.Executar(sqlUpdate);

                return((int[])precosIDs.ToArray(typeof(int)));
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                bd.Fechar();
            }
        }
Beispiel #10
0
        public DataTable getDttCotaItemPorCotaID(int[] cotaItemArray)
        {
            try
            {
                DataTable     dtt    = this.getEstruturaCotaItem();
                StringBuilder stbSQL = new StringBuilder();
                stbSQL.Append("SELECT it.ID, it.CotaID, it.PrecoIniciaCom, it.Quantidade, it.QuantidadePorCliente, it.ParceiroID, ");
                stbSQL.Append("it.ValidaBin, it.TextoValidacao, it.ObrigatoriedadeID, it.Nominal, it.QuantidadePorCodigo, it.TermoSite ");
                stbSQL.Append("FROM tCotaItem it (NOLOCK) ");
                stbSQL.Append("WHERE it.ID IN (" + Utilitario.ArrayToString(cotaItemArray));
                stbSQL.Append(") ORDER BY it.PrecoIniciaCom");
                bd.Consulta(stbSQL.ToString());

                while (bd.Consulta().Read())
                {
                    DataRow dtr = dtt.NewRow();
                    dtr["ID"]                   = bd.LerInt("ID");
                    dtr["CotaID"]               = bd.LerInt("CotaID");
                    dtr["PrecoIniciaCom"]       = bd.LerString("PrecoIniciaCom");
                    dtr["Quantidade"]           = bd.LerInt("Quantidade");
                    dtr["QuantidadePorCliente"] = bd.LerInt("QuantidadePorCliente");
                    dtr["ParceiroID"]           = bd.LerInt("ParceiroID");
                    dtr["ValidaBin"]            = bd.LerBoolean("ValidaBin");
                    dtr["TextoValidacao"]       = bd.LerString("TextoValidacao");
                    dtr["ObrigatoriedadeID"]    = bd.LerInt("ObrigatoriedadeID");
                    dtr["Nominal"]              = bd.LerBoolean("Nominal");
                    dtr["QuantidadePorCodigo"]  = bd.LerInt("QuantidadePorCodigo");
                    dtr["TermoSite"]            = bd.LerString("TermoSite");
                    dtt.Rows.Add(dtr);
                }
                return(dtt);
            }
            catch (Exception)
            {
                throw;
            }
            finally
            {
                bd.Fechar();
            }
        }
Beispiel #11
0
        public void FiltrarPorNome(string texto)
        {
            if (lista.Count > listaBasePesquisa.Count || listaBasePesquisa.Count == 0)
            {
                listaBasePesquisa = lista;
            }

            string IDsAtuais = Utilitario.ArrayToString(listaBasePesquisa);
            BD     bd        = new BD();

            try
            {
                bd.Consulta("SELECT ID FROM tCanalTipo WHERE ID IN (" + IDsAtuais + ") AND Nome like '%" + texto.Replace("'", "''").Trim() + "%' ORDER BY  Nome");

                ArrayList listaNova = new ArrayList();
                while (bd.Consulta().Read())
                {
                    listaNova.Add(bd.LerInt("ID"));
                }

                if (listaNova.Count > 0)
                {
                    lista = listaNova;
                }
                else
                {
                    throw new Exception("Nenhum resultado para a pesquisa!");
                }

                lista.TrimToSize();
                this.Primeiro();
            }
            catch
            {
                throw;
            }
            finally
            {
                bd.Fechar();
            }
        }
Beispiel #12
0
        /// <summary>
        /// Obtem todas os bloqueios
        /// </summary>
        /// <returns></returns>
        public DataTable Todos(ArrayList locaisIDs)
        {
            try
            {
                DataTable tabela = new DataTable("Bloqueio");

                tabela.Columns.Add("ID", typeof(int));
                tabela.Columns.Add("Nome", typeof(string));
                tabela.Columns.Add("CorID", typeof(int));
                tabela.Columns.Add("RGB", typeof(string));
                tabela.Columns.Add("LocalID", typeof(int));

                string sql = "SELECT b.ID,b.Nome,b.CorID,b.LocalID,c.RGB " +
                             "FROM tBloqueio AS b,tCor AS c " +
                             "WHERE c.ID=b.CorID AND b.LocalID in (" + Utilitario.ArrayToString(locaisIDs) + ") " +
                             "ORDER BY b.LocalID,b.Nome";

                bd.Consulta(sql);

                while (bd.Consulta().Read())
                {
                    DataRow linha = tabela.NewRow();
                    linha["ID"]      = bd.LerInt("ID");
                    linha["Nome"]    = bd.LerString("Nome");
                    linha["CorID"]   = bd.LerInt("CorID");
                    linha["RGB"]     = bd.LerString("RGB");
                    linha["LocalID"] = bd.LerInt("LocalID");
                    tabela.Rows.Add(linha);
                }

                bd.Fechar();

                return(tabela);
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
Beispiel #13
0
        public List <EstruturaEventoEntregaControle> Carregar(List <int> eventoIDs, int controleID)
        {
            try
            {
                List <EstruturaEventoEntregaControle> retorno = new List <EstruturaEventoEntregaControle>();
                EstruturaEventoEntregaControle        eEECAux = new EstruturaEventoEntregaControle();
                string sql = @"SELECT  tEventoEntregaControle.ID, tEventoEntregaControle.EventoID, tEventoEntregaControle.EntregaControleID, tEventoEntregaControle.DiasTriagem,
                CASE WHEN LEN(tEventoEntregaControle.ProcedimentoEntrega) > 0
	                THEN tEventoEntregaControle.ProcedimentoEntrega 
	                ELSE
		                CASE WHEN LEN(tEntregaControle.ProcedimentoEntrega) > 0
			                THEN tEntregaControle.ProcedimentoEntrega
			                ELSE tEntrega.ProcedimentoEntrega
		                END
	                END AS ProcedimentoEntrega
                FROM tEventoEntregaControle 
                INNER JOIN tEntregaControle ON tEntregaControle.ID = tEventoEntregaControle.EntregaControleID
                INNER JOIN tEntrega ON tEntrega.ID = tEntregaControle.EntregaID WHERE EventoID IN (" + Utilitario.ArrayToString(eventoIDs.ToArray()) + ") and EntregaControleID = " + controleID;
                bd.Consulta(sql);

                if (bd.Consulta().Read())
                {
                    eEECAux.ID                  = bd.LerInt("ID");
                    eEECAux.EventoID            = bd.LerInt("EventoID");
                    eEECAux.EntregaControleID   = bd.LerInt("EntregaControleID");
                    eEECAux.ProcedimentoEntrega = bd.LerString("ProcedimentoEntrega");
                    eEECAux.DiasTriagem         = bd.LerInt("DiasTriagem");

                    retorno.Add(eEECAux);
                }

                bd.Fechar();

                return(retorno);
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
Beispiel #14
0
        public DataTable getFormaPagamentoCotaItem(int[] cotaItemID)
        {
            try
            {
                DataTable dtt = new DataTable("CotaItemFormaPagamento");
                dtt.Columns.Add("FormaPagamentoID", typeof(int));
                dtt.Columns.Add("CotaItemID", typeof(int));

                bd.Consulta("SELECT FormaPagamentoID, CotaItemID FROM tCotaItemFormaPagamento (NOLOCK) WHERE CotaItemID IN ( " + Utilitario.ArrayToString(cotaItemID) + ") ORDER BY FormaPagamentoID");

                while (bd.Consulta().Read())
                {
                    DataRow dr = dtt.NewRow();
                    dr["FormaPagamentoID"] = bd.LerInt("FormaPagamentoID");
                    dr["CotaItemID"]       = bd.LerInt("CotaItemID");
                    dtt.Rows.Add(dr);
                }
                return(dtt);
            }
            catch (Exception)
            {
                throw;
            }
            finally
            {
                bd.Fechar();
            }
        }
Beispiel #15
0
        public bool SalvarRespostaBlack(string Key, string Value, string XmlRetorno, string XmlTipo, bool enviado)
        {
            try
            {
                StringBuilder sql;

                sql = new StringBuilder();
                sql.Append("INSERT INTO tLogEnvioXml (TimeStamp, XmlEnviado, XmlRetorno, XmlTipo, CodigoBarra) ");
                sql.Append("VALUES ('@000', '@001', '@002', '@003', '@004')");
                sql.Replace("@000", DateTime.Now.ToString("yyyyMMddHHmmss"));
                sql.Replace("@001", Value);
                sql.Replace("@002", XmlRetorno);
                sql.Replace("@003", XmlTipo);
                sql.Replace("@004", Key);

                int x = bd.Executar(sql.ToString());

                bool result = (x == 1);

                if (result == false)
                {
                    return(false);
                }

                bd.FecharConsulta();

                object id = bd.ConsultaValor("SELECT ID FROM tIngressoCodigoBarra (NOLOCK) WHERE CodigoBarra = '" + Key + "' AND BlackList = 'T' AND EventoID IN (" + Utilitario.ArrayToString(EventoIDsBlack.ToArray()) + ")");

                if (enviado)
                {
                    int ID = Convert.ToInt32(id);

                    if (ID > 0)
                    {
                        this.AtualizarListaCodigoBarraIngresso(ID, bd);
                    }
                }

                return(true);
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
Beispiel #16
0
        public List <EstruturaFonteNova> Buscar_BlacklistRecordFonte()
        {
            BD bd = new BD();

            try
            {
                List <EstruturaFonteNova> retorno = new List <EstruturaFonteNova>();
                EventoIDsBlack = new List <int>();

                string SQL = string.Format(@"SELECT DISTINCT te.ID 
                FROM tEvento AS te (NOLOCK)
                INNER JOIN tApresentacao ta (NOLOCK) ON te.ID = ta.EventoID
                WHERE te.LocalID IN ({0}) AND ta.Horario >= '{1}%'", this.LocalID, DateTime.Now.AddDays(-1).ToString("yyyyMMdd"));

                bd.Consulta(SQL);

                while (bd.Consulta().Read())
                {
                    EventoIDsBlack.Add(bd.LerInt("ID"));
                }

                bd.FecharConsulta();

                if (EventoIDsBlack.Count > 0)
                {
                    SQL = string.Format(@"
                    SELECT DISTINCT ti.ID, ticb.CodigoBarra, te.Nome AS Evento, tasf.aIdEvento
                    FROM tIngressoCodigoBarra ticb (NOLOCK) 
                    INNER JOIN tIngressoLog til (NOLOCK) ON til.CodigoBarra = ticb.CodigoBarra
                    INNER JOIN tIngresso ti (NOLOCK) ON ti.ID = til.IngressoID AND ti.EventoID = ticb.EventoID
                    INNER JOIN tApresentacao ta (NOLOCK) ON ta.ID = ti.ApresentacaoID AND ta.EventoID = ticb.EventoID
                    INNER JOIN tPreco tp (NOLOCK) ON tp.ID = til.PrecoID AND tp.ApresentacaoSetorID = ti.ApresentacaoSetorID
                    INNER JOIN tSetor ts (NOLOCK) ON ts.ID = ti.SetorID
                    LEFT JOIN tLugar tl (NOLOCK) ON tl.ID = ti.LugarID
                    LEFT JOIN tCliente tc (NOLOCK) ON tc.ID = ti.ClienteID
                    INNER JOIN tAuxiliarSetoresFonte tasf (NOLOCK) ON tasf.SetorID = ti.SetorID AND tasf.PrecoID = ti.PrecoID
                    INNER JOIN tEvento te (NOLOCK) ON te.ID = ta.EventoID
                    WHERE ticb.EventoID IN ({0}) AND ticb.BlackList = 'T' AND ticb.Sincronizado = 'T'", Utilitario.ArrayToString(EventoIDsBlack.ToArray()));

                    bd.Consulta(SQL);

                    while (bd.Consulta().Read())
                    {
                        retorno.Add(new EstruturaFonteNova()
                        {
                            CodigoBarra = bd.LerString("CodigoBarra"),
                            Evento      = bd.LerString("Evento"),
                            aIdEvento   = bd.LerString("aIdEvento")
                        });
                    }

                    return(retorno);
                }
                else
                {
                    return(null);
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                bd.Fechar();
            }
        }
Beispiel #17
0
        /// <summary>
        /// Captura os detalhes das taxas de entrega do evento
        /// </summary>
        /// <param name="eventoIDs">Lista de Eventos ID</param>
        /// <param name="taxaEntregaID">TaxaEntrega ID</param>
        /// <returns></returns>
        public List <string> DetalhesEntregaPorEventos(List <int> eventoIDs, int taxaEntregaID)
        {
            List <string> retorno = new List <string>();

            try
            {
                List <int> procedimentos = new List <int>();

                string sql = "";
                if (eventoIDs.Count > 0)
                {
                    sql = @"SELECT DISTINCT
                            CASE WHEN
		                            LEN(tEventoEntregaControle.ProcedimentoEntrega) > 0
			                            THEN tEventoEntregaControle.ProcedimentoEntrega
		                            ELSE
			                            CASE WHEN
				                            LEN(tEntregaControle.ProcedimentoEntrega) > 0
				                            THEN tEntregaControle.ProcedimentoEntrega
				                            ELSE tEntrega.ProcedimentoEntrega
			                            END
                            END as ProcedimentoEntrega,
                            CASE WHEN
		                            LEN(tEventoEntregaControle.ProcedimentoEntrega) > 0
			                            THEN 3
		                            ELSE
			                            CASE WHEN
				                            LEN(tEntregaControle.ProcedimentoEntrega) > 0
				                            THEN 2
				                            ELSE 1
			                            END
                            END as PrioridadeProcedimento
                            FROM tEventoEntregaControle
                            INNER JOIN tEntregaControle on  tEventoEntregaControle.EntregaControleID = tEntregaControle.ID
                            INNER JOIN tEntrega on tEntregaControle.EntregaID = tEntrega.ID
                            WHERE 
                            tEventoEntregaControle.EventoID IN ( " + Utilitario.ArrayToString(eventoIDs.ToArray()) + @") AND
                            tEntrega.ID = " + taxaEntregaID + @"
                            GROUP BY tEntregaControle.ID,tEntrega.ProcedimentoEntrega,tEntregaControle.ProcedimentoEntrega,
                            tEventoEntregaControle.ProcedimentoEntrega,tEventoEntregaControle.EventoID";
                }
                else
                {
                    sql = @"SELECT
			                tEntrega.ProcedimentoEntrega as ProcedimentoEntrega,
			                1 as PrioridadeProcedimento
                            FROM tEntrega 
                            WHERE tEntrega.ID = " + taxaEntregaID + @"";
                }

                using (IDataReader oDataReader = bd.Consulta(sql))
                {
                    while (oDataReader.Read())
                    {
                        switch (bd.LerInt("PrioridadeProcedimento"))
                        {
                        case 3:
                            retorno.Add(bd.LerString("ProcedimentoEntrega"));
                            break;

                        case 2:
                            if (!procedimentos.Contains(2))
                            {
                                procedimentos.Add(2);
                                retorno.Add(bd.LerString("ProcedimentoEntrega"));
                            }
                            break;

                        case 1:
                            if (!procedimentos.Contains(1))
                            {
                                procedimentos.Add(1);
                                retorno.Add(bd.LerString("ProcedimentoEntrega"));
                            }
                            break;

                        default:
                            break;
                        }
                    }
                }


                bd.Fechar();
            }
            catch (Exception ex)
            {
                throw new Exception("Procedimento de Entrega: " + ex.Message);
            }
            finally
            {
                bd.Fechar();
            }

            return(retorno);
        }
Beispiel #18
0
        private List <EstruturaAssinaturaBloqueio> CarregarAssinatura(List <int> lstAssClienteID)
        {
            BD bdaux = new BD();

            try
            {
                string sql = @"SELECT distinct i.Grupo,i.Classificacao, ac.id as AssinaturaClienteID, ac.AssinaturaID, i.LugarID, s.ID as SetorID, i.Codigo AS Lugar,s.Nome AS Setor, ass.Nome as NomeAssinatura, 
                                ISNULL(c.Nome,'') AS Assinante, ISNULL(c.ID,0) AS ClienteID, ISNULL(c.CPF,'') as CPF ,ISNULL(pt.Nome,'') AS Preco, ISNULL(ac.Status,'') as StatusAssinatura , ISNULL(ac.Acao,'') as AcaoAssinatura , 
                                i.Status as StatusIngresso, i.BloqueioID as IngressoBloqueioID,ass.BloqueioID AssinaturaBloqueioID, ass.DesistenciaBloqueioID AssinaturaDesistenciaBloqueioID, ass.ExtintoBloqueioID as AssinaturaExtintoBloqueioID, bl.Nome as BloqueioUtilizado,
                                l.PosicaoY, l.PosicaoX, bl.CorID AS BloqueioCorID
                                FROM tAssinaturaCliente ac
                                INNER JOIN tIngresso i (NOLOCK) ON ac.ID = i.AssinaturaClienteID
                                INNER JOIN tLugar l (NOLOCK) on i.LugarID = l.ID
                                INNER JOIN tAssinatura ass (NOLOCK) on ass.ID = ac.AssinaturaID
                                INNER JOIN tApresentacao ap (NOLOCK) on i.ApresentacaoID = ap.ID
                                INNER JOIN tSetor s (NOLOCK) on i.SetorID = s.ID
                                LEFT JOIN tCliente c (NOLOCK) ON ac.ClienteID = c.ID
                                LEFT JOIN tPrecoTipo pt (NOLOCK) ON ac.PrecoTipoID = pt.ID 
                                LEFT JOIN tBloqueio bl(NOLOCK) ON i.BloqueioID = bl.ID
                                WHERE ac.ID in(" + Utilitario.ArrayToString(lstAssClienteID.ToArray()) + @") 
                                ORDER BY i.Grupo,i.Classificacao";

                bdaux.Consulta(sql);

                var lstRetorno = new List <EstruturaAssinaturaBloqueio>();

                EstruturaAssinaturaBloqueio eABaux = new EstruturaAssinaturaBloqueio();

                while (bdaux.Consulta().Read())
                {
                    if (lstRetorno.Where(c => c.LugarID == bdaux.LerInt("LugarID")).Count() == 0)
                    {
                        string statusAssinatura = bdaux.LerString("StatusAssinatura") != "" ? ((AssinaturaCliente.EnumStatus)Convert.ToChar(bdaux.LerString("StatusAssinatura"))).ToString() : "--";
                        string statusIngresso   = bdaux.LerString("StatusIngresso") != "" ? ((Ingresso.StatusIngresso)Convert.ToChar(bdaux.LerString("StatusIngresso"))).ToString() : "--";


                        eABaux = new EstruturaAssinaturaBloqueio()
                        {
                            LugarID                 = bdaux.LerInt("LugarID"),
                            NomeAssinatura          = bdaux.LerString("NomeAssinatura"),
                            Assinante               = bdaux.LerString("Assinante"),
                            CPF                     = bdaux.LerString("CPF"),
                            Setor                   = bdaux.LerString("Setor"),
                            Lugar                   = bdaux.LerString("Lugar"),
                            Preco                   = bdaux.LerString("Preco"),
                            ClienteID               = bdaux.LerInt("ClienteID"),
                            AssinaturaClienteID     = bdaux.LerInt("AssinaturaClienteID"),
                            AssinaturaBloqueioID    = bdaux.LerInt("AssinaturaBloqueioID"),
                            BloqueioUtilizado       = bdaux.LerString("BloqueioUtilizado") != "" ? bdaux.LerString("BloqueioUtilizado") : "--",
                            StatusAssinatura        = statusAssinatura,
                            StatusIngresso          = statusIngresso,
                            SetorID                 = bdaux.LerInt("SetorID"),
                            Selecionar              = false,
                            PosicaoX                = bdaux.LerInt("PosicaoX"),
                            PosicaoY                = bdaux.LerInt("PosicaoY"),
                            BloqueioID              = bdaux.LerInt("IngressoBloqueioID"),
                            BloqueioCorID           = bdaux.LerInt("BloqueioCorID"),
                            AssinaturaID            = bdaux.LerInt("AssinaturaID"),
                            AssinaturaDesistenciaID = bdaux.LerInt("AssinaturaDesistenciaBloqueioID"),
                        };

                        eABaux.Status = this.VerificaStatusVisual(bdaux.LerString("StatusIngresso"), bdaux.LerString("StatusAssinatura"), bdaux.LerString("AcaoAssinatura"), bdaux.LerInt("IngressoBloqueioID"), bdaux.LerInt("AssinaturaBloqueioID"), bdaux.LerInt("AssinaturaExtintoBloqueioID"), bdaux.LerInt("AssinaturaDesistenciaBloqueioID"));

                        lstRetorno.Add(eABaux);
                    }
                    else
                    {
                        eABaux.Status            = EnumStatusVisual.Indisponivel;
                        eABaux.StatusIngresso    = "--";
                        eABaux.StatusAssinatura  = "--";
                        eABaux.BloqueioUtilizado = "--";
                        eABaux.BloqueioID        = 0;
                    }
                }

                return(lstRetorno);
            }
            catch (Exception)
            {
                throw;
            }
            finally
            {
                bdaux.Fechar();
            }
        }
Beispiel #19
0
        public DataTable CarregarTabelaPDV(List <int> eventosID, string estado, string cidade)
        {
            //if (eventosID.Count == 0)
            //    return CarregarTabelaPDV(estado, cidade);

            DataRow dr = null;

            string sql = "";

            DataTable PontoVenda = new DataTable("PontoVenda");

            PontoVenda.Columns.Add("ID", typeof(int));
            PontoVenda.Columns.Add("Local", typeof(string));
            PontoVenda.Columns.Add("Nome", typeof(string));
            PontoVenda.Columns.Add("Endereco", typeof(string));
            PontoVenda.Columns.Add("Numero", typeof(string));
            PontoVenda.Columns.Add("Compl", typeof(string));
            PontoVenda.Columns.Add("Cidade", typeof(string));
            PontoVenda.Columns.Add("Estado", typeof(string));
            PontoVenda.Columns.Add("Bairro", typeof(string));
            PontoVenda.Columns.Add("Obs", typeof(string));
            PontoVenda.Columns.Add("Referencia", typeof(string));
            PontoVenda.Columns.Add("CEP", typeof(string));
            PontoVenda.Columns.Add("PermiteRetirada", typeof(bool));

            try
            {
                // Pontos de Venda
                if (eventosID.Count != 0)
                {
                    sql =
                        string.Format(@"
                        SELECT 
		                    DISTINCT pv.ID, pv.Local, pv.Nome, pv.Endereco, pv.Numero, Compl, Cidade, Estado, Bairro, pv.Obs, Referencia, CEP, PermiteRetirada,
							                (COUNT(DISTINCT epv.EventoID) + 
							                CASE WHEN ev.HabilitarRetiradaTodosPDV = 'T'
								                THEN 1
								                ELSE 0
							                END) AS Disponivel
			                INTO #tmp
			                FROM tPontoVenda pv (NOLOCK)
	                        LEFT JOIN tEventoPontoDeVenda epv (NOLOCK) ON pv.ID = epv.PontoDeVendaID AND epv.EventoID IN ({0})
	                        LEFT JOIN tEvento ev (NOLOCK) ON ev.ID IN ({0})
	                        WHERE pv.Estado = '{1}' AND pv.Cidade = '{2}' AND pv.PermiteRetirada = 'T' AND (epv.ID IS NOT NULL OR ev.HabilitarRetiradaTodosPDV = 'T')
	                        GROUP BY pv.ID, pv.Local, pv.Nome, pv.Endereco, pv.Numero, Compl, Cidade, 
					                Estado, Bairro, pv.Obs, Referencia, CEP, PermiteRetirada, ev.HabilitarRetiradaTodosPDV                          
	                 SELECT 
		                ID, Local, Nome, Endereco, Numero, Compl, Cidade, 
					                Estado, Bairro, Obs, Referencia, CEP, PermiteRetirada
	                FROM #tmp
	                GROUP BY ID, Local, Nome, Endereco, Numero, Compl, Cidade, 
					                Estado, Bairro, Obs, Referencia, CEP, PermiteRetirada
	                HAVING SUM(Disponivel) = {3}
	                DROP TABLE #tmp
                    ", Utilitario.ArrayToString(eventosID.ToArray()), estado, cidade, eventosID.Count);
                }
                else
                {
                    sql = "SELECT * FROM tPontoVenda WHERE PermiteRetirada = 'T' AND IR = 'T' AND Estado = '" + estado + "' AND Cidade = '" + cidade + "' ORDER BY Nome";
                }

                bd.Consulta(sql);

                while (bd.Consulta().Read())
                {
                    dr = PontoVenda.NewRow();
                    PontoVenda.Rows.Add(dr);

                    dr["ID"]              = bd.LerInt("ID");
                    dr["Local"]           = bd.LerString("Local");
                    dr["Nome"]            = bd.LerString("Nome");
                    dr["Endereco"]        = bd.LerString("Endereco");
                    dr["Numero"]          = bd.LerString("Numero");
                    dr["Compl"]           = bd.LerString("Compl");
                    dr["Cidade"]          = bd.LerString("Cidade");
                    dr["Estado"]          = bd.LerString("Estado");
                    dr["Bairro"]          = bd.LerString("Bairro");
                    dr["Obs"]             = bd.LerString("Obs");
                    dr["Referencia"]      = bd.LerString("Referencia");
                    dr["CEP"]             = bd.LerString("CEP");
                    dr["PermiteRetirada"] = true;
                }
                bd.Fechar();


                return(PontoVenda);
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
Beispiel #20
0
        public int[] AdicionarMulti(int eventoID, int apresentacaoID, int setorID, int precoID, int todosID, string precoNome)
        {
            try
            {
                DataTable tabelaPrecosAlteraveis = precosAlteraveis(eventoID, apresentacaoID, setorID, precoID, todosID, precoNome);

                //verificar quais ainda nao existem na tabela
                Array precosIDs = Array.CreateInstance(typeof(DataRow), tabelaPrecosAlteraveis.Rows.Count);
                tabelaPrecosAlteraveis.Rows.CopyTo(precosIDs, 0);
                string precos = Utilitario.ArrayToString(precosIDs);

                string sqlPrecos = "SELECT tPreco.ID AS PrecoID, tCanalPreco.CanalID " +
                                   "FROM tPreco (NOLOCK) " +
                                   "LEFT JOIN tCanalPreco (NOLOCK) ON tCanalPreco.PrecoID=tPreco.ID AND tCanalPreco.CanalID=" + this.CanalID.Valor + " " +
                                   "WHERE tPreco.ID in (" + precos + ")";

                bd.Consulta(sqlPrecos);

                DataTable tabela = new DataTable("Canais");
                tabela.Columns.Add("PrecoID", typeof(int));
                tabela.Columns.Add("CanalID", typeof(int));

                while (bd.Consulta().Read())
                {
                    DataRow linha = tabela.NewRow();
                    linha["PrecoID"] = bd.LerInt("PrecoID");
                    linha["CanalID"] = bd.LerInt("CanalID");
                    tabela.Rows.Add(linha);
                }
                bd.Consulta().Close();

                CanalPreco canalPreco = new CanalPreco(this.Control.UsuarioID);
                canalPreco.Limpar();
                canalPreco.CanalID.Valor    = this.CanalID.Valor;
                canalPreco.DataInicio.Valor = this.DataInicio.Valor;
                canalPreco.DataFim.Valor    = this.DataFim.Valor;
                canalPreco.Quantidade.Valor = this.Quantidade.Valor;

                bd.IniciarTransacao();

                int countInseridos = 0;

                foreach (DataRow linha in tabela.Rows)
                {
                    int pID = (int)linha["PrecoID"];
                    int cID = (int)linha["CanalID"];

                    if (cID == 0)
                    { //null, pode incluir
                        canalPreco.PrecoID.Valor = pID;
                        canalPreco.Inserir(bd, true);

                        countInseridos++;
                    }
                }//while (bd.Consulta().Read())

                bd.FinalizarTransacao();
                int[] retorno = new int[2];
                retorno[0] = tabela.Rows.Count;
                retorno[1] = countInseridos;
                return(retorno);
            }
            catch (Exception ex)
            {
                bd.DesfazerTransacao();
                throw ex;
                //} finally {
                //    bd.Fechar();
                //    bd.Cnn.Dispose();
            }
        }
Beispiel #21
0
        public DataTable getInformacoesPorCotaItem(int[] IDs)
        {
            try
            {
                DataTable dtt = this.estrutura();
                bd.Consulta("SELECT tObrigatoriedade.* FROM tObrigatoriedade (NOLOCK) INNER JOIN tCotaItem (NOLOCK) " +
                            "ON tObrigatoriedade.ID = tCotaItem.ObrigatoriedadeID WHERE tCotaItem.ID IN( " + Utilitario.ArrayToString(IDs) + ")");

                while (bd.Consulta().Read())
                {
                    DataRow linha = dtt.NewRow();
                    linha["ID"]                 = bd.LerInt("ID");
                    linha["Nome"]               = bd.LerBoolean("Nome");
                    linha["RG"]                 = bd.LerBoolean("RG");
                    linha["CPF"]                = bd.LerBoolean("CPF");
                    linha["Telefone"]           = bd.LerBoolean("Telefone");
                    linha["TelefoneComercial"]  = bd.LerBoolean("TelefoneComercial");
                    linha["Celular"]            = bd.LerBoolean("Celular");
                    linha["DataNascimento"]     = bd.LerBoolean("DataNascimento");
                    linha["Email"]              = bd.LerBoolean("Email");
                    linha["CEPCliente"]         = bd.LerBoolean("CEPCliente");
                    linha["EnderecoCliente"]    = bd.LerBoolean("EnderecoCliente");
                    linha["NumeroCliente"]      = bd.LerBoolean("NumeroCliente");
                    linha["ComplementoCliente"] = bd.LerBoolean("ComplementoCliente");
                    linha["BairroCliente"]      = bd.LerBoolean("BairroCliente");
                    linha["EstadoCliente"]      = bd.LerBoolean("EstadoCliente");
                    linha["CidadeCliente"]      = bd.LerBoolean("CidadeCliente");
                    linha["NomeEntrega"]        = bd.LerBoolean("NomeEntrega");
                    linha["CPFEntrega"]         = bd.LerBoolean("CPFEntrega");
                    linha["RGEntrega"]          = bd.LerBoolean("RGEntrega");
                    linha["CEPEntrega"]         = bd.LerBoolean("CEPEntrega");
                    linha["EnderecoEntrega"]    = bd.LerBoolean("EnderecoEntrega");
                    linha["NumeroEntrega"]      = bd.LerBoolean("NumeroEntrega");
                    linha["ComplementoEntrega"] = bd.LerBoolean("ComplementoEntrega");
                    linha["BairroEntrega"]      = bd.LerBoolean("BairroEntrega");
                    linha["CidadeEntrega"]      = bd.LerBoolean("CidadeEntrega");
                    linha["EstadoEntrega"]      = bd.LerBoolean("EstadoEntrega");
                    linha["NomeResponsavel"]    = bd.LerBoolean("NomeResponsavel");
                    linha["CPFResponsavel"]     = bd.LerBoolean("CPFResponsavel");
                    dtt.Rows.Add(linha);
                }

                return(dtt);
            }
            catch (Exception)
            {
                throw;
            }
            finally
            {
                bd.Fechar();
            }
        }
Beispiel #22
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, bool isEntradaFranca)
        {
            BD               bd               = new BD(ConfigurationManager.AppSettings["ConexaoReadOnly"]);
            BD               bdReserva        = new BD();
            Ingresso         oIngresso        = new Ingresso();
            Bilheteria       oBilheteria      = new Bilheteria();
            Cota             oCota            = new Cota();
            CotaItemControle cotaItemControle = new CotaItemControle();
            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 ConfigGerenciador().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;

                var qtdIncrementada = 0;

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

                    oCotaItem.AtualizarInformacoesCota(listaCotaItem, preco, cotaInfo);

                    if (listaCotaItem.Any() && cotaInfo.CotaItemID > 0)
                    {
                        cotaInfo.QuantidadeJaVendida = cotaItemControle.getQuantidadeNovo(cotaInfo.CotaItemID, cotaInfo.CotaItemID_APS, cotaInfo.ApresentacaoID, cotaInfo.ApresentacaoSetorID);
                        var qtdReservar = preco.QuantidadeReservar();
                        if (!cotaInfo.ValidaReserva(qtdReservar))
                        {
                            throw new BilheteriaException(string.Format("Não será possível reservar o preço \"{0}\", o limite de venda foi excedido.", preco.PrecoNome), Bilheteria.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(string.Format("A quantidade disponível para o preço \"{0}\" foi excedida.", preco.PrecoNome), Bilheteria.CodMensagemReserva.PrecoIndisponivel);
                    }
                    //incrementa a quantidade
                    qtdPrecos += preco.Quantidade;

                    if (tipoSetor != IRLib.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        = cotaInfo.CotaItemID;
                            itemPreco.CotaItemIDAPS     = cotaInfo.CotaItemID_APS;
                            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        = cotaInfo.CotaItemID;
                        itemPreco.CotaItemIDAPS     = cotaInfo.CotaItemID_APS;
                        itemPreco.CodigoCinema      = preco.CodigoCinema;
                        itemPreco.CodigoProgramacao = preco.CodigoProgramacao;
                        listaPreco.Add(itemPreco);
                    }
                }
                //Lugares marcados. Precisa achar os melhores lugares.
                if (tipoSetor != IRLib.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.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.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.Setor.enumLugarMarcado.MesaFechada)
                                {
                                    p++;
                                }
                            }
                            if (tipoSetor == IRLib.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"]);

                        var readerCount = bdBusca.ConsultaCount(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));

                        if (readerCount.rowCount > 0 && readerCount.rowCount != preco.Quantidade)
                        {
                            throw new Exception("Quantidade de ingressos selecionado não está disponível. Tente com uma quantidade menor.");
                        }

                        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
                            {
                                Control = { ID = bdBusca.LerInt("ID") },
                                PrecoID = { Valor = preco.ID },
                                GerenciamentoIngressosID = { Valor = preco.GerenciamentoIngressosID },
                                UsuarioID              = { Valor = estruturaReserva.UsuarioID },
                                Codigo                 = { Valor = bdBusca.LerString("Codigo") },
                                LojaID                 = { Valor = estruturaReserva.LojaID },
                                ClienteID              = { Valor = clienteID },
                                SessionID              = { Valor = sessionID },
                                TimeStampReserva       = { Valor = timeStamp },
                                LugarID                = { Valor = bdBusca.LerInt("LugarID") },
                                TxConv                 = valorProcessamento > 0 ? 0 : valorConv,
                                TaxaProcessamentoValor = valorProcessamento,
                                CotaItemID             = preco.CotaItemID,
                                CotaItemIDAPS          = preco.CotaItemIDAPS,
                                SerieID                = { Valor = serieID },
                                CompraGUID             = { Valor = estruturaReserva.GUID }
                            };

                            //Se for EntradaGratuita OU (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, isEntradaFranca);
                                }

                                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();
            }
        }
Beispiel #23
0
        public List <EstruturaTrocaValeIngresso> ValidarTrocaValeIngresso(List <int> IDs)
        {
            try
            {
                StringBuilder stbSQL;

                stbSQL = new StringBuilder();
                List <EstruturaTrocaValeIngresso> retorno = new List <EstruturaTrocaValeIngresso>();

                stbSQL.Append("SELECT DISTINCT vi.ID, vip.Nome, vi.CodigoTroca, vip.CodigoTrocaFixo, vi.Status, vip.Valor, vip.Acumulativo, ");
                stbSQL.Append(" vip.TrocaConveniencia, vip.TrocaEntrega, vip.TrocaIngresso, vip.ValorPagamento, vip.ValorTipo ");
                stbSQL.Append("FROM tValeIngresso vi (NOLOCK) ");
                stbSQL.Append("INNER JOIN tValeIngressoTipo vip (NOLOCK) ON vi.ValeIngressoTipoID = vip.ID ");
                stbSQL.Append("WHERE vi.Status = '" + (char)ValeIngresso.enumStatus.Impresso + "' ");
                stbSQL.Append("AND (((vi.ID IN (" + Utilitario.ArrayToString(IDs.ToArray()) + ") ");
                stbSQL.Append("AND DataExpiracao >= '" + DateTime.Now.Date.ToString("yyyyMMdd") + "' ) ");
                stbSQL.Append("AND (DataExpiracao >= '" + System.DateTime.Now.Date.ToString("yyyyMMdd") + "'))) ");

                bd.Consulta(stbSQL.ToString());
                if (!bd.Consulta().Read())
                {
                    throw new Exception("Os vale ingressos utilizados não foram encontrados.");
                }

                do
                {
                    retorno.Add(new EstruturaTrocaValeIngresso()
                    {
                        ID                = bd.LerInt("ID"),
                        Nome              = bd.LerString("Nome"),
                        CodigoTroca       = bd.LerString("CodigoTroca"),
                        CodigoTrocaFixo   = bd.LerString("CodigoTrocaFixo"),
                        Acumulativo       = bd.LerString("Acumulativo"),
                        Status            = bd.LerString("Status"),
                        Valor             = bd.LerDecimal("Valor"),
                        Encontrado        = true,
                        TrocaConveniencia = bd.LerBoolean("TrocaConveniencia"),
                        TrocaEntrega      = bd.LerBoolean("TrocaEntrega"),
                        TrocaIngresso     = bd.LerBoolean("TrocaIngresso"),
                        ValorPagamento    = bd.LerDecimal("ValorPagamento"),
                        ValorTipo         = Convert.ToChar(bd.LerString("ValorTipo")),
                    });
                } while (bd.Consulta().Read());

                //this.AlterarStatus(enumStatus.Aguardando, oRetorno.ID);

                if (retorno.Count != IDs.Count)
                {
                    throw new Exception("Não foi possível encontrar todos os Vale Ingresos. Por favor tente novamente.");
                }
                return(retorno);
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                bd.Fechar();
            }
        }