/// <summary>
/// Método usado para retornar a lista de melhores lugares juntos.
/// Apesar de estar na classe Lugar o acesso ao banco acessando a tabela ingresso.
/// Na Classe ingresso existe um método de mesmo nome que retorna os melhores ingresso (tambem buscados através desse método)
/// </summary>
/// <param name="quantidade">Quantidade de lugares juntos</param>
/// <param name="apresentacaoSetorID"></param>
/// <returns></returns>
public List <Lugar> MelhorLugarMarcado(int quantidade, int apresentacaoSetorID, Setor.enumLugarMarcado setorTipo)
{
try
{
List <Lugar> lugares = new List <Lugar>();
int[] aux;
int lugarID;
int classificacao;
Lugar lugar = new Lugar();
Apresentacao oAp = new Apresentacao();
if (!oAp.PossuiClassificacao(apresentacaoSetorID))
{
throw new Exception("Atenção, nenhum ingresso foi reservado. O Setor selecionado não possui agrupamento e classificação e por este motivo não será possível efetuar a reserva dos melhores lugares.");
}
ArrayList gruposTemp;
switch (setorTipo)
{
case Setor.enumLugarMarcado.MesaAberta:
#region Melhores Lugares - Mesa Aberta
string sqlMesaAberta = "SELECT " +
"Grupo,LugarID " +
"FROM tIngresso (NOLOCK) " +
"WHERE " +
"ApresentacaoSetorID = " + apresentacaoSetorID + " AND " +
"Grupo > 0 AND " +
"Classificacao > 0 " +
"AND Status = 'D' " +
"ORDER BY Grupo, Classificacao";
bd.Consulta(sqlMesaAberta);
ArrayList gruposMesaAberta = new ArrayList();
while (bd.Consulta().Read())
{
gruposMesaAberta.Add(new int[] { bd.LerInt("Grupo"), bd.LerInt("LugarID") });
}
bd.FecharConsulta();
/// Vai do primeiro ao último grupo.
bool primeiroIngresso = true;
int classificacaoAnteriorMesaAberta = -1;
int classificacaoAtualMesaAberta;
int grupoMesaAberta;
int lugaresQuantidadeTotal = 0; //Contagem de quantos lugares já foram selecionados.
for (int i = 0; i < gruposMesaAberta.Count && lugaresQuantidadeTotal < quantidade; i++)
{
aux = (int[])gruposMesaAberta[i];
grupoMesaAberta = aux[0];
lugarID = aux[1];
// Busca os lugares do grupo em questão.
bd.Consulta("SELECT ID, Codigo, Classificacao, LugarID FROM tIngresso (NOLOCK) " +
"WHERE " +
"ApresentacaoSetorID = " + apresentacaoSetorID + " AND " +
"Grupo = " + grupoMesaAberta + " AND LugarID = " + lugarID + " AND " +
"Classificacao > 0 " +
"AND Status = '" + Ingresso.DISPONIVEL + "' " +
"ORDER BY Classificacao");
primeiroIngresso = true;
//variável para controle. nescessárias para saber se mudou ou não de mesa.
int lugarIDAnterior = 0;
if (bd.Consulta().Read())
{
do //(do/while)
{
/// Verifica se a classificação do item anterior + 1 é diferente da atual.
/// _____
/// 1
/// 2
/// 3
/// -------
/// 3 + 1 != da classificacao atual?!
/// Classificação Atual = 4 = OK
/// Classificação Atual = 5 = ERRADO.
///
classificacaoAtualMesaAberta = bd.LerInt("Classificacao");
if (primeiroIngresso)
{
if (lugaresQuantidadeTotal > 0 && classificacaoAnteriorMesaAberta != -1 && classificacaoAnteriorMesaAberta + 1 != classificacaoAtualMesaAberta)
{
lugares.Clear();
}
}
if (lugarIDAnterior != lugarID)
{
lugares.Clear();
//preenche o objeto de retorno com os lugares.
lugar = new Lugar();
lugar.Control.ID = lugarID;
lugar.Grupo.Valor = grupoMesaAberta;
lugar.Classificacao.Valor = classificacaoAtualMesaAberta;
lugar.Quantidade.Valor = 1;
lugaresQuantidadeTotal = 1;
//lugaresQuantidadeTotal++;
lugares.Add(lugar);
}
else //se ainda não mudou de lugar não deve inserir um novo. Deve-se atualizar a quantidade.
{
lugar.Quantidade.Valor++; //só incrementa a quantidade.
lugaresQuantidadeTotal++; //incrementa a cotagem geral de lugares.
}
lugarIDAnterior = lugarID;
classificacaoAnteriorMesaAberta = classificacaoAtualMesaAberta; //atualiza a classificação anterior
primeiroIngresso = false;
}while (bd.Consulta().Read() && lugaresQuantidadeTotal < quantidade);
}
}
bd.FecharConsulta();
#endregion
break;
case Setor.enumLugarMarcado.MesaFechada:
#region Melhores Lugares - Mesa Fechada
string sqlMesaFechada = "SELECT " +
"DISTINCT " +
"Grupo, Classificacao,LugarID " +
"FROM tIngresso (NOLOCK) " +
"WHERE " +
"ApresentacaoSetorID = " + apresentacaoSetorID + " AND " +
"Grupo > 0 AND " +
"Classificacao > 0 " +
"AND Status = 'D' " +
"ORDER BY Grupo, Classificacao";
bd.Consulta(sqlMesaFechada);
ArrayList grupos = new ArrayList();
gruposTemp = new ArrayList();
int grupoAtual = 1;
int grupoAnterior = 1;
while (bd.Consulta().Read())
{
grupoAtual = bd.LerInt("Grupo");
if (gruposTemp.Count > 0 && grupoAnterior != grupoAtual && gruposTemp.Count >= quantidade)
{
grupos.AddRange(gruposTemp);
gruposTemp.Clear();
}
if (grupoAtual != grupoAnterior)
{
gruposTemp.Clear();
}
gruposTemp.Add(new int[] { grupoAtual, bd.LerInt("Classificacao"), bd.LerInt("LugarID") });
grupoAnterior = grupoAtual;
}
bd.FecharConsulta();
if (gruposTemp.Count > 0 && gruposTemp.Count >= quantidade)
{
grupos.AddRange(gruposTemp);
gruposTemp.Clear();
}
/// Vai do primeiro ao último grupo.
int grupoMesaFechada;
for (int i = 0; i < grupos.Count && lugares.Count < quantidade; i++)
{
aux = (int[])grupos[i];
grupoMesaFechada = aux[0];
classificacao = aux[1];
lugarID = aux[2];
/// Verifica se a classificação do item anterior + 1 é diferente da atual.
/// _____
/// 1
/// 2
/// 3
/// -------
/// 3 + 1 != da classificacao atual?!
/// Classificação Atual = 4 = OK
/// Classificação Atual = 5 = ERRADO.
///
if (lugares.Count > 0 && ((Lugar)lugares[lugares.Count - 1]).Classificacao.Valor + 1 != classificacao)
{
lugares.Clear();
}
lugar = new Lugar();
lugar.Control.ID = lugarID;
lugar.Grupo.Valor = grupoMesaFechada;
lugar.Classificacao.Valor = classificacao;
lugares.Add(lugar);
}
#endregion
break;
case Setor.enumLugarMarcado.Cadeira:
#region Melhores Lugares - Cadeira
string sql = "SELECT " +
"Grupo, COUNT(ID) Quantidade " +
"FROM tIngresso (NOLOCK) " +
"WHERE " +
"ApresentacaoSetorID = " + apresentacaoSetorID + " AND " +
"Grupo > 0 AND " +
"Classificacao > 0 " +
"AND Status = 'D' " +
"GROUP BY Grupo " +
"HAVING COUNT(ID) >= " + quantidade +
" ORDER BY Grupo, Quantidade";
//SqlDataReader dr = bd.ConsultaDR(sql);
ArrayList gruposCadeira = bd.ConsultaDR(sql);
//if (!dr.Read())
// throw new Exception("Não existem " + quantidade + " ingressos juntos para esse setor. Tente reservar os ingressos separadamente");
//while (dr.Read())
// gruposCadeira.Add(dr["Grupo"]);
//bd.FecharConsulta();
//bd.Fechar();
//dr.Close();
ArrayList ingressos = new ArrayList();
/// Vai do primeiro ao último grupo.
int grupo;
int classificacaoAnterior = -1;
int classificacaoAtual;
for (int i = 0; i < gruposCadeira.Count && ingressos.Count < quantidade; i++)
{
grupo = (int)gruposCadeira[i];
// Busca os lugares do grupo em questão.
bd.Consulta("SELECT ID, Codigo, Classificacao, LugarID FROM tIngresso (NOLOCK) " +
"WHERE " +
"ApresentacaoSetorID = " + apresentacaoSetorID + " AND " +
"Grupo = " + grupo + " AND " +
"Classificacao > 0 " +
"AND Status = '" + Ingresso.DISPONIVEL + "' " +
"ORDER BY Classificacao");
while (bd.Consulta().Read() && lugares.Count < quantidade)
{
/// Verifica se a classificação do item anterior + 1 é diferente da atual.
/// _____
/// 1
/// 2
/// 3
/// -------
/// 3 + 1 != da classificacao atual?!
/// Classificação Atual = 4 = OK
/// Classificação Atual = 5 = ERRADO.
///
classificacaoAtual = bd.LerInt("Classificacao");
if (lugares.Count > 0 && classificacaoAnterior != -1 && classificacaoAnterior + 1 != classificacaoAtual)
{
lugares.Clear();
}
classificacaoAnterior = classificacaoAtual;
//preenche o objeto de retorno com os lugares.
lugar = new Lugar();
lugar.Control.ID = bd.LerInt("LugarID");
lugar.Grupo.Valor = grupo;
lugar.Classificacao.Valor = classificacaoAtual;
lugares.Add(lugar);
}
}
#endregion
break;
default:
break;
}
return(lugares);
}
catch (Exception)
{
throw;
}
finally
{
bd.Fechar();
}
}
// passar o Usuario logado no sistema
public LugarLista_B(int usuarioIDLogado)
{
lugar = new Lugar(usuarioIDLogado);
}
/// <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();
}
}
// passar o Usuario logado no sistema
public LugarLista_B()
{
lugar = new Lugar();
}