private async Task <ProjectsViewModel> GetProjectsViewModelAsync(IPagingParameters pagingParameters) { var sortingParameter = new SortingParameters(); sortingParameter.Add(new SortingPair(nameof(IProjectPoco.DateCreated), false)); var statuses = lookupService.GetAllTaskStatus(); var domainList = await projectService.GetProjectsPagedAsync(pagingParameters, p => p.CompanyId == this.CompanyId, sortingParameter, this.ToNavPropertyString(nameof(IProjectPoco.Tasks)), this.ToNavPropertyString(nameof(IProjectPoco.ProjectUsers), nameof(IProjectUserPoco.User))); var vmProjects = new StaticPagedList <ProjectPreviewViewModel>(Mapper.Map <IEnumerable <ProjectPreviewViewModel> >(domainList.ToList()), pagingParameters.PageNumber, pagingParameters.PageSize, domainList.TotalItemCount); foreach (var project in vmProjects) { var tasks = domainList.First(p => p.Id == project.Id).Tasks; var team = Mapper.Map <IEnumerable <UserPreviewViewModel> >(domainList.First(p => p.Id == project.Id).ProjectUsers.Select(d => d.User)); project.TaskCount = tasks.Count(); project.CompletedTaskCount = tasks.Where(d => d.StatusId == statuses.First(s => s.Abrv == "CLOSED").Id).Count(); project.LateTaskCount = tasks.Where(p => p.DueDate <= DateTime.UtcNow).Count(); project.TeamMembers = team; } var vm = new ProjectsViewModel() { Projects = vmProjects }; return(vm); }
public PolyPhaseSorting(SortingParameters sortingParameters, FileParameters fileParameters) { CreateSortingObjects(sortingParameters, fileParameters); distributionTask = new Task(distribute); stepTask = new Task(step); mergeTask = new Task(merge); }
public async Task <IActionResult> Products(int pageNumber = 1, int pageSize = 10, string orderBy = "", bool isAscending = true) { _logger.LogInformation("Request received for [{action}] GET action", nameof(ProductsController.Products)); if (string.IsNullOrWhiteSpace(orderBy)) { orderBy = nameof(Product.DateCreated); } var sortingParameters = new SortingParameters(); sortingParameters.Add(orderBy, isAscending); var list = await _catalogService.GetProductsPagedAsync(null, sortingParameters, pageNumber, pageSize); var lkpCategories = _lookupServiceFactory.Create <ProductCategory>(); var productCategories = await lkpCategories.GetAllAsync(); var vm = new ProductsViewModel { Products = new PagedCollection <ProductDTO>(Mapper.Map(list).ToANew <IEnumerable <ProductDTO> >(), list.TotalItemCount, list.PageNumber, list.PageSize), Categories = productCategories.ToDictionary(key => key.Id, value => value.Name) }; return(View(vm)); }
public void sortAlreadySortedfile() { var testFilePath = "D:\\FileToSort.txt"; var unsortedFileLinesArray = new string[] { "1", "2", "3", "4", "5" }; var sortedFileContent = string.Join(Environment.NewLine, unsortedFileLinesArray) + Environment.NewLine; File.WriteAllText(testFilePath, string.Join(Environment.NewLine, unsortedFileLinesArray) + Environment.NewLine); var sortingParameters = new SortingParameters() { NumberOfTemporaryFiles = 2 }; var fileParameters = new FileParameters() { BlockSize = 4, SourceFileName = testFilePath, TemporaryBufferFileDirectory = "D:\\", Separator = " " }; var sorter = new PolyPhaseSorting(sortingParameters, fileParameters); sorter.Distribution.Distribute(); sorter.Merger.Merge(); sorter.RestoreOriginalFileName(); var actualFileContent = File.ReadAllText(testFilePath); Assert.AreEqual(sortedFileContent, actualFileContent); Console.WriteLine("Statistics:\nRead accesses:\t{0}\nWrite acesses:\t{1}\nSteps:\t{2}", sorter.ReadAccesses, sorter.WriteAccesses, sorter.Steps); File.Delete(testFilePath); }
public void test() { var testFilePath = "D:\\TestFile.txt"; var sortingParameters = new SortingParameters() { NumberOfTemporaryFiles = 2 }; var fileParameters = new FileParameters() { BlockSize = 8, SourceFileName = testFilePath, TemporaryBufferFileDirectory = "D:\\", Separator = " " }; var sorter = new PolyPhaseSorting(sortingParameters, fileParameters); sorter.Distribution.Distribute(); sorter.Merger.Merge(); sorter.RestoreOriginalFileName(); var actualFileContent = File.ReadAllText(testFilePath); Assert.IsTrue(true); Console.WriteLine("Statistics:\nRead accesses:\t{0}\nWrite acesses:\t{1}\nSteps:\t{2}", sorter.ReadAccesses, sorter.WriteAccesses, sorter.Steps); File.Delete(testFilePath); }
/// <summary> /// Returns a <see cref="System.String" /> that represents this instance. /// </summary> /// <returns> /// A <see cref="System.String" /> that represents this instance. /// </returns> public override string ToString() { return(string.Format("{0}; {1}; {2}", SortingParameters != null ? SortingParameters.ToString() : string.Empty, PagingParameters != null ? PagingParameters.ToString() : string.Empty, Filter != null ? Filter.ToString() : string.Empty)); }
/// <summary> /// Get a list of <see cref="User"/>. /// </summary> /// <param name="lang">The language.</param> /// <param name="paging">The paging parameters.</param> /// <param name="sorting">The sorting parameters.</param> /// <param name="filtering">The filtering parameters.</param> /// <param name="fielding">The fielding parameters. (not used)</param> /// <returns>The pagined list of <see cref="User"/>.</returns> public PagedCollection <User> GetUsers(string lang, PagingParameters paging, SortingParameters sorting, FilteringParameters filtering, FieldingParameters fielding) { if (Session == null) { throw new Exception("Session is null"); } var result = Session.Read("users", paging.ToMDBPagingParameters(), sorting.ToSortDefinition(), filtering.ToFilterDefinition()); return(new PagedCollection <User> { Items = result.Items.ToUserList(), TotalNumberOfItems = result.TotalNumberOfItems, PageIndex = paging.Index, PageSize = paging.Size, TotalNumberOfPages = (long)Math.Ceiling(result.TotalNumberOfItems / (double)paging.Size) }); }
public ActionResult Item(int forumId, PagerParameters pagerParameters, SortingParameters sortingParameters) { if (!_orchardServices.Authorizer.Authorize(Permissions.ViewForum, T("Not allowed to view forum"))) return new HttpUnauthorizedResult(); var forumPart = _forumService.Get(forumId, VersionOptions.Published).As<ForumPart>(); if (forumPart == null) return HttpNotFound(); Pager pager = new Pager(_siteService.GetSiteSettings(), pagerParameters); var threads = _threadService .Get(forumPart, pager.GetStartIndex(), pager.PageSize, VersionOptions.Published) .Select(b => _orchardServices.ContentManager.BuildDisplay(b, "Summary")); dynamic forum = _orchardServices.ContentManager.BuildDisplay(forumPart); var list = Shape.List(); list.AddRange(threads); forum.Content.Add(Shape.Parts_Forums_Thread_List(ContentPart: forumPart, ContentItems: list), "5"); var totalItemCount = forumPart.ThreadCount; forum.Content.Add(Shape.Pager(pager).TotalItemCount(totalItemCount), "Content:after"); return new ShapeResult(this, forum); }
/// <summary> /// Gets vehicles. /// </summary> /// <param name="id">Id.</param> /// <param name="makerId">Maker id.</param> /// <param name="findVehicle">Find vehicle.</param> /// <param name="sortField">Sort field.</param> /// <param name="sortOrder">Sort order.</param> /// <param name="pageNumber">Page number.</param> /// <param name="pageSize">Page size.</param> /// <param name="sorting">Sorting.</param> /// <returns>Vehicles.</returns> public async Task <ActionResult> GetVehicles(Guid id, Guid?makerId, string findVehicle, string sortField, string sortOrder, int pageNumber = 1, int pageSize = 12, string sorting = "VehicleMaker.Name") { try { PagingParameters paging = new PagingParameters(pageNumber, pageSize); VehicleFilter filtering = new VehicleFilter(id, findVehicle, makerId); ViewBag.SortMaker = sorting == "VehicleMaker.Name" ? "VehicleMaker.Name desc" : "VehicleMaker.Name"; if (sorting.Contains("desc")) { string[] sorts = sorting.Split(); sortField = sorts[0]; sortOrder = sorts[1]; } else { sortField = sorting; sortOrder = ""; } SortingParameters sortingFilter = new SortingParameters(sortField, sortOrder); ViewBag.Makers = new SelectList(await makerService.GetMakersAsync(), "Id", "Name"); ViewBag.CurrentSort = sorting; ViewBag.CurrentSearch = findVehicle; ViewBag.CurrentMaker = makerId; return(View(await vehicleService.GetVehiclesAsync(paging, filtering, sortingFilter))); } catch { return(new HttpNotFoundResult("There are no vehicles")); } }
public static string GetDynamicLinqOrderByClauseExpression(this SortingParameters orderingParameters) { if (string.IsNullOrWhiteSpace(orderingParameters.SortField)) { throw new ArgumentException("Sort field cannot be null or empty", nameof(orderingParameters.SortField)); } return(string.Format("{0} {1}", orderingParameters.SortField, orderingParameters.SortReverse ? "desc" : "asc")); }
public static MvcHtmlString SortableHeader(this HtmlHelper row, string currentSort, string currentDirection, string columnId, string title, Func <object, string> actionFunc, object htmlAttributes = null) { var sortingInfo = new SortingParameters(); sortingInfo.ActionFunc = actionFunc; sortingInfo.Sort = currentSort; sortingInfo.SortDirection = currentDirection; return(row.SortableHeader(sortingInfo, columnId, title, htmlAttributes)); }
public static ISortingParameters FillSortingParameters(this ISortingParameters destination, ISortingParameters parameters) { if (destination == null) { destination = new SortingParameters(); } destination.Sort = parameters.Sort; destination.SortDirection = parameters.SortDirection; return destination; }
private async Task <IPagedList <UserPreviewViewModel> > GetUsersListViewModelsPaged(IPagingParameters pagingParameters, Guid companyId) { var sortingParameters = new SortingParameters(); sortingParameters.Add("DateCreated", false); var users = await UserStore.GetUsersByCompanyIdPagedAsync(pagingParameters, sortingParameters, companyId, this.ToNavPropertyString(nameof(IUserPoco.UserRoles), nameof(IUserRolePoco.Role))); return(new StaticPagedList <UserPreviewViewModel>(Mapper.Map <IEnumerable <UserPreviewViewModel> >(users.ToList()), pagingParameters.PageNumber, pagingParameters.PageSize, users.TotalItemCount)); }
public static ISortingParameters FillSortingParameters(this ISortingParameters destination, ISortingParameters parameters) { if (destination == null) { destination = new SortingParameters(); } destination.Sort = parameters.Sort; destination.SortDirection = parameters.SortDirection; return(destination); }
public override object BindModel(ControllerContext controllerContext, ModelBindingContext bindingContext) { object model = base.BindModel(controllerContext, bindingContext); var pagedModel = (ISortingParameters)model; if (pagedModel == null) { pagedModel = new SortingParameters(); } return(pagedModel); }
private async Task <IPagedList <TaskDTO> > GetTasksListPaged(IPagingParameters pagingParameters, Guid projectId) { var sortingParameters = new SortingParameters(); sortingParameters.Add("DateUpdated", false); var tasks = await taskService.GetTasksPagedAsync(pagingParameters, p => p.ProjectId == projectId, sortingParameters, this.ToNavPropertyString(nameof(ITaskPoco.AssignedToUser)), this.ToNavPropertyString(nameof(ITaskPoco.TaskComments))); var vm = new StaticPagedList <TaskDTO>(Mapper.Map <IEnumerable <TaskDTO> >(tasks.ToList()), pagingParameters.PageNumber, pagingParameters.PageSize, tasks.TotalItemCount); return(vm); }
public IHttpActionResult GetUsersList(string lang = null, PagingParameters paging = null, SortingParameters sorting = null, FilteringParameters filtering = null, FieldingParameters fielding = null) { try { if (paging == null) { paging = new PagingParameters(); } if (paging != null && !paging.IsValid) { throw new ArgumentException(nameof(paging)); } if (sorting != null && !sorting.IsValid) { throw new ArgumentException(nameof(sorting)); } if (filtering != null && !filtering.IsValid) { throw new ArgumentException(nameof(filtering)); } if (fielding != null && !fielding.IsValid) { throw new ArgumentException(nameof(fielding)); } return(Ok(Repository.GetUsers(lang, paging, sorting, filtering, fielding))); } catch (ArgumentException aex) { return(BadRequest(aex.Message)); } catch (SecurityException) { throw new HttpResponseException(HttpStatusCode.Forbidden); } catch (Exception ex) { return(InternalServerError(ex)); } }
protected static IQueryable <TEntity> ProcessSortingParameters <TEntity>(SortingParameters sortingParameters, IQueryable <TEntity> query) where TEntity : class { if (sortingParameters == null) { return(query); } var sortingNeeded = sortingParameters.SortNeeded(); if (sortingNeeded) { query = query.OrderBy(sortingParameters.GetDynamicLinqOrderByClauseExpression()); } return(query); }
private void createNewSorter() { TextBox_FileToSort.Text = filePath; linesIfChoosenFile = Utilities.getNumberOfLinesInFile(filePath); var fileParameters = new FileParameters() { BlockSize = int.Parse(TextBox_BlockSize.Text), Separator = " ", SourceFileName = filePath, TemporaryBufferFileDirectory = TextBox_BufferLocation.Text }; var sortingParameters = new SortingParameters() { NumberOfTemporaryFiles = int.Parse(TextBox_NumberOfTemporaryBuffers.Text) }; Sorter = new PolyPhaseSorting(sortingParameters, fileParameters); Sorter.Distribution.Distribute(); }
public async Task <IActionResult> Index(string categorySlug) { var sortingParameters = new SortingParameters(); sortingParameters.Add("Id", false); Expression <Func <Product, bool> > predicate = categorySlug == null ? (Expression <Func <Product, bool> >)null : o => o.ProductCategory.Slug == categorySlug; var products = _catalogService.GetProductsPagedAsync(predicate, sortingParameters, 1, 10); var categories = _lookupServiceFactory.Create <ProductCategory>().GetAllAsync(); await Task.WhenAll(products, categories); var vm = new IndexViewModel { Products = Mapper.Map(await products).ToANew <IEnumerable <ProductDTO> >(), Categories = Mapper.Map(await categories).ToANew <IEnumerable <CategoryDTO> >() }; return(View(vm)); }
/// <summary> /// Prepares the sort parameters. /// </summary> /// <param name="parameters">The parameters.</param> /// <param name="allowedSortBy">Fields that are allowed for sorting in overview.</param> /// <returns></returns> protected virtual SortingParameters PrepareSortParameters(PagingSortingBaseModel parameters, ICollection <string> allowedSortBy) { var isValidParameter = parameters.SortBy != null && allowedSortBy.Contains(parameters.SortBy.ToLower()); if (isValidParameter) { return(new SortingParameters { SortField = parameters.SortBy, SortReverse = parameters.Order == DescendingSortOrder }); } var defaultSortingParameters = GetDefaultSortingParameters(); if (defaultSortingParameters != null) { return(defaultSortingParameters); } return(SortingParameters.CreateNoSortingNeededParams()); }
/// <summary> /// Converts sorting parameters to MongoDB sort definition. /// </summary> /// <param name="sorting">The sorting parameters to convert.</param> /// <returns>The converted MongoDB sorting parameters.</returns> public static SortDefinition <BsonDocument> ToSortDefinition(this SortingParameters sorting) { if (sorting == null) { return(null); } var builder = Builders <BsonDocument> .Sort; SortDefinition <BsonDocument> result = null; foreach (var sort in sorting.Sorts) { if (result == null) { if (sort.Direction == SortingDirection.Ascending) { result = builder.Ascending(sort.Attribute); } else { result = builder.Descending(sort.Attribute); } } else { if (sort.Direction == SortingDirection.Ascending) { result = result.Ascending(sort.Attribute); } else { result = result.Descending(sort.Attribute); } } } return(result); }
public async Task <IEnumerable <T> > GetAsync( Expression <Func <T, bool> > filter = null, TextSearchParameters textSearchParameters = null, SortingParameters sortingParameters = null, PagingParameters pagingParameters = null, Func <IQueryable <T>, IIncludableQueryable <T, object> > include = null, bool disableTracking = false) { IQueryable <T> query = context.Set <T>(); query = ProcessFilter(filter, query); query = ProcessDisableTracking(disableTracking, query); query = ProcessTextSearchParameters(textSearchParameters, query); query = ProcessSortingParameters(sortingParameters, query); query = ProcessPagingParameters(pagingParameters, query); query = ProcessIncludes(include, query); return(await query.ToListAsync()); }
private async Task <TeamViewModel> GetTeamViewModelPaged(Guid projectId, IPagingParameters pagingParameters) { var project = await projectService.GetProjectAsync(projectId, this.ToNavPropertyString(nameof(IProjectPoco.ProjectUsers), this.ToNavPropertyString(nameof(IProjectUserPoco.User)))); var sortingParameters = new SortingParameters(); sortingParameters.Add("DateUpdated", false); var projectUsers = await projectService.GetProjectUsersPagedAsync(pagingParameters, p => p.ProjectId == projectId, sortingParameters, this.ToNavPropertyString(nameof(IProjectUserPoco.User))); var vmUsers = new StaticPagedList <UserPreviewViewModel>(Mapper.Map <IEnumerable <UserPreviewViewModel> >(projectUsers.Select(p => p.User).ToList()), pagingParameters.PageNumber, pagingParameters.PageSize, projectUsers.TotalItemCount); var vm = new TeamViewModel() { ProjectId = project.Id, ProjectName = project.Name, ProjectUsers = vmUsers }; await SetTeamListViewBagAsync(vm.ProjectUsers, project.CompanyId, vm.ProjectId); return(vm); }