public LecturerApplication(
IMapper mapper,
ILecturerRepository lecturerRepository)
{
_lecturerRepository = lecturerRepository;
_mapper = mapper;
}
public CourseDomain(IDatabaseUnitOfWork databaseUnitOfWork, IStudentRepository studentRepository, ICourseRepository courseRepository, ILecturerRepository lecturerRepository)
{
DatabaseUnitOfWork = databaseUnitOfWork;
StudentRepository = studentRepository;
CourseRepository = courseRepository;
LecturerRepository = lecturerRepository;
}
public CourseService(IDatabaseUnitOfWork databaseUnitOfWork, IStudentRepository studentRepository, ICourseRepository courseRepository, ILecturerRepository lecturerRepository, IMemoryCache cache)
{
DatabaseUnitOfWork = databaseUnitOfWork;
StudentRepository = studentRepository;
CourseRepository = courseRepository;
LecturerRepository = lecturerRepository;
Cache = cache;
}
public AccountService(ILecturerRepository lecturerRepository, IStudentRepository studentRepository, IAdministratorRepository administratorRepository,
IHashService hashService, IHttpContextAccessor httpContextAccessor)
{
_lecturerRepository = lecturerRepository;
_studentRepository = studentRepository;
_administratorRepository = administratorRepository;
_hashService = hashService;
_httpContextAccessor = httpContextAccessor;
}
public ProposalController(IProposalRepository proposal,
ILecturerRepository lecturer,
IProjectRepository project,
IHostingEnvironment environment)
{
_proposalctx = proposal;
_lecturerctx = lecturer;
_projectx = project;
this.environment = environment;
}
public BoardEnrollmentController(IMapper mapper, IUnitOfWork unitOfWork,
IBoardEnrollmentRepository boardEnrollmentRepository,
ILecturerRepository lecturerRepository, IBoardRepository boardRepository)
{
this.mapper = mapper;
this.unitOfWork = unitOfWork;
this.boardEnrollmentRepository = boardEnrollmentRepository;
this.lecturerRepository = lecturerRepository;
this.boardRepository = boardRepository;
}
public UserManager(IUserRepository userRepository, IStudentRepository studentRepository, ILecturerRepository lecturerRepository,
IStudentCourseRepository studentCourseRepository, ILecturerCourseRepository lecturerCourseRepository,
ICourseRepository courseRepository)
{
_userRepository = userRepository;
_studentRepository = studentRepository;
_lecturerRepository = lecturerRepository;
_lecturerCourseRepository = lecturerCourseRepository;
_studentCourseRepository = studentCourseRepository;
_courseRepository = courseRepository;
}
public ExcelController(IHostingEnvironment host, IExcelRepository excelRepository,
IStudentRepository studentRepository, ILecturerRepository lecturerRepository,
IMapper mapper, IUnitOfWork unitOfWork)
{
this.host = host;
this.mapper = mapper;
this.unitOfWork = unitOfWork;
this.excelRepository = excelRepository;
this.studentRepository = studentRepository;
this.lecturerRepository = lecturerRepository;
}
public CourseManager(ICourseRepository courseRepository,
IStudentCourseRepository studentCourseRepository,
ILecturerCourseRepository lecturerCourseRepository,
IStudentRepository studentRepository,
ILecturerRepository lecturerRepository)
{
_courseRepository = courseRepository;
_studentCourseRepository = studentCourseRepository;
_lecturerCourseRepository = lecturerCourseRepository;
_studentRepository = studentRepository;
_lecturerRepository = lecturerRepository;
}
public GroupController(IGroupRepository groupRepository,
IProjectRepository projectRepository,
ILecturerRepository lecturerRepository,
IStudentRepository studentRepository,
IProjectChoiceRepository projectChoiceRepository)
{
this.groupRepository = groupRepository;
this.projectRepository = projectRepository;
this.lecturerRepository = lecturerRepository;
this.studentRepository = studentRepository;
this.projectChoiceRepository = projectChoiceRepository;
}
public void FindLecturers_ValidCall()
{
Mock <ILecturerRepository> mockStudentRepository = MockLecturerRepository;
mockStudentRepository.Setup(mr => mr.FindAll()).Returns(GetSampleLecturers());
_mockLecturerRepository = mockStudentRepository.Object;
IEnumerable <LecturerModel> Grades = _mockLecturerRepository.FindAll();
Assert.True(Grades != null); // Test if null
Assert.AreEqual(GetSampleLecturers().Count(), Grades.Count()); // Verify the correct Number
}
public ProjectController(ApplicationDbContext context, IMapper mapper, IUnitOfWork unitOfWork,
IProjectRepository projectRepository, IMajorRepository majorRepository,
IHostingEnvironment host, IExcelRepository excelRepository, ILecturerRepository lecturerRepository)
{
this.context = context;
this.mapper = mapper;
this.unitOfWork = unitOfWork;
this.projectRepository = projectRepository;
this.majorRepository = majorRepository;
this.host = host;
this.excelRepository = excelRepository;
this.lecturerRepository = lecturerRepository;
}
public DashboardService(ISchoolRepository schoolRepository, IDepartmentRepository departmentRepository, IProgrammeRepository programmeRepository,
ICourseRepository courseRepository, ILecturerRepository lecturerRepository, IStudentRepository studentRepository, ISessionSemesterRepository sessionSemesterRepository,
ILecturerCourseRepository lecturerCourseRepository, IRegisteredCourseRepository registeredCourseRepository)
{
_schoolRepository = schoolRepository;
_departmentRepository = departmentRepository;
_programmeRepository = programmeRepository;
_courseRepository = courseRepository;
_lecturerRepository = lecturerRepository;
_studentRepository = studentRepository;
_sessionSemesterRepository = sessionSemesterRepository;
_lecturerCourseRepository = lecturerCourseRepository;
_registeredCourseRepository = registeredCourseRepository;
}
public GroupController(IMapper mapper, IUnitOfWork unitOfWork,
IGroupRepository groupRepository, ILecturerRepository lecturerRepository,
IProjectRepository projectRepository, IMajorRepository majorRepository,
IQuarterRepository quarterRepository, IEnrollmentRepository enrollmentRepository)
{
this.mapper = mapper;
this.unitOfWork = unitOfWork;
this.groupRepository = groupRepository;
this.lecturerRepository = lecturerRepository;
this.projectRepository = projectRepository;
this.majorRepository = majorRepository;
this.quarterRepository = quarterRepository;
this.enrollmentRepository = enrollmentRepository;
}
public LecturerController(ApplicationDbContext context, IMapper mapper,
ILecturerRepository lecturerRepository, IUnitOfWork unitOfWork,
UserManager <ApplicationUser> userManager, IMajorRepository majorRepository,
IHostingEnvironment host, IExcelRepository excelRepository)
{
this.userManager = userManager;
this.context = context;
this.mapper = mapper;
this.lecturerRepository = lecturerRepository;
this.majorRepository = majorRepository;
this.unitOfWork = unitOfWork;
this.host = host;
this.excelRepository = excelRepository;
}
public AccountController(
UserManager <ApplicationUser> userManager,
SignInManager <ApplicationUser> signInManager,
IEmailSender emailSender,
ILogger <AccountController> logger,
IStudentRepository studentRepository, ILecturerRepository lecturerRepository)
{
_userManager = userManager;
_signInManager = signInManager;
_emailSender = emailSender;
_logger = logger;
_studentRepository = studentRepository;
_lecturerRepository = lecturerRepository;
}
public EnrollmentController(IConfiguration config, IMapper mapper, IUnitOfWork unitOfWork, IEnrollmentRepository enrollmentRepository,
IStudentRepository studentRepository, IGroupRepository groupRepository,
UserManager <ApplicationUser> userManager, IQuarterRepository quarterRepository,
ILecturerRepository lecturerRepository)
{
this.mapper = mapper;
this.unitOfWork = unitOfWork;
this.enrollmentRepository = enrollmentRepository;
this.studentRepository = studentRepository;
this.groupRepository = groupRepository;
this.userManager = userManager;
this.quarterRepository = quarterRepository;
this.lecturerRepository = lecturerRepository;
this.config = config;
}
public void FindLecturersById_ValidCall()
{
Mock <ILecturerRepository> mockGradeRepository = MockLecturerRepository;
mockGradeRepository.Setup(mr => mr.FindByID(It.IsAny <int>()))
.Returns((int s) => GetSampleLecturers().Where(x => x.Id == s).FirstOrDefault());
_mockLecturerRepository = mockGradeRepository.Object;
int checkingId = 1;
LecturerModel expected = _mockLecturerRepository.FindByID(checkingId);
var t = GetSampleLecturers().Where(x => x.Id == checkingId);
Assert.True(expected != null); // Test if null
Assert.That(expected.Le_Last_Name, Is.EqualTo(GetSampleLecturers().FirstOrDefault(x => x.Id == checkingId).Le_Last_Name));
}
public void UpdateLecturers_Successful()
{
Mock <ILecturerRepository> mockGradeRepository = MockLecturerRepository;
mockGradeRepository.Setup(mr => mr.UpdateLecturer(It.IsAny <LecturerModel>()))
.Returns((LecturerModel s) => s);
_mockLecturerRepository = mockGradeRepository.Object;
LecturerModel expected = new LecturerModel()
{
Id = 4,
Le_Last_Name = "dd",
Le_First_Name = "s",
Phone = "8 999 999-99-99",
Email = "*****@*****.**",
};
var actual = _mockLecturerRepository.UpdateLecturer(expected);
Assert.IsNotNull(expected); // Test if null
Assert.AreEqual(expected.Id, actual.Id); // Verify the expected Number pre-insert
}
public void AddLecturers_Successful()
{
Mock <ILecturerRepository> mockGradeRepository = MockLecturerRepository;
mockGradeRepository.Setup(mr => mr.AddLecturer(It.IsAny <LecturerModel>()))
.Returns(GetSampleLecturers().Max(u => u.Id) + 1);
_mockLecturerRepository = mockGradeRepository.Object;
LecturerModel expected = new LecturerModel()
{
Id = 3,
Le_Last_Name = "dd",
Le_First_Name = "s",
Phone = "8 999 999-99-99",
Email = "*****@*****.**",
};
int count = _mockLecturerRepository.AddLecturer(expected);
Assert.IsNotNull(expected); // Test if null
Assert.AreEqual(expected.Id + 1, count); // Verify the expected Number pre-insert
}
public LecturerManager(ILecturerRepository LectureRepository, ILecturerCourseRepository lectureCourseRepository)
{
_lectureRepository = LectureRepository;
_lectureCourseRepository = lectureCourseRepository;
}
public LecturerManager(ILecturerRepository lecturerRepository, ILecturerCourseRepository lecturerCourseRepository, ICourseRepository courseRepository)
{
_lecturerRepository = lecturerRepository;
_lecturerCourseRepository = lecturerCourseRepository;
_courseRepository = courseRepository;
}
public LecturersController()
{
lecturerRepo = new LecturerRepository();
}
public void FillDatabaseTestData()
{
_educationRepository.EnsureDeleted();
_educationRepository.EnsureCreated();
List <Student> students = new List <Student>()
{
new Student()
{
FullName = "Ivan Ivanov", EMail = "*****@*****.**", Phone = "123456"
},
new Student()
{
FullName = "Nikolai Ivanov", EMail = "*****@*****.**", Phone = "123456"
},
new Student()
{
FullName = "Serdei Ivanov", EMail = "*****@*****.**", Phone = "123456"
},
new Student()
{
FullName = "Petr Ivanov", EMail = "*****@*****.**", Phone = "123456"
}
};
IStudentRepository studentRepository = _educationRepository.GetStudentRepository();
students.ForEach(s => studentRepository.InsertStudent(s));
studentRepository.Save();
List <Lecturer> lecturers = new List <Lecturer>()
{
new Lecturer()
{
FullName = "Sergei Petrov"
}, new Lecturer()
{
FullName = "Nick Petrov"
}
};
ILecturerRepository lecturerRepository = _educationRepository.GetLecturerRepository();
lecturers.ForEach(l => lecturerRepository.InsertLecturer(l));
lecturerRepository.Save();
List <Lecture> lectures = new List <Lecture> {
new Lecture()
{
Title = "Jamping", Lecturer = lecturerRepository.GetLecturers().First()
},
new Lecture()
{
Title = "Riding", Lecturer = lecturerRepository.GetLecturers().First()
},
new Lecture()
{
Title = "Joging", Lecturer = lecturerRepository.GetLecturers().First()
},
new Lecture()
{
Title = "Climbing", Lecturer = lecturerRepository.GetLecturers().Last()
}
};
ILectureRepository lectureRepository = _educationRepository.GetLectureRepository();
lectures.ForEach(l => lectureRepository.InsertLecture(l));
lectureRepository.Save();
List <AttendingLecture> attendingLectures = new List <AttendingLecture> {
new AttendingLecture()
{
Atended = false, Lecture = lectureRepository.GetLectures().ToList()[0], Student = studentRepository.GetStudents().ToList()[0]
},
new AttendingLecture()
{
Atended = false, Lecture = lectureRepository.GetLectures().ToList()[1], Student = studentRepository.GetStudents().ToList()[0]
},
new AttendingLecture()
{
Atended = false, Lecture = lectureRepository.GetLectures().ToList()[2], Student = studentRepository.GetStudents().ToList()[0]
},
new AttendingLecture()
{
Atended = false, Lecture = lectureRepository.GetLectures().ToList()[3], Student = studentRepository.GetStudents().ToList()[0]
},
new AttendingLecture()
{
Atended = true, Lecture = lectureRepository.GetLectures().ToList()[0], Student = studentRepository.GetStudents().ToList()[1]
},
new AttendingLecture()
{
Atended = true, Lecture = lectureRepository.GetLectures().ToList()[1], Student = studentRepository.GetStudents().ToList()[1]
},
new AttendingLecture()
{
Atended = true, Lecture = lectureRepository.GetLectures().ToList()[2], Student = studentRepository.GetStudents().ToList()[1]
},
new AttendingLecture()
{
Atended = false, Lecture = lectureRepository.GetLectures().ToList()[3], Student = studentRepository.GetStudents().ToList()[1]
},
new AttendingLecture()
{
Atended = false, Lecture = lectureRepository.GetLectures().Last(), Student = studentRepository.GetStudents().Last()
}
};
IAttendingLectureRepository attendingLectureRepository = _educationRepository.GetAttendingLectureRepository();
attendingLectures.ForEach(a => attendingLectureRepository.InsertAttendingLecture(a));
attendingLectureRepository.Save();
attendingLectures = attendingLectureRepository.GetAttendingLectures().ToList();
List <HomeWork> homeWorks = new List <HomeWork> {
new HomeWork()
{
AttendingLecture = attendingLectures[0], CourseGrade = 0
},
new HomeWork()
{
AttendingLecture = attendingLectures[1], CourseGrade = 1
},
new HomeWork()
{
AttendingLecture = attendingLectures[2], CourseGrade = 2
},
new HomeWork()
{
AttendingLecture = attendingLectures[3], CourseGrade = 3
},
new HomeWork()
{
AttendingLecture = attendingLectures[4], CourseGrade = 4
},
new HomeWork()
{
AttendingLecture = attendingLectures[5], CourseGrade = 4
},
new HomeWork()
{
AttendingLecture = attendingLectures[6], CourseGrade = 4
},
new HomeWork()
{
AttendingLecture = attendingLectures[7], CourseGrade = 4
},
new HomeWork()
{
AttendingLecture = attendingLectures[8], CourseGrade = 1
},
};
IHomeWorkRepository homeWorkRepository = _educationRepository.GetHomeWorkRepository();
homeWorks.ForEach(h => homeWorkRepository.InsertHomeWork(h));
homeWorkRepository.Save();
}
public TokenService(ITokenRepository tokenRepository, IStudentRepository studentRepository, ILecturerRepository lecturerRepository)
{
_tokenRepository = tokenRepository;
_studentRepository = studentRepository;
_lecturerRepository = lecturerRepository;
}
public LecturerService(ILecturerRepository lecturerRepository)
{
_lecturerRepository = lecturerRepository;
}
public LecturerService(ILecturerRepository lecturerRepository, IMailService mailService, IDepartmentRepository departmentRepository)
{
_lecturerRepository = lecturerRepository;
_mailService = mailService;
_departmentRepository = departmentRepository;
}
public LecturerUpdateCommandHandler(IMediator mediator, ILecturerRepository repository)
{
_mediator = mediator;
_repository = repository;
}
public LecturerManager(ILecturerRepository lecturerRepository)
{
_lecturerRepository = lecturerRepository;
}
public HomeController(IDisciplineRepository DisciplineRepository, ILecturerRepository LecturerRepository, IHostingEnvironment AppEnvironment)
{
_StorageService = new LocalFileStorageService(AppEnvironment);
_DisciplineRepository = DisciplineRepository;
_LecturerRepository = LecturerRepository;
}
