public void InvalidFilteringModel(bool descending, FlashcardsSortingCriterion criterion)
{
var model = new FlashcardsFilteringModel("", criterion, descending, 1, 1);
var query = Context.Flashcards.AsQueryable();
Assert.Throws <ArgumentOutOfRangeException>(() => FilteringServices.Filter(query, model));
}
public void ReturnsProperlyFilteredCategories(string searchText, FlashcardsSortingCriterion criterion,
bool descending, int pageIndex, int pageSize)
{
var model = new FlashcardsFilteringModel(searchText, criterion, descending, pageIndex, pageSize);
var categories = AddCategories();
var flashards = AddFlashcards(categories[0], 50);
var query = Context.Flashcards.AsQueryable();
var filteredFlashcards = FilteringServices.Filter(query, model).ToList();
var expected = flashards.Where(f =>
f.Key.Contains(model.SearchText) || f.Value.Contains(model.SearchText) || f.KeyDescription.Contains(model.SearchText) ||
f.ValueDescription.Contains(model.SearchText) || f.Category.Name.Contains(model.SearchText));
var lambda = GetLambda(criterion);
expected = descending ? expected.OrderByDescending(lambda) : expected.OrderBy(lambda);
var expectedList = expected.Skip(model.PageIndex * model.PageSize).Take(model.PageSize)
.ToList();
Assert.Equal(expectedList.Count, filteredFlashcards.Count);
for (var i = 0; i < expectedList.Count; i++)
{
var returned = filteredFlashcards[i];
var exp = new FlashcardDto(expectedList[i]);
Assert.True(exp.Id == returned.Id);
}
}
public ActionResult ViewAllWorkers(string searchName, string orderBy, string roleSpec, string depID, string viewType)
{
ViewBag.Supervisor = User.IsInRole("Supervisor");
var data = _data.Worker.AllWorkers();
data = SortingAndFilteringData.SortAndFilterWorkers(searchName, orderBy, roleSpec, depID, data);
if (User.IsInRole("Supervisor"))
{
var user = _data.ApplicationUser.FindUserByID(User.Identity.GetUserId());
data = FilteringServices.FilterWorkersPerDepartment(user.Worker.DepartmentID, data);
}
ViewBag.SortOptions = _fillViewBag.WorkerSortingOptionsViewBag();
ViewBag.RoleOptions = _fillViewBag.AvailableRolesFilteringViewBag();
ViewBag.DepartmentOptions = _fillViewBag.AvailableDepartmentsFilteringViewBag();
ViewBag.Names = _fillViewBag.GetWorkerNamesForAutocomplete(data);
ViewBag.Parameters = new List <string> {
searchName, orderBy, roleSpec, depID
};
if (string.IsNullOrEmpty(viewType))
{
return(View(data));
}
else
{
return(View("ViewAllWorkersList", data));
}
}
public UsersController(UserServices services, FilteringServices filteringServices, UserManager <User> userManager, IOptions <RoleNamesOptions> roleNamesOptions)
{
_services = services;
_filteringServices = filteringServices;
_userManager = userManager;
_roleNamesOptions = roleNamesOptions.Value;
}
public void ReturnsProperlyFilteredCategories(string searchText, UsersSortingCriterion criterion,
bool descending, int pageIndex, int pageSize)
{
var model = new UsersFilteringModel(searchText, criterion, descending, pageIndex, pageSize);
var users = AddUsers(31);
var categories = AddCategories();
var flashards = AddFlashcards(categories[0], 50);
var userProgress = AddUserProgress(flashards, users.GetRange(0, 20));
var query = Context.Users.AsQueryable();
var filteredUserDtos = FilteringServices.Filter(query, model).ToList();
var expected = users.Where(u =>
u.Name.Contains(model.SearchText) || u.Surname.Contains(model.SearchText) || u.UserName.Contains(model.SearchText));
var lambda = GetLambda(criterion);
expected = descending ? expected.OrderByDescending(lambda) : expected.OrderBy(lambda);
var expectedList = expected.Skip(model.PageIndex * model.PageSize).Take(model.PageSize)
.Select(u => new UserDto(u.Name, u.Surname, u.UserName,
new Score(userProgress.Where(up => up.UserId == u.Id).Sum(progress => progress.Progress))))
.ToList();
Assert.Equal(expectedList.Count, filteredUserDtos.Count);
for (var i = 0; i < expectedList.Count; i++)
{
Assert.True(expectedList[i].UserName.Equals(filteredUserDtos[i].UserName));
}
}
/// <summary>
/// Give me the List of Roles to sort and the parameters to filter and sort and I will do the work and return
/// </summary>
/// <param name="searchString"></param>
/// <param name="sort"></param>
/// <param name="data"></param>
/// <returns></returns>
public static List <IdentityRole> SortAndFilterRoles(string searchString, string sort, List <IdentityRole> data)
{
if (!string.IsNullOrEmpty(searchString))
{
data = FilteringServices.FilterRoleByName(searchString, data);
}
if (!string.IsNullOrEmpty(sort))
{
data = SortingServices.SortRoles(sort, data);
}
return(data);
}
/// <summary>
/// Give me the List of Departments to sort and the parameters to filter and sort and I will do the work and return
/// </summary>
/// <param name="search"></param>
/// <param name="sort"></param>
/// <param name="data"></param>
public static List <Department> SortAndFilterDepartments(string search, string sort, List <Department> data)
{
if (!string.IsNullOrEmpty(sort))
{
data = SortingServices.SortDepartments(sort, data);
}
if (!string.IsNullOrEmpty(search))
{
data = FilteringServices.FilterDepartmentsByCity(search, data);
}
return(data);
}
public static List <Worker> SortAndFilteringPayments(string searchName, string orderBy, List <Worker> data)
{
if (!string.IsNullOrEmpty(searchName))
{
data = FilteringServices.FilterWorkerByName(searchName, data);
}
if (!string.IsNullOrEmpty(orderBy))
{
data = SortingServices.SortSalary(orderBy, data);
}
return(data);
}
public ActionResult Index(string searchName, string orderBy, string status)
{
var data = _data.Worker.AllWorkers();
data = SortingAndFilteringData.SortAndFilteringPayments(searchName, orderBy, data);
data = FilteringServices.PaymentStatus(status, data);
ViewBag.PaymentStatus = _fillViewBag.PayStatusSortOptionsViewBag();
ViewBag.SortSalary = _fillViewBag.SalarySortingOptionsViewBag();
ViewBag.Names = _fillViewBag.GetWorkerNamesForAutocomplete(data);
return(View(data));
}
/// <summary>
/// Give me the List of Projects to sort and the parameters to filter and sort and I will do the work and return
/// </summary>
/// <param name="title"></param>
/// <param name="orderBy"></param>
/// <param name="depID"></param>
/// <param name="status"></param>
/// <param name="data"></param>
/// <returns></returns>
public static List <Project> SortAndFilterProjects(string title, string orderBy, string depID, string status, List <Project> data)
{
if (!string.IsNullOrEmpty(title))
{
data = FilteringServices.FilterProjectByTitle(title, data);
}
if (!string.IsNullOrEmpty(orderBy))
{
data = SortingServices.SortProject(orderBy, data);
}
if (!string.IsNullOrEmpty(depID))
{
data = FilteringServices.FilterProjectsPerDepartment(int.Parse(depID), data);
}
if (!string.IsNullOrEmpty(status))
{
data = FilteringServices.StatusProject(status, data);
}
return(data);
}
/// <summary>
/// Give me the List of Workers to sort and the parameters to filter and sort and I will do the work and return
/// </summary>
/// <param name="searchName"></param>
/// <param name="orderBy"></param>
/// <param name="roleSpec"></param>
/// <param name="depID"></param>
/// <param name="data"></param>
public static List <Worker> SortAndFilterWorkers(string searchName, string orderBy, string roleSpec, string depID, List <Worker> data)
{
if (!string.IsNullOrEmpty(searchName))
{
data = FilteringServices.FilterWorkerByName(searchName, data);
}
if (!string.IsNullOrEmpty(orderBy))
{
data = SortingServices.SortWorker(orderBy, data);
}
if (!string.IsNullOrEmpty(roleSpec))
{
data = FilteringServices.FilterWorkersInRole(roleSpec, data);
}
if (!string.IsNullOrEmpty(depID))
{
data = FilteringServices.FilterWorkersPerDepartment(int.Parse(depID), data);
}
return(data);
}
public void ReturnsProperlyFilteredCategories(string searchText, CategoriesSortingCriterion criterion,
bool descending, int pageIndex, int pageSize)
{
var model = new CategoriesFilteringModel(searchText, criterion, descending, pageIndex, pageSize);
var categories = AddCategories(30);
var query = Context.Categories.AsQueryable();
var filteredCategories = FilteringServices.Filter(query, model).ToList();
var expected = categories.Where(c => c.Name.Contains(searchText));
var lambda = GetLambda(criterion);
expected = descending ? expected.OrderByDescending(lambda) : expected.OrderBy(lambda);
var expectedList = expected.Skip(model.PageIndex * model.PageSize).Take(model.PageSize).ToList();
Assert.Equal(expectedList.Count, filteredCategories.Count);
for (var i = 0; i < expectedList.Count; i++)
{
Assert.True(expectedList[i].Id == (filteredCategories[i].Id));
}
}
public ActionResult ViewAllProjects(string title, string orderBy, string depID, string status)
{
ViewBag.Admin = User.IsInRole("Admin");
ViewBag.Supervisor = User.IsInRole("Supervisor");
var data = _data.Project.AllProjects();
var userOnline = _data.ApplicationUser.FindUserByID(User.Identity.GetUserId());
if (!ViewBag.Admin)
{
data = data.Where(w => w.WorkersInMe.Any(s => s.WorkerID == userOnline.Worker.ID)).ToList();
}
data = SortingAndFilteringData.SortAndFilterProjects(title, orderBy, depID, status, data);
if (ViewBag.Supervisor)
{
data = FilteringServices.FilterProjectsPerDepartment(userOnline.Worker.DepartmentID, data);
}
else if (!ViewBag.Admin && !ViewBag.Supervisor)
{
data = FilteringServices.FilterProjectsPerDepartment(userOnline.Worker.DepartmentID, data);
}
ViewBag.SortOptions = _fillViewBag.GetProjectSortOptions();
ViewBag.StatusOptions = _fillViewBag.StatusSortOptionsViewBag();
ViewBag.DepartmentOptions = _fillViewBag.ProjectInDepartmentsSortViewBag();
ViewBag.Names = _fillViewBag.GetProjectNamesForAutocomplete(data);
return(View(data));
}
