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);
}
