public IHttpActionResult CreateCourse(CourseCreator courseCreator)
{
coursesService = new CoursesService();
subjectsService = new SubjectsService();
teachersService = new TeachersService();
subjectToExposeService = new SubjectToExposeService();
courseToExposeService = new CourseToExposeService();
if (courseCreator == null)
{
return(BadRequest());
}
bool exists = false;
exists = coursesService.CheckIfCourseAlreadyExists(courseCreator.Title);
if (exists)
{
return(BadRequest());
}
List <CourseSubject> courseSubjects = coursesService.CreateCourse(courseCreator);
List <SubjectToExpose> subjectsToExpose = new List <SubjectToExpose>();
foreach (CourseSubject courseSubject in courseSubjects)
{
Subject subject = new Subject();
subject = subjectsService.Find(courseSubject.SubjectId);
if (subject == null)
{
return(BadRequest());
}
if (subject.ID == 0)
{
return(BadRequest());
}
Teacher teacher = new Teacher();
teacher = teachersService.GetTeacherNameByID(subject.TeacherId);
if (teacher == null)
{
return(BadRequest());
}
SubjectToExpose subjectToExpose = subjectToExposeService.TrimSubject(subject);
subjectsToExpose.Add(subjectToExpose);
}
CourseToExpose course = courseToExposeService
.TrimSubject(courseSubjects, courseCreator, subjectsToExpose);
return(Created(new Uri(Request.RequestUri + "/" + course.Id), course));
}
// DELETE /api/teachers/id
public IHttpActionResult DeleteTeacher(int id)
{
if (id == 0)
{
return(NotFound());
}
teachersService = new TeachersService();
bool teacherHasSubject = false;
teacherHasSubject = teachersService.CheckIfTeacherHasSubject(id);
if (!teacherHasSubject)
{
teachersService.DeleteTeacherById(id);
return(Ok(teachersService.GetListJustOfTeachers()));
}
bool teacherHasAReplacementAvailable = teachersService
.GetNonAllocatedTeachers().Count() > 0 ? true : false;
if (!teacherHasAReplacementAvailable)
{
return(BadRequest());
}
// deletes from teachers table and staff table
teachersService.DeleteTeacherAndSubstituteHim(id);
return(Ok(teachersService.GetListJustOfTeachers().Select(Mapper.Map <Teacher, TeacherDTO>)));
}
public IHttpActionResult CreateTeacher(TeacherDTO teacherDTO)
{
teachersService = new TeachersService();
Teacher teacher = Mapper.Map <TeacherDTO, Teacher>(teacherDTO);
// check if teacher already exists
bool teacherExists = teachersService.CheckIfTeacherAlreadyExists(teacher);
if (teacherExists)
{
return(BadRequest());
}
Teacher newTeacher = teachersService.CreateNewTeacher(teacher);
if (teacher == null)
{
return(BadRequest());
}
// add teacher to staff
teachersService.AddTeacherToStaff(teacher);
TeacherDTO theTeacherDTO = Mapper.Map <Teacher, TeacherDTO>(teacher);
return(Created(new Uri(Request.RequestUri + "/" + theTeacherDTO.Id), theTeacherDTO));
}
// GET /api/teachers/
public IHttpActionResult GetTeachers()
{
teachersService = new TeachersService();
if (teachersService.GetListJustOfTeachers().Count() == 0)
{
return(NotFound());
}
return(Ok(teachersService.GetListJustOfTeachers().Select(Mapper.Map <Teacher, TeacherDTO>)));
}
public void GetTeacherByUserId_ThrowsEntityNotFound_WhenUserDoesNotExist()
{
//arrange
var nonExistingUserId = "7299FFCC-435E-4A6D-99DF-57A4D6FBA747";
var teacherService = new TeachersService(teacherRepoMock.Object, courseRepoMock.Object);
//act
//assert
Assert.ThrowsException <EntityNotFoundException>(() => {
teacherService.GetTeacherByUserId(nonExistingUserId);
});
}
// GET non-allocated teachers
public IHttpActionResult GetNonAllocatedTeachers()
{
teachersService = new TeachersService();
List <Teacher> teachers = teachersService.GetNonAllocatedTeachers();
if (teachers.Count() == 0)
{
return(NotFound());
}
return(Ok(teachers.Select(Mapper.Map <Teacher, TeacherDTO>)));
}
public void GetTeacherByUserId_ThrowsException_WhenUserIdHasInvalidValue()
{
//arrange
//ITeacherRepository teacherRepository, ICourseRepository
var teacherService = new TeachersService(teacherRepoMock.Object, courseRepoMock.Object);
var badUserId = "jkajsdkasj dkj daksdj as";
//act
//assert
Assert.ThrowsException <Exception>(() => {
teacherService.GetTeacherByUserId(badUserId);
});
}
// POST /api/subjects
public IHttpActionResult CreateSubject(SubjectDTO subjectDTO)
{
if (subjectDTO == null)
{
return(BadRequest());
}
subjectsService = new SubjectsService();
teachersService = new TeachersService();
Subject subject = Mapper.Map <SubjectDTO, Subject>(subjectDTO);
// check if the subject already exists
Subject newSubject = subjectsService.CheckIfSubjectExistsByName(subject);
if (newSubject.ID != 0)
{
return(BadRequest());
}
// if the subject teacher already has a subject it's a bad request
bool teacherHasASubject = false;
teacherHasASubject = teachersService.CheckIfTeacherHasSubject(subject.TeacherId);
if (teacherHasASubject)
{
return(BadRequest());
}
// you can only create a subject if there's a teacher available to teach it
if (teachersService.GetNonAllocatedTeachers().Count() <= 0)
{
return(BadRequest());
}
;
// will give the subject to a non-allocated teacher
Subject theSubject = subjectsService.CreateSubject(subject);
if (theSubject == null)
{
return(NotFound());
}
SubjectDTO theSubjectDTO = Mapper.Map <Subject, SubjectDTO>(theSubject);
return(Created(new Uri(Request.RequestUri + "/" + theSubjectDTO.ID), theSubjectDTO));
}
public void GetTeacherByUserId_Returns_UserWhenExists()
{
Exception throwException = null;
var teacherService = new TeachersService(teacherRepoMock.Object, courseRepoMock.Object);
Teacher user = null;
//act
try
{
user = teacherService.GetTeacherByUserId(existingUserId.ToString());
}
catch (Exception e)
{
throwException = e;
}
//assert
Assert.IsNull(throwException, $"Exception was thrown");
Assert.IsNotNull(user);
}
// GET /api/teachers/id
public IHttpActionResult GetTeacher(int id)
{
teachersService = new TeachersService();
if (id == 0)
{
return(BadRequest());
}
Teacher teacher = teachersService.GetTeacherByID(id);
if (teacher == null)
{
return(NotFound());
}
TeacherDTO teacherDTO = Mapper.Map <Teacher, TeacherDTO>(teacher);
return(Ok(teacherDTO));
}
public IHttpActionResult UpdateTeacher(int id, TeacherDTO teacherDTO)
{
if (id == 0)
{
return(BadRequest());
}
Teacher teacher = Mapper.Map <TeacherDTO, Teacher>(teacherDTO);
if (teacher == null)
{
return(BadRequest());
}
teachersService = new TeachersService();
Teacher theTeacher = teachersService.UpdateTeacher(id, teacher);
TeacherDTO theTeacherDTO = Mapper.Map <Teacher, TeacherDTO>(theTeacher);
return(Ok(theTeacherDTO));
}
public void TeachersServiceTestsInitialize()
{
var teachers = new List <Teacher>()
{
new Teacher()
{
Id = 1,
Name = "Макаренко",
Category = TeacherCategory.Maniac,
Photo = new Image()
}
};
_mock = new Mock <IRepository <Teacher> >();
_mock.Setup(m => m.Add(It.IsAny <Teacher>())).Callback <Teacher>(teachers.Add);
_mock.Setup(m => m.Count()).Returns(teachers.Count);
_mock.Setup(m => m.Delete(It.IsAny <int>()))
.Callback <int>(id =>
{
var teacher = teachers.Find(item => item.Id == id);
teachers.Remove(teacher);
});
_mock.Setup(m => m.GetAll()).Returns(teachers.AsQueryable <Teacher>());
_mock.Setup(m => m.GetById(It.IsAny <int>()))
.Returns <int>(id => teachers.Find(item => item.Id == id));
_mock.Setup(m => m.SaveOrUpdate(It.IsAny <Teacher>()))
.Callback <Teacher>(teacher =>
{
var oldTeacher = teachers.Find(item => item.Id == teacher.Id);
if (oldTeacher != null)
{
teachers.Remove(oldTeacher);
}
teachers.Add(teacher);
});
_teachersService = new TeachersService(_mock.Object);
}
public TeachersGrpcServiceImpl()
{
TeachersService = new TeachersService();
}
protected override void ExecuteTest()
{
var service = new TeachersService(staffInformationRepository, staffEducationOrgInformationRepository, staffSectionCohortRepository, uniqueListIdProvider, staffAreaLinksFake);
actualModel = service.Get(TeachersRequest.Create(suppliedSchoolId1));
}
public TeacherController(UserManager <IdentityUser> userManager, TeachersService teachersService)
{
this.userManager = userManager;
this.teachersService = teachersService;
}
public CoursesController()
{
teachersService = new TeachersService();
coursesService = new CoursesService();
}
public TeachersController(IRepository <Teacher> repository, TeachersService service)
{
_repository = repository ?? throw new ArgumentNullException(nameof(repository));
_service = service ?? throw new ArgumentNullException(nameof(service));
}
public void Init()
{
this.teachersService = new TeachersService(
this.dbContext, new MockedTeachersRepository(this.dbContext));
}
private async void Button_OnClicked(object sender, EventArgs e)
{
bool resultPost = false;
LoadingText.IsVisible = true;
activityIndicator.IsVisible = true;
activityIndicator.IsRunning = true;
if (name.Text == null || email.Text == null || phone.Text == null)
{
await DisplayAlert("Errore", "Nessun campo può essere vuoto", "Ok");
}
else
{
if (PickerRole.SelectedIndex == 0)
{
StudentViewModel student = new StudentViewModel
{
FullName = name.Text,
Email = email.Text,
PhoneNumber = phone.Text,
CoursesId = new List <string>(),
Deleted = false,
GroupsId = new List <string>(),
};
resultPost = await new StudentsService().Post(student);
}
else
{
if (PickerRole.SelectedIndex == 1)
{
TeacherViewModel teacher = new TeacherViewModel
{
FullName = name.Text,
Email = email.Text,
PhoneNumber = phone.Text,
CoursesId = new List <string>(),
Deleted = false,
GroupsId = new List <string>(),
Subject = new List <string>(),
};
resultPost = new TeachersService().Post(teacher).Result;
}
}
if (resultPost)
{
await DisplayAlert("Result", "Utente aggiunto", "Ok");
email.Text = "";
name.Text = "";
phone.Text = "";
}
else
{
await DisplayAlert("Errore", "Errore Generico", "Ok");
}
}
activityIndicator.IsRunning = false;
activityIndicator.IsVisible = false;
LoadingText.IsVisible = false;
}
public override void SetUp()
{
base.SetUp();
_service = new TeachersService(TeachersRepository);
}
public TeacherUC()
{
InitializeComponent();
_teacher = new Teacher();
_teacherService = new TeachersService();
}
