Exemple #1
0
        public async Task <ActionResult <PetsitterDTO[]> > GetPetsittersBySearchParameters
            ([FromQuery] PetsittersSearchParameters petsittersSearchParameters)
        {
            try
            {
                var petsittersFiltered = await _petsitterRepository
                                         .GetAllPetsittersBySearchParametersAsync(petsittersSearchParameters);


                var listPetsittersDto = _mapper.Map <PetsitterDTO[]>(petsittersFiltered);

                foreach (var petsitter in listPetsittersDto)
                {
                    petsitter.Price = petsittersFiltered
                                      .FirstOrDefault(p => p.Id == petsitter.Id)
                                      .Services
                                      .FirstOrDefault(s => (int)s.Name == petsittersSearchParameters.ServiceId)
                                      .Price;
                }
                return(Ok(listPetsittersDto));
            }
            catch (Exception ex)
            {
                return(NotFound("There are no petsitters to show"));
            }
        }
        public async Task <IEnumerable <Petsitter> > GetAllPetsittersBySearchParametersAsync(
            PetsittersSearchParameters petsittersSearchParameters)
        {
            if (petsittersSearchParameters == null)
            {
                throw new ArgumentNullException(nameof(petsittersSearchParameters));
            }

            //filtering by City and ServiceId
            if (string.IsNullOrWhiteSpace(petsittersSearchParameters.Street) &&
                petsittersSearchParameters.MaxPrice.Equals(Int32.MaxValue) &&
                petsittersSearchParameters.MinPrice.Equals(0))
            {
                var conditionCity = petsittersSearchParameters.City.Trim();

                var query = _context.Petsitters
                            .AsQueryable()
                            .Include(p => p.Services)
                            .Include(p => p.Coordinates)
                            .Where(p => p.City.Contains(conditionCity))
                            .Where(p => p.Services
                                   .All(s => (int)s.Name == petsittersSearchParameters.ServiceId))
                            .ToListAsync();

                return(await query);
            }

            //filtering by City, ServiceId and Price
            if (string.IsNullOrWhiteSpace(petsittersSearchParameters.Street))
            {
                var conditionCity = petsittersSearchParameters.City.Trim();

                var query = _context.Petsitters
                            .AsQueryable()
                            .Include(p => p.Services)
                            .Include(p => p.Coordinates)
                            .Where(p => p.City.Contains(conditionCity))
                            .Where(p => p.Services
                                   .All(s => (int)s.Name == petsittersSearchParameters.ServiceId))
                            .Where(p => p.Services
                                   .All(s => s.Price >= petsittersSearchParameters.MinPrice))
                            .Where(p => p.Services
                                   .All(s => s.Price <= petsittersSearchParameters.MaxPrice))
                            .ToListAsync();
                return(await query);
            }

            //filtering by City, ServiceId, street
            if (!string.IsNullOrWhiteSpace(petsittersSearchParameters.Street) &&
                petsittersSearchParameters.MaxPrice.Equals(Int32.MaxValue) &&
                petsittersSearchParameters.MinPrice.Equals(0))
            {
                var conditionCity   = petsittersSearchParameters.City.Trim();
                var conditionStreet = petsittersSearchParameters.Street.Trim();

                var query = _context.Petsitters
                            .AsQueryable()
                            .Include(p => p.Services)
                            .Include(p => p.Coordinates)
                            .Where(p => p.City == conditionCity)
                            .Where(p => p.Street.Contains(conditionStreet))
                            .Where(p => p.Services
                                   .All(s => (int)s.Name == petsittersSearchParameters.ServiceId))
                            .ToListAsync();

                return(await query);
            }

            //filtering by City, SerrviceId, Street and  Prices
            if (!string.IsNullOrWhiteSpace(petsittersSearchParameters.Street))
            {
                var conditionCity   = petsittersSearchParameters.City.Trim();
                var conditionStreet = petsittersSearchParameters.Street.Trim();

                var query = _context.Petsitters
                            .AsQueryable()
                            .Include(p => p.Services)
                            .Include(p => p.Coordinates)
                            .Where(p => p.City.Contains(conditionCity))
                            .Where(p => p.Street.Contains(conditionStreet))
                            .Where(p => p.Services
                                   .All(s => (int)s.Name == petsittersSearchParameters.ServiceId))
                            .Where(p => p.Services
                                   .All(s => s.Price >= petsittersSearchParameters.MinPrice))
                            .Where(p => p.Services
                                   .All(s => s.Price <= petsittersSearchParameters.MaxPrice))
                            .ToListAsync();
                return(await query);
            }
            else
            {
                return(await GetAllAsync());
            }
        }
Exemple #3
0
        public async Task <ActionResult <PagedResponse <PetsitterDTO[]> > > GetPettsittersWithPaging([FromQuery] PagingParameters parameters, [FromQuery] PetsittersSearchParameters petsittersSearchParameters)
        {
            try
            {
                var validParameter = new PagingParameters(parameters.PageNumber, parameters.PageSize);

                var petsittersFilteredByParameter = await _petsitterRepository
                                                    .GetAllPetsittersBySearchParametersAsync(petsittersSearchParameters);

                var listPetsittersToReturn = _mapper.Map <PetsitterDTO[]>(petsittersFilteredByParameter);

                var pagedData = listPetsittersToReturn
                                .Skip((validParameter.PageNumber - 1) * validParameter.PageSize)
                                .Take(validParameter.PageSize)
                                .ToArray();

                var totalRecords = petsittersFilteredByParameter.Count();


                return(Ok(new PagedResponse <PetsitterDTO[]>(pagedData, validParameter.PageNumber,
                                                             validParameter.PageSize)));
            }

            catch (Exception ex)
            {
                return(StatusCode(500, "Internal server error"));
            }
        }