Exemplo n.º 1
0
        /// <summary>
        ///1.Reserva a quantidade que tiver disponível para o vale ingresso
        ///2. Verifica se a quantidade reservada foi suficiente
        ///  2.1. Se for suficiente: finaliza e retorna a informação
        ///  2.2. Se não for suficiente: Vale tem quantidade limitada?
        ///      2.2.1. Sim: Não tem vir suficiente para a reserva
        ///     2.2.2. Não: Cria a quantidade de virs restante e reserva novamente
        /// </summary>
        /// <param name="bd"></param>
        public BindingList <EstruturaRetornoReservaValeIngresso> Reservar(CTLib.BD bd, int valeIngressoTipoID, int quantidadeReservar, int clienteID, int canalID, int lojaID, int usuarioID, string sessionID)
        {
            BD bdInserirVir = new BD();

            try
            {
                int quantidadeReservada = 0, quantidadeNaoReservada = 0;
                BindingList <EstruturaRetornoReservaValeIngresso> reserva = new BindingList <EstruturaRetornoReservaValeIngresso>();
                BindingList <EstruturaRetornoReservaValeIngresso> reservados;

                ValeIngressoTipo valeIngressoTipo = new ValeIngressoTipo();
                ValeIngresso     valeIngresso;
                valeIngressoTipo.Ler(valeIngressoTipoID);//Preenche as informações do tipo
                if (valeIngressoTipo.Control.ID == 0)
                {
                    throw new Exception("ValeIngresso inexistente");
                }

                if (string.IsNullOrEmpty(sessionID))
                {
                    reserva = this.Reservar(bd, quantidadeReservar, valeIngressoTipoID, canalID, lojaID, usuarioID, clienteID);
                }
                else
                {
                    reserva = this.ReservarInternet(bd, quantidadeReservar, valeIngressoTipoID, canalID, lojaID, usuarioID, clienteID, sessionID);
                }

                quantidadeReservada    = reserva.Count;
                quantidadeNaoReservada = quantidadeReservar - quantidadeReservada;

                //Verifica se a quantidade reservada foi suficiente.
                if (quantidadeReservada == quantidadeReservar)
                {
                    return(reserva);
                }
                else//Não conseguiu reservar tudo
                {
                    //O vale ingresso tem quantidade limitada?
                    if (valeIngressoTipo.QuantidadeLimitada.Valor)
                    {
                        return(reserva);
                    }
                    else
                    {//Se não tem quantidade limitada deve criar os vale ingressos restante
                        for (int i = 0; i < quantidadeNaoReservada; i++)
                        {
                            //preenche o objeto
                            valeIngresso = new ValeIngresso();
                            valeIngresso.ValeIngressoTipoID.Valor = valeIngressoTipoID;
                            valeIngresso.DataCriacao.Valor        = new DateTime(DateTime.Now.Year, DateTime.Now.Month, DateTime.Now.Day);
                            valeIngresso.Status.Valor             = ((char)ValeIngresso.enumStatus.Disponivel).ToString();
                            valeIngresso.UsuarioID.Valor          = usuarioID;

                            if (valeIngressoTipo.CodigoTrocaFixo.Valor.Length > 0)
                            {
                                //Codigo fixo. Todos devem ter todos os códigos
                                valeIngresso.CodigoTroca.Valor = valeIngressoTipo.CodigoTrocaFixo.Valor;
                            }
                            else
                            {
                                valeIngresso.CodigoTroca.Valor = string.Empty;
                            }

                            //Se der algum erro joga exception. e desfaz a transação de reserva.
                            valeIngresso.Inserir(bdInserirVir);
                        }
                        //Após Inserir tenta reservar os vales restantes
                        if (string.IsNullOrEmpty(sessionID))
                        {
                            reservados = this.Reservar(bd, quantidadeReservar, valeIngressoTipoID, canalID, lojaID, usuarioID, clienteID);
                        }
                        else
                        {
                            reservados = this.ReservarInternet(bd, quantidadeReservar, valeIngressoTipoID, canalID, lojaID, usuarioID, clienteID, sessionID);
                        }

                        foreach (EstruturaRetornoReservaValeIngresso item in reservados)
                        {
                            reserva.Add(item);
                        }
                    }
                }

                return(reserva);
            }
            catch (Exception)
            {
                throw;
            }
        }
Exemplo n.º 2
0
 // passar o Usuario logado no sistema
 public ValeIngressoLista_B()
 {
     valeIngresso = new ValeIngresso();
 }
Exemplo n.º 3
0
        public string[] ValidarCotaInformacoesNovo(EstruturaCotasInfo cotasInfo, string precoNome, int BIN, int formaPagamentoID, bool somenteVIR, bool somenteCortesias)
        {
            string[]         msgCota           = new string[2];
            CotaItemControle oCotaItemControle = new CotaItemControle();
            ValeIngresso     oValeIngresso     = new ValeIngresso();

            try
            {
                if (string.IsNullOrEmpty(msgCota[0]) && cotasInfo.ValidaBin)
                {
                    if (BIN == 0)
                    {
                        msgCota[0] = "1";

                        if (somenteVIR)
                        {
                            msgCota[1] = "Atenção, O preço: " + precoNome + " requer que o ingresso seja pago com um cartão válido para a promoção <br /> Não será possivel comprar somente com Vale Ingressos";
                        }

                        else
                        {
                            msgCota[1] = "Atenção, O preço: " + precoNome + " requer que o ingresso seja pago com um cartão válido para a promoção. <br /> Compras com Visa Electron, ItauShopLine e Somente Vale Ingressos não serão aceitas";
                        }
                    }
                    else if (!this.ValidarBin(BIN, cotasInfo.CotaItemID > 0 ? cotasInfo.CotaItemID : cotasInfo.CotaItemID_APS, cotasInfo.ParceiroID))
                    {
                        msgCota[0] = "1";
                        msgCota[1] = "Atenção, o BIN digitado não corresponde a um BIN válido para o preço: " + precoNome + ".";
                    }
                }

                if (string.IsNullOrEmpty(msgCota[0]))
                {
                    if (somenteVIR)
                    {
                        formaPagamentoID = oValeIngresso.FormaDePagamentoID;
                    }
                    else if (somenteCortesias)
                    {
                        return(msgCota);
                    }

                    if (!this.ValidarFormaPagamento(formaPagamentoID, cotasInfo.CotaItemID > 0 ? cotasInfo.CotaItemID : cotasInfo.CotaItemID_APS))
                    {
                        msgCota[0] = "2";

                        if (somenteVIR)
                        {
                            msgCota[1] = "A Forma de Pagamento Somente Vale Ingresso não é válida para o Preço: " + precoNome;
                        }
                        else
                        {
                            msgCota[1] = "A Forma de Pagamento selecionada é válida para o Preço: " + precoNome;
                        }
                    }
                }

                return(msgCota);
            }
            catch (Exception)
            {
                throw;
            }
        }
Exemplo n.º 4
0
        public bool SalvarValeIngresso(EstruturaValeIngressoWizard dadosSalvar)
        {
            ValeIngresso      valeIngresso;
            CanalValeIngresso canalValeIngresso;
            bool novoVirTipo = false;
            BD   bdDelete    = new BD();

            try
            {
                //td deve estar dentro de transaction
                bd.IniciarTransacao();
                bdDelete.IniciarTransacao();
                novoVirTipo = dadosSalvar.ValeIngressoTipo.ID == 0;

                //TODO: Fazer a validação dos dados. Inclusive usuarioID


                //Popula o objeto para salvar no banco
                this.Nome.Valor  = dadosSalvar.ValeIngressoTipo.Nome;
                this.Valor.Valor = dadosSalvar.ValeIngressoTipo.Valor;
                this.ValidadeDiasImpressao.Valor = dadosSalvar.ValeIngressoTipo.ValidadeDiasImpressao;
                if (this.ValidadeDiasImpressao.Valor == 0)
                {
                    this.ValidadeData.Valor = dadosSalvar.ValeIngressoTipo.ValidadeData;
                }
                this.CodigoTrocaFixo.Valor    = dadosSalvar.ValeIngressoTipo.CodigoTrocaFixo;
                this.ClienteTipo.Valor        = ((char)dadosSalvar.ValeIngressoTipo.ClienteTipo).ToString();
                this.ProcedimentoTroca.Valor  = dadosSalvar.ValeIngressoTipo.ProcedimentoTroca;
                this.SaudacaoPadrao.Valor     = dadosSalvar.ValeIngressoTipo.SaudacaoPadrao;
                this.SaudacaoNominal.Valor    = dadosSalvar.ValeIngressoTipo.SaudacaoNominal;
                this.QuantidadeLimitada.Valor = dadosSalvar.ValeIngressoTipo.QuantidadeLimitada;
                this.EmpresaID.Valor          = dadosSalvar.ValeIngressoTipo.EmpresaID;
                this.Acumulativo.Valor        = dadosSalvar.ValeIngressoTipo.Acumulativo;
                this.PublicarInternet.Valor   = dadosSalvar.ValeIngressoTipo.PublicarInternet;
                this.ReleaseInternet.Valor    = dadosSalvar.ValeIngressoTipo.ReleaseInternet;
                this.TrocaConveniencia.Valor  = dadosSalvar.ValeIngressoTipo.TrocaConveniencia;
                this.TrocaIngresso.Valor      = dadosSalvar.ValeIngressoTipo.TrocaIngresso;
                this.TrocaEntrega.Valor       = dadosSalvar.ValeIngressoTipo.TrocaEntrega;
                this.ValorTipo.Valor          = ((char)dadosSalvar.ValeIngressoTipo.ValorTipo).ToString();
                this.ValorPagamento.Valor     = dadosSalvar.ValeIngressoTipo.ValorPagamento;

                if (novoVirTipo)
                {//Inserir
                    this.Inserir(bd);
                    //Insere na tValeIngressoTipo
                }
                else
                {//Atualizar
                    this.Control.ID = dadosSalvar.ValeIngressoTipo.ID;
                    this.Atualizar(bd);
                }

                //Verifica a necessidade de inserir registros na tValeIngresso
                if (dadosSalvar.ValeIngressoTipo.QuantidadeLimitada)
                { //Inserir na tValeIngresso
                    for (int i = 0; i < dadosSalvar.AdicionarQuantidade; i++)
                    {
                        try
                        {
                            valeIngresso = new ValeIngresso();
                            valeIngresso.ValeIngressoTipoID.Valor = this.Control.ID;
                            valeIngresso.DataCriacao.Valor        = DateTime.Now;
                            valeIngresso.Status.Valor             = ((char)ValeIngresso.enumStatus.Disponivel).ToString();

                            if (dadosSalvar.ValeIngressoTipo.CodigoTrocaFixo != String.Empty)
                            {
                                //Codigo fixo. Todos devem ter todos os códigos
                                valeIngresso.CodigoTroca.Valor = dadosSalvar.ValeIngressoTipo.CodigoTrocaFixo;
                            }
                            else
                            {
                                valeIngresso.CodigoTroca.Valor = string.Empty;
                            }

                            valeIngresso.Inserir(bd);
                        }
                        catch
                        {
                            throw;
                        }
                    }
                }

                int canalInternet = Canal.CANAL_INTERNET;
                int canalCC       = Canal.CANAL_CALL_CENTER;
                //Atualiza os canais
                string sql = string.Empty;
                if (!novoVirTipo)
                {
                    //Verifica se deve remover ou inserir os canais ir (tirando call center e internet)
                    if (dadosSalvar.acaoCanaisIR == EnumAcaoCanais.Distribuir)
                    {
                        //Inserre todos os canais IR. Tirando Call Center e Internet
                        sql = "INSERT INTO tCanalValeIngresso (CanalID,ValeIngressoTipoID) " +
                              " SELECT c.ID, " + this.Control.ID + " FROM tCanal c (NOLOCK) " +
                              " LEFT JOIN tCanalValeIngresso vi (NOLOCK) ON vi.CanalID = c.ID AND vi.ValeIngressoTipoID =" + this.Control.ID +
                              " INNER JOIN tEmpresa e (NOLOCK) ON e.ID = c.EmpresaID " +
                              " WHERE (e.EmpresaVende = 'T' AND e.EmpresaPromove = 'F') AND vi.ID IS NULL AND c.ID NOT IN (" + canalInternet + "," + canalCC + ")";
                    }
                    else if (dadosSalvar.acaoCanaisIR == EnumAcaoCanais.Remover) // Remove somente os canais que não forem IR
                    {
                        sql = "DELETE cvir FROM tCanalValeIngresso AS cvir " +
                              "LEFT JOIN tCanal ON tCanal.ID = cvir.CanalID " +
                              "INNER JOIN tEmpresa ON tCanal.EmpresaID = tEmpresa.ID AND (tEmpresa.EmpresaVende = 'T' AND tEmpresa.EmpresaPromove = 'F') " +
                              "WHERE ValeIngressoTipoID = " + dadosSalvar.ValeIngressoTipo.ID + " AND tCanal.ID NOT IN (" + canalInternet + "," + canalCC + ")";
                    }
                    if (dadosSalvar.acaoCanaisIR != EnumAcaoCanais.Manter)
                    {
                        bd.Executar(sql);
                    }
                }
                //Distribui os canais próprios + Call Center e Internet
                foreach (EstruturaCanalValeIngresso canal in dadosSalvar.Canais)
                {
                    if (canal.acao == CanalValeIngresso.EnumAcaoCanal.Inserir)
                    {
                        canalValeIngresso = new CanalValeIngresso(usuarioIDLogado);
                        canalValeIngresso.CanalID.Valor            = canal.CanalID;
                        canalValeIngresso.ValeIngressoTipoID.Valor = this.Control.ID;
                        canalValeIngresso.Inserir(bd);
                    }
                    else if (canal.acao == CanalValeIngresso.EnumAcaoCanal.Remover)
                    {
                        canalValeIngresso                          = new CanalValeIngresso(usuarioIDLogado);
                        canalValeIngresso.Control.ID               = canal.CanalValeIngressoID;
                        canalValeIngresso.CanalID.Valor            = canal.CanalID;
                        canalValeIngresso.ValeIngressoTipoID.Valor = canal.ValeIngressoTipoID;
                        //Call Center e Internet
                        if (canal.CanalValeIngressoID == 0 && (canal.CanalID == canalInternet || canal.CanalID == canalCC))
                        {
                            canalValeIngresso.Excluir(canal.CanalID, canal.ValeIngressoTipoID, bd);
                        }
                        else
                        {
                            canalValeIngresso.Excluir(canalValeIngresso.Control.ID, bd);
                        }
                    }
                }

                bd.FinalizarTransacao();
                bdDelete.FinalizarTransacao();
                return(true);
            }
            catch (Exception)
            {
                bdDelete.DesfazerTransacao();
                bd.DesfazerTransacao();
                throw;
            }
            finally
            {
                bd.Fechar();
            }
        }
Exemplo n.º 5
0
        public void ValidarCotaInformacoes(int apresentacaoID, int setorID, EstruturaCotaItemReserva item, EstruturaPrecoReservaSite preco, int BIN, int formaPagamentoID, int clienteID, string sessionID, ref string[] msgCota, bool somenteVIR)
        {
            CotaItemControle oCotaItemControle = new CotaItemControle();
            ValeIngresso     oValeIngresso     = new ValeIngresso();

            try
            {
                int[] quantidades = new int[2] {
                    0, 0
                };
                int apresentacaoSetorID = new ApresentacaoSetor().ApresentacaoSetorID(apresentacaoID, setorID);
                quantidades = oCotaItemControle.getQuantidade(item.ID, apresentacaoID, apresentacaoSetorID);
                if (((quantidades[0] + preco.Quantidade > item.Quantidade || quantidades[1] + preco.Quantidade > item.Quantidade) && item.Quantidade != 0) ||
                    (quantidades[0] + preco.Quantidade > item.QuantidadeApresentacao && item.QuantidadeApresentacao != 0) ||
                    (quantidades[1] + preco.Quantidade > item.QuantidadeApresentacaoSetor && item.QuantidadeApresentacaoSetor != 0))
                {
                    msgCota[0] = "4";
                    msgCota[1] = "O Limite de venda do preço especial: " + preco.PrecoNome + " foi excedido";
                }
                if (string.IsNullOrEmpty(msgCota[0]) && item.ValidaBin)
                {
                    if (item.ValidaBin && BIN == 0)
                    {
                        msgCota[0] = "1";

                        if (somenteVIR)
                        {
                            msgCota[1] = "Atenção, O Preço: " + preco.PrecoNome + " requer que o ingresso seja pago com um cartão válido para a promoção <br /> Não será possivel comprar somente com Vale Ingressos";
                        }

                        else
                        {
                            msgCota[1] = "Atenção, O Preço: " + preco.PrecoNome + " requer que o ingresso seja pago com um cartão válido para a promoção. <br /> Compras com Visa Electron, ItauShopLine e Somente Vale Ingressos não serão aceitas";
                        }
                    }
                    else if (!this.ValidarBin(BIN, item.ID, item.ParceiroID))
                    {
                        msgCota[0] = "1";
                        msgCota[1] = "Atenção, o BIN do cartão digitado não corresponde a um BIN válido para o preço: " + preco.PrecoNome + ".";
                    }
                }
                else if (string.IsNullOrEmpty(msgCota[0]))
                {
                    if (somenteVIR)
                    {
                        formaPagamentoID = oValeIngresso.FormaDePagamentoID;
                    }
                    if (!this.ValidarFormaPagamento(formaPagamentoID, item.ID))
                    {
                        msgCota[0] = "2";

                        if (somenteVIR)
                        {
                            msgCota[1] = "A Forma de Pagamento Somente Vale Ingresso não é válida para o Preço: " + preco.PrecoNome;
                        }
                        else
                        {
                            msgCota[1] = "A Forma de Pagamento selecionada é válida para o Preço: " + preco.PrecoNome;
                        }
                    }
                }
            }
            catch (Exception)
            {
                throw;
            }
        }