public async Task ShowModal()
{
Current = new ScienceTheme
{
Lecturers = await LecturerService.GetAsync()
};
}
private void lv_rooster_activity_SelectedIndexChanged(object sender, EventArgs e)
{
lv_rooster_replacement.Clear();
btn_replacement.Enabled = false;
if (lv_rooster_activity.SelectedItems.Count > 1)
{
lv_rooster_activity.SelectedItems[0].Selected = false;
}
else if (lv_rooster_activity.SelectedItems.Count == 1)
{
LecturerService lecturerService = new LecturerService();
lv_rooster_replacement.Clear();
lv_rooster_replacement.Columns.Add("Name");
lv_rooster_replacement.Columns.Add("ID");
foreach (Lecturer lecturer in lecturerService.getLecturers())
{
if (lv_rooster_lecturers.SelectedItems[0].SubItems[0].Text != lecturer.name)
{
ListViewItem li = new ListViewItem(lecturer.name);
li.SubItems.Add(lecturer.number.ToString());
lv_rooster_replacement.Items.Add(li);
}
}
}
}
public async Task ShowModal()
{
Current = new Traineeship
{
Lecturers = await LecturerService.GetAsync()
};
}
private void btn_replacement_Click(object sender, EventArgs e)
{
int oldLecturerId = Int32.Parse(lv_rooster_lecturers.SelectedItems[0].SubItems[1].Text);
int newLecturerId = Int32.Parse(lv_rooster_replacement.SelectedItems[0].SubItems[1].Text);
int activityId = Int32.Parse(lv_rooster_activity.SelectedItems[0].SubItems[3].Text);
ActivityService activityService = new ActivityService();
activityService.ChangeActivityLecturer(activityId, newLecturerId, oldLecturerId);
lv_rooster_activity.Clear();
foreach (Activity activity in activityService.GetActivitiesByLecturer(Int32.Parse(lv_rooster_lecturers.SelectedItems[0].SubItems[1].Text)))
{
ListViewItem li = new ListViewItem(activity.Omschrijving);
li.SubItems.Add(activity.AantalStudenten.ToString());
li.SubItems.Add(activity.AantalBegeleiders.ToString());
li.SubItems.Add(activity.Id.ToString());
lv_rooster_activity.Items.Add(li);
}
LecturerService lecturerService = new LecturerService();
lv_rooster_replacement.Clear();
foreach (Lecturer lecturer in lecturerService.getLecturers())
{
if (lv_rooster_lecturers.SelectedItems[0].SubItems[0].Text != lecturer.name)
{
ListViewItem li = new ListViewItem(lecturer.name);
li.SubItems.Add(lecturer.number.ToString());
lv_rooster_replacement.Items.Add(li);
}
}
}
public async Task ShowModal()
{
Current = new Diploma
{
Lecturers = await LecturerService.GetAsync(),
Students = await StudentService.GetAsync()
};
}
public async Task ShowModal(int id)
{
Current = await DiplomaService.GetAsync(id).ConfigureAwait(false);
Current.Lecturers = await LecturerService.GetAsync();
Current.Students = await StudentService.GetAsync();
}
protected override async Task OnInitializedAsync()
{
Id = Id ?? "1";
Lecturer = await LecturerService.GetLecturer(int.Parse(Id));
Lecturers = (await LecturerService.GetLecturers()).ToList();
LecturersModules = (await LMService.GetLecturersModules()).ToList();
}
public async Task Add()
{
await LecturerService.AddAsync(Current).ConfigureAwait(false);
Collection = await LecturerService.GetAsync().ConfigureAwait(false);
StateHasChanged();
}
public async Task ShowModal()
{
Current = new Plan
{
Lecturers = await LecturerService.GetAsync(),
Disciplines = await DisciplineService.GetAsync()
};
}
public async Task ShowModal(int id)
{
Current = await PlanService.GetAsync(id).ConfigureAwait(false);
Current.Lecturers = await LecturerService.GetAsync();
Current.Disciplines = await DisciplineService.GetAsync();
}
protected async Task Soft_delete()
{
await LecturerService.DeleteLecturer(Lecturer.Id);
await OnLecturerDeleted.InvokeAsync(Lecturer.Id);
//NavigationManager.NavigateTo("/",true);
}
public async Task ShowModal()
{
Current = new Control
{
Lecturers = await LecturerService.GetAsync(),
Disciplines = await DisciplineService.GetAsync(),
Students = await StudentService.GetAsync()
};
}
public CourseController(CourseService courseService, StudentService studentService, HometaskService hometaskService,
HomeTaskAssessmentService homeTaskAssessmentService, LecturerService lecturerService)
{
this.courseService = courseService;
this.studentService = studentService;
this.hometaskService = hometaskService;
this.homeTaskAssessmentService = homeTaskAssessmentService;
this.lecturerService = lecturerService;
}
private void populateData()
{
ILecturerService lecturerService = new LecturerService();
List <Lecturer> lecturersArray = lecturerService.getAllLecturers();
foreach (Lecturer lecturer in lecturersArray)
{
dataGridLecturers.Rows.Add(lecturer.Id, lecturer.Name, lecturer.EmployeeID, lecturer.Faculty, lecturer.Department, lecturer.Center, lecturer.Building, lecturer.Level, lecturer.Rank);
}
}
public async Task Update()
{
if (Collection is List <Lecturer> lecturers)
{
lecturers[lecturers.FindIndex(r => r.Id == Current.Id)] = Current;
}
else
{
Collection = await LecturerService.GetAsync().ConfigureAwait(false);
}
StateHasChanged();
Current = await LecturerService.UpdateAsync(Current).ConfigureAwait(false);
}
public void Setup()
{
Repository = new Mock <ILecturerRepository>();
UnitOfWork = new Mock <IUnitOfWork>();
Logger = new Mock <ILogger <LecturerService> >();
UnitOfWork.SetupGet(x => x.Lecturers)
.Returns(Repository.Object);
Service = new LecturerService(UnitOfWork.Object, Logger.Object);
}
public void Create_ReturnsBadRequest_WhenLecturerParameterIsNull()
{
//Arrange
Lecturer lecturer = null;
LecturerService lecturerService = Substitute.For <LecturerService>();
LecturerController controller = new LecturerController(lecturerService);
//Act
IActionResult actual = controller.Create(lecturer);
//Assert
actual.Should().BeAssignableTo <BadRequestResult>();
}
public async Task AssignLecturers_ReturnsBadRequest_WhenAssignmentViewModelIsEmpty()
{
//Arrange
CourseLecturerAssignmentViewModel model = null;
CourseService courseService = Substitute.For <CourseService>();
LecturerService LecturerService = Substitute.For <LecturerService>();
CourseController controller = new CourseController(courseService, null, LecturerService);
//Act
IActionResult actual = controller.AssignLecturers(model);
//Assert
actual.Should().BeAssignableTo <BadRequestResult>();
}
public void Edit_ReturnNotFound_WhenLecturerDoesNotExist()
{
//Arrange
LecturerService lecturerService = Substitute.For <LecturerService>();
LecturerController controller = new LecturerController(lecturerService);
//Act
IActionResult actual = controller.Edit(0);
//Assert
var expected = new NotFoundResult();
actual.Should().BeEquivalentTo(expected);
}
/// <summary>
/// inside this method we call the rest api and retrieve a data
/// </summary>
/// <returns></returns>
protected async override Task OnInitializedAsync()
{
int.TryParse(Id, out int planId);
if (planId != 0)
{
Plan = await PlanService.GetPlan(int.Parse(Id));
AutumnSemester = Plan.AutumnSemester;
SpringSemester = Plan.SpringSemester;
Semesters = new List <SemesterDto> {
AutumnSemester, SpringSemester
};
SemesterId = Semester.SemesterId.ToString();
ModuleId = Module.ModuleId.ToString();
Lmr = new LecturerModuleRunDto();
SelectedPlanId = Plan.Id;
ListLmr = (await LecturerModuleRunService.GetLecturerModuleRuns()).ToList();
foreach (var sem in Semesters)
{
foreach (var mr in sem.ModuleRuns)
{
ModuleRuns.Add(mr);
}
}
await ShowLastYearPlan();
}
else
{
Plan = new PlanDto {
};
Semester = new SemesterDto {
};
Module = new ModuleDto {
};
ListLmr = new List <LecturerModuleRunDto> {
};
}
Plans = (await PlanService.GetPlans()).ToList();
ModuleRuns = (await ModuleRunService.GetModuleRuns()).ToList();
Modules = (await ModuleService.GetModules()).ToList();
Lecturers = (await LecturerService.GetLecturers()).ToList();
LecturerGroups = (await LecturerGroupService.GetLecturerGroups()).ToList();
}
public void Create_RedirectsToLecturersAndCreatesLecturer_WhenRequestIsValid()
{
//Arrange
Lecturer lecturer = new Lecturer {
Name = "New Lecturer"
};
LecturerService lecturerService = Substitute.For <LecturerService>();
LecturerController controller = new LecturerController(lecturerService);
//Act
var actionResult = controller.Create(lecturer);
lecturerService.Received().CreateLecturer(lecturer);
// Assert
actionResult.Should().BeOfType <RedirectToActionResult>().Which.ActionName.Should().Be("Lecturers");
}
public async Task Lecturers_ReturnsViewResult_WithListOfLecturers()
{
// Arrange
LecturerService lecturersService = Substitute.For <LecturerService>();
lecturersService.GetAllLecturers().Returns(this.GetLecturersList());
var controller = new LecturerController(lecturersService);
// Act
var result = controller.Lecturers();
// Assert
var viewResult = Assert.IsType <ViewResult>(result);
var model = Assert.IsAssignableFrom <List <Lecturer> >(viewResult.ViewData.Model);
Assert.Equal(2, model.Count);
}
public void Create_ReturnsViewResult_WhenLecturerModelStateIsInvalid()
{
//Arrange
Lecturer lecturer = new Lecturer {
Name = "New Lecturer"
};
LecturerService lecturerService = Substitute.For <LecturerService>();
LecturerController controller = new LecturerController(lecturerService);
//Act
controller.ModelState.AddModelError("test", "test"); //makes model invalid => if (!ModelState.IsValid)
IActionResult actual = controller.Create(lecturer);
//Assert
Assert.IsAssignableFrom <ViewResult>(actual);
actual.Should().BeAssignableTo <ViewResult>();
}
protected async Task HandleValidSubmit()
{
LecturerDto result = null;
if (Lecturer.Id != 0)
{
result = await LecturerService.UpdateLecturer(Lecturer);
}
else
{
result = await LecturerService.CreateLecturer(Lecturer);
}
if (result != null)
{
NavigationManager.NavigateTo("/lecturers");
}
}
public async Task AddLecturerTest(LecturerDto lecturerDto, Lecturer expected)
{
// Arrange
Mock <ICrudRepository <Lecturer> > repositoryMock = new();
var loggerMock = new Mock <ILogger <LecturerService> >();
var mapperMock = new Mock <IMapper>();
mapperMock.Setup(mapper => mapper.Map <Lecturer>(lecturerDto)).Returns(expected);
var service = new LecturerService(repositoryMock.Object, mapperMock.Object, loggerMock.Object);
// Act
int id = await service.AddLecturer(lecturerDto);
// Assert
Assert.That(id, Is.EqualTo(expected.Id));
repositoryMock.Verify(repository => repository.SaveAsync(expected, It.IsAny <CancellationToken>()));
repositoryMock.VerifyNoOtherCalls();
}
public void Delete_RedirectsToLecturers_WhenLecturerExists()
{
//Arrange
Lecturer lecturer = new Lecturer()
{
Name = "Test Lecturer"
};
LecturerService lecturersService = Substitute.For <LecturerService>();
lecturersService.GetLecturerById(5).Returns(lecturer);
LecturerController controller = new LecturerController(lecturersService);
//Act
var actionResult = controller.Delete(lecturer.Id);
// Assert
actionResult.Should().BeOfType <RedirectToActionResult>().Which.ActionName.Should().Be("Lecturers");
}
protected async override Task OnInitializedAsync()
{
int.TryParse(Id, out int lecturerGroupId);
if (lecturerGroupId != 0)
{
PageHeaderText = "Edit LecturerGroup";
LecturerGroup = await LecturerGroupService.GetLecturerGroup(int.Parse(Id));
}
else
{
PageHeaderText = "Create LecturerGroup";
LecturerGroup = new LecturerGroupDto
{
};
}
Lecturers = (await LecturerService.GetLecturers()).ToList();
}
public void Edit_RedirectsToLecturers_WhenModelStateIsValid()
{
//Arrange
Lecturer lecturer = new Lecturer {
Name = "Test Lecturer"
};
LecturerService lecturerService = Substitute.For <LecturerService>();
lecturerService.GetLecturerById(5).Returns(lecturer);
LecturerController controller = new LecturerController(lecturerService);
//Act
var actionResult = controller.Edit(lecturer);
lecturerService.Received().UpdateLecturer(lecturer);
// Assert
actionResult.Should().BeOfType <RedirectToActionResult>().Which.ActionName.Should().Be("Lecturers");
}
public async Task AssignLecturers_ReturnsViewResult_WithViewModel()
{
// Arrange
var courseServiceMock = Substitute.For <CourseService>();
courseServiceMock.GetCourse(Arg.Any <int>()).Returns(new Course());
LecturerService lecturerService = Substitute.For <LecturerService>();
lecturerService.GetAllLecturers().Returns(new List <Lecturer>());
var controller = new CourseController(courseServiceMock, null, lecturerService);
// Act
var result = controller.AssignLecturers(0);
// Assert
var viewResult = Assert.IsType <ViewResult>(result);
Assert.IsAssignableFrom <CourseLecturerAssignmentViewModel>(viewResult.ViewData.Model);
}
public void Edit_ReturnViewResultWithModel_WhenLecturerExists()
{
//Arrange
Lecturer lecturer = new Lecturer {
Name = "Test Lecturer"
};
LecturerService lecturerService = Substitute.For <LecturerService>();
lecturerService.GetLecturerById(5).Returns(lecturer);
LecturerController controller = new LecturerController(lecturerService);
//Act
IActionResult actual = controller.Edit(5);
//Assert
actual.Should().BeAssignableTo <ViewResult>();
ViewResult viewResult = (ViewResult)actual;
viewResult.Model.Should().BeEquivalentTo(lecturer);
}
