public async Task <IActionResult> PutMark([FromRoute] int id, [FromBody] MarkDTO markDto)
{
var mark = await _context.Marks.FirstOrDefaultAsync(m => m.ID == id);
mark.IsAbsent = markDto.IsAbsent;
mark.IsCredited = markDto.IsCredited;
mark.Value = markDto.Value;
mark.StudentId = markDto.Student.Id;
mark.LessonId = markDto.Lesson.ID;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!MarkExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> PutTopic([FromRoute] int id, [FromBody] TopicDTO topicDto)
{
if (id != topicDto.ID)
{
return(BadRequest());
}
var topic = await _context.Topics.FirstOrDefaultAsync(s => s.ID == topicDto.ID);
topic.Name = topicDto.Name;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!TopicExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(Ok());
}
public async Task <IActionResult> PutStudent([FromRoute] int id, [FromBody] StudentDTO studentDto)
{
if (id != studentDto.Id)
{
return(BadRequest());
}
var user = await _context.Users.FirstOrDefaultAsync(u => u.Id == studentDto.User.Id);
user.FirstName = studentDto.User.FirstName;
user.LastName = studentDto.User.LastName;
user.UserName = studentDto.User.Username;
var student = await _context.Students.Include(d => d.SubGroup).FirstOrDefaultAsync(d => d.ID == studentDto.Id);
student.SubGroupId = studentDto.SubGroup.ID;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!StudentExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(Ok());
}
public async Task <IActionResult> PutSubGroup([FromRoute] int id, [FromBody] SubGroupDTO subGroupDto)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != subGroupDto.ID)
{
return(BadRequest());
}
var subGroup = await _context.SubGroups.FirstOrDefaultAsync(s => s.ID == subGroupDto.ID);
subGroup.Name = subGroupDto.Name;
subGroup.GroupId = subGroupDto.Group.ID;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!SubGroupExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <Course> AddAsync(Course course)
{
_context.Courses.Add(course);
await _context.SaveChangesAsync();
return(course);
}
public async Task <IActionResult> PutCollegeGroup([FromRoute] int id, [FromBody] CollegeGroupDTO collegeGroupDto)
{
if (id != collegeGroupDto.ID)
{
return(BadRequest());
}
var group = await _context.CollegeGroups.Include(g => g.Specialty).ThenInclude(s => s.College)
.FirstOrDefaultAsync(g => g.ID == collegeGroupDto.ID);
group.Number = collegeGroupDto.Number;
group.SpecialtyId = collegeGroupDto.Specialty.ID;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!CollegeGroupExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(Ok());
}
public async Task <Faculty> AddAsync(Faculty faculty)
{
_context.Faculties.Add(faculty);
await _context.SaveChangesAsync();
return(faculty);
}
public async Task <IActionResult> PutSpecialty([FromRoute] int id, [FromBody] SpecialtyDTO specialtyDto)
{
if (id != specialtyDto.ID)
{
return(BadRequest());
}
var specialty = await _context.Specialties.Include(s => s.College).FirstOrDefaultAsync(s => s.ID == specialtyDto.ID);
specialty.CollegeId = specialtyDto.College.ID;
specialty.Name = specialtyDto.Name;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!SpecialtyExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(Ok());
}
public async Task <IActionResult> PutUser([FromRoute] string id, [FromBody] User user)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != user.Id)
{
return(BadRequest());
}
_context.Entry(user).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!UserExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> PutCollege([FromRoute] int id, [FromBody] CollegeDTO collegeDto)
{
if (id != collegeDto.ID)
{
return(BadRequest());
}
var college = await _context.Colleges.FirstOrDefaultAsync(c => c.ID == collegeDto.ID);
college.Name = collegeDto.Name;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!CollegeExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(Ok());
}
public async Task <IActionResult> CreateTsi([FromBody] TsiDto tsiDto)
{
var tsi = _context.TeacherSubjectInfos.Add(new TeacherSubjectInfo()
{
SemesterId = tsiDto.Semester.ID,
SubjectId = tsiDto.Subject.ID,
TeacherId = tsiDto.Teacher.ID,
}).Entity;
var semester = await _context.Semesters.FirstOrDefaultAsync(s => s.ID == tsiDto.Semester.ID);
var date = semester.StartDate;
while (date <= semester.EndDate)
{
_context.Lessons.Add(new Lesson()
{
Date = date, TeacherSubjectInfoId = tsi.ID
});
date = date.AddDays(1);
}
await _context.SaveChangesAsync();
return(Ok());
}
public async Task <Student> AddAsync(Student student)
{
_context.Students.Add(student);
await _context.SaveChangesAsync();
return(student);
}
public async Task <Department> AddAsync(Department department)
{
_context.Departments.Add(department);
await _context.SaveChangesAsync();
return(department);
}
public async Task<IActionResult> PutTeacher([FromRoute] int id, [FromBody] TeacherDTO teacherDto)
{
if (id != teacherDto.ID)
{
return BadRequest();
}
var user = await _context.Users.FirstOrDefaultAsync(u => u.Id == teacherDto.User.Id);
user.FirstName = teacherDto.User.FirstName;
user.LastName = teacherDto.User.LastName;
user.UserName = teacherDto.User.Username;
var teacher = await _context.Teachers.Include(t => t.Group).FirstOrDefaultAsync(d => d.ID == teacherDto.ID);
teacher.CollegeId = teacherDto.College.ID;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!TeacherExists(id))
{
return NotFound();
}
else
{
throw;
}
}
return Ok();
}
public async Task <IHttpActionResult> PutMajor(int id, Major major)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != major.ID)
{
return(BadRequest());
}
db.Entry(major).State = EntityState.Modified;
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!MajorExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
public async Task <IActionResult> PutSubject([FromRoute] int id, [FromBody] SubjectDTO subjectDto)
{
if (id != subjectDto.ID)
{
return(BadRequest());
}
var subject = await _context.Subjects.FirstOrDefaultAsync(s => s.ID == subjectDto.ID);
subject.Name = subjectDto.Name;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!SubjectExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(Ok());
}
public async Task <IActionResult> PutSemester([FromRoute] int id, [FromBody] SemesterDTO semesterDto)
{
if (id != semesterDto.ID)
{
return(BadRequest());
}
var semester = await _context.Semesters.FirstOrDefaultAsync(c => c.ID == semesterDto.ID);
semester.Number = semesterDto.Number;
semester.EndDate = DateTime.ParseExact(semesterDto.EndDate, "yyyy-MM-dd", null);
semester.StartDate = DateTime.ParseExact(semesterDto.StartDate, "yyyy-MM-dd", null);
semester.SubGroupId = semesterDto.SubGroup.ID;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!SemesterExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(Ok());
}
public async Task <IActionResult> PutLesson([FromRoute] int id, [FromBody] LessonDTO lessonDto)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var lesson = await _context.Lessons.FirstOrDefaultAsync(l => l.ID == id);
lesson.TopicId = lessonDto.Topic.ID;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!LessonExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> PutDirector([FromRoute] int id, [FromBody] DirectorDTO directorDto)
{
if (id != directorDto.ID)
{
return(BadRequest());
}
var user = await _context.Users.FirstOrDefaultAsync(u => u.Id == directorDto.User.Id);
user.FirstName = directorDto.User.FirstName;
user.LastName = directorDto.User.LastName;
user.UserName = directorDto.User.Username;
var director = await _context.Directors.Include(d => d.College).FirstOrDefaultAsync(d => d.ID == directorDto.ID);
director.CollegeId = directorDto.College.ID;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!DirectorExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(Ok());
}
public async Task <Professor> AddProfessor(Professor professor)
{
_logger.Log(LogLevel.Debug, "Request Received for ProfessorDAL::AddProfessor");
_collegeDbContext.Professors.Add(professor);
await _collegeDbContext.SaveChangesAsync();
_logger.Log(LogLevel.Debug, "Returning the results from ProfessorDAL::AddProfessor");
return(professor);
}
public async Task <ActionResult> Create([Bind(Include = "Id,StudentId,Value")] Grade grade)
{
if (ModelState.IsValid)
{
db.Grades.Add(grade);
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
return(View(grade));
}
public async Task <ActionResult> Create([Bind(Include = "Title")] CourseViewModel courseViewModel)
{
var course = new Course(courseViewModel.Title);
if (ModelState.IsValid)
{
db.Courses.Add(course);
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
return(View(course));
}
public async Task <IActionResult> OnPostAsync()
{
if (ModelState.IsValid)
{
// ModelState is Valid
try
{
// Save new Assessment
_db.Assessments.Add(Assessment);
await _db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException e)
{
ErrorMessage = "CreateAssessment: db update concurrency error: ";
if (e.Message != null)
{
ErrorMessage += e.Message;
}
if (e.InnerException.Message != null)
{
ErrorMessage += e.InnerException.Message;
}
return(RedirectToPage("/MyErrorPage", new { area = "ErrorPages", id = Assessment.AssessmentID }));
}
catch (DbUpdateException e)
{
ErrorMessage = "CreateAssessment: db update error: ";
if (e.Message != null)
{
ErrorMessage += e.Message;
}
if (e.InnerException.Message != null)
{
ErrorMessage += e.InnerException.Message;
}
return(RedirectToPage("/MyErrorPage", new { area = "ErrorPages", id = Assessment.AssessmentID }));
}
catch (Exception e)
{
ErrorMessage = "CreateAssessment: general error: ";
if (e.Message != null)
{
ErrorMessage += e.Message;
}
if (e.InnerException.Message != null)
{
ErrorMessage += e.InnerException.Message;
}
return(RedirectToPage("/MyErrorPage", new { area = "ErrorPages", id = Assessment.AssessmentID }));
}
return(RedirectToPage("/ShowAssessmentDetails", new { area = "AssessmentPages", id = Assessment.AssessmentID }));
}
else
{
// ModelState is InValid
return(Page());
}
}
public async Task <IActionResult> OnPostAsync()
{
if (!ModelState.IsValid)
{
return(Page());
}
try
{
_db.Attach(Assessment).State = EntityState.Modified;
await _db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException e)
{
ErrorMessage = "UpdateAssessmentDetails: db update concurrency error: ";
if (e.Message != null)
{
ErrorMessage += e.Message;
}
if (e.InnerException.Message != null)
{
ErrorMessage += e.InnerException.Message;
}
return(RedirectToPage("/MyErrorPage", new { area = "ErrorPages", id = Assessment.AssessmentID }));
}
catch (DbUpdateException e)
{
ErrorMessage = "UpdateAssessmentDetails: db update error: ";
if (e.Message != null)
{
ErrorMessage += e.Message;
}
if (e.InnerException.Message != null)
{
ErrorMessage += e.InnerException.Message;
}
return(RedirectToPage("/MyErrorPage", new { area = "ErrorPages", id = Assessment.AssessmentID }));
}
catch (Exception e)
{
ErrorMessage = "UpdateAssessmentDetails: general error: ";
if (e.Message != null)
{
ErrorMessage += e.Message;
}
if (e.InnerException.Message != null)
{
ErrorMessage += e.InnerException.Message;
}
return(RedirectToPage("/MyErrorPage", new { area = "ErrorPages", id = Assessment.AssessmentID }));
}
return(RedirectToPage("/ShowAssessmentDetails", new { area = "AssessmentPages", id = Assessment.AssessmentID }));
}
public async Task<ActionResult> Create([Bind(Include = "Title,CourseId")] SubjectViewModel subjectViewModel)
{
var subject = new Subject(subjectViewModel.CourseId, subjectViewModel.Title);
try
{
if (ModelState.IsValid)
{
db.Subjects.Add(subject);
await db.SaveChangesAsync();
return RedirectToAction("Index");
}
}
catch (DataException /* dex */)
{
//Log the error (uncomment dex variable name and add a line here to write a log.
ModelState.AddModelError("", "Unable to save changes. Try again, and if the problem persists see your system administrator.");
}
PopulateCoursesDropDownList(subject.CourseId);
return View(subject);
}
public async Task <Address> AddAddress(Address address)
{
_logger.Log(LogLevel.Debug, "Request Received for AddressDAL::AddAddress");
_collegeDbContext.AddressBook.Add(address);
await _collegeDbContext.SaveChangesAsync();
_logger.Log(LogLevel.Debug, "Returning the results from AddressDAL::AddAddress");
return(address);
}
public async Task <ActionResult> Create([Bind(Include = "SubjectId,Salary,Name,Birthday")] TeacherViewModel teacherViewModel)
{
var teacher = new Teacher(teacherViewModel.Name, teacherViewModel.Birthday, teacherViewModel.Salary, teacherViewModel.SubjectId);
try
{
if (ModelState.IsValid)
{
db.Teachers.Add(teacher);
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
}
catch (DataException /* dex */)
{
//Log the error (uncomment dex variable name and add a line here to write a log.
ModelState.AddModelError("", "Unable to save changes. Try again, and if the problem persists see your system administrator.");
}
PopulateSubjectsDropDownList(teacher.SubjectId);
return(View(teacher));
}
public async Task <IActionResult> PostMessage([FromBody] MessageDTO messageDto)
{
var userReciever = await _context.Users.FirstOrDefaultAsync(u => u.Id == messageDto.UserReciever.Id);
Reciever reciever = await _context.Recievers.FirstOrDefaultAsync(r => r.UserRecieverId == userReciever.Id);
if (reciever == null)
{
_context.Recievers.Add(new Reciever()
{
UserRecieverId = userReciever.Id
});
await _context.SaveChangesAsync();
reciever = await _context.Recievers.FirstOrDefaultAsync(r => r.UserRecieverId == userReciever.Id);
}
_context.Messages.Add(new Message()
{
Text = messageDto.Text,
Topic = messageDto.Topic,
Date = DateTime.Parse(messageDto.Date),
Reciever = reciever,
UserSenderId = messageDto.UserSender.Id
});
try
{
await _context.SaveChangesAsync();
return(Ok());
}
catch (Exception e)
{
return(StatusCode(500, "Sending Error"));
}
}
public override async Task <NewProfessorResponse> AddProfessor(NewProfessorRequest request, ServerCallContext context)
{
var newProfessor = new NewProfessorResponse
{
Message = "success"
};
var professor = new Professor
{
Name = request.Name,
Doj = request.Doj.ToDateTime(),
Teaches = request.Teaches,
Salary = Convert.ToDecimal(request.Salary),
IsPhd = request.IsPhd
};
var results = _collegeDbContext.Professors.Add(professor);
await _collegeDbContext.SaveChangesAsync();
newProfessor.ProfessorId = results.Entity.ProfessorId.ToString();
return(newProfessor);
}
public async Task <IActionResult> OnPostAsync()
{
try
{
var mod = await _db.Modules.FindAsync(Module.ModuleID);
if (mod != null)
{
_db.Modules.Remove(mod);
await _db.SaveChangesAsync();
}
}
catch (DbUpdateConcurrencyException e)
{
ErrorMessage = "DeleteModule: db update concurrency error: ";
if (e.Message != null)
{
ErrorMessage += e.Message;
}
if (e.InnerException.Message != null)
{
ErrorMessage += e.InnerException.Message;
}
return(RedirectToPage("/MyErrorPage", new { area = "ErrorPages", id = Module.ModuleID }));
}
catch (DbUpdateException e)
{
ErrorMessage = "DeleteModule: db update error: ";
if (e.Message != null)
{
ErrorMessage += e.Message;
}
if (e.InnerException.Message != null)
{
ErrorMessage += e.InnerException.Message;
}
return(RedirectToPage("/MyErrorPage", new { area = "ErrorPages", id = Module.ModuleID }));
}
catch (InvalidOperationException e)
{
ErrorMessage = "DeleteModule: invalid operation error: ";
if (e.Message != null)
{
ErrorMessage += e.Message;
}
if (e.InnerException.Message != null)
{
ErrorMessage += e.InnerException.Message;
}
return(RedirectToPage("/MyErrorPage", new { area = "ErrorPages", id = Module.ModuleID }));
}
catch (Exception e)
{
ErrorMessage = "DeleteModule: general error: ";
if (e.Message != null)
{
ErrorMessage += e.Message;
}
if (e.InnerException.Message != null)
{
ErrorMessage += e.InnerException.Message;
}
return(RedirectToPage("/MyErrorPage", new { area = "ErrorPages", id = Module.ModuleID }));
}
return(RedirectToPage("/ListProgrammeModules", new { area = "ProgrammePages" }));
}
