Example #1
0
        public int InserirControladorReplicando(BD bd, List <EstruturaCotaItem> lstReplicar)
        {
            BD       bd2       = new BD();
            CotaItem oCotaItem = new CotaItem();

            try
            {
                for (int i = 0; i < lstReplicar.Count; i++)
                {
                    int CotaItemID    = lstReplicar[i].ID;
                    int qtdCadastrada = 0;
                    qtdCadastrada = oCotaItem.GetCamposCotaPromoCodigoqtd(CotaItemID);


                    if (qtdCadastrada > 0)
                    {
                        this.CotaItemID.Valor = lstReplicar[i].ID;
                        this.Quantidade.Valor = lstReplicar[i].quantidade;
                        this.Inserir(bd);
                    }
                }
                return(lstReplicar.Count);
            }
            catch (Exception)
            {
                throw;
            }
            finally
            {
                bd2.Fechar();
            }
        }
Example #2
0
        public void SalvarItemCota(List <EstruturaCotaItem> listaCotaItem, int idCota, bool novo)
        {
            bd.IniciarTransacao();

            CotaItem oCotaItem = new CotaItem(this.Control.UsuarioID);

            oCotaItem.SalvarItem(bd, listaCotaItem, idCota, novo);
            bd.FinalizarTransacao();
        }
Example #3
0
        public int SalvarCota(List <EstruturaCotaItem> listaCotaItem, EstruturaCota cota)
        {
            try
            {
                bd.IniciarTransacao();

                int cotaID = 0;
                this.Nome.Valor                 = cota.Nome;
                this.LocalID.Valor              = cota.LocalID;
                this.Quantidade.Valor           = cota.Quantidade;
                this.QuantidadePorCliente.Valor = cota.QuantidadePorCliente;
                if (cota.Novo)
                {
                    this.Inserir(bd);
                    cotaID = this.Control.ID;
                }
                else
                {
                    cotaID          = cota.ID;
                    this.Control.ID = cotaID;
                    this.Atualizar(bd);
                }

                CotaItem oCotaItem = new CotaItem(this.Control.UsuarioID);
                oCotaItem.SalvarItem(bd, listaCotaItem, cotaID, !cota.Novo);

                bd.FinalizarTransacao();
                return(cotaID);
            }
            catch (Exception ex)
            {
                bd.DesfazerTransacao();
                throw ex;
            }
            finally
            {
                bd.Fechar();
            }
        }
Example #4
0
        public void ValidarLugarMarcadoInternet(EstruturaPrecoReservaSite preco, Setor.enumLugarMarcado tipoSetor,
                                                EstruturaCotasInfo cotaInfo, int serieID, EstruturaReservaInternet estruturaReserva)
        {
            int              cortesiaID                   = 0;
            Bilheteria       oBilheteria                  = new Bilheteria();
            CotaItem         oCotaItem                    = new CotaItem();
            CotaItemControle cotaItemControle             = new CotaItemControle();
            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      = this.ApresentacaoID.Valor;
            cotaInfo.ApresentacaoSetorID = this.ApresentacaoSetorID.Valor;

            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);
                }
            }

            decimal 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(this.ClienteID.Valor, this.SessionID.Valor, preco.ID, preco.Quantidade, ref precoValor, false, serieID, estruturaReserva))
            {
                throw new BilheteriaException(string.Format("A quantidade disponivel para o preço \"{0}\" foi excedida.", preco.PrecoNome), Bilheteria.CodMensagemReserva.PrecoIndisponivel);
            }

            this.TxConv = oBilheteria.TaxaConveniencia(this.EventoID.Valor, preco.ID, estruturaReserva.CanalID);

            if (this.TxConv > 0)
            {
                this.TaxaProcessamentoValor = oBilheteria.ValorTaxaProcessamento(this.EventoID.Valor);
                if (this.TaxaProcessamentoValor > 0)
                {
                    this.TxConv = 0;
                }
            }
            //Aqui precisa fazer a validação, é cortesia??
            if (preco.Valor == 0 && TxConv == 0 && TaxaProcessamentoValor == 0)
            {
                cortesiaID = new Cortesia().CortesiaPadraoEvento(this.EventoID.Valor);
                if (cortesiaID <= 0)
                {
                    throw new Exception("Não possível encontrar a cortesia associada a este evento!");
                }

                this.CortesiaID.Valor = cortesiaID;
            }

            this.PrecoID.Valor = preco.ID;
            this.CotaItemID    = cotaInfo.CotaItemID;
            this.CotaItemIDAPS = cotaInfo.CotaItemID_APS;
            this.SerieID.Valor = serieID;
        }
Example #5
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();
            }
        }
Example #6
0
 // passar o Usuario logado no sistema
 public CotaItemLista_B(int usuarioIDLogado)
 {
     cotaItem = new CotaItem(usuarioIDLogado);
 }
Example #7
0
 // passar o Usuario logado no sistema
 public CotaItemLista_B()
 {
     cotaItem = new CotaItem();
 }