Exemple #1
0
        public async Task <SumaryRatingDto> GetReviewByStoreId(int storeId, int currentPage, int pageSize)
        {
            var listComment = await _reviewRepository.GetReviewByStoreId(storeId);

            var listCommentDto = _mapper.Map <List <ReviewDto> >(listComment);

            var commentPaging = MakePaging.CommentDtoToPaging(listCommentDto, currentPage, pageSize);

            var result = new SumaryRatingDto();

            result.Collection  = commentPaging.Collection;
            result.CurrentPage = commentPaging.CurrentPage;
            result.TotalPage   = commentPaging.TotalPage;
            //result.SummaryRating = listComment.Count > 0 ? listComment[0].StoreModel.Rating.GetValueOrDefault() : 0;



            result.TotalOne   = commentPaging.Collection.Count(c => c.Rating == 1);
            result.TotalTwo   = commentPaging.Collection.Count(c => c.Rating == 2);
            result.TotalThree = commentPaging.Collection.Count(c => c.Rating == 3);
            result.TotalFour  = commentPaging.Collection.Count(c => c.Rating == 4);
            result.TotalFive  = commentPaging.Collection.Count(c => c.Rating == 5);


            var totalVote = result.TotalFive + result.TotalFour + result.TotalThree + result.TotalTwo + result.TotalOne;

            result.SummaryRating = (5 * (decimal)result.TotalFive + 4 * (decimal)result.TotalFour + 3 * (decimal)result.TotalThree + 2 * (decimal)result.TotalTwo + 1 * (decimal)result.TotalOne)
                                   / totalVote;

            return(result);
        }
        public async Task <BasePagingDto <YourStore> > GetYourStores(int ownerId, int currentPage, int pageSize)
        {
            var listStore = await _storeRepository.GetStoreByOwnerId(ownerId);

            var listStoreDto = _mapper.Map <List <YourStore> >(listStore);

            var result = MakePaging.YourStoreDtoToPaging(listStoreDto, currentPage, pageSize);

            return(result);
        }
        public async Task <BasePagingDto <StoreDto> > GetListStore(int currentPage, int pageSize)
        {
            var listStore = await _storeRepository.GetAll();

            var listStoreDto = _mapper.Map <List <StoreDto> >(listStore);

            var result = MakePaging.StoreDtoToPaging(listStoreDto, currentPage, pageSize);

            return(result);
        }
Exemple #4
0
        public async Task <BasePagingDto <FieldDto> > GetFieldByStoreId(int storeId, int currentPage, int pageSize)
        {
            var listStore = await _fieldRepository.GetByStoreId(storeId);

            var listFieldDto = _mapper.Map <List <FieldDto> >(listStore);

            var result = MakePaging.FieldDtotoToPaging(listFieldDto, currentPage, pageSize);

            return(result);
        }
Exemple #5
0
        public async Task <BasePagingDto <FieldDto> > GetFieldBySearch(SearchFieldRequest request, int currentPage, int pageSize)
        {
            var listField = await _fieldRepository.GetFieldBySearch(request);

            var listFieldDto = _mapper.Map <List <FieldDto> >(listField);

            var result = MakePaging.FieldDtotoToPaging(listFieldDto, currentPage, pageSize);

            return(result);
        }
        public async Task <BasePagingDto <ReservationDto> > GetReservationBySearch(int userId, SearchReservationRequest request, int currentPage, int pageSize)
        {
            var listReservation = await _reservationRepository.GetReservationBySearch(userId, request);

            var lisReservationDto = _mapper.Map <List <ReservationDto> >(listReservation);

            var result = MakePaging.ReservationDtoToPaging(lisReservationDto, currentPage, pageSize);

            return(result);
        }
        public async Task <BasePagingDto <ReservationDto> > GetYourReservation(int userId, int currentPage, int pageSize)
        {
            var reservations = await _reservationRepository.GetYourReservation(userId);

            var list = _mapper.Map <List <ReservationModel>, List <ReservationDto> >(reservations, opt =>
            {
                opt.AfterMap((src, dest) =>
                {
                    foreach (var d in dest)
                    {
                        d.Image = src[0].StoreModel.Image;
                    }
                });
            });
            var result = MakePaging.ReservationDtoToPaging(list, currentPage, pageSize);

            return(result);
        }
        public async Task <BasePagingDto <GrahpDto> > GraphYearReservation(int userId, int year, int currentPage, int pageSize)
        {
            var listStore = await _reservationRepository.GetYourReservation(userId);

            var result = new ObservableCollection <GrahpDto>();

            foreach (var data in listStore)
            {
                if (data.CreatedDate.Value.Year == year)
                {
                    result.Add(new GrahpDto
                    {
                        Days   = data.CreatedDate == null ? 0 : data.CreatedDate.Value.Day,
                        Months = data.CreatedDate == null ? 0 : data.CreatedDate.Value.Month,
                        Years  = data.CreatedDate == null ? 0 : data.CreatedDate.Value.Year
                    });;
                }
            }
            var listFieldDto = _mapper.Map <List <GrahpDto> >(result);

            var resultPaging = MakePaging.GraphDtoToPaging(listFieldDto, currentPage, pageSize);

            return(resultPaging);
        }