예제 #1
0
        public async ValueTask <Teacher> SelectTeacherByIdAsync(Guid teacherId)
        {
            using var broker = new StorageBroker(this.configuration);
            broker.ChangeTracker.QueryTrackingBehavior = QueryTrackingBehavior.NoTracking;

            return(await broker.Teachers.FindAsync(teacherId));
        }
예제 #2
0
        public async ValueTask <ExamFee> SelectExamFeeByIdAsync(Guid id)
        {
            using var broker = new StorageBroker(this.configuration);
            broker.ChangeTracker.QueryTrackingBehavior = QueryTrackingBehavior.NoTracking;

            return(await broker.ExamFees.FindAsync(id));
        }
        public async ValueTask <StudentGuardian> SelectStudentGuardianByIdAsync(Guid studentId, Guid guardianId)
        {
            using var broker = new StorageBroker(this.configuration);
            broker.ChangeTracker.QueryTrackingBehavior = QueryTrackingBehavior.NoTracking;

            return(await broker.StudentGuardians.FindAsync(studentId, guardianId));
        }
예제 #4
0
        public async ValueTask <Attachment> SelectAttachmentByIdAsync(Guid attachmentId)
        {
            using var broker = new StorageBroker(this.configuration);
            broker.ChangeTracker.QueryTrackingBehavior = QueryTrackingBehavior.NoTracking;

            return(await Attachments.FindAsync(attachmentId));
        }
예제 #5
0
        public async ValueTask <Course> SelectCourseByIdAsync(Guid courseId)
        {
            using var broker = new StorageBroker(this.configuration);
            broker.ChangeTracker.QueryTrackingBehavior = QueryTrackingBehavior.NoTracking;

            return(await broker.Courses.FindAsync(courseId));
        }
        public async ValueTask <Classroom> SelectClassroomByIdAsync(Guid classroomId)
        {
            using var broker = new StorageBroker(this.configuration);
            broker.ChangeTracker.QueryTrackingBehavior = QueryTrackingBehavior.NoTracking;

            return(await broker.Classrooms.FindAsync(classroomId));
        }
        public async ValueTask <Registration> SelectRegistrationByIdAsync(Guid registrationId)
        {
            using var broker = new StorageBroker(this.configuration);
            this.ChangeTracker.QueryTrackingBehavior = QueryTrackingBehavior.NoTracking;

            return(await broker.Registrations.FindAsync(registrationId));
        }
예제 #8
0
        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);
        }
예제 #9
0
        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 <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 <StudentSemesterCourse> SelectStudentSemesterCourseByIdAsync(
            Guid studentId, Guid semesterCourseId)
        {
            using var broker = new StorageBroker(this.configuration);
            broker.ChangeTracker.QueryTrackingBehavior = QueryTrackingBehavior.NoTracking;

            return(await broker.StudentSemesterCourses.FindAsync(studentId, semesterCourseId));
        }
예제 #12
0
        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);
        }
예제 #13
0
        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);
        }
예제 #14
0
        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);
        }
예제 #15
0
        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);
        }
예제 #16
0
        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);
        }
예제 #17
0
        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);
        }
예제 #18
0
        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);
        }
예제 #19
0
        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);
        }
예제 #20
0
        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);
        }
예제 #21
0
        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);
        }
예제 #22
0
        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);
        }
예제 #23
0
        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 <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 <CalendarEntryAttachment> SelectCalendarEntryAttachmentByIdAsync(
            Guid calendarEntryId,
            Guid attachmentId)
        {
            using var broker = new StorageBroker(this.configuration);
            broker.ChangeTracker.QueryTrackingBehavior = QueryTrackingBehavior.NoTracking;

            return(await broker.CalendarEntriesAttachments.FindAsync(calendarEntryId, attachmentId));
        }
예제 #26
0
        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);
        }
예제 #27
0
        public async ValueTask <StudentExamFee> SelectStudentExamFeeByIdsAsync(
            Guid studentId,
            Guid examFeeId)
        {
            using var broker = new StorageBroker(this.configuration);
            this.ChangeTracker.QueryTrackingBehavior = QueryTrackingBehavior.NoTracking;

            return(await broker.StudentExamFees.FindAsync(studentId, examFeeId));
        }
        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);
        }
예제 #29
0
        public async ValueTask <Calendar> SelectCalendarByIdAsync(Guid calendarId)
        {
            using var broker = new StorageBroker(this.configuration);

            broker.ChangeTracker.QueryTrackingBehavior =
                QueryTrackingBehavior.NoTracking;

            return(await Calendars.FindAsync(calendarId));
        }
        public async ValueTask <GuardianContact> SelectGuardianContactByIdAsync(
            Guid guardianId,
            Guid contactId)
        {
            using var broker = new StorageBroker(this.configuration);
            broker.ChangeTracker.QueryTrackingBehavior = QueryTrackingBehavior.NoTracking;

            return(await broker.GuardianContacts.FindAsync(guardianId, contactId));
        }