Пример #1
0
        public async Task <PagedResult <BrandVm> > GetSizesPagings(GetBrandPagingRequest request)
        {
            //1. Select join
            var query = from p in _context.productBrand

                        select new { p };

            //2. filter
            if (!string.IsNullOrEmpty(request.Keyword))
            {
                query = query.Where(x => x.p.brandName.Contains(request.Keyword));
            }
            //3. Paging
            int totalRow = await query.CountAsync();

            var data = await query.Skip((request.PageIndex - 1) *request.PageSize)
                       .Take(request.PageSize)
                       .Select(x => new BrandVm()
            {
                IdBrand = x.p.idBrand,
                Name    = x.p.brandName,
                Details = x.p.brandDetail,
            }).ToListAsync();

            //4. Select and projection
            var pagedResult = new PagedResult <BrandVm>()
            {
                TotalRecords = totalRow,
                PageSize     = request.PageSize,
                PageIndex    = request.PageIndex,
                Items        = data
            };

            return(pagedResult);
        }
Пример #2
0
        public async Task <PagedResult <BrandVm> > GetBrandsPagings(GetBrandPagingRequest request)
        {
            var data = await GetAsync <PagedResult <BrandVm> >(
                $"/api/brands/paging?pageIndex={request.PageIndex}" +
                $"&pageSize={request.PageSize}" +
                $"&keyword={request.Keyword}&categoryId={request.BrandId}");

            return(data);
        }
Пример #3
0
        public async Task <PagedResult <BrandViewModel> > GetBrandPagings(GetBrandPagingRequest request)
        {
            var client = _httpClientFactory.CreateClient();

            client.BaseAddress = new Uri(_configuration["BaseAddress"]);
            var respone = await client.GetAsync($"/api/brand/paging?Keyword={request.Keyword}&pageIndex=" +
                                                $"{request.PageIndex}&pageSize={request.PageSize}");

            var body = await respone.Content.ReadAsStringAsync();

            var brand = JsonConvert.DeserializeObject <PagedResult <BrandViewModel> >(body);

            return(brand);
        }
Пример #4
0
        public async Task <IActionResult> Index(string keyword, int pageIndex = 1, int pageSize = 15)
        {
            var request = new GetBrandPagingRequest()
            {
                Keyword   = keyword,
                PageIndex = pageIndex,
                PageSize  = pageSize,
            };
            var data = await _brandApiClient.GetBrandPagings(request);

            ViewBag.Keyword = keyword;
            if (TempData["result"] != null)
            {
                ViewBag.SuccessMsg = TempData["result"];
            }
            if (TempData["error"] != null)
            {
                ViewBag.ErrorMsg = TempData["error"];
            }
            return(View(data));
        }
Пример #5
0
        public async Task <IActionResult> Index(string keyword, int pageIndex = 1, int pageSize = 10)
        {
            var languageId = HttpContext.Session.GetString(SystemConstants.AppSettings.DefaultLanguageId);

            var sessions = HttpContext.Session.GetString("Token");
            var request  = new GetBrandPagingRequest()
            {
                Keyword    = keyword,
                PageIndex  = pageIndex,
                PageSize   = pageSize,
                LanguageId = languageId
            };
            var data = await _brandApiClient.GetBrandsPagings(request);

            ViewBag.Keyword = keyword;
            if (TempData["result"] != null)
            {
                ViewBag.SuccessMsg = TempData["result"];
            }

            return(View(data));
        }
Пример #6
0
        public async Task <PagedResult <BrandViewModel> > GetAllPaging(GetBrandPagingRequest request)
        {
            var query = from brand in _context.Brands
                        where brand.isDelete == false
                        select brand;

            if (!String.IsNullOrEmpty(request.Keyword))
            {
                query = query.Where(x => x.brand_name.Contains(request.Keyword));
            }

            int totalRow = await query.CountAsync();

            var data = query.OrderByDescending(m => m.create_at)
                       .Skip((request.PageIndex - 1) * request.PageSize)
                       .Take(request.PageSize)
                       .Select(a => new BrandViewModel()
            {
                id                = a.id,
                brand_name        = a.brand_name,
                brand_slug        = a.brand_slug,
                meta_descriptions = a.meta_descriptions,
                meta_keywords     = a.meta_keywords,
                meta_title        = a.meta_title,
                isActive          = a.isActive,
            }).ToListAsync();

            var pageResult = new PagedResult <BrandViewModel>()
            {
                TotalRecords = totalRow,
                PageIndex    = request.PageIndex,
                PageSize     = request.PageSize,
                Items        = await data,
            };

            return(pageResult);
        }
Пример #7
0
        public async Task <IActionResult> GetAllPaging([FromQuery] GetBrandPagingRequest requet)
        {
            var customer = await _brandService.GetAllPaging(requet);

            return(Ok(customer));
        }
Пример #8
0
        public async Task <IActionResult> GetAllPaging([FromQuery] GetBrandPagingRequest request)
        {
            var brands = await _brandService.GetSizesPagings(request);

            return(Ok(brands));
        }