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" })); }