public async Task <ActionResult> Index(int id)
        {
            HistorialPagosPersonasDTO historial = new HistorialPagosPersonasDTO
            {
                Consecutivo = id
            };

            PayUModel payModel = await _pagosService.ConfigurarPayU(historial);

            return(View(payModel));
        }
        public async Task PagosBusiness_ConfigurarPayU_ShouldConfigure()
        {
            PagosBusiness pagosBusiness = new PagosBusiness();

            HistorialPagosPersonas historial = new HistorialPagosPersonas
            {
                Consecutivo = 23
            };

            PayUModel payUModel = await pagosBusiness.ConfigurarPayU(historial);

            Assert.IsNotNull(payUModel);
        }
        public async Task <PayUModel> ConfigurarPayU(HistorialPagosPersonas pagoParaProcesar)
        {
            using (SportsGoEntities context = new SportsGoEntities(false))
            {
                PagosRepository pagosRepo = new PagosRepository(context);

                HistorialPagosPersonasDTO pagoBuscado = await pagosRepo.BuscarHistorialPagoPersona(pagoParaProcesar);

                if (pagoBuscado.EstadoDelPago != EstadoDeLosPagos.EsperaPago && pagoBuscado.EstadoDelPago != EstadoDeLosPagos.Rechazado)
                {
                    throw new InvalidOperationException("El pago no se puede procesar porque no esta en un estado valido");
                }

                string descripcion = string.Empty;
                switch (pagoBuscado.Personas.IdiomaDeLaPersona)
                {
                case Idioma.EspaƱol:
                    descripcion = "PayU Pago para el plan " + pagoBuscado.Planes.DescripcionIdiomaBuscado;
                    break;

                case Idioma.Ingles:
                    descripcion = "PayU Payment for plan " + pagoBuscado.Planes.DescripcionIdiomaBuscado;
                    break;

                case Idioma.Portugues:
                    descripcion = "PayU Plano de pagamento " + pagoBuscado.Planes.DescripcionIdiomaBuscado;
                    break;
                }

                HasherCryptoService <MD5Cng> hashingService = new HasherCryptoService <MD5Cng>();
                string signatureBuilder = AppConstants.PayUApiKey + "~" + AppConstants.PayUMerchantID + "~" + pagoBuscado.Consecutivo + "~" + Math.Round(pagoBuscado.Precio, 2, MidpointRounding.AwayFromZero).ToString().Replace(",", ".") + "~COP";

                PayUModel payUModel = new PayUModel
                {
                    merchantId    = AppConstants.PayUMerchantID,
                    accountId     = AppConstants.PayUAccountID,
                    tax           = 0,
                    taxReturnBase = 0,
                    test          = AppConstants.PayUTest,
                    Url           = AppConstants.PayUURL,
                    currency      = "COP",
                    amount        = pagoBuscado.Precio,
                    referenceCode = pagoBuscado.Consecutivo.ToString(),
                    buyerEmail    = pagoBuscado.Personas.Usuarios.Email,
                    description   = descripcion,
                    signature     = hashingService.GetStringHash(signatureBuilder)
                };

                return(payUModel);
            }
        }
Example #4
0
        public ActionResult PayUReq()
        {
            if (TempData["Membership"] == null)
            {
                return(null);
            }

            MembershipModel Membership = (MembershipModel)TempData["Membership"];
            PayUModel       Model      = new PayUModel(Membership.Email, Membership.Type, Membership.EMECI);
            PayUT           PayU       = new PayUT();

            PayU.AddTransaction(Membership, Model.referenceCode);
            TempData.Remove("Membership");

            return(PartialView(Model));
        }
Example #5
0
        public async Task <PayUModel> ConfigurarPayU(HistorialPagosPersonasDTO pagoParaProcesar)
        {
            if (pagoParaProcesar == null)
            {
                throw new ArgumentNullException("No puedes procesar el pago en PayU si pagoParaProcesar es nulo!.");
            }
            if (pagoParaProcesar.Consecutivo <= 0)
            {
                throw new ArgumentException("pagoParaProcesar vacio y/o invalido!.");
            }

            IHttpClient client = ConfigurarHttpClient();

            PayUModel payUModel = await client.PostAsync <HistorialPagosPersonasDTO, PayUModel> ("Pagos/ConfigurarPayU", pagoParaProcesar);

            return(payUModel);
        }
Example #6
0
        public async Task <IHttpActionResult> ConfigurarPayU(HistorialPagosPersonas pagoParaProcesar)
        {
            if (pagoParaProcesar == null || pagoParaProcesar.Consecutivo <= 0)
            {
                return(BadRequest("pagoParaProcesar vacio y/o invalido!."));
            }

            try
            {
                PayUModel payUModel = await _pagosBusiness.ConfigurarPayU(pagoParaProcesar);

                return(Ok(payUModel));
            }
            catch (Exception ex)
            {
                return(InternalServerError(ex));
            }
        }