public override async Task <IEnumerable <CurrencyDTO> > Get(CurrencyFilterDTO filteringModel)
        {
            filteringModel.WithHistory = true;
            var currencies = (await _wrappedCurrencyService.Get(filteringModel)).ToList();

            if (filteringModel.WithHistory == false)
            {
                return(currencies);
            }

            var previousCurrencies = new List <CurrencyArchive>();

            foreach (var currency in currencies)
            {
                var currencyArchive = await _unitOfWork.GetRepository <ICurrencyArchiveRepository>().GetPreviousCurrencyChange(currency.Id, currency.CityId);

                if (currencyArchive != null)
                {
                    currency.CurrencyTrending = currency.Rate > currencyArchive.Rate ? CurrencyTrending.Down :
                                                currency.Rate < currencyArchive.Rate ? CurrencyTrending.Up : CurrencyTrending.NotChanged;
                }
            }

            return(currencies);
        }
        public async Task <IEnumerable <Currency> > Get(CurrencyFilterDTO filteringModel)
        {
            var query = FilterCurrencies(filteringModel);

            query = query.Include(c => c.City);
            return(await query.ToListAsync());
        }
        private IQueryable <Currency> FilterCurrencies(CurrencyFilterDTO filteringModel)
        {
            var query = _currencyExchangeContext.Set <Currency>().AsQueryable();

            if (filteringModel == null)
            {
                return(query);
            }

            if (!string.IsNullOrWhiteSpace(filteringModel.SearchTerm))
            {
                var trimmedSearchTerm = filteringModel.SearchTerm.Trim();
                query = query.Where(c =>
                                    c.CurrencyCode.Contains(trimmedSearchTerm, StringComparison.InvariantCultureIgnoreCase) ||
                                    c.CurrencyName.Contains(trimmedSearchTerm, StringComparison.InvariantCultureIgnoreCase));
            }
            if (filteringModel.CityId.HasValue && filteringModel.CityId.Value > 0)
            {
                query = query.Where(c => c.CityId == filteringModel.CityId.Value);
            }
            if (filteringModel.CurrencyDate.HasValue && filteringModel.CurrencyDate.Value > DateTime.MinValue)
            {
                query = query.Where(c => c.ChangeTime == filteringModel.CurrencyDate);
            }
            return(query);
        }
        public virtual async Task <IEnumerable <CurrencyDTO> > Get(CurrencyFilterDTO filteringModel)
        {
            var currencies = await _unitOfWork.GetRepository <ICurrencyRepository>().Get(filteringModel);

            var result = _mapper.Map <IEnumerable <CurrencyDTO> >(currencies);

            return(result);
        }
示例#5
0
        public async Task <IActionResult> Get([FromQuery] CurrencyFilterDTO filter)
        {
            var result = await _currencyService.Get(filter);

            return(new JsonResult(result));
        }