public async Task <Page <EmployeeViewData> > GetPaginatedResultsAsync(
            int pageSize,
            int currentPage,
            string searchText,
            EmployeeSearchOptions sortBy,
            EmployeeSearchOptions searchBy)
        {
            var filters = new Filters <EmployeeViewData>();

            switch (searchBy)
            {
            case EmployeeSearchOptions.LastName:
                filters.Add(!string.IsNullOrEmpty(searchText), x => x.LastName.Contains(searchText));
                break;

            case EmployeeSearchOptions.FirstName:
            default:
                filters.Add(!string.IsNullOrEmpty(searchText), x => x.FirstName.Contains(searchText));
                break;
            }

            var sorts = new Sorts <EmployeeViewData>();

            sorts.Add(sortBy == EmployeeSearchOptions.FirstName, x => x.FirstName);
            sorts.Add(sortBy == EmployeeSearchOptions.LastName, x => x.LastName);

            return(await _dbContext.Employees
                   .Select(e => _mapper.MapToViewModel(e))
                   .PaginateAsync(currentPage, pageSize, sorts, filters));
        }
Esempio n. 2
0
        private void sortGroups(ref List <AttributeGroupDTO> groups, Sorts s)
        {
            switch (s)
            {
            case Sorts.ArabicNameDown: groups.Sort((a, b) => - 1 * a.ArabicName.CompareTo(b.ArabicName));     //products.OrderBy(op => op.Name);
                break;

            case Sorts.ArabicNameUp: groups.Sort((a, b) => a.ArabicName.CompareTo(b.ArabicName));
                break;

            case Sorts.EnglishNameDown: groups.Sort((a, b) => - 1 * a.EnglishName.CompareTo(b.EnglishName));   //products.OrderBy(op => op.Price);
                break;

            case Sorts.EnglishNameUp: groups.Sort((a, b) => a.EnglishName.CompareTo(b.EnglishName));
                break;

            case Sorts.IdDown: groups.Sort((a, b) => - 1 * a.Id.CompareTo(b.Id));
                break;

            case Sorts.IdUp: groups.Sort((a, b) => a.Id.CompareTo(b.Id));
                break;
                //case Sorts.StatusDown: groups.Sort((a, b) => -1 * a.Status.CompareTo(b.Status));
                //    break;
                //case Sorts.StatusUp: groups.Sort((a, b) => a.Status.CompareTo(b.Status));
                //    break;
            }
        }
        public Page <Employee> GetFilteredEmployees(int pageSize, int currentPage, string searchText, int sortBy, string jobTitle)
        {
            Page <Employee> employees;
            var             filters = new Filters <Employee>();

            filters.Add(!string.IsNullOrEmpty(searchText), x => x.LoginID.Contains(searchText));
            filters.Add(!string.IsNullOrEmpty(jobTitle), x => x.JobTitle.Equals(jobTitle));

            var sorts = new Sorts <Employee>();

            //Example without priority.
            //sorts.Add(sortBy == 2, x => x.LoginID);
            //sorts.Add(sortBy == 1, x => x.BusinessEntityID);
            //sorts.Add(sortBy == 3, x => x.JobTitle);

            sorts.Add(sortBy == 3, x => x.JobTitle, false, 1);
            sorts.Add(sortBy == 1, x => x.BusinessEntityID, true, 2);
            sorts.Add(true, x => x.LoginID, true, 3);

            using (var context = new AdventureWorksEntities())
            {
                employees = context.Employees.Paginate(currentPage, pageSize, sorts, filters);
            }

            return(employees);
        }
Esempio n. 4
0
 private void SetOrderByForMember(MemberExpression memberExp, LambdaExpression fullExpression, SortType sortType)
 {
     if (memberExp.Expression.NodeType == ExpressionType.MemberAccess)
     {
         //分组查询
         if (IsGroupBy)
         {
             var descriptor = GroupByPropertyList.FirstOrDefault(m => m.Alias == memberExp.Member.Name);
             if (descriptor != null)
             {
                 var colName = GetColumnName(descriptor.Name, descriptor.JoinDescriptor);
                 Sorts.Add(new Sort(colName, sortType));
             }
         }
         else
         {
             if (memberExp.Expression.Type.IsString())
             {
                 var memberName = memberExp.Member.Name.Equals("Length");
                 //解析Length函数
                 if (memberName)
                 {
                     var funcName = _sqlAdapter.FuncLength;
                     var colName  = GetColumnName(memberExp.Expression as MemberExpression, fullExpression);
                     Sorts.Add(new Sort($"{funcName}({colName})", sortType));
                 }
             }
         }
     }
     else
     {
         var colName = GetColumnName(memberExp, fullExpression);
         Sorts.Add(new Sort(colName, sortType));
     }
 }
Esempio n. 5
0
        public Page <STUDENT> FilterStudent(int PageSize, int CurrentPage, string SearchText, int SortBy, string Department)
        {
            /*
             * PageSize - no. of records
             * CurrentPage - Page no.
             * SearchText - Student Name only
             * SortBy - drop down for section (value returned=1) sem(2) USN(3)
             * Department - dropdown department name. (value returned should be dept name)
             */
            Page <STUDENT> students;
            var            filters = new Filters <STUDENT>();

            filters.Add(!string.IsNullOrEmpty(SearchText), x => x.NAME.Contains(SearchText));
            filters.Add(!string.IsNullOrEmpty(SearchText), x => x.DEPT.DeptName.Equals(Department));
            var sorts = new Sorts <STUDENT>();

            sorts.Add(SortBy == 1, x => x.Section, true);
            sorts.Add(SortBy == 2, x => x.Sem, true);
            sorts.Add(SortBy == 3, x => x.USN, true);
            using (var Context = new RNSITEntities())
            {
                students = Context.STUDENTs.Paginate(CurrentPage, PageSize, sorts, filters);
            }
            return(students);
        }
Esempio n. 6
0
        async Task SendLastUpdatedContentsAsync()
        {
            try
            {
                var filterBy = Filters <Content> .And(
                    Filters <Content> .Equals("Status", $"{ApprovalStatus.Published}"),
                    Filters <Content> .GreaterOrEquals("StartingTime", "@nowHourQuater()"),
                    Filters <Content> .Or(
                        Filters <Content> .Equals("EndingTime", "-"),
                        Filters <Content> .LessThan("EndingTime", "@nowHourQuater()")
                        ),
                    Filters <Content> .IsNull("ParentID")
                    );

                Func <string> func_GetNowHourQuater = () => this.GetNowHourQuater().ToDTString();
                filterBy.Prepare(null, null, new Dictionary <string, object>
                {
                    { "nowHourQuater", func_GetNowHourQuater }
                });
                var sortBy = Sorts <Content> .Descending("StartingTime").ThenByDescending("LastUpdated");

                var objects = await Content.FindAsync(filterBy, sortBy, 20, 1, $"{this.GetCacheKey(filterBy, sortBy)}:1", this.CancellationTokenSource.Token).ConfigureAwait(false);

                var messages = objects.Select(content => new BaseMessage
                {
                    Type = $"{this.ServiceName}#Content#Update",
                    Data = content.ToJson()
                }).ToList();
                await this.SendUpdateMessagesAsync(messages, "*", null, this.CancellationTokenSource.Token).ConfigureAwait(false);
            }
            catch { }
        }
 public Sort(Sorts sortilege, int coutMana, int puissance)
 {
     m_Niveau = 1;
     m_CoutMana = coutMana;
     m_Sortilege = sortilege;
     m_Puissance = puissance;
 }
            public Page <Employee> GetEmployeeReport(int pageSize, int currentPage, string searchText, int sortBy, string jobPosition, string empDepartment)
            {
                Page <Employee> employees;
                var             filters = new Filters <Employee>();

                filters.Add(!string.IsNullOrEmpty(searchText), x => x.Firstname.Contains(searchText));
                filters.Add(!string.IsNullOrEmpty(jobPosition), x => x.JobTitle.Equals(jobPosition));
                filters.Add(!string.IsNullOrEmpty(empDepartment), x => x.Department.Equals(empDepartment));

                var sorts = new Sorts <Employee>();

                //Example without priority.
                //sorts.Add(sortBy == 2, x => x.LoginID);
                //sorts.Add(sortBy == 1, x => x.BusinessEntityID);
                //sorts.Add(sortBy == 3, x => x.JobTitle);

                sorts.Add(sortBy == 3, x => x.JobTitle, false, 1);
                sorts.Add(sortBy == 1, x => x.Department, true, 2);
                sorts.Add(true, x => x.Firstname, true, 3);



                employees = _context.Employees.Paginate(currentPage, pageSize, sorts, filters);


                return(employees);
            }
Esempio n. 9
0
        public void QuickSortTest()
        {
            var arr    = new int[] { 10, 5, 3, 12, 45, 90, 110, 100, 120 };
            var expect = new int[] { 3, 5, 10, 12, 45, 90, 100, 110, 120 };

            Assert.Equal(expect, Sorts.QuickSort(arr, 0, 8));
        }
Esempio n. 10
0
        public async Task <TransactionHistoryPage <TransactionHistory> > GetEvents(TransactionHistoryQuery transactionHistoryQuery)
        {
            if (transactionHistoryQuery.From != null)
            {
                transactionHistoryQuery.From = transactionHistoryQuery.From.Value.ToUniversalTime();
            }
            if (transactionHistoryQuery.To != null)
            {
                transactionHistoryQuery.To = transactionHistoryQuery.To.Value.ToUniversalTime();
            }

            var sorts = new Sorts <Data.Models.TransactionHistory>();

            sorts.Add(true, x => x.OccuredAt, true);

            var filters = new Filters <Data.Models.TransactionHistory>();

            filters.Add(!string.IsNullOrEmpty(transactionHistoryQuery.NodeId), x => x.NodeId == transactionHistoryQuery.NodeId);
            filters.Add(transactionHistoryQuery.NodeIds != null && transactionHistoryQuery.NodeIds.Any(), x => transactionHistoryQuery.NodeIds.Contains(x.NodeId));
            filters.Add(transactionHistoryQuery.From != null, x => x.OccuredAt > transactionHistoryQuery.From);
            filters.Add(transactionHistoryQuery.To != null, x => x.OccuredAt < transactionHistoryQuery.To);

            var result = await _transactionHistoryRepository.GetTransactionHistory(transactionHistoryQuery.CurrentPage, transactionHistoryQuery.PageSize, sorts, filters);

            return(_mapper.Map <TransactionHistoryPage <TransactionHistory> >(result));
        }
Esempio n. 11
0
        private void sortCategories(ref List <CategoryManegerDTO> categories, Sorts s)
        {
            switch (s)
            {
            case Sorts.ArabicNameDown: categories.Sort((a, b) => - 1 * a.ArabicName.CompareTo(b.ArabicName));      //products.OrderBy(op => op.Name);
                break;

            case Sorts.ArabicNameUp: categories.Sort((a, b) => a.ArabicName.CompareTo(b.ArabicName));
                break;

            case Sorts.EnglishNameDown: categories.Sort((a, b) => - 1 * a.EnglishName.CompareTo(b.EnglishName));    //products.OrderBy(op => op.Price);
                break;

            case Sorts.EnglishNameUp: categories.Sort((a, b) => a.EnglishName.CompareTo(b.EnglishName));
                break;

            case Sorts.IdDown: categories.Sort((a, b) => - 1 * a.Id.CompareTo(b.Id));
                break;

            case Sorts.IdUp: categories.Sort((a, b) => a.Id.CompareTo(b.Id));
                break;

            case Sorts.StatusDown: categories.Sort((a, b) => - 1 * a.Status.CompareTo(b.Status));
                break;

            case Sorts.StatusUp: categories.Sort((a, b) => a.Status.CompareTo(b.Status));
                break;
            }
        }
Esempio n. 12
0
        private void sortDiscounts(ref List <DiscountDTO> options, Sorts s)
        {
            switch (s)
            {
            case Sorts.ArabicNameDown: options.Sort((a, b) => - 1 * a.ArabicName.CompareTo(b.ArabicName));
                break;

            case Sorts.ArabicNameUp: options.Sort((a, b) => a.ArabicName.CompareTo(b.ArabicName));
                break;

            case Sorts.EnglishNameDown: options.Sort((a, b) => - 1 * a.EnglishName.CompareTo(b.EnglishName));
                break;

            case Sorts.EnglishNameUp: options.Sort((a, b) => a.EnglishName.CompareTo(b.EnglishName));
                break;

            case Sorts.IdDown: options.Sort((a, b) => - 1 * a.Id.CompareTo(b.Id));
                break;

            case Sorts.IdUp: options.Sort((a, b) => a.Id.CompareTo(b.Id));
                break;

            case Sorts.StatusDown: options.Sort((a, b) => - 1 * a.IsPercentage.CompareTo(b.IsPercentage));
                break;

            case Sorts.StatusUp: options.Sort((a, b) => a.IsPercentage.CompareTo(b.IsPercentage));
                break;

            case Sorts.ValueDown: options.Sort((a, b) => - 1 * a.Value.CompareTo(b.Value));
                break;

            case Sorts.ValueUp: options.Sort((a, b) => a.Value.CompareTo(b.Value));
                break;
            }
        }
Esempio n. 13
0
        public void MergeSortTest()
        {
            var arr    = new int[] { 10, 5, 3, 12, 45 };
            var expect = new int[] { 3, 5, 10, 12, 45 };

            Assert.Equal(expect, Sorts.MergeSort(arr));
        }
Esempio n. 14
0
        public async Task <IActionResult> PutSorts([FromRoute] Guid id, [FromBody] Sorts sorts)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            if (id != sorts.Id)
            {
                return(BadRequest());
            }

            _context.Entry(sorts).State = EntityState.Modified;

            try
            {
                await _context.SaveChangesAsync();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!SortsExists(id))
                {
                    return(NotFound());
                }
                else
                {
                    throw;
                }
            }

            return(NoContent());
        }
Esempio n. 15
0
        public JsonResult UserTypeTableAjax(JQueryDataTableParamModel param)
        {
            #region byDefaultReturnData

            int rowCount   = 0;
            int lnRowCount = 0;
            var result     = from q in new List <UserType>()
                             select new
            {
                q.Id,
                q.Name
            };

            #endregion
            var oUserType = new UserType();
            if (!string.IsNullOrEmpty(Request.QueryString["Name"]))
            {
                oUserType.Name = Request.QueryString["Name"];
            }

            DataTableProcessModel m         = new DataTableProcessModel();
            DataTableProcessModel dtProcess = DataTableProcesses.DataTableEslestir(param, m);
            //oUserType.SortCol = dtProcess.SortCol;
            //oUserType.SortType = dtProcess.SortType;
            //oUserType.Page = dtProcess.Page;
            //oUserType.RowPerPage = dtProcess.RowPerPage;
            //var oResultModel = DAL.Account.UserType.GetUserType(oUserType);

            var filters = new Filters <UserType>();
            //filters.Add(Convert.ToBoolean(oUserType.Name), x => x.Name == oUserType.Name);
            filters.Add(true, x => x.IsDeleted == false);

            var sorts = new Sorts <UserType>();
            sorts.Add(dtProcess.SortCol == "Id", x => x.Name);

            var getUsers = _db.UserTypes.Paginate(dtProcess.Page, dtProcess.RowPerPage, sorts, filters);

            if (getUsers.RecordCount > 0)
            {
                var lstUserType = getUsers.Results;

                rowCount   = getUsers.RecordCount;
                lnRowCount = rowCount;

                result = from q in lstUserType
                         select new
                {
                    q.Id,
                    q.Name
                };
            }
            return(Json(new
            {
                param.sEcho,
                iTotalRecords = rowCount,
                iTotalDisplayRecords = lnRowCount,
                aaData = result
            },
                        JsonRequestBehavior.AllowGet));
        }
        public async Task <IHttpActionResult> PutSorts(int id, Sorts sorts)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            if (id != sorts.Id_sorts)
            {
                return(BadRequest());
            }

            db.Entry(sorts).State = EntityState.Modified;

            try
            {
                await db.SaveChangesAsync();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!SortsExists(id))
                {
                    return(NotFound());
                }
                else
                {
                    throw;
                }
            }

            return(StatusCode(HttpStatusCode.NoContent));
        }
Esempio n. 17
0
        public List <UserDTO> Filter(string fName, string email, Sorts s)
        {
            List <string> usersIds = db.Users.ToList().Select(c => c.Id).ToList();

            if (!String.IsNullOrEmpty(fName))
            {
                List <string> ids = db.Users.ToList().Where(c => (c.FirstName + " " + c.LastName).ToLower().Contains(fName.ToLower())).Select(c => c.Id).ToList();;
                usersIds = usersIds.Intersect(ids).ToList();
            }
            if (!String.IsNullOrEmpty(email))
            {
                List <string> ids = db.Users.ToList().Where(c => c.Email.ToLower().Contains(email.ToLower())).Select(c => c.Id).ToList();;
                usersIds = usersIds.Intersect(ids).ToList();
            }
            var users = db.Users.ToList().Where(c => usersIds.Contains(c.Id)).ToList();

            var usersDtos = new List <UserDTO>();

            foreach (var user in users)
            {
                var userDto = new UserDTO();
                userDto.Email         = user.Email;
                userDto.FirstName     = user.FirstName;
                userDto.LastName      = user.LastName;
                userDto.AccountLock   = user.LockoutEnabled;
                userDto.AccountStatus = user.EmailConfirmed;
                userDto.Id            = user.Id;
                userDto.UserName      = user.UserName;
                usersDtos.Add(userDto);
            }
            // return usersDtos;
            sortUsers(ref usersDtos, s);
            return(usersDtos);
        }
Esempio n. 18
0
        public void Sort_Tests(int[,] array, Sorts strategy, SortOrder sortOrder, int[,] expectedArray)
        {
            SortContext sortContext = new SortContext(strategy);

            sortContext.ExecuteSort(array, sortOrder);
            Assert.AreEqual(array, expectedArray);
        }
Esempio n. 19
0
        private void sortUsers(ref List <UserDTO> users, Sorts s)
        {
            switch (s)
            {
            case Sorts.EmailDown: users.Sort((a, b) => - 1 * a.Email.CompareTo(b.Email));
                break;

            case Sorts.EmailUp: users.Sort((a, b) => a.Email.CompareTo(b.Email));
                break;

            case Sorts.CustomerNameDown: users.Sort((a, b) => - 1 * a.FullName.CompareTo(b.FirstName));
                break;

            case Sorts.CustomerNameUp: users.Sort((a, b) => a.FullName.CompareTo(b.FirstName));
                break;

            case Sorts.StatusUp: users.Sort((a, b) => a.AccountStatus.CompareTo(b.AccountStatus));     //products.OrderBy(op => op.Price);
                break;

            case Sorts.StatusDown: users.Sort((a, b) => - 1 * a.AccountStatus.CompareTo(b.AccountStatus));
                break;

            case Sorts.lockedUp: users.Sort((a, b) => a.AccountLock.CompareTo(b.AccountLock));     //products.OrderBy(op => op.Price);
                break;

            case Sorts.lockedDown: users.Sort((a, b) => - 1 * a.AccountLock.CompareTo(b.AccountLock));
                break;
            }
        }
Esempio n. 20
0
        public async Task <HttpResponseMessage> GetAllPeopleAsync(string name, string last = "", string ascDesc = "")
        {
            var page    = new Pages();
            var filter  = new Filters();
            var sorting = new Sorts();

            // 1. Da bi mogli search koristiti korisnik mora barem "name" napisati  kako bi mogao pretrazivati
            // 2. Korisnik ne mora puno ime napisati moze cak i pocetno slovo
            // 3. Dodatno moze koristiti i "last" da pretrazuje po prezimenu osobu
            // 4. Moze asc ili desc koristiti za age  (harkodirano zbog malo atributa u tablici)

            filter.FirstName = name;
            filter.LastName  = last;

            page.PageSize = 5;
            //Age harkodirano zato sto imamo malo atributa u tablici pa cisto radi testiranja je stavjeno Age
            sorting.OrderBy = "Age";
            sorting.AscDesc = ascDesc;

            var allPeople = await Service.GetAllPeopleAsync(filter, page, sorting);

            if (allPeople != null)
            {
                return(Request.CreateResponse(HttpStatusCode.OK, allPeople));
            }
            return(Request.CreateResponse(HttpStatusCode.NotFound, "Not Found"));
        }
Esempio n. 21
0
 public HomePageViewModel(MainWindow mainForm)
 {
     this.mainForm    = mainForm;
     TmpList          = AdList;
     CurrentSelection = Sorts.First();
     SortChangedClick();
 }
Esempio n. 22
0
        public void TestBucketSort_ExpectedException()
        {
            var expected = sortArray;
            var actual   = Sorts.BucketSort(array, -0);

            CollectionAssert.AreEqual(expected, actual);
        }
Esempio n. 23
0
        private void ParseSort(string query)
        {
            var rexFilter = new Regex(SortParseRegex);

            var matches = rexFilter.Matches(query);

            foreach (Match match in matches)
            {
                string field     = null;
                var    direction = true;

                if (!string.IsNullOrEmpty(match.Groups[SortFieldName].Value))
                {
                    field = match.Groups[SortFieldName].Value;
                }
                if (!string.IsNullOrEmpty(match.Groups[SortDirectionName].Value))
                {
                    direction = match.Groups[SortDirectionName].Value == AscOperator;
                }

                var filter = new QuerySort
                {
                    Field = field,
                    Asc   = direction
                };

                Sorts.Add(filter);
            }
        }
Esempio n. 24
0
        public void TestBucketSort_null()
        {
            int[] expected = null;
            var   actual   = Sorts.BucketSort(expected, 100);

            CollectionAssert.AreEqual(expected, actual);
        }
Esempio n. 25
0
        public void TestBucketSort_norm()
        {
            var expected = sortArray;
            var actual   = Sorts.BucketSort(array, 100);

            CollectionAssert.AreEqual(expected, actual);
        }
Esempio n. 26
0
        static void Main(string[] args)
        {
            int    size          = 100000;
            string fileName      = "file.txt";
            string referenceFile = "referenceFile.txt";
            string sortFile      = "sortFile.txt";

            if (File.Exists(fileName))
            {
                File.Delete(fileName);
            }
            if (File.Exists(referenceFile))
            {
                File.Delete(referenceFile);
            }
            if (File.Exists(sortFile))
            {
                File.Delete(sortFile);
            }

            Generator(fileName, referenceFile, 1000000);

            Sorts.ExternalSort(fileName, sortFile, size);
            Console.ReadKey();
        }
Esempio n. 27
0
        //builds and starts a sorting thread of the given sorting type.
        private void sort(Sorts the_sort)
        {
            //removes the old sorting thread if present
            if (my_drawable != null)
            {
                resetOldThread();
            }

            //gets the maximum input value from the user
            int max = getMax();

            if (max == -1)
            {
                return;
            }

            //setup new sorting thread
            my_drawable = new DrawnSort(the_sort, getInputArray(max), pnlDraw.Width, pnlDraw.Height, max, drawPanel, this);

            //make sure old memory is reclaimed (otherwise a leak can occur)
            GC.Collect();
            GC.WaitForPendingFinalizers();

            //start the sorting thread
            my_drawable.start();
        }
Esempio n. 28
0
        public void MergeSortTestMethod_Null_Array()
        {
            //Arange
            int[] initialArray = null;

            //Assert
            Assert.Throws <ArgumentNullException>(() => Sorts.QuickSort(initialArray));
        }
Esempio n. 29
0
        public void MergeSortTestMethod_Empty_Array()
        {
            //Arange
            int[] initialArray = new int[] { };

            //Assert
            Assert.Throws <ArgumentException>(() => Sorts.QuickSort(initialArray));
        }
Esempio n. 30
0
 /// <summary>
 /// 解析函数
 /// </summary>
 /// <param name="callExp"></param>
 /// <param name="funcName"></param>
 /// <param name="sortType"></param>
 private void ResolveSelectForFunc(MethodCallExpression callExp, string funcName, SortType sortType)
 {
     if (callExp.Arguments[0] is UnaryExpression unary && unary.Operand is LambdaExpression lambda)
     {
         var colName = GetColumnName(lambda.Body as MemberExpression, lambda);
         Sorts.Add(new Sort($"{funcName}({colName})", sortType));
     }
 }
Esempio n. 31
0
        private void SortBtn_Click(object sender, EventArgs e)
        {
            Sorts sorts = new Sorts();

            sorts.QuicSort(list);
            list.Reverse();
            SetDGV();
        }
Esempio n. 32
0
 public PocketRetrieveItem(string ConsumerKey, string AccessToken, States State = States.Unread, Favorites Favorite = Favorites.Both, string Tag = null, ContentTypes ContentType = ContentTypes.All, Sorts Sort = Sorts.NoSort, DetailTypes DetailType = DetailTypes.NoType, string Search = null, string Domain = null, string Since = null, int Count = -1, int Offset = -1)
 {
     _consumerKey = ConsumerKey;
     _accessToken = AccessToken;
     _state = State;
     _favorite = Favorite;
     _tag = Tag;
     _contentType = ContentType;
     _sort = Sort;
     _detailType = DetailType;
     _search = Search;
     _domain = Domain;
     _since = Since;
     _count = Count;
     _offset = Offset;
 }
Esempio n. 33
0
 public ActionResult GetProducts(int page,int pageSize,int? categoryId,int? parentCategoryId,string brandIds,string colorIds,Sorts? sortCondition)
 {
     var brandIdValues = new List<int>();
     if (!string.IsNullOrEmpty(brandIds))
     {
         brandIdValues = brandIds.Split(',').Select(int.Parse).ToList();
     }
     var colorIdValues = new List<int>();
     if (!string.IsNullOrEmpty(colorIds))
     {
         colorIdValues = colorIds.Split(',').Select(int.Parse).ToList();
     }
     var isLastPage = false;
     var products = _productService.GetProductsByCondition(page, pageSize, out isLastPage, categoryId, parentCategoryId, brandIdValues, colorIdValues, sortCondition);
     var productsModel = AutoMapper.Mapper.Map<List<ProductViewModel>>(products);
     var html = this.RenderPartialViewToString("GetProducts", productsModel);
     return Json(new {isLastPage, html});
 }
Esempio n. 34
0
        public List<Product> GetProductsByCondition(int page, int pageSize, out bool isLastPage, int? categoryId,int? parentCategoryId,List<int> brandIds,List<int> colorIds,Sorts? sortCondition )
        {
            Func<Product, bool> whereClause = delegate(Product p)
                                  {

                                      if (!categoryId.HasValue)
                                      {
                                          if (!parentCategoryId.HasValue)
                                          {
                                              return true;
                                          }
                                          else
                                          {
                                              return
                                                  p.ProductCategories.Select(x => x.Category.ParentCategoryId).Contains(
                                                      parentCategoryId.Value);
                                          }
                                      }
                                      else
                                      {
                                          return p.ProductCategories.Select(k => k.CategoryId).Contains(categoryId.Value);
                                      }
                                  };
            Func<Product, bool> whereBrandClause = delegate(Product p)
            {
                if(brandIds!=null&&brandIds.Count!=0)
                {
                    if(p.BrandId.HasValue)
                    {
                        return brandIds.Contains(p.BrandId.Value);
                    }
                    else
                    {
                        return false;
                    }

                }
                else
                {
                    return true;
                }

            };
            Func<Product, bool> whereColorsClause = delegate(Product p)
                                                        {
                                                            if(colorIds!=null)
                                                            {
                                                                if(colorIds.Count==0)
                                                                {
                                                                    return true;
                                                                }
                                                                else
                                                                {
                                                                    var productColors = p.ProductColors.Select(x => x.ColorId).Distinct().ToList();
                                                                    return productColors.Any(colorIds.Contains);
                                                                }
                                                            }
                                                            else
                                                            {
                                                                return true;
                                                            }

                                                        };
            var productsList = Context.Products
                .Where(whereClause).Where(whereBrandClause).Where(whereColorsClause);
            if(sortCondition.HasValue)
            {
                switch (sortCondition.Value)
                {
                    case Sorts.New:
                        productsList =
                            productsList.OrderByDescending(x => x.CreatedDate).ThenByDescending(x => x.UpdatedDate);
                        break;
                    case Sorts.Old:
                        productsList =
                           productsList.OrderBy(x => x.CreatedDate).ThenBy(x => x.UpdatedDate);
                        break;
                    case Sorts.BestSell:
                        productsList = productsList.OrderBy(x =>
                                                                {
                                                                    var countInOrder = 0;
                                                                    if(x.OrderDetails!=null)
                                                                    {
                                                                        countInOrder =
                                                                            x.OrderDetails.Sum(k => k.Quantity);
                                                                    }
                                                                    return countInOrder;
                                                                });
                        break;
                    case Sorts.DescPrice:
                        productsList = productsList.OrderByDescending(x => x.Price);
                        break;
                    case Sorts.AscPrice:
                        productsList = productsList.OrderBy(x => x.Price);
                        break;
                    case Sorts.Az:
                        productsList = productsList.OrderBy(x => x.ProductName);
                        break;
                    case Sorts.Za:
                        productsList = productsList.OrderByDescending(x => x.ProductName);
                        break;
                }
            }
            else
            {
                productsList =
                           productsList.OrderByDescending(x => x.CreatedDate).ThenByDescending(x => x.UpdatedDate);
            }
            var products = productsList.Skip((page) * pageSize)
                      .Take(pageSize);
            isLastPage = !Context.Products
                .Where(whereClause).Where(whereBrandClause).Where(whereColorsClause).Skip((page + 1) * pageSize).Take(pageSize).Any();
            return products.ToList();
        }
Esempio n. 35
0
 public Tile(Sorts sort)
 {
     this.Sort = sort;
 }