Esempio n. 1
0
        public async Task <PaginationModels <laptopModels> > GetLaptopAsync(SearchString search, int current = 1)
        {
            var movies = await _unitOfWork.Laptop.GetAllAsync();

            var product = _mapper.Map <IEnumerable <Laptop>, IEnumerable <laptopModels> >(movies);

            if (search.Name != "")
            {
                product = product.Where(a =>
                                        a.Nameproduct.ToLower().Contains(search.Name.ToLower()));
            }
            if (search.Manufacturer != "")
            {
                // int tmp = Int32.Parse(search.Manufacturer);
                product = product.Where(a =>
                                        a.Idmanufacturer.ToString().Contains(search.Manufacturer.ToLower()));
            }

            PaginationModels <laptopModels> _product = new PaginationModels <laptopModels>();
            int total = product.Count();

            _product.array     = product.Skip((current - 1) * _product.PageSize).Take <laptopModels>(_product.PageSize);
            _product.totalPage = (int)Math.Ceiling(total / (double)_product.PageSize);
            _product.count     = _product.array.Count();
            _product.current   = current;
            return(_product);
        }
Esempio n. 2
0
        public async Task <PaginationModels <cartdetailModels> > GetCartdetailAsync([FromQuery] SearchString search, int current = 1)
        {
            var cartdetal = await _unitOfWork.CartDetail.GetAllAsync();

            var cartdetails = _mapper.Map <IEnumerable <Cartdetail>, IEnumerable <cartdetailModels> >(cartdetal);

            PaginationModels <cartdetailModels> _cartdetail = new PaginationModels <cartdetailModels>();
            int total = cartdetails.Count();

            _cartdetail.array     = cartdetails.Skip((current - 1) * _cartdetail.PageSize).Take <cartdetailModels>(_cartdetail.PageSize);
            _cartdetail.totalPage = (int)Math.Ceiling(total / (double)_cartdetail.PageSize);
            _cartdetail.count     = _cartdetail.array.Count();
            _cartdetail.current   = current;
            return(_cartdetail);
        }
        public async Task <PaginationModels <cartModels> > GetCartAsync([FromQuery] searchString search, [FromQuery] Pagination pagination)
        {
            var movies = await _unitOfWork.Cart.GetAllAsync();

            var cart = _mapper.Map <IEnumerable <Cart>, IEnumerable <cartModels> >(movies);

            PaginationModels <cartModels> _cart = new PaginationModels <cartModels>();
            int total = cart.Count();

            _cart.array     = cart.Skip((pagination.Current - 1) * pagination.PageSize).Take <cartModels>(pagination.PageSize);
            _cart.totalPage = (int)Math.Ceiling(total / (double)pagination.PageSize);
            _cart.count     = _cart.array.Count();
            _cart.current   = pagination.Current;
            return(_cart);
        }
Esempio n. 4
0
        public async Task <PaginationModels <promotionModels> > GetPromotionAsync([FromQuery] searchString search, [FromQuery] Pagination pagination)
        {
            var promotion = await _unitOfWork.Promotion.GetAllAsync();

            var result = _mapper.Map <IEnumerable <Promotion>, IEnumerable <promotionModels> >(promotion);

            PaginationModels <promotionModels> _promotion = new PaginationModels <promotionModels>();
            int total = result.Count();

            _promotion.array     = result.Skip((pagination.Current - 1) * pagination.PageSize).Take <promotionModels>(pagination.PageSize);
            _promotion.totalPage = (int)Math.Ceiling(total / (double)pagination.PageSize);
            _promotion.count     = _promotion.array.Count();
            _promotion.current   = pagination.Current;
            return(_promotion);
        }
Esempio n. 5
0
        //
        // GET: /Admin/User/

        public ActionResult Index(int page = 1)
        {
            Title = "Quản trị tài khoản hệ thống";
            int pageSize    = this.systemSettingService.Get <int>("PageSizeAdmin", 10);
            var PagerModels = new PaginationModels
            {
                PageNumber   = page,
                PageSize     = pageSize,
                TotalRecords = userService.GetAllCount()
            };

            ViewData["PagerModels"] = PagerModels;
            IEnumerable <User> users = userService.GetAll(page, pageSize);

            return(View(users));
        }
Esempio n. 6
0
        public ActionResult Index(int?page)
        {
            //HomeModels homeModels = new HomeModels();
            var users = userRepository.Get();
            //homeModels.users = users;

            //var dummyItems = Enumerable.Range(1, 39).Select(x => "Item " + x);/*don't understad why it loop*/
            var dummyItems = Enumerable.Range(1, users.Count()).Select(x => users);
            var pager      = new Pager(dummyItems.Count(), page);

            var exampleModel = new PaginationModels
            {
                users = users.Skip((pager.CurrentPage - 1) * pager.PageSize).Take(pager.PageSize),
                Pager = pager
            };

            return(View(exampleModel));
        }
        public async Task <PaginationModels <productModels> > GetProductAsync([FromQuery] searchString search, [FromQuery] Pagination pagination)
        {
            var movies = await _unitOfWork.Product.GetAllAsync();

            var product = _mapper.Map <IEnumerable <Product>, IEnumerable <productModels> >(movies);

            if (search.Name != "")
            {
                product = product.Where(a =>
                                        a.Nameproduct.ToLower().Contains(search.Name.ToLower()));
            }

            PaginationModels <productModels> _product = new PaginationModels <productModels>();
            int total = product.Count();

            _product.array     = product.Skip((pagination.Current - 1) * pagination.PageSize).Take <productModels>(pagination.PageSize);
            _product.totalPage = (int)Math.Ceiling(total / (double)pagination.PageSize);
            _product.count     = _product.array.Count();
            _product.current   = pagination.Current;
            return(_product);
        }