public ActionResult UsersPartial(UserSearchQueryModel queryModel)
{
var userRoles = usersRepo.FilterUsers(queryModel, userManager);
var model = GetUserListModel(userRoles, queryModel.CourseId);
return(PartialView("_UserListPartial", model));
}
public ActionResult ListPartial(UserSearchQueryModel queryModel)
{
var userRoles = usersRepo.FilterUsers(queryModel);
var model = GetUserListModel(userRoles);
return(PartialView("_UserListPartial", model));
}
public ActionResult Users(UserSearchQueryModel queryModel)
{
if (string.IsNullOrEmpty(queryModel.CourseId))
{
return(RedirectToAction("CourseList"));
}
return(View(queryModel));
}
/* Pass limit=0 to disable limiting */
public List <UserRolesInfo> FilterUsers(UserSearchQueryModel query, int limit = 100)
{
var usersIdsByNamePrefix = string.IsNullOrEmpty(query.NamePrefix)
? null
: GetUsersByNamePrefix(query.NamePrefix).Select(u => u.Id);
return(FilterUsers(query, usersIdsByNamePrefix, limit));
}
public async Task <ActionResult> ListPartial(UserSearchQueryModel queryModel)
{
var userRolesByEmail = User.IsSystemAdministrator() ? usersRepo.FilterUsersByEmail(queryModel) : null;
var userRoles = usersRepo.FilterUsers(queryModel);
var model = await GetUserListModel(userRolesByEmail.EmptyIfNull().Concat(userRoles).DistinctBy(r => r.UserId).ToList());
return(PartialView("_UserListPartial", model));
}
public List <UserRolesInfo> FilterUsersByEmail(UserSearchQueryModel query, int limit = 100)
{
if (string.IsNullOrEmpty(query.NamePrefix) || !query.NamePrefix.Contains('@'))
{
return(null);
}
var email = query.NamePrefix;
var usersIdsByEmail = db.Users.Where(u => u.Email == email).Select(u => u.Id);
return(FilterUsers(query, usersIdsByEmail, limit));
}
public List <UserRolesInfo> FilterUsers(UserSearchQueryModel query, UserManager <ApplicationUser> userManager)
{
var role = db.Roles.FirstOrDefault(r => r.Name == query.Role);
return(db.Users
.FilterByName(query.NamePrefix)
.FilterByRole(role, userManager)
.FilterByUserIds(
userRolesRepo.GetListOfUsersWithCourseRole(query.CourseRole, query.CourseId),
userRolesRepo.GetListOfUsersByPrivilege(query.OnlyPrivileged, query.CourseId)
)
.GetUserRolesInfo(50, userManager));
}
/* Pass limit=0 to disable limiting */
public List <UserRolesInfo> FilterUsers(UserSearchQueryModel query, UserManager <ApplicationUser> userManager, int limit = 100)
{
var role = db.Roles.FirstOrDefault(r => r.Name == query.Role);
var users = db.Users.Where(u => !u.IsDeleted);
if (!string.IsNullOrEmpty(query.NamePrefix))
{
var usersIds = GetUsersByNamePrefix(query.NamePrefix).Select(u => u.Id);
users = users.Where(u => usersIds.Contains(u.Id));
}
return(users
.FilterByRole(role, userManager)
.FilterByUserIds(
userRolesRepo.GetListOfUsersWithCourseRole(query.CourseRole, query.CourseId, query.IncludeHighCourseRoles),
userRolesRepo.GetListOfUsersByPrivilege(query.OnlyPrivileged, query.CourseId)
)
.GetUserRolesInfo(limit, userManager));
}
private List <UserRolesInfo> FilterUsers(UserSearchQueryModel query, [CanBeNull] IQueryable <string> userIds, int limit)
{
var roles = db.Roles.ToList();
var role = string.IsNullOrEmpty(query.Role) ? null : roles.FirstOrDefault(r => r.Name == query.Role);
var users = db.Users.Include(u => u.Roles).Where(u => !u.IsDeleted);
if (userIds != null)
{
users = users.Where(u => userIds.Contains(u.Id));
}
return(users
.FilterByRole(role)
.FilterByUserIds(
userRolesRepo.GetListOfUsersWithCourseRole(query.CourseRole, query.CourseId, query.IncludeHighCourseRoles),
userRolesRepo.GetListOfUsersByPrivilege(query.OnlyPrivileged, query.CourseId)
)
.GetUserRolesInfo(limit, roles));
}
public ActionResult List(UserSearchQueryModel queryModel)
{
return(View(queryModel));
}
private StudentSubmissionsModel GetStudentSubmissionsModel(string courseId, Guid slideId, string name)
{
const int maxUsersCount = 30;
var course = courseManager.GetCourse(courseId);
var slide = course.GetSlideById(slideId) as ExerciseSlide;
if (slide == null)
{
throw new HttpResponseException(HttpStatusCode.NotFound);
}
var canViewAllSubmissions = User.HasAccessFor(courseId, CourseRole.CourseAdmin) || User.HasCourseAccess(courseId, CourseAccessType.ViewAllStudentsSubmissions);
var hasFilterByName = !string.IsNullOrEmpty(name);
/* By default show members of `my` groups, but if filter is enabled course admin's and users with special access can view any student's submissions */
SubmissionsFilterOptions filterOptions;
var slideIdInList = new List <Guid> {
slideId
};
var visitedUserIds = visitsRepo.GetVisitsInPeriod(new VisitsFilterOptions {
CourseId = courseId, SlidesIds = slideIdInList, PeriodStart = DateTime.MinValue, PeriodFinish = DateTime.MaxValue
})
.Select(v => v.UserId)
.ToList();
if (hasFilterByName && canViewAllSubmissions)
{
/* Get all members who has visits to this slide */
filterOptions = new SubmissionsFilterOptions
{
CourseId = courseId,
UserIds = visitedUserIds,
SlideIds = slideIdInList,
};
}
else
{
/* Get members of `my` groups */
filterOptions = ControllerUtils.GetFilterOptionsByGroup <SubmissionsFilterOptions>(groupsRepo, User, courseId, groupsIds: new List <string>());
filterOptions.SlideIds = slideIdInList;
/* Filter out only users with visits to this slide */
filterOptions.UserIds = filterOptions.UserIds.Intersect(visitedUserIds).ToList();
}
if (hasFilterByName)
{
var userQueryModel = new UserSearchQueryModel {
NamePrefix = name, OnlyPrivileged = false
};
var filteredUsers = usersRepo.FilterUsers(userQueryModel, userManager, 0);
filterOptions.UserIds = filterOptions.UserIds.Intersect(filteredUsers.Select(u => u.UserId)).ToList();
}
filterOptions.UserIds = filterOptions.UserIds.Take(maxUsersCount).ToList();
var submissions = userSolutionsRepo.GetAllSubmissionsByUsers(filterOptions);
var submissionsByUser = submissions.GroupBy(s => s.UserId).ToDictionary(g => g.Key, g => g.ToList()).ToDefaultDictionary();
var automaticCheckingScores = slideCheckingsRepo.GetAutomaticScoresForSlide(courseId, slideId, filterOptions.UserIds);
var manualCheckingScores = slideCheckingsRepo.GetManualScoresForSlide(courseId, slideId, filterOptions.UserIds);
var userGroups = groupsRepo.GetUsersGroupsNamesAsStrings(courseId, filterOptions.UserIds, User).ToDefaultDictionary();
return(new StudentSubmissionsModel
{
CourseId = courseId,
Slide = slide,
Users = usersRepo.GetUsersByIds(filterOptions.UserIds).ToDictionary(u => u.Id),
SubmissionsByUser = submissionsByUser,
AutomaticCheckingScores = automaticCheckingScores,
ManualCheckingScores = manualCheckingScores,
HasFilterByName = hasFilterByName,
UserGroups = userGroups,
});
}
