public ActionResult DeleteTeacher(int sqno)
{
CourseTeacher model = db.CourseTeacher.Where(cc => cc.sqno == sqno).FirstOrDefault();
if (model == null)
{
var result = new
{
success = false,
errorMessage = "找不到資料",
};
return(Json(result));
}
else
{
if (model.courses != null && model.courses.Count > 0)
{
db.CourseTeacherRelation.RemoveRange(model.courses);
}
db.CourseTeacher.Remove(model);
db.SaveChanges();
var result = new { success = true };
return(Json(result));
}
}
public bool AssignCourseTeacher(CourseTeacher courseTeacher)
{
try
{
if (IsCourseTeacherPairExist(courseTeacher))
{
throw new Exception("This course already assigned to this teacher.");
}
else
{
if (IsCourseAssign(courseTeacher.CourseId))
{
throw new Exception("Course already assigned.");
}
else
{
CourseGetway courseGetway = new CourseGetway();
return(courseGetway.AssignCourseTeacher(courseTeacher));
}
}
}
catch (Exception)
{
throw;
}
}
public CourseTeacher GetCourseCourseTeacherById(int id, int cid, int tid)
{
CourseTeacher courseTeacher = new CourseTeacher();
DBPlayer db = new DBPlayer();
try
{
db.cmdText = "SELECT * FROM CourseTeacherDepartmentView WHERE Id = @Id AND CourseId = @CourseId AND TeacherId = @TeacherId";
db.command.Parameters.AddWithValue("@Id", id);
db.command.Parameters.AddWithValue("@CourseId", cid);
db.command.Parameters.AddWithValue("@TeacherId", tid);
db.Open();
SqlDataReader reader = db.command.ExecuteReader();
if (reader.HasRows)
{
while (reader.Read())
{
courseTeacher.Id = int.Parse(reader["Id"].ToString());
courseTeacher.CourseId = int.Parse(reader["CourseId"].ToString());
courseTeacher.CourseCode = reader["CourseCode"].ToString();
courseTeacher.CourseName = reader["CourseName"].ToString();
courseTeacher.CourseCredit = Convert.ToInt32(reader["CourseCredit"]);
courseTeacher.TeacherId = int.Parse(reader["TeacherId"].ToString());
courseTeacher.TeacherName = reader["TeacherName"].ToString();
courseTeacher.TeacherDesignation = reader["TeacherDesignation"].ToString();
courseTeacher.TeacherCreditToBeTaken = Convert.ToInt32(reader["TeacherCreditToBeTaken"]);
courseTeacher.TeacherRemainingCredit = Convert.ToInt32(reader["TeacherRemainingCredit"]);
courseTeacher.DepartmentId = int.Parse(reader["DepartmentId"].ToString());
courseTeacher.DepartmentName = reader["DepartmentName"].ToString();
courseTeacher.CourseAssignStatus = Convert.ToBoolean(reader["Status"].ToString());
if (courseTeacher.CourseAssignStatus)
{
courseTeacher.Status = "Assigned";
}
else
{
courseTeacher.Status = "Not Assigned";
}
break;
}
}
reader.Close();
}
catch (Exception)
{
throw;
}
finally
{
db.Close();
}
return(courseTeacher);
}
public ActionResult DeleteConfirmed(int id)
{
CourseTeacher courseteacher = db.CourseTeachers.Find(id);
db.CourseTeachers.Remove(courseteacher);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public ActionResult DeleteConfirmed(int cid, int tid)
{
CourseTeacher courseteacher = db.CourseTeacher.Where(c => c.CourseOccurrenceId == cid && c.TeacherId == tid).FirstOrDefault();
db.CourseTeacher.Remove(courseteacher);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public List <CourseTeacher> GetAllCourseCourseTeacher()
{
List <CourseTeacher> listOfCourseTeacher = new List <CourseTeacher>();
DBPlayer db = new DBPlayer();
try
{
db.cmdText = "SELECT * FROM CourseTeacherDepartmentView";
db.Open();
SqlDataReader reader = db.command.ExecuteReader();
if (reader.HasRows)
{
while (reader.Read())
{
CourseTeacher courseTeacher = new CourseTeacher();
courseTeacher.Id = int.Parse(reader["Id"].ToString());
courseTeacher.CourseId = int.Parse(reader["CourseId"].ToString());
courseTeacher.CourseCode = reader["CourseCode"].ToString();
courseTeacher.CourseName = reader["CourseName"].ToString();
courseTeacher.CourseCredit = Convert.ToInt32(reader["CourseCredit"]);
courseTeacher.TeacherId = int.Parse(reader["TeacherId"].ToString());
courseTeacher.TeacherName = reader["TeacherName"].ToString();
courseTeacher.TeacherDesignation = reader["TeacherDesignation"].ToString();
courseTeacher.TeacherCreditToBeTaken = Convert.ToInt32(reader["TeacherCreditToBeTaken"]);
courseTeacher.TeacherRemainingCredit = Convert.ToInt32(reader["TeacherRemainingCredit"]);
courseTeacher.DepartmentId = int.Parse(reader["DepartmentId"].ToString());
courseTeacher.DepartmentName = reader["DepartmentName"].ToString();
courseTeacher.CourseAssignStatus = Convert.ToBoolean(reader["Status"].ToString());
if (courseTeacher.CourseAssignStatus)
{
courseTeacher.Status = "Assigned";
}
else
{
courseTeacher.Status = "Not Assigned";
}
listOfCourseTeacher.Add(courseTeacher);
}
}
reader.Close();
}
catch (Exception)
{
throw;
}
finally
{
db.Close();
}
return(listOfCourseTeacher);
}
public ActionResult EditExistingHours(CourseTeacher courseteacher)
{
if (ModelState.IsValid)
{
db.Entry(courseteacher).State = EntityState.Modified;
db.SaveChanges();
}
return(RedirectToAction("Details/" + courseteacher.CourseOccurrenceId));
}
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));
}
public ActionResult Details(int cid = 0, int tid = 0)
{
CourseTeacher courseteacher = db.CourseTeacher.Where(c => c.CourseOccurrenceId == cid && c.TeacherId == tid).FirstOrDefault();
if (courseteacher == null)
{
return(HttpNotFound());
}
return(View(courseteacher));
}
//DELETE METHODS
public CourseTeacherResponseDTO DeleteTeacherOnCourse(string uuid, string teacherUUID)
{
//provera da li postoji profesor na kursu
CourseTeacher courseTeacher = FindTeacherOnCourseOrThrow(uuid, teacherUUID);
courseTeacher.activeTeacher = false;
courseTeacher = this._queryExecutor.Execute <CourseTeacher>(DatabaseConsts.USER_SCHEMA, this._sqlCommands.UPDATE_TEACHER_COURSE(courseTeacher), this._modelMapper.MapToCourseTeacher);
CourseTeacherResponseDTO response = this._autoMapper.Map <CourseTeacherResponseDTO>(courseTeacher);
return(connectWithUser(response));
}
public CourseTeacher FindTeacherOnCourseOrThrow(string courseUUID, string teacherUUID)
{
CourseTeacher teacher = this._queryExecutor.Execute <CourseTeacher>(DatabaseConsts.USER_SCHEMA, this._sqlCommands.GET_ONE_COURSE_TEACHER(courseUUID, teacherUUID), this._modelMapper.MapToCourseTeacher);
if (teacher == null)
{
throw new EntityNotFoundException($"Teacher with uuid: {teacherUUID} in course with uuid: {courseUUID} does not exist!", GeneralConsts.MICROSERVICE_NAME);
}
return(teacher);
}
public ActionResult Edit(CourseTeacher courseteacher)
{
if (ModelState.IsValid)
{
db.Entry(courseteacher).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.CourseOccurrenceId = new SelectList(db.CourseOccurrence, "CourseOccurrenceID", "Year", courseteacher.CourseOccurrenceId);
ViewBag.TeacherId = new SelectList(db.Teacher, "TeacherId", "TeacherName", courseteacher.TeacherId);
return(View(courseteacher));
}
public ActionResult Delete(int cid, int tid)
{
CourseTeacher courseteacher = db.CourseTeacher.Where(c => c.CourseOccurrenceId == cid && c.TeacherId == tid).FirstOrDefault();
if (courseteacher == null)
{
return(HttpNotFound());
}
db.CourseTeacher.Remove(courseteacher);
db.SaveChanges();
return(RedirectToAction("Details/" + courseteacher.CourseOccurrenceId));
}
public bool IsCourseTeacherPairExist(CourseTeacher courseTeacher)
{
try
{
CourseGetway courseGetway = new CourseGetway();
return(courseGetway.IsCourseTeacherPairExist(courseTeacher));
}
catch (Exception)
{
throw;
}
}
public ActionResult Edit(int cid = 0, int tid = 0)
{
CourseTeacher courseteacher = db.CourseTeacher.Where(c => c.CourseOccurrenceId == cid && c.TeacherId == tid).FirstOrDefault();
if (courseteacher == null)
{
return(HttpNotFound());
}
ViewBag.CourseOccurrenceId = new SelectList(db.CourseOccurrence, "CourseOccurrenceID", "Year", courseteacher.CourseOccurrenceId);
ViewBag.TeacherId = new SelectList(db.Teacher, "TeacherId", "TeacherName", courseteacher.TeacherId);
return(View(courseteacher));
}
public bool UpdateCourseTeacher(CourseTeacher courseTeacher)
{
try
{
CourseGetway courseGetway = new CourseGetway();
return(courseGetway.UpdateCourseTeacher(courseTeacher));
}
catch (Exception)
{
throw;
}
}
public ActionResult Edit([Bind(Include = "CourseTeacherId,DepartmentId,TeacherId,CourseId")] CourseTeacher courseteacher)
{
if (ModelState.IsValid)
{
db.Entry(courseteacher).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.CourseId = new SelectList(db.Courses, "CourseId", "Code", courseteacher.CourseId);
ViewBag.DepartmentId = new SelectList(db.Departments, "DepartmentId", "Name", courseteacher.DepartmentId);
ViewBag.TeacherId = new SelectList(db.Teachers, "TeacherId", "Name", courseteacher.TeacherId);
return(View(courseteacher));
}
public bool MakeCourseAssinged(CourseTeacher courseTeacher)
{
string query = "Update Course SET TeacherId = '" + courseTeacher.TeacherId + "' WHERE Id='" +
courseTeacher.CourseId + "'";
Connection.Open();
Command.CommandText = query;
int rowsEffected = Command.ExecuteNonQuery();
Connection.Close();
return(true);
}
public ActionResult EditTeacherPopup(int sqno)
{
CourseTeacher teacher = db.CourseTeacher.Where(t => t.sqno == sqno).FirstOrDefault();
if (teacher == null)
{
ViewBag.ErrorMessage = "找不到資料";
return(RedirectToAction("Index"));
}
else
{
return(View(teacher));
}
}
// GET: /CourseTeacher/Details/5
public ActionResult Details(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
CourseTeacher courseteacher = db.CourseTeachers.Find(id);
if (courseteacher == null)
{
return(HttpNotFound());
}
return(View(courseteacher));
}
public bool IsCourseAssign(int courseId)
{
bool flag = false;
DBPlayer db = new DBPlayer();
try
{
db.cmdText = "SELECT * FROM CourseTeacher WHERE CourseId = @CourseId AND Status = @Status";
db.command.Parameters.AddWithValue("@CourseId", courseId);
db.command.Parameters.AddWithValue("@Status", true);
db.Open();
SqlDataReader reader = db.command.ExecuteReader();
if (reader.HasRows)
{
while (reader.Read())
{
CourseTeacher courseTeacher = new CourseTeacher();
courseTeacher.CourseAssignStatus = bool.Parse(reader["CourseAssignStatus"].ToString());
if (courseTeacher.CourseAssignStatus)
{
flag = true;
}
else
{
flag = false;
}
}
}
else
{
flag = false;
}
reader.Close();
}
catch (Exception)
{
throw;
}
finally
{
db.Close();
}
return(flag);
}
public ActionResult Index(CourseTeacher courseTeacher, int CourseCredit)
{
List <Department> departments = departmentManager.GetAll();
ViewBag.Departments = departments;
List <Teacher> teachers = new List <Teacher>
{
new Teacher {
Id = ' ', Name = "--Select--"
}
};
ViewBag.Teachers = teachers;
List <Course> courses = new List <Course>
{
new Course {
Id = ' ', Code = "--Select--"
}
};
ViewBag.Courses = courses;
string message = "";
int teacherId = courseManager.GetTeacherIdByCourseId(courseTeacher.CourseId);
if (teacherId == 0)
{
bool isSave = courseTeacherManager.Save(courseTeacher);
bool addCreditToTeacher = teacherManager.AddCreditToTeacherById(courseTeacher.TeacherId, CourseCredit);
bool makeCourseAssinged = courseManager.MakeCourseAssinged(courseTeacher);
Teacher tempTeacher = new Teacher();
tempTeacher = teacherManager.GetTeacherById(courseTeacher.TeacherId);
message = " Save Successful. Course has been assigned to " + tempTeacher.Name;
}
else
{
Teacher tempTeacher = new Teacher();
tempTeacher = teacherManager.GetTeacherById(teacherId);
message = "Sorry, this Course is already Assinged to Mr." + tempTeacher.Name + " and you can contact with him by Email: " + tempTeacher.Email;
}
ViewBag.message = message;
ModelState.Clear();
return(View());
}
// GET: /CourseTeacher/Edit/5
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
CourseTeacher courseteacher = db.CourseTeachers.Find(id);
if (courseteacher == null)
{
return(HttpNotFound());
}
ViewBag.CourseId = new SelectList(db.Courses, "CourseId", "Code", courseteacher.CourseId);
ViewBag.DepartmentId = new SelectList(db.Departments, "DepartmentId", "Name", courseteacher.DepartmentId);
ViewBag.TeacherId = new SelectList(db.Teachers, "TeacherId", "Name", courseteacher.TeacherId);
return(View(courseteacher));
}
public bool AssignCourseTeacher(CourseTeacher courseTeacher)
{
bool flag = false;
DBPlayer db = new DBPlayer();
try
{
db.cmdText = "INSERT INTO CourseTeacher(DepartmentId, TeacherId, CourseId, Status) VALUES(@DepartmentId, @TeacherId, @CourseId, @Status)";
db.command.Parameters.AddWithValue("@DepartmentId", courseTeacher.DepartmentId);
db.command.Parameters.AddWithValue("@TeacherId", courseTeacher.TeacherId);
db.command.Parameters.AddWithValue("@CourseId", courseTeacher.CourseId);
db.command.Parameters.AddWithValue("@Status", true);
db.Open();
int rowsAffected = db.command.ExecuteNonQuery();
if (rowsAffected > 0)
{
if (UpdateTeacherRemainingCourse(courseTeacher.TeacherId, courseTeacher.CourseCredit))
{
flag = true;
}
else
{
flag = false;
}
}
else
{
flag = false;
}
}
catch (Exception)
{
throw;
}
finally
{
db.Close();
}
return(flag);
}
public ActionResult SaveCourseTeacher(CourseTeacher courseTeacher)
{
ActionResult rtn = Json(0, JsonRequestBehavior.AllowGet);
using (dbContext)
{
try
{
dbContext.CourseTeachers.Add(courseTeacher);
int rowAff = dbContext.SaveChanges();
rtn = Json(HttpStatusCode.OK, JsonRequestBehavior.AllowGet);
}
catch (Exception exception)
{
rtn = Json(exception.Message, JsonRequestBehavior.AllowGet);
}
return(rtn);
}
}
public void Insert(CourseInputInsert model, int teacherId)
{
var course = new Course();
course.Code = model.Code;
course.Name = model.Name;
course.Description = model.Description;
course.Level = model.Level;
course.BeginDate = model.BeginDate;
course.EndDate = model.EndDate;
course.RegisterDate = model.RegisterDate;
course.MaxPeople = model.MaxPeople;
_context.Course.Add(course);
_context.SaveChanges();
var courseTeacher = new CourseTeacher();
courseTeacher.CourseId = course.Id;
courseTeacher.TeacherId = teacherId;
_context.SaveChanges();
}
public void InsertCourse(CourseInputInsert model, int TeacherID)
{
var course = new Course();
course.Code = model.Code;
course.Description = model.Description;
course.Level = model.Level;
course.TimeStar = model.TimeStar;
course.TimeEnd = model.TimeEnd;
course.CreateDate = model.CreateDate;
course.MaxStudent = model.MaxStudent;
_context.Course.Add(course);
_context.SaveChanges();
//
CourseTeacher courseTeacher = new CourseTeacher();
courseTeacher.CourseId = course.Id;
courseTeacher.TeacherId = TeacherID;
_context.SaveChanges();
}
public ActionResult EditCourseResponsible(int courseID, int newcourseresponsibleId, int hours = 0)
{
CourseOccurrence courseoccurrence = db.CourseOccurrence.Find(courseID);
Teacher newTeacher = db.Teacher.Where(t => t.TeacherId == newcourseresponsibleId).FirstOrDefault();
// Create CourseTeacher instance
string currentYear = GetCurrentEducationalYear();
List <Teacher> teacherList = db.CourseTeacher.Where(c => c.CourseOccurrenceId == courseID && courseoccurrence.Year == currentYear).Select(t => t.Teacher).ToList();
// If the list of current teachers does NOT contain the course responsible, we add this teacher to the CourseTeacher table
if (!teacherList.Contains(newTeacher))
{
CourseTeacher courseTeacher = new CourseTeacher()
{
CourseOccurrence = courseoccurrence,
CourseOccurrenceId = courseoccurrence.CourseOccurrenceID,
Teacher = newTeacher,
TeacherId = newTeacher.TeacherId,
Hours = hours
};
db.CourseTeacher.Add(courseTeacher);
}
else
{
CourseTeacher courseTeacher = db.CourseTeacher.Where(c => c.TeacherId == newTeacher.TeacherId && c.CourseOccurrenceId == courseoccurrence.CourseOccurrenceID && c.CourseOccurrence.Year == currentYear).FirstOrDefault();
//Checking so that a current teacher doesn't get their hours reset if the field is not filled in
if (hours != 0)
{
courseTeacher.Hours = hours;
}
}
courseoccurrence.CourseResponsibleID = newTeacher.TeacherId;
db.Entry(courseoccurrence).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Details/" + courseoccurrence.CourseOccurrenceID));
}
public ActionResult CourseTeacher(string id = null, string cid = null, string tid = null)
{
try
{
session.IsAuthenticated();
GetDepartmentAndCourse();
if (id != null && cid != null && tid != null)
{
CourseTeacher courseTeacher = courseManager.GetCourseCourseTeacherById(Convert.ToInt32(Security.Decrypt(id)), Convert.ToInt32(Security.Decrypt(cid)), Convert.ToInt32(Security.Decrypt(tid)));
ViewBag.CourseTeacher = courseTeacher;
}
}
catch (Exception ex)
{
ViewBag.ExErrorMessage = ex.Message;
return(View());
}
return(View());
}
//PUT METHODS
public CourseTeacherResponseDTO UpdateTeacherOnCourse(UpdateCourseTeacherRequestDTO request)
{
//provera da li postoji profesor na kursu
CourseTeacher oldCourseTeacher = FindTeacherOnCourseOrThrow(request.courseUUID, request.teacherUUID);
CourseTeacher newCourseTeacher = this._autoMapper.Map <CourseTeacher>(request);
newCourseTeacher.course = new Course()
{
uuid = request.courseUUID
};
newCourseTeacher.teacher = new Teacher()
{
uuid = request.teacherUUID
};
newCourseTeacher = this._queryExecutor.Execute <CourseTeacher>(DatabaseConsts.USER_SCHEMA, this._sqlCommands.UPDATE_TEACHER_COURSE(newCourseTeacher), this._modelMapper.MapToCourseTeacher);
CourseTeacherResponseDTO response = this._autoMapper.Map <CourseTeacherResponseDTO>(newCourseTeacher);
return(connectWithUser(response));
}
