public async Task <IActionResult> Edit(int id, [Bind("CaseID,LocalGroupID")] GroupAssignment groupAssignment)
{
if (id != groupAssignment.CaseID)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(groupAssignment);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!GroupAssignmentExists(groupAssignment.CaseID))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["CaseID"] = new SelectList(_context.Case, "CaseID", "CaseID", groupAssignment.CaseID);
ViewData["LocalGroupID"] = new SelectList(_context.LocalGroup, "LocalGroupID", "LocalGroupID", groupAssignment.LocalGroupID);
return(View(groupAssignment));
}
public async Task <IActionResult> Edit(int group, string student, [Bind("GroupId,StudentId,Role")] GroupAssignment groupAssignment)
{
if (group != groupAssignment.GroupId || student != groupAssignment.StudentId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(groupAssignment);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!GroupAssignmentExists(groupAssignment.GroupId, groupAssignment.StudentId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["GroupId"] = new SelectList(_context.Group, "GroupId", "GroupName", groupAssignment.GroupId);
return(View(groupAssignment));
}
public async Task <IActionResult> GetById(int id, int?groupId = null)
{
Assignment assignment = await _assignmentService.GetByIdAsync(id, x => x.Subject, x => x.Attachments);
if (assignment == null)
{
return(NotFound());
}
if (assignment.Subject.TeacherId != _userService.UserId)
{
return(Forbid());
}
var result = _mapper.Map <AssignmentDetailsDto>(assignment);
if (groupId != null)
{
GroupAssignment ga = _assignmentService.GetGroupAssignment(groupId.Value, id);
if (ga != null)
{
_mapper.Map(ga, assignment);
}
}
return(Ok(result));
}
public void Handle(GroupAssignment message)
{
if (message.ComputeGroup == "Group 1")
{
_group2Members.Remove(message.GroupId);
_group1Members.Add(message.GroupId);
}
if (message.ComputeGroup == "Group 2")
{
_group1Members.Remove(message.GroupId);
_group2Members.Add(message.GroupId);
}
StringBuilder sbGroups = new StringBuilder();
foreach (var grp in _group1Members)
{
sbGroups.Append(grp + ",");
}
foreach (var grp in _group2Members)
{
sbGroups.Append(grp + ",");
}
Groups = sbGroups.ToString();
_computeService.SetGroups(_group1Members, _group2Members);
}
public void TestRefreshCommandSucceeded()
{
var groupAssignmentToReturn = new GroupAssignment
{
Solution = "http://www.163.com/"
};
var dialogShown = false;
var stubIDialogService = new StubIDialogService();
stubIDialogService.ShowAsync(async message => dialogShown = true);
var refreshRequested = false;
var stubIGroupAssignmentService = new StubIGroupAssignmentService();
stubIGroupAssignmentService.GetAsync(async id => {
refreshRequested = true;
return(new ServiceResult <GroupAssignment> {
Status = ServiceResultStatus.OK,
Result = groupAssignmentToReturn
});
});
var groupAssignmentViewModel =
new GroupAssignmentViewModel(stubIDialogService,
stubIGroupAssignmentService, null, null);
groupAssignmentViewModel.RefreshCommand.Execute(null);
Assert.IsFalse(dialogShown);
Assert.IsTrue(refreshRequested);
Assert.AreSame(groupAssignmentToReturn,
groupAssignmentViewModel.GroupAssignment);
}
/// <summary>
/// 提交小组作业。
/// </summary>
/// <param name="groupAssignment">小组作业。</param>
/// <returns>服务结果。</returns>
public async Task <ServiceResult> SubmitAsync(
GroupAssignment groupAssignment)
{
var groupAssignmentToSubmit = new GroupAssignment {
GroupID = groupAssignment.GroupID,
HomeworkID = groupAssignment.HomeworkID,
Score = groupAssignment.Score,
Solution = groupAssignment.Solution
};
var identifiedHttpMessageHandler =
_identityService.GetIdentifiedHttpMessageHandler();
using (var httpClient =
new HttpClient(identifiedHttpMessageHandler)) {
var json = JsonConvert.SerializeObject(groupAssignmentToSubmit);
HttpResponseMessage response;
try {
response = await httpClient.PutAsync(
App.ServerEndpoint + "/api/GroupAssignment/" +
groupAssignment.HomeworkID,
new StringContent(json, Encoding.UTF8,
"application/json"));
} catch (Exception e) {
return(new ServiceResult {
Status = ServiceResultStatus.Exception,
Message = e.Message
});
}
var serviceResult = new ServiceResult {
Status =
ServiceResultStatusHelper.FromHttpStatusCode(
response.StatusCode)
};
switch (response.StatusCode)
{
case HttpStatusCode.Unauthorized:
case HttpStatusCode.Forbidden:
break;
case HttpStatusCode.NoContent:
break;
case HttpStatusCode.BadRequest:
serviceResult.Message =
await response.Content.ReadAsStringAsync();
break;
default:
serviceResult.Message = response.ReasonPhrase;
break;
}
return(serviceResult);
}
}
public ActionResult DeleteConfirmed(int id)
{
GroupAssignment groupAssignment = db.GroupAssignments.Find(id);
db.GroupAssignments.Remove(groupAssignment);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public void TestSubmitCommand()
{
var groupAssignmentToSubmit = new GroupAssignment {
HomeworkID = -1, Solution = "http://www.bing.com/",
Homework = new Homework {
Deadline = DateTime.MaxValue
}
};
var dialogShown = false;
var messageShown = "";
var stubIDialogService = new StubIDialogService();
stubIDialogService.ShowAsync(async message => {
dialogShown = true;
messageShown = message;
});
GroupAssignment groupAssignmentSubmitted = null;
var submitRequested = false;
var stubIGroupAssignmentService = new StubIGroupAssignmentService();
stubIGroupAssignmentService.SubmitAsync(async groupAssignment => {
submitRequested = true;
groupAssignmentSubmitted = groupAssignment;
return(new ServiceResult
{
Status = ServiceResultStatus.NoContent
});
});
var stubIRootNavigationService = new StubIRootNavigationService();
var backNavigated = false;
stubIRootNavigationService.GoBack(() => backNavigated = true);
var stubITileService = new StubITileService();
var updateRequested = false;
stubITileService.ForceUpdate(() => updateRequested = true);
var groupAssignmentViewModel =
new GroupAssignmentViewModel(stubIDialogService,
stubIGroupAssignmentService, stubIRootNavigationService, stubITileService);
groupAssignmentViewModel.GroupAssignment = groupAssignmentToSubmit;
groupAssignmentViewModel.GroupAssignmentId =
groupAssignmentToSubmit.HomeworkID;
groupAssignmentViewModel.SubmitCommand.Execute(null);
Assert.IsTrue(dialogShown);
Assert.AreSame(UvpClient.App.SolutionSubmittedMessage,
messageShown);
Assert.IsTrue(submitRequested);
Assert.AreSame(groupAssignmentToSubmit, groupAssignmentSubmitted);
Assert.IsTrue(backNavigated);
Assert.IsTrue(updateRequested);
}
public ActionResult Edit([Bind(Include = "GroupAssignmentId,TeamId,GroupId")] GroupAssignment groupAssignment)
{
if (ModelState.IsValid)
{
db.Entry(groupAssignment).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.GroupId = new SelectList(db.Groups, "GroupId", "GroupId", groupAssignment.GroupId);
ViewBag.TeamId = new SelectList(db.Teams, "TeamId", "manager", groupAssignment.TeamId);
return(View(groupAssignment));
}
public async Task <IActionResult> Create([Bind("CaseID,LocalGroupID")] GroupAssignment groupAssignment)
{
if (ModelState.IsValid)
{
_context.Add(groupAssignment);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["CaseID"] = new SelectList(_context.Case, "CaseID", "CaseID", groupAssignment.CaseID);
ViewData["LocalGroupID"] = new SelectList(_context.LocalGroup, "LocalGroupID", "LocalGroupID", groupAssignment.LocalGroupID);
return(View(groupAssignment));
}
// GET: GroupAssignments/Details/5
public ActionResult Details(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
GroupAssignment groupAssignment = db.GroupAssignments.Find(id);
if (groupAssignment == null)
{
return(HttpNotFound());
}
return(View(groupAssignment));
}
// GET: GroupAssignments/Edit/5
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
GroupAssignment groupAssignment = db.GroupAssignments.Find(id);
if (groupAssignment == null)
{
return(HttpNotFound());
}
ViewBag.GroupId = new SelectList(db.Groups, "GroupId", "GroupId", groupAssignment.GroupId);
ViewBag.TeamId = new SelectList(db.Teams, "TeamId", "manager", groupAssignment.TeamId);
return(View(groupAssignment));
}
public void TestSubmitCommandOther()
{
var groupAssignmentToSubmit = new GroupAssignment {
HomeworkID = -1, Solution = "http://www.bing.com/",
Homework = new Homework {
Deadline = DateTime.MaxValue
}
};
var messageToShow = "Error Message";
var dialogShown = false;
var messageShown = "";
var stubIDialogService = new StubIDialogService();
stubIDialogService.ShowAsync(async message => {
dialogShown = true;
messageShown = message;
});
GroupAssignment groupAssignmentSubmitted = null;
var submitRequested = false;
var stubIGroupAssignmentService = new StubIGroupAssignmentService();
stubIGroupAssignmentService.SubmitAsync(async groupAssignment => {
submitRequested = true;
return(new ServiceResult {
Status = ServiceResultStatus.NotFound,
Message = messageToShow
});
});
var groupAssignmentViewModel =
new GroupAssignmentViewModel(stubIDialogService,
stubIGroupAssignmentService, null, null);
groupAssignmentViewModel.GroupAssignment = groupAssignmentToSubmit;
groupAssignmentViewModel.GroupAssignmentId =
groupAssignmentToSubmit.HomeworkID;
groupAssignmentViewModel.SubmitCommand.Execute(null);
Assert.IsTrue(dialogShown);
Assert.AreEqual(
UvpClient.App.HttpClientErrorMessage + messageToShow,
messageShown);
Assert.IsTrue(submitRequested);
}
public void TestOpenGroupAssignmentCommand()
{
var groupAssignmentToNavigate = new GroupAssignment();
var rootFrameNavigated = false;
var stubIRootNavigationService = new StubIRootNavigationService();
stubIRootNavigationService.Navigate((type, parameter, transition) =>
rootFrameNavigated = type == typeof(GroupAssignmentPage) &&
parameter == groupAssignmentToNavigate &&
transition == NavigationTransition
.DrillInNavigationTransition);
var myUvpViewModel = new MyUvpViewModel(null, null,
stubIRootNavigationService, null);
myUvpViewModel.OpenGroupAssignmentCommand.Execute(
groupAssignmentToNavigate);
Assert.IsTrue(rootFrameNavigated);
}
public async Task <IActionResult> Create([Bind("GroupId,StudentId,Role")] GroupAssignment groupAssignment)
{
/* Convert user-readable email to internal ID. */
var student = await _context.Users.FirstOrDefaultAsync(u => u.Email == groupAssignment.StudentId);
if (student == null)
{
return(NotFound());
}
groupAssignment.StudentId = student.Id;
groupAssignment.Student = student;
if (ModelState.IsValid)
{
_context.Add(groupAssignment);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["GroupId"] = new SelectList(_context.Group, "GroupId", "GroupName", groupAssignment.GroupId);
ViewData["StudentId"] = new SelectList((await _userManager.GetUsersInRoleAsync(Constants.StudentRole)).ToList(), "Email", "Email", groupAssignment.StudentId);
return(View(groupAssignment));
}
public void TestSubmitCommandUnauthorized()
{
var groupAssignmentToSubmit = new GroupAssignment {
HomeworkID = -1, Solution = "http://www.bing.com/",
Homework = new Homework {
Deadline = DateTime.MaxValue
}
};
var dialogShown = false;
var stubIDialogService = new StubIDialogService();
stubIDialogService.ShowAsync(async message => dialogShown = true);
var submitRequested = false;
var stubIGroupAssignmentService = new StubIGroupAssignmentService();
stubIGroupAssignmentService.SubmitAsync(async groupAssignment => {
submitRequested = true;
return(new ServiceResult
{
Status = ServiceResultStatus.Unauthorized
});
});
var groupAssignmentViewModel =
new GroupAssignmentViewModel(stubIDialogService,
stubIGroupAssignmentService, null, null);
groupAssignmentViewModel.GroupAssignment = groupAssignmentToSubmit;
groupAssignmentViewModel.GroupAssignmentId =
groupAssignmentToSubmit.HomeworkID;
groupAssignmentViewModel.SubmitCommand.Execute(null);
Assert.IsFalse(dialogShown);
Assert.IsTrue(submitRequested);
}
public GroupsController(QuestContext context, GroupAssignment groupAssignment)
{
_context = context;
_groupAssignment = groupAssignment;
}
public IActionResult AssignFaculty(GroupAssignment enrollment)
{
db.GroupAssignments.Add(enrollment);
db.SaveChangesAsync();
return(View());
}
public async Task AssignStudentsToGroupAsync(GroupAssignment assignment)
{
_context.GroupAssignment.Add(assignment);
await _context.SaveChangesAsync();
}
public MentorController(QuestContext context, GroupsController group, GroupAssignment groupAssignment)
{
_context = context;
_group = group;
_groupAssignment = groupAssignment;
}
public async Task <IActionResult> AssignConfirmed(int id)
{
var cohort = await _context.Cohort.FindAsync(id);
var cohortProjects = await _context.Project.Where(p => p.CohortId == id).ToListAsync();
var cohortPreferences = await _context.Preferences.Include(p => p.Student).Where(p => p.CohortId == id).ToListAsync();
/* Create container to organise students as they are sorted.*/
var tempAssignments = new Dictionary <Project, List <Preferences> >();
var assignmentsValidated = new Dictionary <Project, bool>();
foreach (var project in cohortProjects)
{
tempAssignments.Add(project, new List <Preferences>());
assignmentsValidated.Add(project, false);
}
/* Allocate students to their first preferences.*/
foreach (var preference in cohortPreferences)
{
tempAssignments[preference.ProjectFirst].Add(preference);
}
/* Attempt to reallocate students if first preference is not suitable.*/
var round = 0; /* Stop optimisation after 5 rounds.*/
while (assignmentsValidated.Any(a => a.Value == false) && round < 5)
{
foreach (var project in cohortProjects)
{
var studentsForProject = tempAssignments[project].Count;
var projectGroupQty = (double)studentsForProject / project.MaxSize;
/* Check if either there aren't enough students to fill a group or there are too many students
* to fill the maximum number of groups.*/
if (projectGroupQty * project.MinSize <= studentsForProject &&
studentsForProject <= project.MaxSize * project.MaxGroups)
{
assignmentsValidated[project] = true;
}
else
{
assignmentsValidated[project] = false;
}
}
foreach (var projectValidated in assignmentsValidated.Where(a => a.Value == false))
{
var project = projectValidated.Key;
var excessStudents = tempAssignments[project].Count - project.MaxSize * project.MaxGroups;
/* If a project has more than the maximum number of students reallocate from first preference to
* second preference.*/
if (0 < excessStudents)
{
var tempAssignmentsFirstChoice = tempAssignments[project].Where(a => a.ProjectFirst == project).ToList();
for (var i = 0; i < excessStudents; i++)
{
var studentPreferences = tempAssignmentsFirstChoice.FirstOrDefault();
if (studentPreferences != null)
{
tempAssignments[studentPreferences.ProjectSecond].Add(studentPreferences);
tempAssignments[studentPreferences.ProjectFirst].Remove(studentPreferences);
tempAssignmentsFirstChoice.Remove(studentPreferences);
}
}
}
}
round++;
}
foreach (var project in cohortProjects)
{
var groups = new List <Group>();
var projectGroupQty = (double)tempAssignments[project].Count / project.MaxSize;
/* Create new groups sufficient to hold the students for this project. */
for (int i = 0; i < projectGroupQty; i++)
{
var newGroup = new Group(project, id);
if (ModelState.IsValid)
{
_context.Add(newGroup);
await _context.SaveChangesAsync();
}
while (0 < tempAssignments[project].Count && newGroup.GroupAssignments.Count < project.MaxSize)
{
var nextPreference = tempAssignments[project].FirstOrDefault();
var newGroupAssignment = new GroupAssignment(newGroup, nextPreference.Student);
if (ModelState.IsValid)
{
_context.Add(newGroupAssignment);
await _context.SaveChangesAsync();
}
tempAssignments[project].Remove(nextPreference);
}
}
}
return(RedirectToAction(nameof(Details), new { id }));
}
