Esempio n. 1
0
        public List <Contact> SortListWithParameter(List <Contact> oldList, SortEnum parameter)
        {
            List <Contact> list = null;

            if (oldList != null || oldList.Count() > 1)
            {
                switch ((int)parameter)
                {
                case 0:
                {
                    list = oldList.OrderBy(x => x.FullName).ToList();
                    break;
                }

                case 1:
                {
                    list = oldList.OrderBy(x => x.NickName).ToList();
                    break;
                }

                case 2:
                {
                    list = oldList.OrderBy(x => x.AddTime).ToList();
                    break;
                }
                }
            }
            return(list);
        }
Esempio n. 2
0
        private static XslCompiledTransform GetCompiledTransform(SortEnum sort)
        {
            string xsltFile = "";

            switch (sort)
            {
            case SortEnum.ALPHABETICALLY_ASCENDING: xsltFile = "Sort-a.xsl"; break;

            case SortEnum.ALPHABETICALLY_DESCENDENTLY: xsltFile = "Sort-ad.xsl"; break;

            case SortEnum.LENGTH_ASCENDING: xsltFile = "Sort-l.xsl"; break;

            case SortEnum.LENGTH_DESCENDENTLY: xsltFile = "Sort-ld.xsl"; break;
            }
            var xslt     = new XslCompiledTransform();
            var assembly = Assembly.GetExecutingAssembly();

            using (var stream = assembly.GetManifestResourceStream("dotnet_sort." + xsltFile))
            {
                using (var reader = XmlReader.Create(stream))
                {
                    xslt.Load(reader);
                    return(xslt);
                }
            }
        }
Esempio n. 3
0
        /// <summary>
        /// Sort the transfers from a model.
        /// </summary>
        /// <returns>List of sorted transfers</returns>
        /// <param name="m">Model from which to sort transfers</param>
        /// <param name="how">Sort method</param>
        /// <param name="descend">True for descending sort, false for ascending</param>
        public static List <TransferModel> SortTransfers(AstrogationModel m, SortEnum how, bool descend)
        {
            List <TransferModel> transfers = new List <TransferModel>(m.transfers);

            switch (how)
            {
            case SortEnum.Name:
                transfers.Sort((a, b) =>
                               a?.destination?.GetName().CompareTo(b?.destination?.GetName()) ?? 0);
                break;

            case SortEnum.Position:
                // Use the natural/default ordering in the model
                break;

            case SortEnum.Time:
                transfers.Sort((a, b) =>
                               a?.ejectionBurn?.atTime?.CompareTo(b?.ejectionBurn?.atTime ?? 0) ?? 0);
                break;

            case SortEnum.DeltaV:
                transfers.Sort((a, b) =>
                               a?.ejectionBurn?.totalDeltaV.CompareTo(b?.ejectionBurn?.totalDeltaV) ?? 0);
                break;

            default:
                DbgFmt("Bad sort argument: {0}", how.ToString());
                break;
            }
            if (descend)
            {
                transfers.Reverse();
            }
            return(transfers);
        }
Esempio n. 4
0
        public static Dictionary <int, List <T> > PageOrderToDic <T, TK>(IQueryable <T> source,
                                                                         int pageSize,
                                                                         Expression <Func <T, TK> > orderByExpression,
                                                                         SortEnum sortOrder = SortEnum.Original,
                                                                         Expression <Func <T, bool> > filter = null)
        {
            var dic = new Dictionary <int, List <T> >();

            //筛选
            if (filter != null)
            {
                source = source.Where(filter);
            }

            //排序
            if (orderByExpression != null)
            {
                source = Order(source, orderByExpression, sortOrder);
            }

            int pageCount = source.Count() / pageSize + 1;

            for (int pageIndex = 1; pageIndex <= pageCount; pageIndex++)
            {
                int skipCount = pageSize * (pageIndex - 1);//跳过条数
                dic.Add(pageIndex, source.Skip(skipCount).Take(pageSize).ToList());
            }

            return(dic);
        }
        /// <summary>
        /// 获取排序SQL语句
        /// </summary>
        /// <param name="sort">排序</param>
        /// <param name="prop">排序的属性名</param>
        /// <param name="pfx">前辍</param>
        /// <returns>排序SQL语句</returns>
        protected string GetSortSql(SortEnum sort, string prop, string pfx = null)
        {
            if (string.IsNullOrWhiteSpace(prop))
            {
                return(null);
            }
            if (string.IsNullOrWhiteSpace(pfx))
            {
                pfx = Table + ".";
            }

            string field = GetFieldByProp(prop);

            if (string.IsNullOrWhiteSpace(field))
            {
                field = prop;
            }
            StringBuilder sql = new StringBuilder($"ORDER BY {pfx}{field}");

            if (sort == SortEnum.ASC)
            {
                sql.Append(" ASC");
            }
            else
            {
                sql.Append(" DESC");
            }

            return(sql.ToString());
        }
Esempio n. 6
0
        public async Task <List <Contact> > GetListOfContacts(int userId, SortEnum parameter)
        {
            var items = await _repositoryC.GetItemsAsync <Contact>();

            var list = items.Where(x => x.UserId == userId).ToList();

            return(SortListWithParameter(list, parameter));
        }
 public IActionResult OnPost(SortEnum sortBy, SortDirectionEnum sortDirection)
 {
     return(RedirectToPage(
                "./TeamCompositionSummary",
                new {
         sortBy = sortBy,
         sortDirection = sortDirection
     }));
 }
Esempio n. 8
0
 public override void OnNavigatedTo(INavigationParameters parameters)
 {
     selectedSort = (SortEnum)CrossSettings.Current.GetValueOrDefault("Sort", 0);
     ChangeRadioButton();
     selectedTheme = (ThemeEnum)CrossSettings.Current.GetValueOrDefault("Theme", 0);
     ChangeCheckBox();
     selectedLocalization = (LocalizationEnum)CrossSettings.Current.GetValueOrDefault("Localization", 0);
     ChangePicker();
 }
Esempio n. 9
0
        public async Task <Result <IEnumerable <Product> > > GetProducts(SortEnum sortOption, CancellationToken cancellationToken)
        {
            if (sortOption.Equals(SortEnum.Recommended))
            {
                return(await GetRecommendedProducts(cancellationToken));
            }

            return(await GetAllProducts(sortOption, cancellationToken));
        }
Esempio n. 10
0
 /// <summary>
 /// 排序分页
 /// </summary>
 /// <typeparam name="T"></typeparam>
 /// <typeparam name="TK"></typeparam>
 /// <param name="source"></param>
 /// <param name="pageSize"></param>
 /// <param name="pageIndex"></param>
 /// <param name="orderByExpression"></param>
 /// <param name="sortOrder"></param>
 /// <param name="filter"></param>
 /// <returns></returns>
 public static PageResult <T> PageOrder <T, TK>(IEnumerable <T> source,
                                                int pageSize,
                                                int pageIndex,
                                                Expression <Func <T, TK> > orderByExpression,
                                                SortEnum sortOrder = SortEnum.Original,
                                                Expression <Func <T, bool> > filter = null)
 {
     return(PageOrder <T, TK>(source.AsQueryable(), pageSize, pageIndex, orderByExpression: orderByExpression, sortOrder: sortOrder, filter: filter));
 }
Esempio n. 11
0
        /// <summary>
        /// Sorts input text based on a sortEnum value
        /// </summary>
        /// <param name="text">Input text to be used for sorting</param>
        /// <param name="sortEnum">Sorting algorithm of choice</param>
        /// <returns></returns>
        public SortResult Sort(string text, SortEnum sortEnum)
        {
            var sorterAlgorithm = _sortAlgorithmFactory.GetSorter(sortEnum);
            var sortedText      = sorterAlgorithm.Sort(text, _stringSettings.Separators);

            return(new SortResult()
            {
                SortedList = sortedText
            });
        }
 public CircularSearchRequest(float latitude, float longitude, float radius, FuelEnum fuelType, SortEnum sortType)
 {
     _latitude   = latitude;
     _longitude  = longitude;
     _radius     = radius;
     _fuelType   = fuelType;
     _sort       = sortType;
     EndpointUrl = "list.php";
     Method      = HttpMethod.Get;
 }
Esempio n. 13
0
 private void SortClicked(SortEnum which)
 {
     if (Settings.Instance.TransferSort == which)
     {
         Settings.Instance.DescendingSort = !Settings.Instance.DescendingSort;
     }
     else
     {
         Settings.Instance.TransferSort   = which;
         Settings.Instance.DescendingSort = false;
     }
     resetCallback();
 }
Esempio n. 14
0
        public AuthorsSortViewModel(SortEnum sortOrder)
        {
            NameSort    = sortOrder == SortEnum.NAME_ASC ? SortEnum.NAME_DESC : SortEnum.NAME_ASC;
            SurnameSort = sortOrder == SortEnum.SURNAME_ASC ? SortEnum.SURNAME_DESC : SortEnum.SURNAME_ASC;

            Up = true;

            if (sortOrder == SortEnum.NAME_DESC || sortOrder == SortEnum.SURNAME_DESC)
            {
                Up = false;
            }
            Current = sortOrder;
        }
Esempio n. 15
0
        public UsersSortViewModel(SortEnum sortOrder)
        {
            EmailSort     = sortOrder == SortEnum.EMAIL_ASC ? SortEnum.EMAIL_DESC : SortEnum.EMAIL_ASC;
            LoginNameSort = sortOrder == SortEnum.LOGINNAME_ASC ? SortEnum.LOGINNAME_DESC : SortEnum.LOGINNAME_ASC;

            Up = true;

            if (sortOrder == SortEnum.EMAIL_DESC || sortOrder == SortEnum.LOGINNAME_DESC)
            {
                Up = false;
            }
            Current = sortOrder;
        }
Esempio n. 16
0
        public virtual async Task <ActionResult <ProductDTO> > GetUser(
            [FromQuery][Required] SortEnum sortOption,
            CancellationToken token)
        {
            var response = await _productService.GetProducts(sortOption, token);

            if (response.IsSuccess)
            {
                var mappedResponse = _mapper.Map <IList <ProductDTO> >(response.Value);
                return(Ok(mappedResponse));
            }

            return(StatusCode(500, "Error getting products"));
        }
Esempio n. 17
0
        private static void SortImports(string filePath, SortEnum sort)
        {
            Console.Write($"Sorting.. {filePath}");
            var file        = new StreamReader(filePath, Encoding.UTF8);
            var linesToSort = new List <string>();
            var restOfFile  = "";

            string line;
            string pattern = @"^using.*;";

            while ((line = file.ReadLine()) != null && Regex.Match(line, pattern).Success)
            {
                linesToSort.Add(line);
            }
            if (linesToSort.Count == 0)
            {
                Console.WriteLine("\t not necessary");
                return;
            }

            restOfFile = line + "\r\n" + file.ReadToEnd();
            file.Close();

            switch (sort)
            {
            case SortEnum.ALPHABETICALLY_ASCENDING:
                linesToSort = linesToSort.OrderBy(x => x).ToList(); break;

            case SortEnum.ALPHABETICALLY_DESCENDENTLY:
                linesToSort = linesToSort.OrderByDescending(x => x).ToList(); break;

            case SortEnum.LENGTH_ASCENDING:
                linesToSort = linesToSort.OrderBy(x => x.Length).ToList(); break;

            case SortEnum.LENGTH_DESCENDENTLY:
                linesToSort = linesToSort.OrderByDescending(x => x.Length).ToList(); break;
            }
            //Write lines

            using (StreamWriter writer = new System.IO.StreamWriter(filePath, false, Encoding.UTF8))
            {
                foreach (var strLine in linesToSort)
                {
                    writer.WriteLine(strLine);
                }
                writer.Write(restOfFile);
                writer.Close();
            }
            Console.WriteLine("\t done");
        }
Esempio n. 18
0
        public static BeatmapEntry[] GetStringsBySortType(SortEnum sortEnum, IEnumerable <BeatmapEntry> list)
        {
            switch (sortEnum)
            {
            case SortEnum.Artist:
            default:
                return(list.Distinct().OrderBy(k => MetaSelect.GetUnicode(k.Artist, k.ArtistUnicode),
                                               StringComparer.InvariantCulture).ToArray());

            case SortEnum.Title:
                return(list.Distinct().OrderBy(k => MetaSelect.GetUnicode(k.Title, k.TitleUnicode),
                                               StringComparer.InvariantCulture).ToArray());
            }
        }
Esempio n. 19
0
        /// <summary>
        /// Converts a SortEnum value to a corresponding string value
        /// </summary>
        /// <param name="enumValue">The SortEnum value to convert</param>
        /// <returns>The representative string value</returns>
        public static string ToValue(SortEnum enumValue)
        {
            switch (enumValue)
            {
            //only valid enum elements can be used
            //this is necessary to avoid errors
            case SortEnum.ASC:
            case SortEnum.DESC:
                return(stringValues[(int)enumValue]);

            //an invalid enum value was requested
            default:
                return(null);
            }
        }
Esempio n. 20
0
 private void OnRadioButtonChange()
 {
     if (_isCheckedName)
     {
         selectedSort = SortEnum.ByName;
     }
     else if (_isCheckedNick)
     {
         selectedSort = SortEnum.ByNick;
     }
     else if (_isCheckedDate)
     {
         selectedSort = SortEnum.ByDate;
     }
 }
Esempio n. 21
0
        public IEnumerable <Product> SortedProducts(SortEnum sortOption, IEnumerable <Product> products)
        {
            switch (sortOption)
            {
            case SortEnum.Low: return(products.OrderBy(p => p.Price));

            case SortEnum.High: return(products.OrderByDescending(p => p.Price));

            case SortEnum.Ascending: return(products.OrderBy(p => p.Name));

            case SortEnum.Descending: return(products.OrderByDescending(p => p.Name));

            default: return(products);
            }
        }
Esempio n. 22
0
        public List <Feed> GetFeedList(SortEnum sortEnum)
        {
            List <Feed> list = new List <Feed>();

            if (sortEnum == SortEnum.New)
            {
                list = this.GetFeedListWithFeedLikeOrderByDate();
            }
            else if (sortEnum == SortEnum.Like)
            {
                list = this.GetFeedListWithFeedLikeOrderByLike();
            }

            return(list);
        }
Esempio n. 23
0
        public async Task <Result <IEnumerable <Product> > > GetAllProducts(SortEnum sortOption, CancellationToken cancellationToken)
        {
            var httpResponse = await base.Get(_productAPISettings.ProductsUri, cancellationToken);

            try
            {
                var products       = JsonConvert.DeserializeObject <IEnumerable <Product> >(httpResponse);
                var sortedProducts = SortedProducts(sortOption, products);

                return(Results.Ok(sortedProducts));
            }
            catch (Exception ex)
            {
                return(Results.Fail <IEnumerable <Product> >(new Error(ex.Message)));
            }
        }
Esempio n. 24
0
        /// <summary>
        /// Returns a sorter algorithm instance based on sortEnum input
        /// </summary>
        /// <param name="sortEnum">Sort algorithm choice</param>
        /// <returns></returns>
        public virtual ISorterAlgorithm GetSorter(SortEnum sortEnum)
        {
            switch (sortEnum)
            {
            case SortEnum.AlphabeticalSortAlgorithm:
                return(_serviceProvider.GetRequiredService <AlphabeticalSorter>());

            case SortEnum.WordSizeSortAlgorithm:
                return(_serviceProvider.GetRequiredService <WordSizeSorter>());

            case SortEnum.CharacterWithinWordAlgorithm:
                return(_serviceProvider.GetRequiredService <CharacterWithinWordSorter>());

            default:
                throw new NotImplementedException($"Sorter Algorithm is not implemented for SortEnum: {sortEnum}");
            }
        }
        /// <summary>
        /// 排序分页
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <typeparam name="TK"></typeparam>
        /// <param name="source"></param>
        /// <param name="pageSize"></param>
        /// <param name="pageIndex"></param>
        /// <param name="orderByExpression"></param>
        /// <param name="sortOrder"></param>
        /// <param name="filter"></param>
        /// <returns></returns>
        public static PageResultDto <T> PageOrder <T, TK>(IQueryable <T> source,
                                                          int pageSize,
                                                          int pageIndex,
                                                          Expression <Func <T, TK> > orderByExpression,
                                                          SortEnum sortOrder = SortEnum.Original,
                                                          Expression <Func <T, bool> > filter = null)
        {
            int skipCount;  //跳过条数
            int totalCount; //筛选后总条数
            int totalPages; //筛选后总页数

            //筛选
            if (filter != null)
            {
                source = source.Where(filter);
            }
            totalCount = source.Count();
            totalPages = totalCount > 0
                ? (int)Math.Ceiling((double)totalCount / (double)pageSize)
                : 0;
            pageIndex = totalPages <= 0
                ? 1
                : pageIndex > totalPages
                    ? totalPages
                    : pageIndex;
            skipCount = pageSize * (pageIndex - 1);

            //排序
            if (orderByExpression != null)
            {
                source = Order(source, orderByExpression, sortOrder);
            }

            //分页
            source = source.Skip(skipCount).Take(pageSize);

            return(new PageResultDto <T>
            {
                List = source.ToList(),
                PageIndex = totalPages <= 0 ? 1 : (pageIndex > totalPages ? totalPages : pageIndex),
                PageSize = pageSize,
                TotalCount = totalCount,
                TotalPages = totalPages
            });
        }
Esempio n. 26
0
 /// <summary>
 /// Initializes a new instance of the <see cref="Portfolio" /> class.
 /// </summary>
 /// <param name="createdTime">The time in ISO 8601 format when the portfolio was created. (required).</param>
 /// <param name="description">The portfolio&#39;s description. (required).</param>
 /// <param name="link">The link to the portfolio. (required).</param>
 /// <param name="metadata">metadata (required).</param>
 /// <param name="modifiedTime">The time in ISO 8601 format when the portfolio&#39;s data was last modified. (required).</param>
 /// <param name="name">The display name of the portfolio. (required).</param>
 /// <param name="sort">The default video sort order for the portfolio:  Option descriptions:  * &#x60;alphabetical&#x60; - The default sort order is alphabetical by name.  * &#x60;clips&#x60; - The default sort order is video creation date.  * &#x60;modified&#x60; - The default sort order is the order in which the videos were modified.  * &#x60;recent&#x60; - The default sort order is the order in which the videos were added.  (required).</param>
 /// <param name="uri">The canonical relative URI of the portfolio. (required).</param>
 public Portfolio(string createdTime = default(string), string description = default(string), string link = default(string), PortfolioMetadata metadata = default(PortfolioMetadata), string modifiedTime = default(string), string name = default(string), SortEnum sort = default(SortEnum), string uri = default(string))
 {
     // to ensure "createdTime" is required (not null)
     this.CreatedTime = createdTime ?? throw new ArgumentNullException("createdTime is a required property for Portfolio and cannot be null");
     // to ensure "description" is required (not null)
     this.Description = description ?? throw new ArgumentNullException("description is a required property for Portfolio and cannot be null");
     // to ensure "link" is required (not null)
     this.Link = link ?? throw new ArgumentNullException("link is a required property for Portfolio and cannot be null");
     // to ensure "metadata" is required (not null)
     this.Metadata = metadata ?? throw new ArgumentNullException("metadata is a required property for Portfolio and cannot be null");
     // to ensure "modifiedTime" is required (not null)
     this.ModifiedTime = modifiedTime ?? throw new ArgumentNullException("modifiedTime is a required property for Portfolio and cannot be null");
     // to ensure "name" is required (not null)
     this.Name = name ?? throw new ArgumentNullException("name is a required property for Portfolio and cannot be null");
     this.Sort = sort;
     // to ensure "uri" is required (not null)
     this.Uri = uri ?? throw new ArgumentNullException("uri is a required property for Portfolio and cannot be null");
 }
Esempio n. 27
0
        public BooksSortViewModel(SortEnum sortOrder)
        {
            NameSort  = sortOrder == SortEnum.NAME_ASC ? SortEnum.NAME_DESC : SortEnum.NAME_ASC;
            YearSort  = sortOrder == SortEnum.YEAR_ASC ? SortEnum.YEAR_DESC : SortEnum.YEAR_ASC;
            RateSort  = sortOrder == SortEnum.RATE_ASC ? SortEnum.RATE_DESC : SortEnum.RATE_ASC;
            PriceSort = sortOrder == SortEnum.PRICE_ASC ? SortEnum.PRICE_DESC : SortEnum.PRICE_ASC;

            Up = true;

            if (sortOrder == SortEnum.NAME_DESC ||
                sortOrder == SortEnum.YEAR_DESC ||
                sortOrder == SortEnum.PRICE_DESC ||
                sortOrder == SortEnum.RATE_DESC)
            {
                Up = false;
            }
            Current = sortOrder;
        }
Esempio n. 28
0
        /// <summary>
        ///当前排序
        /// </summary>
        public void Sort(SortEnum pse)
        {
            List <string> listKeys = this.Keys.ToList();

            listKeys.Sort(new SortCamparer(pse));
            BaseDictionary pd = new BaseDictionary();

            foreach (string r in listKeys)
            {
                pd.Add(r, this[r]);
            }
            this.Clear();
            foreach (string r in listKeys)
            {
                this.Add(r, pd[r]);
            }
            pd.Clear();
            pd = null;
        }
Esempio n. 29
0
        public BooksSortViewModel(SortEnum sortOrder)
        {
            TitleSort         = sortOrder == SortEnum.TITLE_ASC ? SortEnum.TITLE_DESC : SortEnum.TITLE_ASC;
            YearSort          = sortOrder == SortEnum.YEAR_ASC ? SortEnum.YEAR_DESC : SortEnum.YEAR_ASC;
            AuthorNameSort    = sortOrder == SortEnum.AUTHOR_NAME_ASC ? SortEnum.AUTHOR_NAME_DESC : SortEnum.AUTHOR_NAME_ASC;
            AuthorSurnameSort = sortOrder == SortEnum.AUTHOR_SURNAME_ASC ? SortEnum.AUTHOR_SURNAME_DESC : SortEnum.AUTHOR_SURNAME_ASC;
            RateSort          = sortOrder == SortEnum.RATE_ASC ? SortEnum.RATE_DESC : SortEnum.RATE_ASC;

            Up = true;

            if (sortOrder == SortEnum.TITLE_DESC ||
                sortOrder == SortEnum.YEAR_DESC ||
                sortOrder == SortEnum.AUTHOR_NAME_DESC ||
                sortOrder == SortEnum.AUTHOR_SURNAME_DESC ||
                sortOrder == SortEnum.RATE_DESC)
            {
                Up = false;
            }
            Current = sortOrder;
        }
Esempio n. 30
0
        private static IQueryable <T> Order <T, TK>(IQueryable <T> source,
                                                    Expression <Func <T, TK> > orderByExpression,
                                                    SortEnum sortOrder = SortEnum.Original)
        {
            //排序
            switch (sortOrder)
            {
            case SortEnum.Original:
                break;

            case SortEnum.Asc:
                source = source.OrderBy(orderByExpression);
                break;

            case SortEnum.Desc:
                source = source.OrderByDescending(orderByExpression);
                break;
            }
            return(source);
        }
 public OrderByAnalyser(String property, SortEnum sort)
 {
     this.Property = property;
     this.Sort = sort;
 }
Esempio n. 32
0
        PageData<UserData> IAccountService.GetUsers(SortEnum sortType, string term, int pageId, int pageSize, RoleEnum currentUserRole)
        {
            var pageData = new PageData<UserData> { PageId = pageId, PageSize = pageSize };

            var data = !string.IsNullOrWhiteSpace(term)
                ? _userRepository.GetQueryableData(o => o.UserName.Contains(term))
                : _userRepository.GetQueryableData();

            data = data.Where(o => o.RoleId != (int)RoleEnum.MainAdministrator);

            if (currentUserRole == RoleEnum.Administrator)
                data = data.Where(o => o.RoleId != (int)RoleEnum.Administrator);

            pageData.Count = data.Count();

            if (pageData.Count != 0)
            {
                switch (sortType)
                {
                    case SortEnum.Default:
                        data = data.OrderBy(o => !o.IsActive).ThenBy(o => o.IsBanned).ThenBy(o => o.UserName);
                        break;
                    case SortEnum.Name:
                        data = data.OrderBy(o => o.UserName);
                        break;
                    case SortEnum.Email:
                        data = data.OrderBy(o => o.Email);
                        break;
                    case SortEnum.Actived:
                        data = data.OrderBy(o => !o.IsActive).ThenBy(o => o.IsBanned).ThenBy(o => o.UserName);
                        break;
                    case SortEnum.Banned:
                        data = data.OrderBy(o => !o.IsBanned).ThenBy(o => !o.IsActive).ThenBy(o => o.UserName);
                        break;
                }

                pageData.Data = data.Page(pageData.PageId, pageData.PageSize).Select(o => new UserData
                {
                    Id = o.Id,
                    UserName = o.UserName,
                    Email = o.Email,
                    IsActive = o.IsActive,
                    PhotoPath = o.PhotoPath,
                    IsBanned = o.IsBanned,
                    RoleId = o.RoleId
                }).ToList();
            }

            return pageData;
        }
 public static OrderByAnalyser CreateSort(String property, SortEnum sort)
 {
     return new OrderByAnalyser(property, sort);
 }