public CourseTeacherResponseDTO CreateTeacherOnCourse(CreateCourseTeacherRequestDTO request)
{
//provera da li postoji kurs
CourseResponseDTO course = this._courseService.GetOneByUuid(request.courseUUID);
//provera da li postoji profesor
try
{
TeacherResponseDTO newTeacher = this._httpClientService.SendRequest <TeacherResponseDTO>(HttpMethod.Get, "http://localhost:40001/api/users/" + request.teacherUUID, new UserPrincipal(_httpContextAccessor.HttpContext).token).Result;
}
catch
{
throw new EntityNotFoundException($"Teacher with uuid: {request.teacherUUID} does not exist!", GeneralConsts.MICROSERVICE_NAME);
}
//provera da li vec postoji profesor na kursu
CourseTeacher existingCourseTeacher = FindTeacherOnCourse(request.courseUUID, request.teacherUUID);
if (existingCourseTeacher != null)
{
if (existingCourseTeacher.activeTeacher == false)
{
CourseTeacher updatedTeacher = this._autoMapper.Map <CourseTeacher>(request);
updatedTeacher.activeTeacher = true;
updatedTeacher.course = new Course()
{
uuid = request.courseUUID
};
updatedTeacher.teacher = new Teacher()
{
uuid = request.teacherUUID
};
updatedTeacher = this._queryExecutor.Execute <CourseTeacher>(DatabaseConsts.USER_SCHEMA, this._sqlCommands.UPDATE_TEACHER_COURSE(updatedTeacher), this._modelMapper.MapToCourseTeacher);
CourseTeacherResponseDTO updatedResponse = this._autoMapper.Map <CourseTeacherResponseDTO>(updatedTeacher);
return(connectWithUser(updatedResponse));
}
else
{
throw new EntityAlreadyExistsException("Teacher with uuid " + request.courseUUID + " already exists in course with uuid " + request.teacherUUID, GeneralConsts.MICROSERVICE_NAME);
}
}
CourseTeacher courseTeacher = this._autoMapper.Map <CourseTeacher>(request);
courseTeacher.course = new Course()
{
uuid = request.courseUUID
};
courseTeacher.teacher = new Teacher()
{
uuid = request.teacherUUID
};
courseTeacher.activeTeacher = true;
this._queryExecutor.Execute <CourseTeacher>(DatabaseConsts.USER_SCHEMA, this._sqlCommands.CREATE_TEACHER_COURSE(courseTeacher), this._modelMapper.MapToCourseTeacher);
CourseTeacherResponseDTO response = this._autoMapper.Map <CourseTeacherResponseDTO>(courseTeacher);
return(connectWithUser(response));
}
//DELETE METHODS
public CourseResponseDTO Delete(string uuid)
{
//provera da li postoji kurs
Course course = this.FindOneByUuidOrThrow(uuid);
course = this._queryExecutor.Execute <Course>(DatabaseConsts.USER_SCHEMA, this._sqlCommands.DELETE_COURSE(uuid), this._modelMapper.MapToCourse);
CourseResponseDTO response = this._autoMapper.Map <CourseResponseDTO>(course);
response.subject = this._httpClientService.SendRequest <SubjectResponseDTO>(HttpMethod.Get, "http://localhost:40006/api/subjects/" + response.subject.uuid, new UserPrincipal(_httpContextAccessor.HttpContext).token).Result;
return(response);
}
//PUT METHODS
public CourseResponseDTO Update(UpdateCourseRequestDTO requestDTO)
{
//provera da li postoji kurs
Course oldCourse = this.FindOneByUuidOrThrow(requestDTO.uuid);
SubjectResponseDTO subject;
try
{
subject = this._httpClientService.SendRequest <SubjectResponseDTO>(HttpMethod.Get, "http://localhost:40006/api/subjects/" + requestDTO.subjectUUID, new UserPrincipal(_httpContextAccessor.HttpContext).token).Result;
}
catch
{
throw new EntityNotFoundException("Subject with uuid " + requestDTO.subjectUUID + " doesn't exist", GeneralConsts.MICROSERVICE_NAME);
}
//update u tabeli kurs
Course course = new Course()
{
uuid = requestDTO.uuid,
name = requestDTO.name,
description = requestDTO.description,
active = requestDTO.active,
maxStudents = requestDTO.maxStudents,
minStudents = requestDTO.minStudents,
creationDate = requestDTO.creationDate,
subject = new Subject()
{
uuid = requestDTO.subjectUUID
}
};
this._queryExecutor.Execute <Course>(DatabaseConsts.USER_SCHEMA, this._sqlCommands.UPDATE_COURSE(course), this._modelMapper.MapToCourseAfterInsert);
//insert u tabeli arhiva
CreateCourseArchiveRequestDTO archive = new CreateCourseArchiveRequestDTO()
{
courseUUID = course.uuid,
name = course.name,
description = course.description,
active = course.active,
maxStudents = course.maxStudents,
minStudents = course.minStudents,
creationDate = course.creationDate,
subjectUUID = subject.uuid,
changeDate = DateTime.Now,
moderatorUUID = new UserPrincipal(_httpContextAccessor.HttpContext).uuid
};
_ = this._courseArchiveService.CreateCourseArchive(archive);
CourseResponseDTO response = this._autoMapper.Map <CourseResponseDTO>(course);
response.subject = subject;
return(response);
}
public CourseResponseDTO GetOneByUuid(string uuid)
{
//provera da li postoji taj kurs
CourseResponseDTO course = this._autoMapper.Map <CourseResponseDTO>(this.FindOneByUuidOrThrow(uuid));
try {
course.subject = this._httpClientService.SendRequest <SubjectResponseDTO>(HttpMethod.Get, "http://localhost:40006/api/subjects/" + course.subject.uuid, new UserPrincipal(_httpContextAccessor.HttpContext).token).Result;
} catch {
throw new EntityNotFoundException($"Subject with uuid: {course.subject.uuid} does not exist!", GeneralConsts.MICROSERVICE_NAME);
}
return(course);
}
//POST METHODS
public CourseStudentResponseDTO CreateStudentOnCourse(CreateCourseStudentRequestDTO request)
{
//provera da li postoji kurs
CourseResponseDTO course = this._courseService.GetOneByUuid(request.courseUUID);
String courseDep = course.subject.department.uuid;
StudentResponseDTO student;
//provera da li postoji student
try {
student = this._httpClientService.SendRequest <StudentResponseDTO>(HttpMethod.Get, "http://localhost:40001/api/users/students/" + request.studentUUID, new UserPrincipal(_httpContextAccessor.HttpContext).token).Result;
}
catch
{
throw new EntityNotFoundException("Student with uuid " + request.studentUUID + " doesn't exist", GeneralConsts.MICROSERVICE_NAME);
}
String studentDep = student.departmentUUID;
//provera da li su predmet i student na istom departmanu
if (studentDep != courseDep)
{
throw new EntityNotFoundException("Student with uuid " + request.studentUUID + " and course with uuid: " + request.courseUUID + " are not on the same department", GeneralConsts.MICROSERVICE_NAME);
}
//ako student vrsi zahtev, moze da upise samo sebe
UserPrincipal up = new UserPrincipal(_httpContextAccessor.HttpContext);
if (up.role == RoleConsts.ROLE_STUDENT_ONLY)
{
checkStudent(student.uuid, up.uuid);
}
//provera da li vec postoji student na tom kursu
CourseStudent existingCourseStudent = this.FindStudentOnCourse(request.courseUUID, request.studentUUID);
if (existingCourseStudent != null)
{
if (existingCourseStudent.activeStudent == false)
{
CourseStudent updatedStudent = this._autoMapper.Map <CourseStudent>(request);
updatedStudent.activeStudent = true;
updatedStudent.course = new Course()
{
uuid = request.courseUUID
};
updatedStudent.student = new Student()
{
uuid = request.studentUUID
};
updatedStudent = this._queryExecutor.Execute <CourseStudent>(DatabaseConsts.USER_SCHEMA, this._sqlCommands.UPDATE_STUDENT_ON_COURSE(updatedStudent), this._modelMapper.MapToCourseStudent);
CourseStudentResponseDTO updatedResponse = this._autoMapper.Map <CourseStudentResponseDTO>(updatedStudent);
return(connectWithUser(updatedResponse));
}
else
{
throw new EntityAlreadyExistsException("Student with uuid " + request.studentUUID + " already exists in course with uuid " + request.courseUUID, GeneralConsts.MICROSERVICE_NAME);
}
}
CourseStudent newCourseStudent = this._autoMapper.Map <CourseStudent>(request);
newCourseStudent.activeStudent = true;
newCourseStudent.course = new Course()
{
uuid = request.courseUUID
};
newCourseStudent.student = new Student()
{
uuid = request.studentUUID
};
newCourseStudent = this._queryExecutor.Execute <CourseStudent>(DatabaseConsts.USER_SCHEMA, this._sqlCommands.CREATE_STUDENT_ON_COURSE(newCourseStudent), this._modelMapper.MapToCourseStudent);
CourseStudentResponseDTO response = this._autoMapper.Map <CourseStudentResponseDTO>(newCourseStudent);
response.course = this._courseService.GetOneByUuid(response.course.uuid);
return(connectWithUser(response));
}
