public async Task <List <ExamRoomExamPeriodDTO> > ListExamRoomExamPeriod()
{
ExamProgram currentExamProgram = await ExamProgramService.GetCurrentExamProgram();
ExamRoomExamPeriodFilter filter = new ExamRoomExamPeriodFilter
{
StudentNumber = CurrentContext.StudentNumber,
ExamProgramId = new GuidFilter {
Equal = currentExamProgram.Id
},
OrderBy = ExamOrder.ExamDate,
OrderType = OrderType.ASC
};
List <ExamRoomExamPeriod> res = await ExamRoomExamPeriodService.List(filter);
return(res.Select(r => new ExamRoomExamPeriodDTO
{
ExamPeriodId = r.ExamPeriodId,
ExamRoomId = r.ExamRoomId,
TermId = r.TermId,
ExamProgramId = r.ExamProgramId,
ExamProgramName = r.ExamProgramName,
ExamDate = r.ExamDate.ToString("dd-MM-yyyy"),
StartHour = r.StartHour,
FinishHour = r.FinishHour,
ExamRoomNumber = r.ExamRoomNumber,
ExamRoomAmphitheaterName = r.ExamRoomAmphitheaterName,
ExamRoomComputerNumber = r.ExamRoomComputerNumber,
CurrentNumberOfStudentRegistered = r.Students.Count,
SubjectName = r.SubjectName,
Errors = r.Errors,
}).ToList());
}
public async Task <ExamProgram> Delete(ExamProgram examProgram)
{
if (!await ExamProgramValidator.Delete(examProgram))
{
return(examProgram);
}
using (UOW.Begin())
{
try
{
examProgram = await UOW.ExamProgramRepository.Get(examProgram.Id);
await UOW.ExamProgramRepository.Delete(examProgram.Id);
await UOW.Commit();
}
catch (Exception e)
{
await UOW.Rollback();
examProgram.AddError(nameof(ExamProgramService), nameof(Delete), CommonEnum.ErrorCode.SystemError);
}
}
return(examProgram);
}
public void ShouldRenderIndexViewCorrectly()
{
Mock <IGenericService <ExamProgram> > examProgramServiceMock = new Mock <IGenericService <ExamProgram> >();
ExamProgram examProgram = new ExamProgram()
{
Id = 100,
StartDate = DateTime.Now.Date
};
examProgramServiceMock.Setup(m => m.FindAll(It.IsAny <string[]>(), It.IsAny <int>(), It.IsAny <int>())).Returns(new List <ExamProgram>()
{
examProgram,
new ExamProgram()
{
Id = 101
},
new ExamProgram()
{
Id = 102
},
});
ExamProgramController controller = new ExamProgramController(examProgramServiceMock.Object);
List <ExamProgram> model = (controller.Index() as ViewResult)?.ViewData.Model as List <ExamProgram>;
Assert.Equal(3, model.Count);
Assert.Equal(100, model[0].Id);
Assert.Equal(101, model[1].Id);
Assert.Equal(DateTime.Now.Date, model[0].StartDate);
}
public async Task <ExamProgram> Create(ExamProgram examProgram)
{
if (!await ExamProgramValidator.Create(examProgram))
{
return(examProgram);
}
using (UOW.Begin())
{
try
{
examProgram.Id = Guid.NewGuid();
examProgram = await GetSemesterId(examProgram);
await UOW.ExamProgramRepository.Create(examProgram);
await UOW.Commit();
return(examProgram);
}
catch (Exception e)
{
await UOW.Rollback();
examProgram.AddError(nameof(ExamProgramService), nameof(Create), CommonEnum.ErrorCode.SystemError);
return(examProgram);
}
}
}
private bool ValidateStringLength(ExamProgram examProgram)
{
if (string.IsNullOrEmpty(examProgram.Name))
{
examProgram.AddError(nameof(ExamProgramValidator), nameof(examProgram.Name), ERROR.StringEmpty);
return(false);
}
else if (examProgram.Name.Length > 100)
{
examProgram.AddError(nameof(ExamProgramValidator), nameof(examProgram.Name), ERROR.StringLimited);
return(false);
}
if (string.IsNullOrEmpty(examProgram.SemesterCode))
{
examProgram.AddError(nameof(ExamProgramValidator), nameof(examProgram.SemesterCode), ERROR.SemesterCodeEmpty);
return(false);
}
else if (Regex.IsMatch(examProgram.SemesterCode, @"^\d{4}_\d{4}_\d") == false)
{
examProgram.AddError(nameof(ExamProgramValidator), nameof(examProgram.SemesterCode), ERROR.SemesterCodeInValid);
return(false);
}
return(true);
}
public async Task <List <ExamPeriodDTO> > ListCurrentExamPeriod()
{
ExamProgram currentExamProgram = await ExamProgramService.GetCurrentExamProgram();
ExamPeriodFilter filter = new ExamPeriodFilter
{
StudentNumber = CurrentContext.StudentNumber,
ExamProgramId = new GuidFilter {
Equal = currentExamProgram.Id
}
};
List <ExamPeriod> res = await ExamPeriodService.List(filter);
return(res.Select(r => new ExamPeriodDTO
{
Id = r.Id,
TermId = r.TermId,
ExamProgramId = r.ExamProgramId,
SubjectName = r.SubjectName,
ExamDate = r.ExamDate.ToString("dd-MM-yyyy"),
StartHour = r.StartHour,
FinishHour = r.FinishHour,
ExamProgramName = r.ExamProgramName,
Errors = r.Errors
}).ToList());
}
public ActionResult <Course> DeleteCourse(int id, int courseId)
{
ExamProgram examprogram = dataService.FindById <ExamProgram>(id, new string[] { "Courses" });
Course course = dataService.FindById <Course>(courseId);
if (course == null)
{
return(NotFound("Course not found"));
}
else if (examprogram == null)
{
return(NotFound("Examprogram not found"));
}
foreach (Course courseIn in examprogram.Courses)
{
if (courseIn.Id == courseId)
{
examprogram.Courses.Remove(courseIn);
break;
}
}
if (dataService.Update <ExamProgram>(examprogram) != 1)
{
return(StatusCode(500));
}
return(new OkObjectResult(examprogram));
}
public async Task <List <TermDTO> > ListTerm()
{
ExamProgram currentExamProgram = await ExamProgramService.GetCurrentExamProgram();
if (currentExamProgram == null)
{
return(new List <TermDTO>());
}
List <Term> terms = await TermService.List(new TermFilter
{
SemesterId = new GuidFilter {
Equal = currentExamProgram.SemesterId
},
OrderBy = TermOrder.SubjectName,
OrderType = OrderType.ASC
});
return(terms.Select(t => new TermDTO
{
Id = t.Id,
SubjectName = t.SubjectName,
SemesterId = t.SemesterId,
SemesterCode = t.SemesterCode,
Errors = t.Errors
}).ToList());
}
public async Task <bool> Delete(ExamProgram examProgram)
{
bool IsValid = true;
IsValid &= await ValidateId(examProgram);
return(IsValid);
}
public async Task <bool> Update(ExamProgram examProgram)
{
bool IsValid = true;
IsValid &= await ValidateId(examProgram);
IsValid &= ValidateStringLength(examProgram);
return(IsValid);
}
public ActionResult <ExamProgram> Get(int id)
{
ExamProgram result = dataService.FindById <ExamProgram>(id);
if (result == null)
{
return(NotFound("Examprogram not found"));
}
return(new OkObjectResult(result));
}
public ActionResult <IEnumerable <Course> > GetCourses(int id)
{
ExamProgram course = dataService.FindById <ExamProgram>(id, new string[] { "Courses" });
if (course == null)
{
return(NotFound("Examprogram not found"));
}
return(new OkObjectResult(course.Courses));
}
public async Task <bool> Update(ExamProgram examProgram)
{
await examRegContext.ExamProgram.Where(t => t.Id.Equals(examProgram.Id)).UpdateFromQueryAsync(t => new ExamProgramDAO
{
Name = examProgram.Name,
SemesterId = examProgram.SemesterId,
IsCurrent = examProgram.IsCurrent
});
return(true);
}
public IActionResult Delete(int id)
{
ExamProgram examProgram = examProgramService.FindById(id);
IActionResult actionResult = View();
if (examProgramService.Delete(examProgram) == 1)
{
actionResult = RedirectToAction(nameof(Index));
}
return(actionResult);
}
public async Task <ExamProgramDTO> GetCurrentExamProgram()
{
ExamProgram res = await ExamProgramService.GetCurrentExamProgram();
return(new ExamProgramDTO
{
Id = res.Id,
Name = res.Name,
SemesterId = res.SemesterId,
SemesterCode = res.SemesterCode,
IsCurrent = res.IsCurrent,
Errors = res.Errors
});
}
public async Task <ExamProgram> GetSemesterId(ExamProgram examProgram)
{
SemesterFilter filter = new SemesterFilter
{
Code = new StringFilter {
Equal = examProgram.SemesterCode
}
};
Semester semester = await UOW.SemesterRepository.Get(filter);
examProgram.SemesterId = semester.Id;
return(examProgram);
}
public IActionResult Create(ExamProgram examProgram)
{
IActionResult actionResult = View(examProgram);
if (!ModelState.IsValid)
{
actionResult = View("Error");
}
else if (examProgramService.Insert(examProgram) == 1)
{
actionResult = RedirectToAction(nameof(Index));
}
return(actionResult);
}
public ActionResult <ExamProgram> Post([FromBody] ExamProgramViewModel value)
{
ExamProgram program = new ExamProgram
{
StartDate = value.StartDate,
EndDate = value.EndDate
};
if (dataService.Insert <ExamProgram>(program) != 1)
{
return(StatusCode(500));
}
return(new OkObjectResult(program));
}
public async Task <bool> Create(ExamProgram examProgram)
{
ExamProgramDAO examProgramDAO = new ExamProgramDAO()
{
Id = examProgram.Id,
Name = examProgram.Name,
SemesterId = examProgram.SemesterId,
IsCurrent = false
};
await examRegContext.ExamProgram.AddAsync(examProgramDAO);
await examRegContext.SaveChangesAsync();
return(true);
}
public IActionResult Edit(ExamProgram examProgram)
{
IActionResult actionResult = View(examProgram);
if (!ModelState.IsValid)
{
var errors = ModelState.Values;
actionResult = View("Error");
}
else if (examProgramService.Update(examProgram) == 1)
{
actionResult = RedirectToAction(nameof(Index));
}
return(actionResult);
}
public ActionResult <ExamProgram> Delete(int id)
{
ExamProgram result = dataService.FindById <ExamProgram>(id);
if (result == null)
{
return(NotFound("ExamProgram not found"));
}
if (dataService.Delete(result) != 1)
{
return(StatusCode(500));
}
return(new OkObjectResult(result));
}
/*private async Task<bool> ValidateExist(ExamProgram ExamProgram)
* {
* ExamProgramFilter filter = new ExamProgramFilter
* {
* Name = new StringFilter { Equal = ExamProgram.Name },
* SemesterCode = new StringFilter { Equal = ExamProgram.SemesterCode }
* };
*
* int count = await UOW.ExamProgramRepository.Count(filter);
* if (count == 0)
* {
* ExamProgram.AddError(nameof(ExamProgramValidator), nameof(ExamProgram), ERROR.NotExisted);
* return false;
* }
* return true;
* }*/
public async Task <bool> ValidateId(ExamProgram examProgram)
{
ExamProgramFilter filter = new ExamProgramFilter
{
Id = new GuidFilter {
Equal = examProgram.Id
},
};
int count = await UOW.ExamProgramRepository.Count(filter);
if (count == 0)
{
examProgram.AddError(nameof(ExamProgramValidator), nameof(examProgram), ERROR.IdNotFound);
}
return(count == 1);
}
public void ShouldRenderDetailViewCorrectly()
{
Mock <IGenericService <ExamProgram> > examProgramServiceMock = new Mock <IGenericService <ExamProgram> >();
ExamProgram examProgram = new ExamProgram()
{
Id = 100,
StartDate = DateTime.Now.Date
};
examProgramServiceMock.Setup(m => m.FindById(It.IsAny <int>(), It.IsAny <string[]>())).Returns(examProgram);
ExamProgramController controller = new ExamProgramController(examProgramServiceMock.Object);
ExamProgram model = (controller.Details(examProgram.Id) as ViewResult)?.ViewData.Model as ExamProgram;
Assert.Equal(100, model.Id);
Assert.Equal(DateTime.Now.Date, model.StartDate);
}
public async Task <FileResult> PrintExamRegisterResult()
{
ExamProgram currentExamProgram = await ExamProgramService.GetCurrentExamProgram();
ExamRoomExamPeriodFilter filter = new ExamRoomExamPeriodFilter
{
StudentNumber = CurrentContext.StudentNumber,
ExamProgramId = new GuidFilter {
Equal = currentExamProgram.Id
},
OrderBy = ExamOrder.ExamDate,
OrderType = OrderType.ASC
};
MemoryStream stream = await ExamRoomExamPeriodService.PrintExamRegisterResult(filter);
// Download Word document in the browser
return(File(stream, "application/msword", "ExamRegisterResult.docx"));
}
public async Task <ExamProgramDTO> SetCurrentExamProgram([FromBody] ExamProgramDTO examProgramRequestDTO)
{
ExamProgram examProgram = new ExamProgram
{
Id = examProgramRequestDTO.Id
};
ExamProgram res = await ExamProgramService.SetCurrentExamProgram(examProgram);
return(new ExamProgramDTO
{
Id = res.Id,
SemesterId = res.SemesterId,
Name = res.Name,
SemesterCode = res.SemesterCode,
IsCurrent = res.IsCurrent,
Errors = res.Errors
});
}
public ActionResult <Course> GetCourse(int id, int courseId)
{
ExamProgram program = dataService.FindById <ExamProgram>(id, new string[] { "Courses" });
if (program == null)
{
return(NotFound("Examprogram not found"));
}
foreach (Course course in program.Courses)
{
if (course.Id == courseId)
{
return(new OkObjectResult(course));
}
}
return(NotFound("Course not found"));
}
public ActionResult <ExamProgram> Put(int id, [FromBody] ExamProgramViewModel value)
{
ExamProgram program = dataService.FindById <ExamProgram>(id);
if (program == null)
{
return(NotFound("Examprogram not found!"));
}
program.EndDate = value.EndDate;
program.StartDate = value.StartDate;
if (dataService.Update <ExamProgram>(program) != 1)
{
return(StatusCode(500));
}
return(new OkObjectResult(program));
}
public void CannotEditWithMissingValues()
{
Mock <IGenericService <ExamProgram> > examProgramServiceMock = new Mock <IGenericService <ExamProgram> >();
ExamProgram examProgram = new ExamProgram()
{
Id = 100,
Courses = null
};
ClaimsPrincipal identity = new ClaimsPrincipal(new ClaimsIdentity(new Claim[]
{
new Claim(ClaimTypes.NameIdentifier, "123")
}));
examProgramServiceMock.Setup(m => m.Update(It.IsAny <ExamProgram>())).Returns((ExamProgram model) =>
{
if (model.StartDate != null && model.EndDate != null && model.Courses != null && !string.IsNullOrWhiteSpace(model.Name))
{
return(1);
}
return(0);
});
ExamProgramController controller = new ExamProgramController(examProgramServiceMock.Object)
{
ControllerContext = new ControllerContext()
{
HttpContext = new DefaultHttpContext()
{
User = identity
}
}
};
ViewResult result = controller.Edit(examProgram) as ViewResult;
Assert.NotNull(result);
Assert.NotNull(result.Model);
Assert.True(string.IsNullOrEmpty(result.ViewName) || result.ViewName == "Edit");
}
public void ShouldGetOneItemWithFindByIdMethod()
{
Mock <IGenericRepository <ExamProgram> > examProgramRepositoryMock = new Mock <IGenericRepository <ExamProgram> >();
Mock <IActivityLoggerService> activityLoggerMock = new Mock <IActivityLoggerService>();
examProgramRepositoryMock.Setup((e) => e.FindById("10", null)).Returns(new ExamProgram()
{
Id = 10,
EndDate = System.DateTime.Now.AddYears(1),
StartDate = System.DateTime.Now,
Courses = new List <Course>()
});
IGenericService <ExamProgram> ExamProgramService = new GenericService <ExamProgram>(examProgramRepositoryMock.Object, activityLoggerMock.Object);
ExamProgram result = ExamProgramService.FindById("10");
Assert.NotNull(result);
Assert.Equal(10, result.Id);
}
public void ShouldCreateCorrectly()
{
Mock <IGenericService <ExamProgram> > examProgramServiceMock = new Mock <IGenericService <ExamProgram> >();
ExamProgram examProgram = new ExamProgram()
{
Id = 100,
StartDate = DateTime.Now.Date,
EndDate = DateTime.Now.Date.AddDays(30)
};
ClaimsPrincipal identity = new ClaimsPrincipal(new ClaimsIdentity(new Claim[]
{
new Claim(ClaimTypes.NameIdentifier, "123")
}));
examProgramServiceMock.Setup(m => m.Insert(It.IsAny <ExamProgram>())).Returns((ExamProgram model) =>
{
if (model.StartDate != null && model.EndDate != null && model.Courses != null && !string.IsNullOrWhiteSpace(model.Name))
{
return(1);
}
return(0);
});
ExamProgramController controller = new ExamProgramController(examProgramServiceMock.Object)
{
ControllerContext = new ControllerContext()
{
HttpContext = new DefaultHttpContext()
{
User = identity
}
}
};
RedirectToActionResult result = controller.Create(examProgram) as RedirectToActionResult;
Assert.Equal("Index", result?.ActionName);
}
