public async Task StudentControllerTests_CreateStudent_ShouldFailIfClassDoesNotExist()
{
//Arrange
var schoolClass = new SchoolClassViewModel
{
name = "Science",
classLocation = "Room B",
teacherName = "John Smith"
};
var result = await CreateSchoolClass(schoolClass);
var student = new StudentViewModel
{
firstName = "ABC",
surName = "XYZ",
age = 20,
gpa = (decimal)5.5,
classId = result.classId * 10,
};
// Act
var outResult = await _studentsController.CreateStudent(student);
// Assert
var failedRequest = outResult as BadRequestObjectResult;
Assert.NotNull(failedRequest);
}
public async Task StudentControllerTests_ShouldBeAbleToCreateNew_Student()
{
//Arrange
var schoolClass = new SchoolClassViewModel
{
name = "Science",
classLocation = "Room B",
teacherName = "John Smith"
};
var result = await CreateSchoolClass(schoolClass);
var student = new StudentViewModel
{
firstName = "ABC",
surName = "XYZ",
age = 20,
gpa = (decimal)5.5,
classId = result.classId,
};
// Act
var createdStudent = await CreateStudent(student);
// Assert
Assert.NotNull(createdStudent);
Assert.Equal(student.firstName, createdStudent.firstName);
}
public async Task <IActionResult> Edit(Guid id, [Bind("Id,ClassName,ProgramManagerId,Created")] SchoolClassViewModel schoolClass)
{
if (id != schoolClass.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(schoolClass);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!SchoolClassExists(schoolClass.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(schoolClass));
}
public void EditClass(SchoolClassViewModel viewModel)
{
var src = _repository.GetById <SchoolClass>(viewModel.Id);
src.ClassName = viewModel.Name;
_repository.Save(src);
}
// GET: SchoolClasses/Details/5
public async Task <IActionResult> Details(Guid?id)
{
if (id == null)
{
return(RedirectToAction("Index"));
}
var schoolClass = await _context.SchoolClasses
.FirstOrDefaultAsync(m => m.Id == id);
if (schoolClass == null)
{
return(NotFound());
}
var studentIds = _context.SchoolClassStudents
.Where(scs => scs.SchoolClassId == id)
.Select(scs => scs.StudentId).ToList();
var classStudents = await FetchUsersIdAsync(studentIds);
var newModel = new SchoolClassViewModel()
{
Id = schoolClass.Id,
ClassName = schoolClass.ClassName,
ProgramManager = await _userManager.FindByIdAsync(schoolClass.ProgramManagerId),
Students = classStudents
};
return(View(newModel));
}
public async Task <IActionResult> UpdateSchoolClass(int id, [FromBody] SchoolClassViewModel entity)
{
// validate state
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
// Map view model to DB model
var schoolClass = _mapper.Map <SchoolClassViewModel, SchoolClass>(entity);
_context.Entry(schoolClass).State = EntityState.Modified;
try
{
await _unitOfWork.CompleteAsync();
}
catch (DbUpdateConcurrencyException)
{
// if class not exist in database
if (!SchoolClassExists(id))
{
return(NotFound());
}
throw;
}
// Return Id
return(Ok(id));
}
// GET: SchoolClasses/Details/5
public async Task <IActionResult> Details(int?id)
{
if (id == null)
{
return(RedirectToAction("Index"));
}
var schoolClass = await _context.SchoolClasses
.FirstOrDefaultAsync(m => m.Id == id);
if (schoolClass == null)
{
return(RedirectToAction("Index"));
}
var enrolledStudentIds = _context.SchoolClassStudents
.Where(scs => scs.SchoolClassId == id)
.Select(scs => scs.StudentId).ToList();
var enrolledStudents = await GetUsersFromIdAsync(enrolledStudentIds);
var viewModel = new SchoolClassViewModel()
{
Id = schoolClass.Id,
Name = schoolClass.Name,
Teacher = await _userManager.FindByIdAsync(schoolClass.TeacherId),
Students = enrolledStudents
};
return(View(viewModel));
}
// GET: SchoolClasses/Edit/5
public async Task <IActionResult> Edit(int?id)
{
if (id == null)
{
return(RedirectToAction("Index"));
}
var schoolClass = await _context.SchoolClasses.FindAsync(id);
if (schoolClass == null)
{
return(RedirectToAction("Index"));
}
var enrolledStudentIds = _context.SchoolClassStudents
.Where(scs => scs.SchoolClassId == schoolClass.Id)
.Select(scs => scs.StudentId).ToList();
var enrolledStudents = await GetUsersFromIdAsync(enrolledStudentIds);
var viewModel = new SchoolClassViewModel
{
Id = schoolClass.Id,
Name = schoolClass.Name,
Teacher = await _userManager.FindByIdAsync(schoolClass.TeacherId),
TeacherId = schoolClass.TeacherId,
Students = enrolledStudents,
StudentIds = enrolledStudentIds
};
await SchoolClassViewModel.UpdateUserList(_userManager);
return(View(viewModel));
}
// GET: SchoolClasses
public async Task <IActionResult> Index()
{
var schoolClasses = await _context.SchoolClasses.ToListAsync();
var schoolClassStudents = await _context.SchoolClassStudents.ToListAsync();
var viewModels = new List <SchoolClassViewModel>();
foreach (var sc in schoolClasses)
{
var studentIds = schoolClassStudents
.Where(scs => scs.SchoolClassId == sc.Id)
.Select(scs => scs.StudentId).ToList();
viewModels.Add(new SchoolClassViewModel
{
Id = sc.Id,
Name = sc.Name,
Teacher = await _userManager.FindByIdAsync(sc.TeacherId),
Students = await GetUsersFromIdAsync(studentIds)
});
}
await SchoolClassViewModel.UpdateUserList(_userManager);
return(View(viewModels));
}
protected async Task UpdateSchoolClass(SchoolClassViewModel studentClass)
{
var result = await _schoolClassesController.UpdateSchoolClass(studentClass.classId, studentClass);
var okObjectResult = result as OkObjectResult;
Assert.NotNull(okObjectResult);
}
protected async Task <SchoolClassViewModel> CreateSchoolClass(SchoolClassViewModel studentClass)
{
var result = await _schoolClassesController.CreateSchoolClass(studentClass);
var okObjectResult = result as OkObjectResult;
Assert.NotNull(okObjectResult);
return(okObjectResult.Value as SchoolClassViewModel);
}
public ActionResult AddClass(SchoolClassViewModel viewModel)
{
if (ModelState.IsValid)
{
_classesService.AddClass(viewModel);
ViewBag.Message = "Added";
}
return(RedirectToAction("Index"));
}
public PartialViewResult GetASchoolClass(int?id)
{
SchoolClassViewModel _schoolClassViewModel = new SchoolClassViewModel();
if (id == null)
{
var _exitGradeBlank = from grad in db.GradeMajors //年级和专业来自gradeMajor;
where grad.GradeMajorIsValidate == true
select grad.Grade;
_schoolClassViewModel.GradesList = new SelectList(_exitGradeBlank.Distinct().OrderBy(g => g.GradeID), "GradeID", "GradeName");
var _exitDepartmentBlank = from grad in db.GradeMajors.Include(x => x.Major.Department)
select grad.Major.Department;
_schoolClassViewModel.DepartmentList = new SelectList(_exitDepartmentBlank.Distinct().OrderBy(x => x.DepartmentID), "DepartmentID", "DepartmentName");
var _exitMajorBlank = from maj in db.GradeMajors.Include(x => x.Major)
select maj.Major;
_schoolClassViewModel.MajorsList = new SelectList(_exitMajorBlank.Distinct().OrderBy(x => x.MajorID), "MajorID", "MajorName");
_schoolClassViewModel.StudentNumber = 0;
return(PartialView("_Modal.FormContent", _schoolClassViewModel));
}
SchoolClass _schoolClass = db.SchoolClasses.Find(id);
_schoolClassViewModel.SchoolClassID = _schoolClass.SchoolClassID;
var _exitGrade = from grad in db.GradeMajors //年级和专业来自gradeMajor;
where grad.GradeMajorIsValidate == true
select grad.Grade;
_schoolClassViewModel.GradesList = new SelectList(_exitGrade.Distinct().OrderBy(g => g.GradeID), "GradeID", "GradeName", _schoolClass.GradeMajor.GradeID);
var _exitDepartment = from grad in db.GradeMajors.Include(x => x.Major.Department)
select grad.Major.Department;
_schoolClassViewModel.DepartmentList = new SelectList(_exitDepartment.Distinct().OrderBy(x => x.DepartmentID), "DepartmentID", "DepartmentName", _schoolClass.GradeMajor.Major.DepartmentID);
var _exitMajor = from maj in db.GradeMajors.Include(x => x.Major)
where (maj.GradeMajorIsValidate == true)
select maj.Major;
_schoolClassViewModel.MajorsList = new SelectList(_exitMajor.Distinct().OrderBy(x => x.MajorID), "MajorID", "MajorName", _schoolClass.GradeMajor.MajorID);
_schoolClassViewModel.SchoolClassName = _schoolClass.SchoolClassName;
_schoolClassViewModel.StudentNumber = _schoolClass.StudentNumber;
return(PartialView("_Modal.FormContent", _schoolClassViewModel));
}
public async Task SchoolClassesControllerTests_ShouldBeAbleToRemove_SchoolClass()
{
//Arrange
var schoolClass = new SchoolClassViewModel
{
name = "Science",
classLocation = "Room B",
teacherName = "John Smith"
};
var result = await CreateSchoolClass(schoolClass);
// Act and assert
await RemoveSchoolClass(result.classId);
}
public ActionResult EditClass(long id, SchoolClassViewModel vm)
{
try
{
// TODO: Add update logic here
if (ModelState.IsValid)
{
_classesService.EditClass(vm);
ViewBag.Message = "Edited";
}
return(RedirectToAction("Index"));
}
catch
{
return(View("Index", _classesService.GetClasses()));
}
}
public async Task SchoolClassesControllerTests_ShouldBeAbleToCreateNew_SchoolClass()
{
//Arrange
var schoolClass = new SchoolClassViewModel
{
name = "Science",
classLocation = "Room B",
teacherName = "John Smith"
};
// Act
var result = await CreateSchoolClass(schoolClass);
// Assert
Assert.NotNull(result);
Assert.Equal(schoolClass.name, result.name);
}
public async Task <IActionResult> Create([Bind("Id,Name,TeacherId")] SchoolClassViewModel viewModel)
{
if (ModelState.IsValid)
{
var schoolClass = new SchoolClass
{
Id = viewModel.Id,
Name = viewModel.Name,
TeacherId = viewModel.TeacherId
};
_context.Add(schoolClass);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(viewModel));
}
public async Task <IActionResult> CreateSchoolClass([FromBody] SchoolClassViewModel entity)
{
// validate state
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
// Map view model to DB model
var schoolClass = _mapper.Map <SchoolClassViewModel, SchoolClass>(entity);
_schoolClassRepository.AddSchoolClass(schoolClass);
// Save
await _unitOfWork.CompleteAsync();
schoolClass = await _schoolClassRepository.GetSchoolClassAsync(schoolClass.Id);
// Return mapped model
var result = _mapper.Map <SchoolClass, SchoolClassViewModel>(schoolClass);
return(Ok(result));
}
public async Task <IActionResult> Create([Bind("Id")] SchoolClassViewModel schoolClass)
{
var tests = await _context.Classes.ToListAsync();
foreach (var test in tests)
{
if (test.Id == schoolClass.Id)
{
ViewBag.ErrorMessage = "Klassnamnet finns redan";
return(View("Create", schoolClass));
}
}
if (ModelState.IsValid)
{
_context.Add(schoolClass);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(schoolClass));
}
public void Add(SchoolClassViewModel classViewModel)
{
_context.SchoolClass.Add(new MedicalClass());
}
public void AddClass(SchoolClassViewModel viewModel)
{
_repository.AddNew(Mapper.Instance.Map <SchoolClass>(viewModel));
}
// GET: SchoolClasses/Create
public async Task <IActionResult> Create()
{
await SchoolClassViewModel.UpdateUserList(_userManager);
return(View());
}
public async Task <IActionResult> Edit(int id, [Bind("Id,Name,StudentIds,TeacherId")] SchoolClassViewModel viewModel)
{
if (id != viewModel.Id)
{
return(RedirectToAction("Index"));
}
if (ModelState.IsValid)
{
// Uppdatera tabell (SchoolClass)
var schoolClass = new SchoolClass
{
Id = id,
Name = viewModel.Name,
TeacherId = viewModel.TeacherId
};
try
{
_context.Update(schoolClass);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!SchoolClassExists(schoolClass.Id))
{
return(NotFound());
}
else
{
throw;
}
}
// Uppdatera relation (SchoolClassStudents)
var oldStudentList = await _context.SchoolClassStudents
.Where(scs => scs.SchoolClassId == id).ToListAsync();
var updatedStudentList = viewModel.StudentIds?
.Select(studentId => new SchoolClassStudent
{
StudentId = studentId, SchoolClassId = id
})
.ToList();
var studentsToRemove = new List <SchoolClassStudent>();
if (updatedStudentList == null)
{
studentsToRemove = oldStudentList;
}
else
{
studentsToRemove = oldStudentList.Except(updatedStudentList).ToList();
}
try
{
if (studentsToRemove.Any())
{
foreach (var student in studentsToRemove)
{
_context.Remove(student);
}
}
if (updatedStudentList != null)
{
foreach (var newStudent in updatedStudentList)
{
if (SchoolClassStudentExists(newStudent.StudentId))
{
_context.Update(newStudent);
}
else
{
_context.Add(newStudent);
}
}
}
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!SchoolClassExists(schoolClass.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(viewModel));
}
public PartialViewResult GetASchoolClass(int?id)
{
SchoolClassViewModel _schoolClassViewModel = new SchoolClassViewModel();
//获取当前用户所负责征订的部门；2017.12.30
//var currentDepartments = UserManager.Users.Include(x => x.Departments).SingleOrDefault(x => x.Id == User.Identity.GetUserId()).Departments.ToList();
//获取当前用户所负责征订的部门；2017.12.30
var exitUsers = UserManager.Users.Include(x => x.Departments).ToList(); //获取系统所有用户 及管理的部门。
var currentUser = exitUsers.SingleOrDefault(x => x.Id == User.Identity.GetUserId()); //获取登录用户。
var currentDepartments = currentUser.Departments.ToList(); //获取登录用户所管理的部门。
if (id == null)
{
var _exitGradeBlank = from grad in db.GradeMajors //年级和专业来自gradeMajor;
where grad.GradeMajorIsValidate == true
select grad.Grade;
_schoolClassViewModel.GradesList = new SelectList(_exitGradeBlank.Distinct().OrderBy(g => g.GradeID), "GradeID", "GradeName");
var _exitDepartmentBlank = from grad in db.GradeMajors.Include(x => x.Major.Department)
select grad.Major.Department;
var queryDepartmentsBlank = _exitDepartmentBlank.Distinct().OrderBy(x => x.DepartmentID).ToList();
var returnDepartmentsBlank = new List <Department>();
foreach (var departmentItem in queryDepartmentsBlank)
{
if (currentDepartments.Contains(departmentItem))
{
returnDepartmentsBlank.Add(departmentItem);
}
}
_schoolClassViewModel.DepartmentList = new SelectList(returnDepartmentsBlank.Distinct().OrderBy(x => x.DepartmentID).ToList(), "DepartmentID", "DepartmentName");
var _exitMajorBlank = from maj in db.GradeMajors.Include(x => x.Major)
select maj.Major;
var queryMajorBlank = _exitMajorBlank.Distinct().OrderBy(x => x.DepartmentID).ThenBy(x => x.MajorID).ToList();
var returnMajorsBlank = new List <Major>();
foreach (var majorItem in queryMajorBlank)
{
if (currentDepartments.Contains(majorItem.Department))
{
returnMajorsBlank.Add(majorItem);
}
}
_schoolClassViewModel.MajorsList = new SelectList(returnMajorsBlank.Distinct().OrderBy(x => x.MajorID).ToList(), "MajorID", "MajorName");
_schoolClassViewModel.StudentNumber = 0;
return(PartialView("_Modal.FormContent", _schoolClassViewModel));
}
SchoolClass _schoolClass = db.SchoolClasses.Find(id);
_schoolClassViewModel.SchoolClassID = _schoolClass.SchoolClassID;
var _exitGrade = from grad in db.GradeMajors //年级和专业来自gradeMajor;
where grad.GradeMajorIsValidate == true
select grad.Grade;
_schoolClassViewModel.GradesList = new SelectList(_exitGrade.Distinct().OrderBy(g => g.GradeID).ToList(), "GradeID", "GradeName", _schoolClass.GradeMajor.GradeID);
var _exitDepartment = from grad in db.GradeMajors.Include(x => x.Major.Department)
select grad.Major.Department;
var queryDepartments = _exitDepartment.Distinct().OrderBy(x => x.DepartmentID).ToList();
var returnDepartments = new List <Department>();
foreach (var departmentItem in queryDepartments)
{
if (currentDepartments.Contains(departmentItem))
{
returnDepartments.Add(departmentItem);
}
}
_schoolClassViewModel.DepartmentList = new SelectList(returnDepartments.Distinct().OrderBy(x => x.DepartmentID).ToList(), "DepartmentID", "DepartmentName", _schoolClass.GradeMajor.Major.DepartmentID);
var _exitMajor = from maj in db.GradeMajors.Include(x => x.Major)
where (maj.GradeMajorIsValidate == true)
select maj.Major;
var queryMajor = _exitMajor.Distinct().OrderBy(x => x.DepartmentID).ThenBy(x => x.MajorID).ToList();
var returnMajors = new List <Major>();
foreach (var majorItem in queryMajor)
{
if (currentDepartments.Contains(majorItem.Department))
{
returnMajors.Add(majorItem);
}
}
_schoolClassViewModel.MajorsList = new SelectList(returnMajors.Distinct().OrderBy(x => x.DepartmentID).ThenBy(x => x.MajorID).ToList(), "MajorID", "MajorName", _schoolClass.GradeMajor.MajorID);
_schoolClassViewModel.SchoolClassName = _schoolClass.SchoolClassName;
_schoolClassViewModel.StudentNumber = _schoolClass.StudentNumber;
return(PartialView("_Modal.FormContent", _schoolClassViewModel));
}
public ActionResult Test(int id)
{
var school = db.Schools.Where(s => s.Id == id);
var classes = db.SchoolClasses.Include(s => s.School).Where(c => c.SchoolId == id);
List <SchoolClassViewModel> lista = new List <SchoolClassViewModel>();
List <ClassChartViewModel> chart = new List <ClassChartViewModel>();
foreach (var myClass in classes)
{
var recycles = db.Recycles.Include(t => t.RecycleType)
.Where(c => c.SchoolClassId == myClass.Id);
int finalPoints = 0;
foreach (var item in recycles)
{
finalPoints += item.Units * item.RecycleType.Points;
}
var recyclesMonthly = recycles.Where(c => c.DateStamp.Month.Equals(DateTime.Now.Month - 1));
int points = 0;
int plastic = 0;
int battery = 0;
int glass = 0;
foreach (var item in recyclesMonthly)
{
int test = item.DateStamp.Month;
points += item.Units * item.RecycleType.Points;
switch (item.RecycleTypeId)
{
case RecycleType.Plastic:
plastic += item.Units;
break;
case RecycleType.Battery:
battery += item.Units;
break;
case RecycleType.Glass:
glass += item.Units;
break;
default:
break;
}
}
var viewModel = new SchoolClassViewModel
{
SchoolClass = myClass,
Points = points,
FinalPoints = finalPoints,
Plastic = plastic,
Glass = glass,
Batery = battery
};
lista.Add(viewModel);
}
var viewModel2 = new ClassViewModel
{
List = lista,
School = school.Single(),
ListChart = Function(id).GetRange(0, 9)
};
return(View(viewModel2));
}
