コード例 #1
0
        public async Task <ActionResult> SelectTrialStudentsByBranchId(SortingEnum sort, int id)
        {
            var students = await _studentService.GetTrialStudentsByBranchIdAsync(id, sort);

            ViewBag.BranchId = id;
            return(PartialView("_TrialStudents", students));
        }
コード例 #2
0
        private void ProductListByCategory(int categoryID, SortingEnum DropDown = 0)
        {
            Products = ProductRepository.ListByCategory(categoryID);
            if (DropDown == SortingEnum.MostSold)
            {
                Products = (Products.OrderByDescending(x => x.QuantitySold)).ToList();
            }
            else if (DropDown == SortingEnum.HigherPrize)
            {
                Products = (Products.OrderByDescending(x => x.Prize)).ToList();
            }
            else if (DropDown == SortingEnum.LowerPrize)
            {
                Products = (Products.OrderBy(x => x.Prize)).ToList();
            }
            else if (DropDown == SortingEnum.Last)
            {
                Products = (Products.OrderByDescending(x => x.ProductID)).ToList();
            }
            foreach (var item in Products)
            {
                item.DiscountAmount = string.Format("{0:0.##}", (item.Prize - ((item.Prize * item.Discount) / 100)));

                if (item.Description.Length > 77)
                {
                    item.Description = item.Description.Substring(0, 77);
                }
            }
        }
コード例 #3
0
 //private EnumTyp _activeType_enum;
 public OptionsBuild(EnumTyp typ, SortingEnum sorting, int drawingSize_W, int drawingSize_H)
 {
     _activeType    = (int)typ;
     _activeSort    = (int)sorting;
     _drawingSize_H = drawingSize_H;
     _drawingSize_W = drawingSize_W;
 }
コード例 #4
0
        public async Task <ActionResult> Index(SortingEnum sortState = SortingEnum.LastNameAsc)
        {
            StudentViewModel st = SortStudents.Sort(await _studentService.GetAllStudentsByArchive(), sortState);

            st.branches = await _branchService.GetAllBranch();

            return(View(st));
        }
コード例 #5
0
        public async Task <ActionResult> SelectStudyingStudents(SortingEnum sortState = SortingEnum.LastNameAsc)
        {
            var students = await _studentService.SelectStudyingStudentsAsync(sortState);

            ViewData["Branches"] = await _branchService.GetAllBranch();

            return(View(students));
        }
コード例 #6
0
        public List <Libro> GetLibros(int page, string filter, bool?asc, SortingEnum customFilter, string customFilterValue)
        {
            page = page < 1 ? 1 : page;
            filter ??= "Nombre";
            asc = !asc.HasValue;

            return((List <Libro>)LibroRepository.GetLibros(page, 5, filter, asc.Value, customFilter, customFilterValue));
        }
コード例 #7
0
        public async Task <IActionResult> List(string value,
                                               SortingEnum sortState = SortingEnum.LastNameAsc)
        {
            ViewBag.value = value;
            var students = await _studentService.SearchAsync(value, sortState);

            return(View(students));
        }
コード例 #8
0
 public IActionResult Detail(int productID, int familyID, SortingEnum DropDownID = 0)
 {
     try
     {
         ProductDetailViewModel          = new ProductDetailViewModel(productID, familyID, 0, DropDownID);
         ProductDetailViewModel.Products = ProductDetailViewModel.Products.Where(x => x.DepartmentID == CuponSession.GetDepartmentID(HttpContext.Session)).ToList();
     }
     catch (Exception ex)
     {
         ViewData["ErrorMessage"] = ex.Message;
     }
     return(View(ProductDetailViewModel));
 }
コード例 #9
0
        public IEnumerable <Libro> GetLibros(int page, int pageSize, string currentFilter, bool ascOrder,
                                             SortingEnum customFilter, string customFilterValue)
        {
            IQueryable <Libro> libros = LibroContext.Libro.AsQueryable();

            if (currentFilter != null)
            {
                libros = QueryHelper.GetQuery(libros, currentFilter, customFilter, customFilterValue, ascOrder);
            }


            return(libros.GetPaged <Libro>(page, pageSize).Results.ToList());
        }
コード例 #10
0
ファイル: CFollowUp.cs プロジェクト: dasca/WinShooter-Legacy
        internal Structs.FollowUpReturn[] FollowUp(SortingEnum sorting)
        {
            ArrayList toReturn = new ArrayList();

            DatabaseDataset.ClubsRow[] clubs =
                (DatabaseDataset.ClubsRow[])
                database.Clubs.Select("", "Name");
            foreach (DatabaseDataset.ClubsRow club in clubs)
            {
                toReturn.AddRange(checkClub(club));
            }
            return((Structs.FollowUpReturn[])toReturn.ToArray(typeof(Structs.FollowUpReturn)));
        }
コード例 #11
0
		internal Structs.FollowUpReturn[] FollowUp(SortingEnum sorting)
		{
			ArrayList toReturn = new ArrayList();

			DatabaseDataset.ClubsRow[] clubs =
				(DatabaseDataset.ClubsRow[])
				database.Clubs.Select("", "Name");
			foreach (DatabaseDataset.ClubsRow club in clubs)
			{
				toReturn.AddRange(checkClub(club));
			}
			return (Structs.FollowUpReturn[])toReturn.ToArray(typeof(Structs.FollowUpReturn));
		}
コード例 #12
0
        public List <TShirt> Sort(SortingEnum sortingMethod, List <TShirt> tshirts)
        {
            switch ((int)sortingMethod)
            {
            case 1:
                var tshirtsArr = tshirts.ToArray();
                QuickSort.QuickSortMain(tshirtsArr, 0, tshirtsArr.Length - 1, true, "price");
                var sorted = tshirtsArr.ToList();
                return(sorted);

            case 2:
                tshirtsArr = tshirts.ToArray();
                QuickSort.QuickSortMain(tshirtsArr, 0, tshirtsArr.Length - 1, false, "price");
                sorted = tshirtsArr.ToList();
                return(sorted);

            case 3:
                return(BubbleSort.Ascending(tshirts));

            case 4:
                return(BubbleSort.Descending(tshirts));

            case 5:
                tshirtsArr = tshirts.ToArray();
                QuickSort.QuickSortMain(tshirtsArr, 0, tshirtsArr.Length - 1, true, "size");
                sorted = tshirtsArr.ToList();
                return(sorted);

            case 6:
                tshirtsArr = tshirts.ToArray();
                QuickSort.QuickSortMain(tshirtsArr, 0, tshirtsArr.Length - 1, false, "size");
                sorted = tshirtsArr.ToList();
                return(sorted);

            case 7:
                return(BucketSort.BucketFabricSort(tshirts, true));

            case 8:
                return(BucketSort.BucketFabricSort(tshirts, false));

            case 9:
                return(BubbleSort.AllAsc(tshirts));

            case 10:
                return(BubbleSort.AllDesc(tshirts));

            default:
                return(tshirts);
            }
        }
コード例 #13
0
ファイル: StudentService.cs プロジェクト: ESDP-C-5/ESDP
        public async Task <StudentViewModel> SearchAsync(
            string value,
            SortingEnum sortState = SortingEnum.LastNameAsc)
        {
            var students = await _unitOfWork.Student.GetAllAsync();

            if (!string.IsNullOrWhiteSpace(value))
            {
                students = students.Where(x => (x.Name?.ToUpper() ?? string.Empty).Contains(value.ToUpper()) ||
                                          (x.PhoneNumber?.ToUpper() ?? string.Empty).Contains(value.ToUpper()) ||
                                          (x.LastName?.ToUpper() ?? string.Empty).Contains(value.ToUpper()) ||
                                          (x.ParentLastName?.ToUpper() ?? string.Empty).Contains(value.ToUpper())).ToList();

                return(SortStudents.Sort(students, sortState));
            }

            return(new StudentViewModel()
            {
                Student = new List <Student>()
            });
        }
コード例 #14
0
ファイル: StudentService.cs プロジェクト: ESDP-C-5/ESDP
        internal async Task <StudentViewModel> SelectTrialStudentsAsync(SortingEnum sortState = SortingEnum.LastNameAsc)
        {
            var students = await _unitOfWork.Student.SelectTrialStudentsAsync();

            return(SortStudents.Sort(students, sortState));
        }
コード例 #15
0
ファイル: StudentService.cs プロジェクト: ESDP-C-5/ESDP
        public async Task <StudentViewModel> GetTrialStudentsByBranchIdAsync(int BranchId, SortingEnum sortState)
        {
            var groups = await _unitOfWork.Groups.GetIncludeStudentsByBranchIdAsync(BranchId);

            var students = new List <Student>();

            foreach (var g in groups)
            {
                students.AddRange(g.Students);
            }

            students = students.Where(x => x.Status == StudentStatusEnum.trial).ToList();

            return(SortStudents.Sort(students, sortState));
        }
コード例 #16
0
ファイル: MailService.cs プロジェクト: ozel981/MailBox
        public PagingMailInboxView GetUserMails(int userID, int page, SortingEnum sorting, FilterEnum filter, string filterPhrase)
        {
            filterPhrase ??= "";

            bool firstPage = (page == 1);

            var userMails = _context.UserMails
                            .Include(x => x.Mail)
                            .ThenInclude(x => x.Sender)
                            .Where(x => x.UserID == userID).AsQueryable();

            switch (filter)
            {
            case FilterEnum.FilterTopic:
                userMails = userMails.Where(x => x.Mail.Topic.StartsWith(filterPhrase)).AsQueryable();
                break;

            case FilterEnum.FilterSenderName:
                userMails = userMails.Where(x => x.Mail.Sender.FirstName.StartsWith(filterPhrase)).AsQueryable();
                break;

            case FilterEnum.FilterSenderSurname:
                userMails = userMails.Where(x => x.Mail.Sender.LastName.StartsWith(filterPhrase)).AsQueryable();
                break;
            }

            switch (sorting)
            {
            case SortingEnum.ByDateFromNewest:
                userMails = userMails.OrderByDescending(x => x.Mail.Date);
                break;

            case SortingEnum.ByDateFromOldest:
                userMails = userMails.OrderBy(x => x.Mail.Date);
                break;

            case SortingEnum.BySenderAZ:
                userMails = userMails.OrderBy(x => x.Mail.Sender.FirstName).ThenBy(x => x.Mail.Sender.LastName).ThenByDescending(x => x.Mail.Date);
                break;

            case SortingEnum.BySenderZA:
                userMails = userMails.OrderByDescending(x => x.Mail.Sender.FirstName).ThenByDescending(x => x.Mail.Sender.LastName).ThenByDescending(x => x.Mail.Date);
                break;

            case SortingEnum.ByTopicAZ:
                userMails = userMails.OrderBy(x => x.Mail.Topic).ThenByDescending(x => x.Mail.Date);
                break;

            case SortingEnum.ByTopicZA:
                userMails = userMails.OrderByDescending(x => x.Mail.Topic).ThenByDescending(x => x.Mail.Date);
                break;
            }

            bool lastPage = (userMails.Count() <= 5 * page);

            userMails = userMails.Skip((page - 1) * 5).Take(5);

            List <MailInboxView> mails = new List <MailInboxView>();

            foreach (var um in userMails)
            {
                MailInboxView miv = new MailInboxView
                {
                    MailID = um.MailID,
                    Read   = um.Read,
                    Sender = new UserGlobalView
                    {
                        Name    = um.Mail.Sender.FirstName,
                        Surname = um.Mail.Sender.LastName,
                        Address = um.Mail.Sender.Email
                    },
                    Topic = um.Mail.Topic,
                    Date  = um.Mail.Date,
                };
                mails.Add(miv);
            }

            return(new PagingMailInboxView {
                Mails = mails, FirstPage = firstPage, LastPage = lastPage
            });
        }
コード例 #17
0
ファイル: SortStudents.cs プロジェクト: ESDP-C-5/ESDP
        public static StudentViewModel Sort(List <Student> students, SortingEnum sortState)
        {
            var model = new StudentViewModel
            {
                LastNameSortState = sortState == SortingEnum.LastNameAsc
                    ? SortingEnum.LastNameDesc
                    : SortingEnum.LastNameAsc,
                CreatedDateSortState = sortState == SortingEnum.CreatedDateAsc
                    ? SortingEnum.CreatedDateDesc
                    : SortingEnum.CreatedDateAsc,
                DateOfBirthdaySortState = sortState == SortingEnum.DateOfBirthdayAsc
                    ? SortingEnum.DateOfBirthdayDesc
                    : SortingEnum.DateOfBirthdayAsc,
                ParentLastNameSortState = sortState == SortingEnum.ParentLastNameAsc
                    ? SortingEnum.ParentLastNameDesc
                    : SortingEnum.ParentLastNameAsc,
                PhoneNumberSortState = sortState == SortingEnum.PhoneNumberAsc
                    ? SortingEnum.PhoneNumberDesc
                    : SortingEnum.PhoneNumberAsc,
                StatusSortState = sortState == SortingEnum.StatusAsc
                    ? SortingEnum.StatusDesc
                    : SortingEnum.StatusAsc,
                GroupSortState = sortState == SortingEnum.GroupAsc
                    ? SortingEnum.GroupDesc
                    : SortingEnum.GroupAsc,
                TrialDateSortState = sortState == SortingEnum.TrialDateAsc
                    ? SortingEnum.TrialDateDesc
                    : SortingEnum.TrialDateAsc,
                LevelSortState = sortState == SortingEnum.LevelAsc
                    ? SortingEnum.LevelDesc
                    : SortingEnum.LevelAsc,
                CommentSortState = sortState == SortingEnum.CommentAsc
                    ? SortingEnum.CommentDesc
                    : SortingEnum.CommentAsc,
                ChangeStatusSortState = sortState == SortingEnum.ChangeStatusAsc
                    ? SortingEnum.ChangeStatusDesc
                    : SortingEnum.ChangeStatusAsc
            };



            switch (sortState)
            {
            case SortingEnum.LastNameAsc:
                students = students.OrderBy(s => s.LastName ?? s.Name ?? s.FatherName).ToList();
                break;

            case SortingEnum.LastNameDesc:
                students = students.OrderByDescending(s => s.LastName ?? s.Name ?? s.FatherName).ToList();
                break;

            case SortingEnum.CreatedDateAsc:
                students = students.OrderBy(s => s.CreatedDate).ToList();
                break;

            case SortingEnum.CreatedDateDesc:
                students = students.OrderByDescending(s => s.CreatedDate).ToList();
                break;

            case SortingEnum.DateOfBirthdayAsc:
                students = students.OrderBy(s => s.DateOfBirthday).ToList();
                break;

            case SortingEnum.DateOfBirthdayDesc:
                students = students.OrderByDescending(s => s.DateOfBirthday).ToList();
                break;

            case SortingEnum.ParentLastNameAsc:
                students = students.OrderBy(s => s.ParentLastName).ToList();
                break;

            case SortingEnum.ParentLastNameDesc:
                students = students.OrderByDescending(s => s.ParentLastName).ToList();
                break;

            case SortingEnum.PhoneNumberAsc:
                students = students.OrderBy(s => s.PhoneNumber).ToList();
                break;

            case SortingEnum.PhoneNumberDesc:
                students = students.OrderByDescending(s => s.PhoneNumber).ToList();
                break;

            case SortingEnum.StatusAsc:
                students = students.OrderBy(s => s.Status).ToList();
                break;

            case SortingEnum.StatusDesc:
                students = students.OrderByDescending(s => s.Status).ToList();
                break;

            case SortingEnum.GroupAsc:
                students = students.OrderBy(s => s.Group).ToList();
                break;

            case SortingEnum.GroupDesc:
                students = students.OrderByDescending(s => s.Group).ToList();
                break;

            case SortingEnum.TrialDateAsc:
                students = students.OrderBy(s => s.TrialDate).ToList();
                break;

            case SortingEnum.TrialDateDesc:
                students = students.OrderByDescending(s => s.TrialDate).ToList();
                break;

            case SortingEnum.LevelAsc:
                students = students.OrderBy(s => s.Level).ToList();
                break;

            case SortingEnum.LevelDesc:
                students = students.OrderByDescending(s => s.Level).ToList();
                break;

            case SortingEnum.CommentAsc:
                students = students.OrderBy(s => s.Comments).ToList();
                break;

            case SortingEnum.CommentDesc:
                students = students.OrderByDescending(s => s.Comments).ToList();
                break;

            case SortingEnum.ChangeStatusAsc:
                students = students.OrderBy(s => s.ChangeStatusDate).ToList();
                break;

            case SortingEnum.ChangeStatusDesc:
                students = students.OrderByDescending(s => s.ChangeStatusDate).ToList();
                break;
            }


            model.Student = students;


            return(model);
        }
コード例 #18
0
ファイル: Sorter.cs プロジェクト: netsouls/eCentral
 /// <summary>
 /// Add parammeters to be ignored for sorting
 /// </summary>
 /// <param name="paramValue"></param>
 /// <returns></returns>
 public Sorter IgnoreSortFor(SortingEnum paramValue)
 {
     ignoreSortFor.Add(paramValue);
     return this;
 }
コード例 #19
0
        public ObservableCollection <User> FilteredAndSortedUsers(string filterQuery, SortingEnum sortingEnum)
        {
            IEnumerable <User> users = GetAllUsers();

            if (!string.IsNullOrEmpty(filterQuery))
            {
                users = users.Where(x => x.Name.ToLower().Contains(filterQuery) ||
                                    x.Surname.ToLower().Contains(filterQuery) ||
                                    x.ChineseSign.ToLower().GetDescription().Contains(filterQuery) ||
                                    x.SunSign.GetDescription().ToLower().Contains(filterQuery) ||
                                    x.Email.ToLower().Contains(filterQuery));
            }

            switch (sortingEnum)
            {
            case SortingEnum.Name:
                users = users.OrderBy(u => u.Name);
                break;

            case SortingEnum.Surname:
                users = users.OrderBy(u => u.Surname);
                break;

            case SortingEnum.Email:
                users = users.OrderBy(u => u.Email);
                break;

            case SortingEnum.SunSign:
                users = users.OrderBy(u => u.SunSign);
                break;

            case SortingEnum.ChineseSign:
                users = users.OrderBy(u => u.ChineseSign);
                break;

            default:
                break;
            }

            return(new ObservableCollection <User>(users));
        }
コード例 #20
0
        public async Task <ActionResult> SelectLeadStudents(SortingEnum sortState = SortingEnum.LastNameAsc)
        {
            var students = await _studentService.SelectLeadStudentsAsync(sortState);

            return(View(students));
        }
コード例 #21
0
        public ProductDetailViewModel(int productID = 0, int familyID = 0, int categoryID = 0, SortingEnum DropDown = 0)
        {
            if (productID > 0)
            {
                ProductRead(productID);
            }
            if (categoryID > 0)
            {
                ProductListByCategory(categoryID, DropDown);
            }
            else
            {
                ProductList(DropDown);
            }

            CategoryList();
            FamilyRead(familyID);
            FamilyList();
        }
コード例 #22
0
 public OrderBy AddOrder(string order, SortingEnum sortingEnum)
 {
     return(new OrderBy(sqlRawBuilder, order, sortingEnum));
 }
コード例 #23
0
 public OrderBy(SqlRawBuilder sqlRawBuilder, string[] orders, SortingEnum sortingEnum = SortingEnum.Asc)
 {
     this.sqlRawBuilder         = sqlRawBuilder;
     this.orders                = orders;
     this.sqlRawBuilder.GetSQL += " ORDER BY " + string.Join(", ", orders) + (sortingEnum == SortingEnum.Desc ? " DESC" : "");
 }
コード例 #24
0
 public OrderBy(SqlRawBuilder sqlRawBuilder, string order, SortingEnum sortingEnum = SortingEnum.Asc)
 {
     this.sqlRawBuilder         = sqlRawBuilder;
     this.order                 = order;
     this.sqlRawBuilder.GetSQL += " ORDER BY " + order + (sortingEnum == SortingEnum.Desc ? " DESC" : "");
 }
コード例 #25
0
        public IActionResult GetMails(int page, SortingEnum sorting, FilterEnum filter, string filterPhrase)
        {
            int userID = int.Parse(User.Claims.First(x => x.Type == ClaimTypes.NameIdentifier).Value);

            return(new JsonResult(_mailService.GetUserMails(userID, page, sorting, filter, filterPhrase)));
        }
コード例 #26
0
ファイル: Sorter.cs プロジェクト: netsouls/eCentral
        protected virtual string CreateSortLink(SortingEnum orderBy, string title, bool isCurrentPage = false)
        {
            var liBulder = new TagBuilder("li");

            liBulder.Attributes.Add("id", orderBy.ToString().ToLower());

            if (isCurrentPage)
                liBulder.AddCssClass("active");

            var builder = new TagBuilder("a");
            builder.SetInnerText(orderBy.ToString());
            var actionLink = urlBuilder((int)orderBy);

            builder.MergeAttribute("href", string.Format("{0}{1}", isHashTag ? "#" : string.Empty, actionLink));
            builder.MergeAttribute("title", title);

            liBulder.InnerHtml = builder.ToString(TagRenderMode.Normal);
            return liBulder.ToString(TagRenderMode.Normal);
        }
コード例 #27
0
 public DescriptionValueBinder(SortingEnum value, string description)
 {
     Value       = value;
     Description = description;
 }
コード例 #28
0
ファイル: QueryResult.cs プロジェクト: senner008/scraping-mvc
 public FoodPropsComparer(SortingEnum sortparam)
 {
     Sortparam = sortparam;
 }
コード例 #29
0
        public static IQueryable <Libro> GetQuery(IQueryable <Libro> libros, string currentFilter, SortingEnum customFilter, string customFilterValue, bool ascOrder)
        {
            PropertyInfo prop = typeof(Libro).GetProperty(currentFilter);

            if (customFilter == SortingEnum.None)
            {
                if (ascOrder)
                {
                    libros = libros.OrderBy(t => EF.Property <string>(t, currentFilter));
                }
                else
                {
                    libros = libros.OrderByDescending(t => EF.Property <string>(t, currentFilter));
                }
            }
            else
            {
                switch (customFilter)
                {
                case SortingEnum.Contains:
                    libros = libros.Where(t => EF.Property <string>(t, currentFilter).ToString().Contains(customFilterValue));
                    break;

                case SortingEnum.NotContains:
                    libros = libros.Where(t => !EF.Property <string>(t, currentFilter).ToString().Contains(customFilterValue));
                    break;

                case SortingEnum.Equals:
                    libros = libros.Where(t => EF.Property <string>(t, currentFilter).ToString() == customFilterValue);
                    break;

                case SortingEnum.NotEqual:
                    libros = libros.Where(t => EF.Property <string>(t, currentFilter).ToString() != customFilterValue);
                    break;

                case SortingEnum.StartsWith:
                    libros = libros.Where(t => EF.Property <string>(t, currentFilter).ToString().StartsWith(customFilterValue));
                    break;

                case SortingEnum.EndsWith:
                    libros = libros.Where(t => EF.Property <string>(t, currentFilter).ToString().EndsWith(customFilterValue));
                    break;
                }
            }
            return(libros);
        }