public async Task <List <Monedas> > ListarMonedas()
        {
            using (SportsGoEntities context = new SportsGoEntities(false))
            {
                PagosRepository pagosRepo    = new PagosRepository(context);
                List <Monedas>  listaMonedas = await pagosRepo.ListarMonedas();

                QueryMoneyExchanger exchanger        = new QueryMoneyExchanger();
                Monedas             monedaColombiana = listaMonedas.Where(x => x.MonedaEnum == MonedasEnum.PesosColombianos).FirstOrDefault();

                foreach (Monedas moneda in listaMonedas.Where(x => x.MonedaEnum != MonedasEnum.PesosColombianos))
                {
                    YahooExchangeEntity exchangeEntity = await exchanger.QueryMoneyExchange(monedaColombiana.AbreviaturaMoneda, moneda.AbreviaturaMoneda);

                    if (exchangeEntity != null)
                    {
                        moneda.CambioMoneda = exchangeEntity.Query.Results.Rate.Rate;
                    }
                }

                try
                {
                    // No es obligatorio para el paso que actualize el cambio de moneda
                    await context.SaveChangesAsync();
                }
                catch (Exception)
                {
                }

                return(listaMonedas);
            }
        }
        public async Task <List <HistorialPagosPersonasDTO> > ListarHistorialPagosDeUnaPersona(BuscadorDTO buscador)
        {
            using (SportsGoEntities context = new SportsGoEntities(false))
            {
                PagosRepository pagosRepo = new PagosRepository(context);
                List <HistorialPagosPersonasDTO> listaHistorialPagos = await pagosRepo.ListarHistorialPagosDeUnaPersona(buscador);

                if (listaHistorialPagos != null && listaHistorialPagos.Count > 0)
                {
                    Monedas monedaColombiana = await pagosRepo.BuscarMonedaColombiana();

                    Dictionary <MonedasEnum, string>  diccionarioAbreviaturas = listaHistorialPagos.Where(x => x.Monedas.MonedaEnum != MonedasEnum.PesosColombianos).Select(x => x.Monedas).DistinctBy(x => x.MonedaEnum).ToDictionary(x => x.MonedaEnum, x => x.AbreviaturaMoneda);
                    Dictionary <MonedasEnum, decimal> diccionarioCambios      = new Dictionary <MonedasEnum, decimal>();

                    QueryMoneyExchanger queryExchanger = new QueryMoneyExchanger();
                    foreach (MonedasEnum monedaParaConsultar in diccionarioAbreviaturas.Keys)
                    {
                        if (monedaParaConsultar != MonedasEnum.PesosColombianos)
                        {
                            YahooExchangeEntity exchangeEntity = await queryExchanger.QueryMoneyExchange(monedaColombiana.AbreviaturaMoneda, diccionarioAbreviaturas[monedaParaConsultar]);

                            Monedas monedaBuscada = await pagosRepo.BuscarMoneda(monedaParaConsultar);

                            if (exchangeEntity != null)
                            {
                                monedaBuscada.CambioMoneda = exchangeEntity.Query.Results.Rate.Rate;
                            }

                            diccionarioCambios.Add(monedaParaConsultar, monedaBuscada.CambioMoneda);
                        }
                        else
                        {
                            diccionarioCambios.Add(monedaParaConsultar, monedaColombiana.CambioMoneda);
                        }
                    }

                    DateTimeHelperNoPortable helper = new DateTimeHelperNoPortable();
                    foreach (HistorialPagosPersonasDTO historial in listaHistorialPagos)
                    {
                        if (historial.Monedas.MonedaEnum != MonedasEnum.PesosColombianos)
                        {
                            historial.Precio *= diccionarioCambios[historial.Monedas.MonedaEnum];
                        }

                        historial.FechaPago = helper.ConvertDateTimeFromAnotherTimeZone(buscador.ZonaHorariaGMTBase, helper.DifferenceBetweenGMTAndLocalTimeZone, historial.FechaPago);
                    }
                }

                try
                {
                    // No es obligatorio para el paso que actualize el cambio de moneda
                    await context.SaveChangesAsync();
                }
                catch (Exception)
                {
                }

                return(listaHistorialPagos);
            }
        }
        public async Task QueryMoneyExchanger_QueryMoneyExchange_ShouldQuery()
        {
            QueryMoneyExchanger queryExchanger = new QueryMoneyExchanger();

            YahooExchangeEntity entity = await queryExchanger.QueryMoneyExchange("COP", "USD");

            Assert.IsNotNull(entity);
        }
Example #4
0
        public async Task <List <PlanesDTO> > ListarPlanesPorIdioma(Planes planParaListar)
        {
            using (SportsGoEntities context = new SportsGoEntities(false))
            {
                PlanesRepository planRepository = new PlanesRepository(context);
                List <PlanesDTO> listaPlanes    = await planRepository.ListarPlanesPorIdioma(planParaListar);

                PagosRepository pagosRepo         = new PagosRepository(context);
                Monedas         monedaDeLaPersona = await pagosRepo.BuscarMonedaDeUnPais(planParaListar.CodigoPaisParaBuscarMoneda);

                if (monedaDeLaPersona.MonedaEnum != MonedasEnum.PesosColombianos)
                {
                    Monedas monedaColombiana = await pagosRepo.BuscarMonedaColombiana();

                    QueryMoneyExchanger queryExchanger = new QueryMoneyExchanger();
                    YahooExchangeEntity exchangeEntity = await queryExchanger.QueryMoneyExchange(monedaColombiana.AbreviaturaMoneda, monedaDeLaPersona.AbreviaturaMoneda);

                    Monedas monedaBuscada = await pagosRepo.BuscarMoneda(monedaDeLaPersona.MonedaEnum);

                    if (exchangeEntity != null)
                    {
                        monedaBuscada.CambioMoneda = exchangeEntity.Query.Results.Rate.Rate;
                    }

                    foreach (PlanesDTO planes in listaPlanes)
                    {
                        planes.Precio *= monedaBuscada.CambioMoneda;
                    }
                }

                try
                {
                    // No es obligatorio para el paso que actualize el cambio de moneda
                    await context.SaveChangesAsync();
                }
                catch (Exception)
                {
                }

                return(listaPlanes);
            }
        }
Example #5
0
        public async Task <PlanesUsuariosDTO> BuscarPlanUsuario(PlanesUsuarios planUsuarioParaBuscar)
        {
            using (SportsGoEntities context = new SportsGoEntities(false))
            {
                PlanesRepository  planRepository       = new PlanesRepository(context);
                PlanesUsuariosDTO planUsuarioExistente = await planRepository.BuscarPlanUsuario(planUsuarioParaBuscar);

                int?codigoUsuario = await planRepository.BuscarCodigoUsuarioPorCodigoPlanUsuario(planUsuarioExistente.Consecutivo);

                PagosRepository pagosRepo        = new PagosRepository(context);
                Monedas         monedaDelUsuario = await pagosRepo.BuscarMonedaDeUnUsuario(codigoUsuario.Value);

                if (monedaDelUsuario.MonedaEnum != MonedasEnum.PesosColombianos)
                {
                    Monedas monedaColombiana = await pagosRepo.BuscarMonedaColombiana();

                    QueryMoneyExchanger queryExchanger = new QueryMoneyExchanger();
                    YahooExchangeEntity exchangeEntity = await queryExchanger.QueryMoneyExchange(monedaColombiana.AbreviaturaMoneda, monedaDelUsuario.AbreviaturaMoneda);

                    if (exchangeEntity != null)
                    {
                        monedaDelUsuario.CambioMoneda = exchangeEntity.Query.Results.Rate.Rate;
                    }

                    planUsuarioExistente.Planes.Precio *= monedaDelUsuario.CambioMoneda;
                }

                try
                {
                    // No es obligatorio para el paso que actualize el cambio de moneda
                    await context.SaveChangesAsync();
                }
                catch (Exception)
                {
                }

                return(planUsuarioExistente);
            }
        }