public static PersonalPronoun GetPersonalPronounOrNull(this ILectureRepository _lectureRepository, Guid id)
{
var personalPronoun = _lectureRepository.GetPersonalPronoun(id);
IsExist(personalPronoun, id);
return(personalPronoun);
}
public static Sentence GetSentenceOrNull(this ILectureRepository _lectureRepository, Guid id)
{
var sentence = _lectureRepository.GetSentence(id);
IsExist(sentence, id);
return(sentence);
}
public static Adverb GetAdverbOrNull(this ILectureRepository _lectureRepository, Guid id)
{
var adverb = _lectureRepository.GetAdverb(id);
IsExist(adverb, id);
return(adverb);
}
public static Noun GetNounOrNull(this ILectureRepository _lectureRepository, Guid id)
{
var noun = _lectureRepository.GetNoun(id);
IsExist(noun, id);
return(noun);
}
public ProgressService(IInstructor instructor, ILectureRepository lectureRepository,
IProgressRepository progressRepository)
{
_instructor = instructor;
_progressRepository = progressRepository;
_lectureRepository = lectureRepository;
}
public static Adjective GetAdjectiveOrNull(this ILectureRepository _lectureRepository, Guid id)
{
var adjective = _lectureRepository.GetAdjectie(id);
IsExist(adjective, id);
return(adjective);
}
public LecturesController(ILectureRepository lectureRepository, ITeacherRepository teacherRepository, IEnrollmentRepository enrollmentRepository, IStudentRepository studentRepository)
{
_lectureRepository = lectureRepository;
_teacherRepository = teacherRepository;
_enrollmentRepository = enrollmentRepository;
_studentRepository = studentRepository;
}
public static Verb GetVerbeOrNull(this ILectureRepository _lectureRepository, Guid id)
{
var verb = _lectureRepository.GetVerb(id);
IsExist(verb, id);
return(verb);
}
public EnrollmentsController()
{
var context = new ApplicationDbContext();
_enrollmentRepository = new EnrollmentRepository(context);
_lectureRepository = new LectureRepository(context);
_studentRepository = new StudentRepository(context);
}
public SubmissionService(ILearningObjectRepository learningObjectRepository,
ISubmissionRepository submissionRepository, ILearnerRepository learnerRepository,
ILectureRepository lectureRepository)
{
_learningObjectRepository = learningObjectRepository;
_submissionRepository = submissionRepository;
_learnerRepository = learnerRepository;
_lectureRepository = lectureRepository;
}
public LectureController(ILectureRepository LectureRepository,
ITPClassRepository tPClassReposiroty,
IHostingEnvironment hostingEnvironment, IConfiguration config)
{
_LectureRepository = LectureRepository;
_tPClassReposiroty = tPClassReposiroty;
_hostingEnvironment = hostingEnvironment;
_config = config;
}
public LectureService(
IUserLectureRepository userLectureRepository,
ILectureRepository lectureRepository,
IUserRepository userRepository)
{
_userLectureRepository = userLectureRepository;
_lectureRepository = lectureRepository;
_userRepository = userRepository;
}
public AttendenceService(
IAttendenceRepository attendenceRepository,
ILectureRepository lectureRepository,
IAttendenceImageRepository attendenceImageRepository)
{
_attendenceRepository = attendenceRepository;
_lectureRepository = lectureRepository;
_attendenceImageRepository = attendenceImageRepository;
}
public static Lecture GetLectureOrFail(this ILectureRepository _lectureRepository, string name)
{
var lecture = _lectureRepository.Get(name);
if (lecture != null)
{
throw new Exception($"Wyklad o podanej nazwie: {name} istnieje");
}
return(lecture);
}
public static Lecture GetLectureOrNull(this ILectureRepository _lectureRepository, Guid id)
{
var lecture = _lectureRepository.GetFullLecture(id);
if (lecture == null)
{
throw new Exception($"Wyklad o podanym id: {id} nie istnieje");
}
return(lecture);
}
public static WordsDictionary GetWordsDictionaryOrNull(this ILectureRepository _lectureRepository, Guid id)
{
var lecture = _lectureRepository.GetOnlyDictionary(id);
if (lecture == null)
{
throw new Exception($"Słownik dla podanego wykladu o podanym id: {id} nie istnieje");
}
return(lecture);
}
public LectureService(ILectureRepository lectureRepository,
IAdminOfConferenceRepository adminOfConferenceRepository,
ISectionRepository sectionRepository,
IRoleInLectureRepository roleInLectureRepository,
IMapper mapper)
{
_mapper = mapper;
_lectureRepository = lectureRepository;
_adminOfConferenceRepository = adminOfConferenceRepository;
_sectionRepository = sectionRepository;
_roleInLectureRepository = roleInLectureRepository;
}
public ContentServices(
ILectureRepository lectureRepository,
IContentRepository contentRepository,
IMediator mediator,
IHttpContextAccessor httpContextAccessor,
IUserRepository userRepository,
UserManager <ApplicationUser> userManager
) : base(mediator, httpContextAccessor, userRepository, userManager)
{
_lectureRepository = lectureRepository;
_contentRepository = contentRepository;
}
public TestController(ITeacherTestRepository TeacherTestRepository,
//IClassRepository ClassRepository,
//ISectionRepository SectionRepository,
//ISubjectRepository SubjectRepository,
ILectureRepository LectureRepository,
IHostingEnvironment hostingEnvironment)
{
_TeacherTestRepository = TeacherTestRepository;
//_ClassRepository = ClassRepository;
//_SectionRepository = SectionRepository;
// _SubjectRepository = SubjectRepository;
_LectureRepository = LectureRepository;
_hostingEnvironment = hostingEnvironment;
}
public VideoServices(
IOptions <VimeoConfig> vimeoConfig,
ILectureRepository lectureRepository,
IVideoRepository videoRepository,
IMediator mediator,
IHttpContextAccessor httpContextAccessor,
IUserRepository userRepository,
UserManager <ApplicationUser> userManager
) : base(mediator, httpContextAccessor, userRepository, userManager)
{
_vimeoConfig = vimeoConfig.Value;
_lectureRepository = lectureRepository;
_videoRepository = videoRepository;
}
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 LectureService(ILectureRepository lectureRepository, IMapper mapper)
{
_lectureRepository = lectureRepository;
_mapper = mapper;
}
public LecturesController(ILectureRepository lectureRepo)
{
this.lectureRepo = lectureRepo;
}
public LectureService(ILectureRepository lectureRepository, IUnitOfWork unitOfWork)
{
_lectureRepository = lectureRepository;
_unitOfWork = unitOfWork;
}
public LecturesService(IEducationRepository educationRepository, ILogger <LecturesService> logger, IMapper mapper)
{
_lectureRepository = educationRepository.GetLectureRepository();
_logger = logger;
_mapper = mapper;
}
public EnrollmentsController(IEnrollmentRepository enrollmentRepository, IStudentRepository studentRepository, ILectureRepository lectureRepository)
{
_enrollmentRepository = enrollmentRepository;
_studentRepository = studentRepository;
_lectureRepository = lectureRepository;
}
public AnnouncementController(IAnnouncementReporitory AnnouncementRepository, ILectureRepository LectureRepository)
{
_AnnouncementRepository = AnnouncementRepository;
_LectureRepository = LectureRepository;
}
public LectureService(ILectureRepository lectureRepository)
{
_lectureRepository = lectureRepository;
}
public LectureService(ILectureRepository repo)
{
_repo = repo;
}
public LectureService(ILectureRepository repository, ITeacherRepository teacherRepository, IStudentRepository studentRepository)
{
_repository = repository;
_teacherRepository = teacherRepository;
_studentRepository = studentRepository;
}
