public async Task <IActionResult> OnPostAsync(string returnUrl = null)
{
returnUrl = returnUrl ?? Url.Content("~/");
ExternalLogins = (await _signInManager.GetExternalAuthenticationSchemesAsync()).ToList();
if (ModelState.IsValid)
{
var user = new NEAUser
{
FirstName = Input.FirstName,
LastName = Input.LastName,
UserName = Input.Email,
Email = Input.Email
};
var result = await _userManager.CreateAsync(user, Input.Password);
await _userManager.AddToRoleAsync(user, Input.AccountType);
if (result.Succeeded)
{
_logger.LogInformation("User created a new account with password.");
var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
code = WebEncoders.Base64UrlEncode(Encoding.UTF8.GetBytes(code));
var callbackUrl = Url.Page(
"/Account/ConfirmEmail",
pageHandler: null,
values: new { area = "Identity", userId = user.Id, code = code, returnUrl = returnUrl },
protocol: Request.Scheme);
await _emailSender.SendEmailAsync(Input.Email, "Confirm your email",
$"Please confirm your account by <a href='{HtmlEncoder.Default.Encode(callbackUrl)}'>clicking here</a>.");
//if (_userManager.Options.SignIn.RequireConfirmedAccount)
{
return(RedirectToPage("RegisterConfirmation", new { email = Input.Email, returnUrl = returnUrl }));
}
//else
{
// await _signInManager.SignInAsync(user, isPersistent: false);
//return LocalRedirect(returnUrl);
}
}
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
}
// If we got this far, something failed, redisplay form
PopulateSelectList();
return(Page());
}
private async Task LoadAsync(NEAUser user)
{
var userName = await _userManager.GetUserNameAsync(user);
var accountType = await _userManager.IsInRoleAsync(user, Constants.StudentRole) ? "Student" : "Teacher";
var phoneNumber = await _userManager.GetPhoneNumberAsync(user);
Username = userName;
AccountType = accountType;
Input = new InputModel
{
FirstName = user.FirstName,
LastName = user.LastName,
PhoneNumber = phoneNumber
};
}
public string AuthorizeAccessToID(NEAUser teacher, NEAContext context, string classID)
{
var list = context.StudentQuestions.ToList();
var id = UserId;
var classroom = context.Users
.SingleOrDefault(u => u.Id == id)
.Enrollments
.SingleOrDefault(e => e.ClassroomID == classID)
.Classroom;
if (classroom.UserID == teacher.Id)
{
return(UserId);
}
return("");
}
public async Task OnGetAsync(string classId, int?simId, bool?showDetails)
{
ClassroomData = new ClassroomIndexData();
if (User.IsInRole(Constants.StudentRole))
{
var userEnrollments = (from e in Context.Enrollments
select e)
.Where(e => e.NEAUserId == UserManager.GetUserId(User));
var classIDs = await(from e in userEnrollments
select e.ClassroomID)
.AsNoTracking()
.ToListAsync();
ClassroomData.Classrooms = await Context.Classrooms
.Include(c => c.Teacher)
.Include(c => c.Enrollments)
.ThenInclude(c => c.NEAUser)
.ThenInclude(c => c.StudentAssignments)
.Include(c => c.Enrollments)
.ThenInclude(c => c.NEAUser)
.ThenInclude(c => c.StudentQuestions)
.Include(c => c.ClassAssignments)
.ThenInclude(c => c.Simulation)
.ThenInclude(c => c.Questions)
.Where(c => classIDs.Contains(c.ClassroomID))
.AsNoTracking()
.ToListAsync();
}
else
{
ClassroomData.Classrooms = await Context.Classrooms
.Include(c => c.Teacher)
.Include(c => c.Enrollments)
.ThenInclude(c => c.NEAUser)
.ThenInclude(c => c.StudentAssignments)
.Include(c => c.Enrollments)
.ThenInclude(c => c.NEAUser)
.ThenInclude(c => c.StudentQuestions)
.Include(c => c.ClassAssignments)
.ThenInclude(c => c.Simulation)
.ThenInclude(c => c.Questions)
.Where(c => c.UserID == UserManager.GetUserId(User))
.AsNoTracking()
.ToListAsync();
}
/*foreach (var item in classroom)
* {
* List<Enrollment> students = await Context.Enrollments
* .Where(e => e.ClassroomID == item.ClassroomID)
* .AsNoTracking()
* .ToListAsync();
*
* ClassroomVM.Add(
* new ClassroomVM
* {
* ID = item.ClassroomID,
* Name = item.Name,
* Teacher = item.Teacher.LastName + ", " + item.Teacher.FirstName,
* StudentCount = students.Count()
* }
* ) ;
* }*/
if (classId != null)
{
ClassID = classId;
Classroom classroom = ClassroomData.Classrooms.Where(c => c.ClassroomID == ClassID).SingleOrDefault();
if (classroom == null)
{
return;
}
ClassroomData.ClassAssignments = classroom.ClassAssignments.Select(c => c);
}
if (simId != null)
{
SimulatorID = simId.Value;
ClassAssignment assignment = ClassroomData.ClassAssignments.Where(c => c.SimulationID == SimulatorID).SingleOrDefault();
if (assignment == null)
{
return;
}
if (User.IsInRole(Constants.StudentRole))
{
NEAUser thisuser = ClassroomData.Classrooms
.Single(c => c.ClassroomID == ClassID)
.Enrollments
.Single(e => e.NEAUserId == UserManager.GetUserId(User))
.NEAUser;
StudentAssignment?studentAssignment = thisuser
.StudentAssignments
.SingleOrDefault(s => s.SimulationID == SimulatorID);
ClassroomData.StudentAssignments = new List <StudentAssignmentIndexVM>
{
new StudentAssignmentIndexVM
{
StudentName = thisuser.LastName + ", " + thisuser.FirstName,
Percentage = studentAssignment?.Percentage,
DateCompleted = studentAssignment?.DateCompleted,
SimulationID = SimulatorID
}
};
}
else
{
var enrollments = ClassroomData.Classrooms
.Single(c => c.ClassroomID == ClassID)
.Enrollments;
var students = from e in enrollments
select e.NEAUser;
var studentAssignments = new List <StudentAssignmentIndexVM>();
foreach (var item in students)
{
var studentAssignment = item.StudentAssignments.SingleOrDefault(s => s.SimulationID == SimulatorID);
studentAssignments.Add(new StudentAssignmentIndexVM()
{
StudentName = item.LastName + ", " + item.FirstName,
Percentage = studentAssignment?.Percentage,
DateCompleted = studentAssignment?.DateCompleted,
SimulationID = SimulatorID
});
}
ClassroomData.StudentAssignments = studentAssignments;
}
if (showDetails != null && showDetails == true)
{
ShowDetails = showDetails.Value;
ClassroomData.Questions = await Context.Questions
.Where(s => s.SimulationID == SimulatorID)
.AsNoTracking()
.ToListAsync();
List <NEAUser> students = await(from e in Context.Enrollments
where e.ClassroomID == ClassID
select e.NEAUser)
.AsNoTracking()
.ToListAsync();
List <StudentQuestion> studentQuestions = await Context.StudentQuestions
.Include(s => s.NEAUser)
.ThenInclude(s => s.Enrollments)
.Where(s => s.SimulationID == SimulatorID)
.AsNoTracking()
.ToListAsync();
var studentQuestionsVM = new List <StudentQuestionVM>();
foreach (var student in students)
{
var thisStudentsQuestions = studentQuestions.Where(s => s.UserID == student.Id);
foreach (var question in ClassroomData.Questions)
{
var studentQuestion = thisStudentsQuestions.SingleOrDefault(s => s.QIndex == question.QIndex);
if (studentQuestion == null)
{
studentQuestion = new StudentQuestion
{
QIndex = question.QIndex,
SimulationID = SimulatorID,
Answer = "",
isCorrect = AnswerType.Unanswered
};
}
var isAuthorized = await AuthorizationService.AuthorizeAsync(User, studentQuestion, Operations.ViewStudentAssignment);
if (!isAuthorized.Succeeded)
{
var enrollment = Context.Enrollments
.Include(e => e.Classroom)
.ThenInclude(e => e.Teacher)
.AsNoTracking()
.SingleOrDefault(e => e.NEAUserId == student.Id && e.ClassroomID == ClassID);
isAuthorized = await AuthorizationService.AuthorizeAsync(User, enrollment, Operations.ViewStudentAssignment);
if (!isAuthorized.Succeeded)
{
continue;
}
}
studentQuestionsVM.Add(
new StudentQuestionVM
{
UserId = student.Id,
QIndex = studentQuestion.QIndex,
StudentName = student.FirstName + " " + student.LastName,
Answer = studentQuestion.Answer,
isCorrect = studentQuestion.isCorrect,
SimID = SimulatorID
});
}
}
ClassroomData.StudentQuestions = studentQuestionsVM;
}
}
}
