Пример #1
0
        public void CanShowCustomPreviousPageText()
        {
            const string previousPageText = "Backward";

            _sut.Info             = _metaData.GetMetaData(10, 10, 1);
            _sut.PreviousPageText = previousPageText;

            _sut.Process(_context, _output);
            var markupResult = _output.Content.GetContent();

            Assert.Contains(previousPageText, markupResult);
        }
        public IActionResult Index(ProductFilter filter = null)
        {
            try
            {
                var courses = _productRepo.getQueryable();

                if (!string.IsNullOrWhiteSpace(filter.title))
                {
                    courses = courses.Where(a => a.name.Contains(filter.title));
                }

                ViewBag.pagerInfo = _paginatedMetaService.GetMetaData(courses.Count(), filter.page, filter.number_of_rows);


                courses = courses.Skip(filter.number_of_rows * (filter.page - 1)).Take(filter.number_of_rows);

                var coursesDetails = courses.ToList();

                CourseIndexViewModel productIndexVM = getProductIndexVM(coursesDetails);

                return(View(productIndexVM));
            }
            catch (Exception ex)
            {
                AlertHelper.setMessage(this, ex.Message, messageType.error);
                return(Redirect("/admin"));
            }
        }
        public IActionResult Index(CareerFilter filter = null)
        {
            try
            {
                var careers = _careerRepo.getQueryable();

                if (!string.IsNullOrWhiteSpace(filter.title))
                {
                    careers = careers.Where(a => a.title.Contains(filter.title));
                }

                careers = careers.Where(a => a.opening_date >= filter.from_date && a.opening_date <= filter.to_date);

                ViewBag.pagerInfo = _paginatedMetaService.GetMetaData(careers.Count(), filter.page, filter.number_of_rows);


                careers = careers.Skip(filter.number_of_rows * (filter.page - 1)).Take(filter.number_of_rows);

                return(View(careers.ToList()));
            }
            catch (Exception ex)
            {
                AlertHelper.setMessage(this, ex.Message, messageType.error);
                return(Redirect("/admin"));
            }
        }
Пример #4
0
        public IActionResult Index(EventFilter filter = null)
        {
            try
            {
                var events = _eventRepository.getQueryable();

                if (!string.IsNullOrWhiteSpace(filter.title))
                {
                    events = events.Where(a => a.title.Contains(filter.title));
                }


                ViewBag.pagerInfo = _paginatedMetaService.GetMetaData(events.Count(), filter.page, filter.number_of_rows);


                events = events.Skip(filter.number_of_rows * (filter.page - 1)).Take(filter.number_of_rows);

                var eventDetails = events.ToList();

                var eventlIndexVM = getViewModelFrom(eventDetails);
                return(View(eventlIndexVM));
            }
            catch (Exception ex)
            {
                AlertHelper.setMessage(this, ex.Message, messageType.error);
                return(Redirect("/admin"));
            }
        }
Пример #5
0
        public IActionResult Index(ExamTermFilter filter = null)
        {
            try
            {
                var examterm = _examTermRepository.getQueryable();

                if (!string.IsNullOrWhiteSpace(filter.title))
                {
                    examterm = examterm.Where(a => a.name.Contains(filter.title));
                }


                ViewBag.pagerInfo = _paginatedMetaService.GetMetaData(examterm.Count(), filter.page, filter.number_of_rows);


                examterm = examterm.Skip(filter.number_of_rows * (filter.page - 1)).Take(filter.number_of_rows);

                return(View(examterm.ToList()));
            }
            catch (Exception ex)
            {
                AlertHelper.setMessage(this, ex.Message, messageType.error);
                return(Redirect("/admin"));
            }
        }
Пример #6
0
        public IActionResult Index(UserFilter filter = null)
        {
            try
            {
                var users = _userRepo.getQueryable();

                if (!string.IsNullOrWhiteSpace(filter.name))
                {
                    users = users.Where(a => a.full_name.Contains(filter.name));
                }

                ViewBag.pagerInfo = _paginatedMetaService.GetMetaData(users.Count(), filter.page, filter.number_of_rows);


                users = users.Skip(filter.number_of_rows * (filter.page - 1)).Take(filter.number_of_rows);

                var userDetails = users.ToList();

                UserIndexViewModel userIndexVM = getUserIndexVMFromUserList(userDetails);

                return(View(userIndexVM));
            }
            catch (Exception ex)
            {
                AlertHelper.setMessage(this, ex.Message, messageType.error);
                return(Redirect("/home"));
            }
        }
        public IActionResult Index(VideoFilter filter = null)
        {
            var videos = _videoRepository.getQueryable().Where(a => a.is_enabled == true);

            ViewBag.pagerInfo = _paginatedMetaService.GetMetaData(videos.Count(), filter.page, 5);
            videos            = videos.Skip(filter.number_of_rows * (filter.page - 1)).Take(5);
            ViewBag.events    = videos.ToList();
            return(View(videos.ToList()));
        }
        public IActionResult Index(BlogFilter filter = null)
        {
            var blogs = _blogRepo.getQueryable().Where(a => a.is_enabled == true);

            ViewBag.pagerInfo = _paginatedMetaService.GetMetaData(blogs.Count(), filter.page, 5);

            blogs = blogs.Skip(filter.number_of_rows * (filter.page - 1)).Take(filter.number_of_rows);

            return(View(blogs.ToList()));
        }
Пример #9
0
        public IActionResult Index(EventFilter filter = null)
        {
            var testimonialValues = _testimonialRepo.getQueryable().ToList();

            ViewBag.testimonial = testimonialValues;
            var events = _eventRepo.getQueryable().Where(a => a.is_closed == false);

            ViewBag.pagerInfo = _paginatedMetaService.GetMetaData(events.Count(), filter.page, 5);
            events            = events.Skip(filter.number_of_rows * (filter.page - 1)).Take(5);
            return(View(events.OrderByDescending(a => a.event_to_date).ToList()));
        }
Пример #10
0
        public IActionResult Index(NoticeFilter filter = null)
        {
            var setupValues = _setupRepo.getQueryable().ToList();

            ViewBag.setup = setupValues;
            var notices = _noticeRepo.getQueryable().Where(a => a.is_closed == false);

            ViewBag.pagerInfo = _paginatedMetaService.GetMetaData(notices.Count(), filter.page, 5);
            notices           = notices.Skip(filter.number_of_rows * (filter.page - 1)).Take(5);

            return(View(notices.ToList()));
        }
        public IActionResult Index(GalleryFilter filter = null)
        {
            var gallery = _galleryRepo.getQueryable().Where(a => a.is_active == true);

            ViewBag.pagerInfo = _paginatedMetaService.GetMetaData(gallery.Count(), filter.page, filter.number_of_rows);


            gallery = gallery.Skip(filter.number_of_rows * (filter.page - 1)).Take(filter.number_of_rows);

            GalleryViewModel model = getViewModel(gallery);

            return(View(model));
        }
        public IActionResult Index(CareerFilter filter = null)
        {
            var setupValues = _setupRepo.getQueryable().ToList();

            ViewBag.setup = setupValues;
            var careers = _careerRepo.getQueryable().Where(a => a.is_closed == false && (a.closing_date == null ? true : (DateTime.Now <= a.closing_date)));

            ViewBag.pagerInfo = _paginatedMetaService.GetMetaData(careers.Count(), filter.page, 2);


            careers         = careers.Skip(filter.number_of_rows * (filter.page - 1)).Take(3);
            ViewBag.careers = careers.ToList();
            return(View(careers.ToList()));
        }
Пример #13
0
 public IActionResult Index()
 {
     try
     {
         var role        = _roleRepo.getQueryable();
         var roles       = role.ToList();
         var roleIndexVM = getViewModelFrom(roles);
         ViewBag.pagerInfo = _paginatedMetaService.GetMetaData(50, 2, 6);
         return(View(roleIndexVM));
     }
     catch (Exception ex)
     {
         AlertHelper.setMessage(this, ex.Message, messageType.error);
         return(Redirect("/home"));
     }
 }
 public IActionResult Index(GalleryImageFilter filter = null)
 {
     try
     {
         var galleries = _galleryImageRepo.getQueryable();
         ViewBag.pagerInfo = _paginatedMetaService.GetMetaData(galleries.Count(), filter.page, filter.number_of_rows);
         galleries         = galleries.Skip(filter.number_of_rows * (filter.page - 1)).Take(filter.number_of_rows);
         var gallery        = galleries.ToList();
         var galleryIndexVM = getViewModelFrom(gallery);
         return(View(galleryIndexVM));
     }
     catch (Exception ex)
     {
         AlertHelper.setMessage(this, ex.Message, messageType.error);
         return(Redirect("index"));
     }
 }
        public IActionResult Index(ServicesFilter filter = null)
        {
            var serv = _servicesRepository.getQueryable();

            if (!string.IsNullOrWhiteSpace(filter.title))
            {
                serv = serv.Where(a => a.name.Contains(filter.title));
            }

            ViewBag.pagerInfo = _paginatedMetaService.GetMetaData(serv.Count(), filter.page, filter.number_of_rows);


            serv = serv.Skip(filter.number_of_rows * (filter.page - 1)).Take(filter.number_of_rows);

            var serviceDetail = serv.ToList();

            var serviceIndexVM = getViewModelFrom(serviceDetail);

            return(View(serviceIndexVM));
        }
        public IActionResult Index(VideoFilter filter = null)
        {
            var videos = _videoRepository.getQueryable();

            if (!string.IsNullOrWhiteSpace(filter.title))
            {
                videos = videos.Where(a => a.title.Contains(filter.title));
            }

            ViewBag.pagerInfo = _paginatedMetaService.GetMetaData(videos.Count(), filter.page, filter.number_of_rows);


            videos = videos.Skip(filter.number_of_rows * (filter.page - 1)).Take(filter.number_of_rows);

            var videoDetails = videos.ToList();

            var videoIndexVM = getViewModelFrom(videoDetails);

            return(View(videoIndexVM));
        }
Пример #17
0
 public IActionResult Index(FileUploadFilter filter = null)
 {
     try
     {
         var files = _fileUploadRepo.getQueryable();
         if (!string.IsNullOrWhiteSpace(filter.title))
         {
             files = files.Where(a => a.title.Contains(filter.title));
         }
         ViewBag.pagerInfo = _paginatedMetaService.GetMetaData(files.Count(), filter.page, filter.number_of_rows);
         files             = files.Skip(filter.number_of_rows * (filter.page - 1)).Take(filter.number_of_rows);
         var file         = files.ToList();
         var filesIndexVM = getViewModelFrom(file);
         return(View(filesIndexVM));
     }
     catch (Exception ex)
     {
         AlertHelper.setMessage(this, ex.Message, messageType.error);
         return(Redirect("index"));
     }
 }
Пример #18
0
        public IActionResult Index(OrderFilter filter = null)
        {
            try
            {
                var menu_type = _orderRepository.getQueryable();
                if (!string.IsNullOrWhiteSpace(filter.name))
                {
                    menu_type = menu_type.Where(a => a.customer_name.Contains(filter.name));
                }
                ViewBag.pagerInfo = _paginatedMetaService.GetMetaData(menu_type.Count(), filter.page, filter.number_of_rows);
                menu_type         = menu_type.Skip(filter.number_of_rows * (filter.page - 1)).Take(filter.number_of_rows);
                var orderDetails = menu_type.ToList();

                var orderIndexVM = getViewModelFromOrder(orderDetails);
                return(View(orderIndexVM));
            }
            catch (Exception ex)
            {
                AlertHelper.setMessage(this, ex.Message, messageType.error);
                return(Redirect("/admin"));
            }
        }
        public IActionResult Index(MenuCategoryFilter filter)
        {
            var menuCategory = _menuCategoryRepo.getQueryable();

            if (!string.IsNullOrWhiteSpace(filter.name))
            {
                menuCategory = menuCategory.Where(a => a.name.Contains(filter.name));
            }
            ViewBag.pagerInfo = _paginatedMetaService.GetMetaData(menuCategory.Count(), filter.page, filter.number_of_rows);


            menuCategory = menuCategory.Skip(filter.number_of_rows * (filter.page - 1)).Take(filter.number_of_rows);
            var categories = menuCategory.OrderByDescending(a => a.menu_category_id).ToList();
            //var topCategory = _menuCategoryRepo.getQueryable().Where(a => a.parent_id == 0 && a.is_enabled == true).ToList();
            //ViewBag.topCategories = new SelectList(topCategory, "menu_category_id", "name");
            //if (filter.parent_category_id > 0)
            //{
            //    categories = menuCategory.Where(a => a.parent_id == filter.parent_category_id).OrderByDescending(a => a.menu_category_id).ToList();
            //}
            MenuCategoryIndexViewModel menuCategoryIndexVM = getViewModelFrom(categories);

            return(View(menuCategoryIndexVM));
        }
        public IActionResult Index(PartnersFilter filter = null)
        {
            try
            {
                var partners = _partnersRepository.getQueryable();

                if (!string.IsNullOrWhiteSpace(filter.title))
                {
                    partners = partners.Where(a => a.name.Contains(filter.title));
                }

                ViewBag.pagerInfo = _paginatedMetaService.GetMetaData(partners.Count(), filter.page, filter.number_of_rows);

                partners = partners.Skip(filter.number_of_rows * (filter.page - 1)).Take(filter.number_of_rows);

                return(View(partners.OrderByDescending(a => a.partners_id).ToList()));
            }
            catch (Exception ex)
            {
                AlertHelper.setMessage(this, ex.Message, messageType.error);
                return(Redirect("/admin"));
            }
        }
        public IActionResult Index(TestimonialFilter filter = null)
        {
            try
            {
                var testimonials = _testimonialRepo.getQueryable();

                if (!string.IsNullOrWhiteSpace(filter.title))
                {
                    testimonials = testimonials.Where(a => a.person_name.Contains(filter.title));
                }

                ViewBag.pagerInfo = _paginatedMetaService.GetMetaData(testimonials.Count(), filter.page, filter.number_of_rows);


                testimonials = testimonials.Skip(filter.number_of_rows * (filter.page - 1)).Take(filter.number_of_rows);
                return(View(testimonials.ToList()));
            }
            catch (Exception ex)
            {
                AlertHelper.setMessage(this, ex.Message, messageType.error);
                return(Redirect("/admin"));
            }
        }
        public void NextPageNotDisplayed()
        {
            var result = _sut.GetMetaData(10, 8, 1);

            Assert.False(result.NextPage.Display, "Expected: Next Page Display = false");
        }
Пример #23
0
        public void CollectionSizeZeroReturnsValidObject()
        {
            var result = _sut.GetMetaData(0, 1, 1);

            Assert.True(result.Pages.Count == 0, "Zero Size Valid Object");
            Assert.True(!result.NextPage.Display, "Zero Size Valid Object");
            Assert.True(!result.PreviousPage.Display, "Zero Size Valid Object");
        }
Пример #24
0
        public void NextPageIsLastPageInCollectionWhenRequestedPageIsGreatedThenCollection()
        {
            var result = _sut.GetMetaData(10, 50, 1);

            Assert.True(result.NextPage.PageNumber == 10, "Expected: Next page should be last page in collection.");
        }
Пример #25
0
        public void PreviousPageNotDisplayed()
        {
            var result = _sut.GetMetaData(10, 1, 1);

            Assert.False(result.PreviousPage.Display, "Expected : Previous Page Displayed = false");
        }