Пример #1
0
        public void EnvioEmailCancelamentoMassa(tCancelamentoLoteFila item, string atendente, string formaDevolucao)
        {
            IngressoBO         iBO       = new IngressoBO();
            CancelamentoLoteBO cBO       = new CancelamentoLoteBO();
            List <tIngresso>   ingressos = iBO.Listar(item.Ingressos.Select(x => x.IngressoID).ToList());

            List <CancelamentoLoteMailModel> mailModel = ado.CarregarCamposEmail(item.VendaBilheteriaID);

            string motivo = cBO.Consultar(item.CancelamentoLoteID).MotivoCancelamento;

            MailServiceSoapClient service      = new MailServiceSoapClient();
            ArrayOfString         codIngressos = new ArrayOfString();

            codIngressos.AddRange(ingressos.Select(x => string.Format("<li>Ingresso: {0} - Evento: {1} - Data: {2}</li>",
                                                                      x.Codigo,
                                                                      (x.tEvento != null) ? x.tEvento.Nome : string.Empty,
                                                                      (x.tApresentacao != null) ? x.tApresentacao.HorarioAsDateTime.ToString("dd/MM/yyyy HH:mm") : string.Empty)
                                                   ).ToList());
            service.EnviarEmailCancelamentoMassa(mailModel[0].Cliente, mailModel[0].Email, mailModel[0].Senha, atendente, mailModel[0].Data.ToString("dd/MM/yyyy HH:mm"), mailModel[0].Canal, string.Join(",", mailModel.Select(x => x.Pagamento).ToList()), mailModel[0].Evento, motivo, formaDevolucao, codIngressos, mailModel[0].DescricaoEmail);
        }
Пример #2
0
        public void ExecutaCancelamentoAutomatico(enumOperacoesCancelamento Operacao, tCancelamentoLoteFila item, int caixaID, int empresaID, int localID, int usuarioID)
        {
            IngressoBO iBO = new IngressoBO();

            CTLib.BD              db                    = new CTLib.BD();
            DbTransaction         dbtrans               = null;
            List <int>            lstIngressosIDs       = null;
            List <tIngresso>      lstIngressos          = null;
            CancelamentoIngressos cancelamento          = new CancelamentoIngressos();
            EstruturaCancelamento dadosCancelamento     = null;
            CancelamentoLoteModel cancelamentoLoteModel = new CancelamentoLoteModel();

            try
            {
                #region Inicia Transação DB
                db.Cnn  = ado.con.conIngresso;
                dbtrans = ado.con.conIngresso.BeginTransaction();
                db.DefinnirEmTransacao(true, dbtrans);

                #endregion

                lstIngressosIDs = item.Ingressos.Select(x => x.IngressoID).ToList();
                lstIngressos    = iBO.Listar(lstIngressosIDs);

                #region Resolução de pendencias
                if (ado.TemCancelamentoPendente(dbtrans, item.VendaBilheteriaID, lstIngressos))
                {
                    List <int> cancelados = new List <int>();
                    List <CancelamentoLoteIngressoPendenteDados> lstIngressosParaPendencia = new List <CancelamentoLoteIngressoPendenteDados>();

                    //Pegar lista de Ingresso pendentes
                    List <CancelamentoLoteIngressoPendente> lstIngressosPendentes = ado.ListarIngressosCancelamentoPendente(dbtrans, item.VendaBilheteriaID, lstIngressos);

                    //Executa cancelamento das pendencias
                    foreach (CancelamentoLoteIngressoPendente pendente in lstIngressosPendentes)
                    {
                        if (!cancelados.Contains(pendente.PendenciaID))
                        {
                            dadosCancelamento = cancelamento.CarregaDadosCancelamento(pendente.PendenciaID);
                            cancelados.Add(pendente.PendenciaID);

                            //TODO: validar dados da Devolucao
                            dadosCancelamento.CaixaIDDevolucao   = caixaID;
                            dadosCancelamento.CanalIDDevolucao   = item.CanalID;
                            dadosCancelamento.EmpresaIDDevolucao = empresaID;
                            dadosCancelamento.LocalIDDevolucao   = localID;
                            dadosCancelamento.LojaIDDevolucao    = item.LojaID;
                            dadosCancelamento.UsuarioIDDevolucao = usuarioID;

                            //Cancela a solicitação pendente
                            cancelamento.CancelarSolicitacao(dadosCancelamento, pendente.PendenciaID, db);
                        }

                        //Se o ingresso pendente nao esta na lista de ingressos para cancelar,
                        //este deve ser colocado em pendente novamente
                        if (!lstIngressosIDs.Contains(pendente.IngressoID))
                        {
                            lstIngressosParaPendencia.Add(new CancelamentoLoteIngressoPendenteDados()
                            {
                                IngressoID        = pendente.IngressoID,
                                PendenciaID       = pendente.PendenciaID,
                                DadosCancelamento = dadosCancelamento
                            });
                        }
                    }

                    //percorre lista de ingressos que devem ficar com cancelamento pendente
                    foreach (int pendeteID in lstIngressosParaPendencia.Select(p => p.PendenciaID).Distinct().ToList())
                    {
                        CancelamentoLoteIngressoPendenteDados pend = lstIngressosParaPendencia.Where(p => p.PendenciaID == pendeteID).FirstOrDefault();

                        #region Carrega a estrutura de cancelamento dos ingressos
                        //TODO: validar dados da Devolucao
                        cancelamentoLoteModel.CaixaID   = caixaID;
                        cancelamentoLoteModel.LojaID    = item.LojaID;
                        cancelamentoLoteModel.LocalID   = localID;
                        cancelamentoLoteModel.CanalID   = item.CanalID;
                        cancelamentoLoteModel.EmpresaID = empresaID;

                        cancelamentoLoteModel.EstornarConveniencia = pend.DadosCancelamento.ValorConvenienciaEstornada > 0;
                        cancelamentoLoteModel.EstornarEntrega      = pend.DadosCancelamento.ValorEntregaEstornado > 0;
                        cancelamentoLoteModel.EstornarSeguro       = pend.DadosCancelamento.ValorSeguroEstornado > 0;

                        cancelamentoLoteModel.TemDevolucao = true;

                        cancelamentoLoteModel.MotivoCancelamento    = pend.DadosCancelamento.MotivoCancelamento;
                        cancelamentoLoteModel.SubMotivoCancelamento = pend.DadosCancelamento.SubMotivoCancelamento;

                        cancelamentoLoteModel.UsuarioID    = usuarioID;
                        cancelamentoLoteModel.SupervisorID = usuarioID;

                        cancelamentoLoteModel.TipoCancelamento = pend.DadosCancelamento.TipoCancelamento;
                        cancelamentoLoteModel.FormaDevolucao   = pend.DadosCancelamento.FormaDevolucao;

                        cancelamentoLoteModel.dadosBancarios     = pend.DadosCancelamento.DadosDeposito;
                        cancelamentoLoteModel.dadosCartaoCredito = pend.DadosCancelamento.DadosEstornoCC;

                        cancelamentoLoteModel.IngressosID = lstIngressosParaPendencia.Where(p => p.PendenciaID == pendeteID).Select(p => p.IngressoID).ToList();
                        #endregion

                        //Carrega a estrutura de cancelamento dos ingressos
                        pend.DadosCancelamento = CarregarEstruturaCancelamento(cancelamentoLoteModel, dbtrans, db);

                        //Efetua a solicitação do Cancelamento
                        cancelamento.SolicitarCancelamento(pend.DadosCancelamento, db);
                    }
                }
                #endregion

                #region Carrega a estrutura de cancelamento dos ingressos
                //TODO: validar dados da Devolucao
                cancelamentoLoteModel.CaixaID   = caixaID;
                cancelamentoLoteModel.LojaID    = item.LojaID;
                cancelamentoLoteModel.LocalID   = localID;
                cancelamentoLoteModel.CanalID   = item.CanalID;
                cancelamentoLoteModel.EmpresaID = empresaID;

                cancelamentoLoteModel.EstornarConveniencia = true;
                cancelamentoLoteModel.EstornarEntrega      = ado.EstornarEntrega(dbtrans, item.VendaBilheteriaID, item.Ingressos.Count);
                cancelamentoLoteModel.EstornarSeguro       = true;

                cancelamentoLoteModel.TemDevolucao = false;

                cancelamentoLoteModel.MotivoCancelamento    = CancelEventoCancelado;
                cancelamentoLoteModel.SubMotivoCancelamento = 0;

                cancelamentoLoteModel.UsuarioID    = usuarioID;
                cancelamentoLoteModel.SupervisorID = usuarioID;

                cancelamentoLoteModel.TipoCancelamento = EstruturaCancelamento.enuTipoCancelamento.Normal;
                cancelamentoLoteModel.FormaDevolucao   = Operacao == enumOperacoesCancelamento.OperacaoE ?
                                                         EstruturaCancelamento.enuFormaDevolucao.PayPal :
                                                         EstruturaCancelamento.enuFormaDevolucao.EstornoCC;

                cancelamentoLoteModel.dadosBancarios = null;

                CancelamentoLoteDadosCliente cliente = ado.CarregarDadosCliente(dbtrans, item.VendaBilheteriaID);
                if (Operacao == enumOperacoesCancelamento.OperacaoE)
                {
                    cancelamentoLoteModel.dadosCartaoCredito = new EstruturaCancelamento.EstruturaDevolucaoEstornoCC()
                    {
                        Bandeira      = "Paypal",
                        Email         = cliente.Email,
                        NumeroCartao  = "Paypal",
                        TitularCartao = cliente.Nome,
                        TitularCPF    = cliente.CPF
                    };
                }
                else
                {
                    cancelamentoLoteModel.dadosCartaoCredito = new EstruturaCancelamento.EstruturaDevolucaoEstornoCC()
                    {
                        Bandeira      = cliente.Bandeira,
                        Email         = cliente.Email,
                        NumeroCartao  = cliente.Cartao,
                        TitularCartao = cliente.Nome,
                        TitularCPF    = cliente.CPF
                    };
                }

                cancelamentoLoteModel.IngressosID = lstIngressosIDs;
                #endregion

                //Carrega a estrutura de cancelamento dos ingressos
                dadosCancelamento = CarregarEstruturaCancelamento(cancelamentoLoteModel, dbtrans, db);

                if (Operacao == enumOperacoesCancelamento.OperacaoE)
                {
                    #region Executa estorno Paypal
                    IRLib.PayPal.CancelaPayPal          paypal = new IRLib.PayPal.CancelaPayPal();
                    IRLib.VendaBilheteriaFormaPagamento vbfp   = new IRLib.VendaBilheteriaFormaPagamento();

                    vbfp.LerPorVendaBilheteriaID(db, item.VendaBilheteriaID);
                    if (vbfp.Valor.Valor == dadosCancelamento.ValorEstornoTotal)
                    {
                        if (paypal.RefundPayPal(vbfp.TransactionID.Valor))
                        {
                            dadosCancelamento.EstornoEfetuado = true;
                        }
                        else
                        {
                            throw new Exception("Falha ao executar estorno com PayPal.");
                        }
                    }
                    else
                    {
                        if (paypal.RefundPartial(vbfp.TransactionID.Valor, dadosCancelamento.ValorEstornoTotal))
                        {
                            dadosCancelamento.EstornoEfetuado = true;
                        }
                        else
                        {
                            throw new Exception("Falha ao executar estorno parcial com PayPal.");
                        }
                    }
                    #endregion
                }

                //Efetua a solicitação do Cancelamento
                cancelamento.SolicitarCancelamento(dadosCancelamento, db);

                dbtrans.Commit();
            }
            catch (Exception ex)
            {
                if (dbtrans != null)
                {
                    dbtrans.Rollback();
                }

                throw ex;
            }
            finally
            {
                db.DefinnirEmTransacao(false);
            }
        }