public async ValueTask <Guardian> DeleteGuardianAsync(Guardian guardian)
{
using var broker = new StorageBroker(this.configuration);
EntityEntry <Guardian> courseEntityEntry = broker.Guardians.Remove(entity: guardian);
await broker.SaveChangesAsync();
return(courseEntityEntry.Entity);
}
public async ValueTask <Attachment> DeleteAttachmentAsync(Attachment attachment)
{
using var broker = new StorageBroker(this.configuration);
EntityEntry <Attachment> attachmentEntityEntry = broker.Attachments.Remove(entity: attachment);
await broker.SaveChangesAsync();
return(attachmentEntityEntry.Entity);
}
public async ValueTask <Exam> UpdateExamAsync(Exam exam)
{
using var broker = new StorageBroker(this.configuration);
EntityEntry <Exam> examEntityEntry = broker.Exams.Update(entity: exam);
await broker.SaveChangesAsync();
return(examEntityEntry.Entity);
}
public async ValueTask <Attendance> DeleteAttendanceAsync(Attendance attendance)
{
using var broker = new StorageBroker(this.configuration);
EntityEntry <Attendance> attendanceEntityEntry = broker.Attendances.Remove(entity: attendance);
await broker.SaveChangesAsync();
return(attendanceEntityEntry.Entity);
}
public async ValueTask <Classroom> DeleteClassroomAsync(Classroom classroom)
{
using var broker = new StorageBroker(this.configuration);
EntityEntry <Classroom> classroomEntityEntry = broker.Classrooms.Remove(entity: classroom);
await broker.SaveChangesAsync();
return(classroomEntityEntry.Entity);
}
public async ValueTask <Student> DeleteStudentAsync(Student student)
{
using var broker = new StorageBroker(this.configuration);
EntityEntry <Student> studentEntityEntry = broker.Students.Remove(entity: student);
await broker.SaveChangesAsync();
return(studentEntityEntry.Entity);
}
public async ValueTask <SemesterCourse> DeleteSemesterCourseAsync(SemesterCourse semesterCourse)
{
using var broker = new StorageBroker(this.configuration);
EntityEntry <SemesterCourse> semesterCourseEntityEntry = broker.SemesterCourses.Remove(entity: semesterCourse);
await broker.SaveChangesAsync();
return(semesterCourseEntityEntry.Entity);
}
public async ValueTask <Assignment> UpdateAssignmentAsync(Assignment assignment)
{
using var broker = new StorageBroker(this.configuration);
EntityEntry <Assignment> assignmentEntityEntry = broker.Assignments.Update(entity: assignment);
await broker.SaveChangesAsync();
return(assignmentEntityEntry.Entity);
}
public async ValueTask <Contact> DeleteContactAsync(Contact contact)
{
using var broker = new StorageBroker(this.configuration);
EntityEntry <Contact> contactEntityEntry = broker.Contacts.Remove(entity: contact);
await broker.SaveChangesAsync();
return(contactEntityEntry.Entity);
}
public async ValueTask <StudentExamFee> UpdateStudentExamFeeAsync(StudentExamFee studentExamFee)
{
using var broker = new StorageBroker(this.configuration);
EntityEntry <StudentExamFee> studentExamFeeEntityEntry = broker.StudentExamFees.Update(studentExamFee);
await broker.SaveChangesAsync();
return(studentExamFeeEntityEntry.Entity);
}
public async ValueTask <Fee> DeleteFeeAsync(Fee fee)
{
using var broker = new StorageBroker(this.configuration);
EntityEntry <Fee> feeEntityEntry = broker.Fees.Remove(entity: fee);
await broker.SaveChangesAsync();
return(feeEntityEntry.Entity);
}
public async ValueTask <Registration> UpdateRegistrationAsync(Registration Registration)
{
using var broker = new StorageBroker(this.configuration);
EntityEntry <Registration> RegistrationEntityEntry = broker.Registrations.Update(Registration);
await broker.SaveChangesAsync();
return(RegistrationEntityEntry.Entity);
}
public async ValueTask <Registration> DeleteRegistrationAsync(Registration registration)
{
using var broker = new StorageBroker(this.configuration);
EntityEntry <Registration> registrationEntityEntry = broker.Registrations.Remove(entity: registration);
await broker.SaveChangesAsync();
return(registrationEntityEntry.Entity);
}
public async ValueTask <Teacher> DeleteTeacherAsync(Teacher teacher)
{
using var broker = new StorageBroker(this.configuration);
EntityEntry <Teacher> teacherEntityEntry = broker.Teachers.Remove(entity: teacher);
await broker.SaveChangesAsync();
return(teacherEntityEntry.Entity);
}
public async ValueTask <Course> DeleteCourseAsync(Course course)
{
using var broker = new StorageBroker(this.configuration);
EntityEntry <Course> courseEntityEntry = broker.Courses.Remove(entity: course);
await broker.SaveChangesAsync();
return(courseEntityEntry.Entity);
}
public async ValueTask <ExamFee> DeleteExamFeeAsync(ExamFee examFee)
{
using var broker = new StorageBroker(this.configuration);
EntityEntry <ExamFee> examFeeEntityEntry = broker.ExamFees.Remove(entity: examFee);
await broker.SaveChangesAsync();
return(examFeeEntityEntry.Entity);
}
public async ValueTask <Guardian> InsertGuardianAsync(Guardian guardian)
{
using var broker = new StorageBroker(this.configuration);
EntityEntry <Guardian> guardianEntityEntry = await broker.Guardians.AddAsync(entity : guardian);
await broker.SaveChangesAsync();
return(guardianEntityEntry.Entity);
}
public async ValueTask <Fee> InsertFeeAsync(Fee fee)
{
using var broker = new StorageBroker(this.configuration);
EntityEntry <Fee> feeEntityEntry = await broker.Fees.AddAsync(fee);
await broker.SaveChangesAsync();
return(feeEntityEntry.Entity);
}
public async ValueTask <ExamFee> InsertExamFeeAsync(ExamFee examFee)
{
using var broker = new StorageBroker(this.configuration);
EntityEntry <ExamFee> examFeeEntityEntry = await broker.ExamFees.AddAsync(examFee);
await broker.SaveChangesAsync();
return(examFeeEntityEntry.Entity);
}
public async ValueTask <StudentGuardian> UpdateStudentGuardianAsync(StudentGuardian studentGuardian)
{
using var broker = new StorageBroker(this.configuration);
EntityEntry <StudentGuardian> studentGuardianEntityEntry =
broker.StudentGuardians.Update(entity: studentGuardian);
await broker.SaveChangesAsync();
return(studentGuardianEntityEntry.Entity);
}
public async ValueTask <CalendarEntry> UpdateCalendarEntryAsync(CalendarEntry calendarEntry)
{
using var broker = new StorageBroker(this.configuration);
EntityEntry <CalendarEntry> calendarEntryEntityEntry =
broker.CalendarEntries.Update(entity: calendarEntry);
await broker.SaveChangesAsync();
return(calendarEntryEntityEntry.Entity);
}
public async ValueTask <Calendar> DeleteCalendarAsync(Calendar calendar)
{
using var broker = new StorageBroker(this.configuration);
EntityEntry <Calendar> calendarEntityEntry =
broker.Calendars.Remove(entity: calendar);
await broker.SaveChangesAsync();
return(calendarEntityEntry.Entity);
}
public async ValueTask <StudentExam> InsertStudentExamAsync(StudentExam studentExam)
{
using var broker = new StorageBroker(this.configuration);
EntityEntry <StudentExam> studentExamEntityEntry =
await broker.StudentExams.AddAsync(entity : studentExam);
await broker.SaveChangesAsync();
return(studentExamEntityEntry.Entity);
}
public async ValueTask <ExamAttachment> DeleteExamAttachmentAsync(
ExamAttachment examAttachment)
{
using var broker = new StorageBroker(this.configuration);
EntityEntry <ExamAttachment> examAttachmentEntityEntry =
broker.ExamAttachments.Remove(entity: examAttachment);
await broker.SaveChangesAsync();
return(examAttachmentEntityEntry.Entity);
}
public async ValueTask <GuardianAttachment> UpdateGuardianAttachmentAsync(
GuardianAttachment guardianAttachment)
{
using var broker = new StorageBroker(this.configuration);
EntityEntry <GuardianAttachment> guardianAttachmentEntityEntry =
broker.GuardianAttachments.Update(entity: guardianAttachment);
await broker.SaveChangesAsync();
return(guardianAttachmentEntityEntry.Entity);
}
public async ValueTask <CourseAttachment> UpdateCourseAttachmentAsync(
CourseAttachment courseAttachment)
{
using var broker = new StorageBroker(this.configuration);
EntityEntry <CourseAttachment> courseAttachmentEntityEntry =
broker.CourseAttachments.Update(entity: courseAttachment);
await broker.SaveChangesAsync();
return(courseAttachmentEntityEntry.Entity);
}
public async ValueTask <StudentSemesterCourse> InsertStudentSemesterCourseAsync(
StudentSemesterCourse studentSemesterCourse)
{
using var broker = new StorageBroker(this.configuration);
EntityEntry <StudentSemesterCourse> studentSemesterCourseEntityEntry =
await broker.StudentSemesterCourses.AddAsync(entity : studentSemesterCourse);
await broker.SaveChangesAsync();
return(studentSemesterCourseEntityEntry.Entity);
}
public async ValueTask <GuardianContact> DeleteGuardianContactAsync(
GuardianContact guardianContact)
{
using var broker = new StorageBroker(this.configuration);
EntityEntry <GuardianContact> guardianContactEntityEntry =
broker.GuardianContacts.Remove(entity: guardianContact);
await broker.SaveChangesAsync();
return(guardianContactEntityEntry.Entity);
}
public async ValueTask <TeacherContact> UpdateTeacherContactAsync(
TeacherContact teacherContact)
{
using var broker = new StorageBroker(this.configuration);
EntityEntry <TeacherContact> teacherContactEntityEntry =
broker.TeacherContacts.Update(entity: teacherContact);
await broker.SaveChangesAsync();
return(teacherContactEntityEntry.Entity);
}
public async ValueTask <UserContact> DeleteUserContactAsync(
UserContact userContact)
{
using var broker = new StorageBroker(this.configuration);
EntityEntry <UserContact> userContactEntityEntry =
broker.UserContacts.Remove(entity: userContact);
await broker.SaveChangesAsync();
return(userContactEntityEntry.Entity);
}