public async Task <SieveResult <CurriculumInfo> > GetSomeWithInfoAsync(SieveModel model) { if (model == null) { return(null); } var curriculaQuery = _context.Set <Entities.Curriculum>() .Include(cur => cur.EducationLevel) .Include(cur => cur.FormOfEducation) .Include(cur => cur.Department) .Include(cur => cur.Specialty) .Include(cur => cur.StructuralUnit) .AsNoTracking(); curriculaQuery = _sieveProcessor.Apply(model, curriculaQuery, applyPagination: false); var result = new SieveResult <Dtos.CurriculumInfo>(); result.TotalCount = await curriculaQuery.CountAsync(); var someCurricula = _sieveProcessor.Apply(model, curriculaQuery, applyFiltering: false, applySorting: false); result.Result = someCurricula.Select(cur => new Dtos.CurriculumInfo { DepartmentId = cur.DepartmentId, EducationLevelId = cur.EducationLevelId, FormOfEducationId = cur.FormOfEducationId, Id = cur.Id, UpdatedAt = cur.UpdatedAt, CreatedAt = cur.CreatedAt, DateOfApproval = cur.DateOfApproval, EducationProgramId = cur.EducationProgramId, ListOfApprovals = cur.ListOfApprovals, OrderOfApprovals = cur.OrderOfApprovals, ProtocolOfAcademicCouncilOfUnit = cur.ProtocolOfAcademicCouncilOfUnit, ProtocolOfAcademicCouncilOfUniversity = cur.ProtocolOfAcademicCouncilOfUniversity, ScheduleOfEducationProcess = cur.ScheduleOfEducationProcess, SpecialtyGuarantor = cur.SpecialtyGuarantor, SpecialtyId = cur.SpecialtyId, StructuralUnitId = cur.StructuralUnitId, YearOfAdmission = cur.YearOfAdmission, ShortName = cur.Specialty.GroupsCode + $" ({ cur.EducationLevel.Name }, {cur.FormOfEducation.Name}) " + cur.Specialty.Code + (cur.DateOfApproval.HasValue ? ' ' + cur.DateOfApproval.Value.ToString("yyyy.MM.dd") : ""), DepartmentName = cur.Department.FullName, FormOfEducation = cur.FormOfEducation.Name, EducationLevel = cur.EducationLevel.Name, SpecialtyName = cur.Specialty.Name, StructuralUnitName = cur.StructuralUnit.FullName }); return(result); }
public async Task <SieveResult <Dtos.Student> > GetSomeAsync(SieveModel model) { if (model == null) { return(null); } var studentsQuery = _context.Set <Entities.Student>() .Include(en => en.UserInfo) .AsNoTracking(); studentsQuery = _sieveProcessor.Apply(model, studentsQuery, applyPagination: false); var result = new SieveResult <Dtos.Student>(); result.TotalCount = await studentsQuery.CountAsync(); var someStudents = _sieveProcessor.Apply(model, studentsQuery, applyFiltering: false, applySorting: false); result.Result = someStudents.Select(s => new Dtos.Student { CreatedAt = s.CreatedAt, Id = s.Id, UpdatedAt = s.UpdatedAt, StudentTicketNumber = s.StudentTicketNumber, Sex = s.Sex, PrivilegeId = s.PrivilegeId, NumberOfRecordBook = s.NumberOfRecordBook, MilitaryRegistration = s.MilitaryRegistration, ForeignLanguage = s.ForeignLanguage, Financing = s.Financing, FormOfEducationId = s.FormOfEducationId, EntryDate = s.EntryDate, AcademicGroupId = s.AcademicGroupId, AcceleratedFormOfEducation = s.AcceleratedFormOfEducation, AddressOfResidence = s.AddressOfResidence, Chummery = s.Chummery, EducationLevelId = s.EducationLevelId, EducationProgramId = s.EducationProgramId, EndDate = s.EndDate, DateOfBirth = s.UserInfo.DateOfBirth, Email = s.UserInfo.Email, FirstName = s.UserInfo.FirstName, FirstNameEng = s.UserInfo.FirstNameEng, LastName = s.UserInfo.LastName, LastNameEng = s.UserInfo.LastNameEng, Patronymic = s.UserInfo.Patronymic, PhoneNumber = s.UserInfo.PhoneNumber }); return(result); }
public async Task <SieveResult <AcademicDisciplineInfo> > GetSomeWithInfoAsync(SieveModel model) { if (model == null) { return(null); } var disciplinesQuery = _context.Set <Entities.AcademicDiscipline>() .Include(ad => ad.Department) .Include(ad => ad.Specialty) .Include(ad => ad.Assistant) .ThenInclude(ass => ass.UserInfo) .Include(ad => ad.Lecturer) .ThenInclude(lec => lec.UserInfo) .AsNoTracking(); disciplinesQuery = _sieveProcessor.Apply(model, disciplinesQuery, applyPagination: false); var result = new SieveResult <Dtos.AcademicDisciplineInfo>(); result.TotalCount = await disciplinesQuery.CountAsync(); var someDisciplines = _sieveProcessor.Apply(model, disciplinesQuery, applyFiltering: false, applySorting: false); result.Result = someDisciplines.Select(discipline => new Dtos.AcademicDisciplineInfo { AssistantId = discipline.AssistantId, Attestation = discipline.Attestation, CreatedAt = discipline.CreatedAt, CurriculumId = discipline.CurriculumId, DepartmentId = discipline.DepartmentId, FullName = discipline.FullName, Id = discipline.Id, LecturerId = discipline.LecturerId, Semester = discipline.Semester, NumberOfCredits = discipline.NumberOfCredits, ShortName = discipline.ShortName, SpecialtyId = discipline.SpecialtyId, TypeOfIndividualWork = discipline.TypeOfIndividualWork, UpdatedAt = discipline.UpdatedAt, DepartmentName = discipline.Department.FullName, SpecialtyName = discipline.Specialty.Name, AssistantName = discipline.Assistant.UserInfo.LastName + ' ' + discipline.Assistant.UserInfo.FirstName + ' ' + discipline.Assistant.UserInfo.Patronymic, LecturerName = discipline.Lecturer.UserInfo.LastName + ' ' + discipline.Lecturer.UserInfo.FirstName + ' ' + discipline.Lecturer.UserInfo.Patronymic }); return(result); }
public async Task <SieveResult <AcademicGroupInfo> > GetSomeWithInfoAsync(SieveModel model) { if (model == null) { return(null); } var groupsQuery = _context.Set <Entities.AcademicGroup>() .Include(grp => grp.Department) .Include(grp => grp.EducationLevel) .Include(grp => grp.FormOfEducation) .Include(grp => grp.Specialty) .Include(grp => grp.StructuralUnit) .AsNoTracking(); groupsQuery = _sieveProcessor.Apply(model, groupsQuery, applyPagination: false); var result = new SieveResult <Dtos.AcademicGroupInfo>(); result.TotalCount = await groupsQuery.CountAsync(); var someGroups = _sieveProcessor.Apply(model, groupsQuery, applyFiltering: false, applySorting: false); result.Result = someGroups.Select(group => new Dtos.AcademicGroupInfo { Captain = group.Captain, CreatedAt = group.CreatedAt, UIN = group.UIN, SpecialtyId = group.SpecialtyId, StructuralUnitId = group.StructuralUnitId, Number = group.Number, Grade = group.Grade, Code = group.Code, Curator = group.Curator, DepartmentId = group.DepartmentId, EducationLevelId = group.EducationLevelId, FormOfEducationId = group.FormOfEducationId, Id = group.Id, UpdatedAt = group.UpdatedAt, DepartmentName = group.Department.FullName, EducationLevel = group.EducationLevel.Name, FormOfEducation = group.FormOfEducation.Name, SpecialtyName = group.Specialty.Name, StructuralUnitName = group.StructuralUnit.FullName }); return(result); }
public async Task <SieveResult <RatingForDisciplineInfo> > GetSomeWithInfoAsync(SieveModel model) { if (model == null) { return(null); } var ratingForDisciplinesQuery = _context.Set <Entities.RatingForDiscipline>() .Include(rfd => rfd.AcademicDiscipline) .Include(rfd => rfd.AcademicGroup) .Include(rfd => rfd.ExamsGradesSpreadsheet) .Include(rfd => rfd.Student) .ThenInclude(st => st.UserInfo) .Include(rfd => rfd.Teacher) .ThenInclude(t => t.UserInfo) .AsNoTracking(); ratingForDisciplinesQuery = _sieveProcessor.Apply(model, ratingForDisciplinesQuery, applyPagination: false); var result = new SieveResult <Dtos.RatingForDisciplineInfo>(); result.TotalCount = await ratingForDisciplinesQuery.CountAsync(); var someRatingForDisciplines = _sieveProcessor.Apply(model, ratingForDisciplinesQuery, applyFiltering: false, applySorting: false); result.Result = someRatingForDisciplines.Select(rfd => new Dtos.RatingForDisciplineInfo { Id = rfd.Id, CreatedAt = rfd.CreatedAt, UpdatedAt = rfd.UpdatedAt, TeacherId = rfd.TeacherId, StudentId = rfd.StudentId, Score = rfd.Score, ExamsGradesSpreadsheetId = rfd.ExamsGradesSpreadsheetId, Date = rfd.Date, AcademicGroupId = rfd.AcademicGroupId, AcademicDisciplineId = rfd.AcademicDisciplineId, AcademicDisciplineName = rfd.AcademicDiscipline.FullName, AcademicGroupCode = rfd.AcademicGroup.Code, ExamsGradesSpreadsheetNumber = rfd.ExamsGradesSpreadsheet.SpreadsheetNumber, StudentName = rfd.Student.UserInfo.LastName + ' ' + rfd.Student.UserInfo.FirstName + ' ' + rfd.Student.UserInfo.Patronymic, TeacherName = rfd.Teacher.UserInfo.LastName + ' ' + rfd.Teacher.UserInfo.FirstName + ' ' + rfd.Teacher.UserInfo.Patronymic, }); return(result); }
public async Task <SieveResult <TeacherInfo> > GetSomeWithInfoAsync(SieveModel model) { if (model == null) { return(null); } var teachersQuery = _context.Set <Entities.Teacher>() .Include(en => en.UserInfo) .Include(en => en.Department) .AsNoTracking(); teachersQuery = _sieveProcessor.Apply(model, teachersQuery, applyPagination: false); var result = new SieveResult <Dtos.TeacherInfo>(); result.TotalCount = await teachersQuery.CountAsync(); var someTeachers = await _sieveProcessor.Apply(model, teachersQuery, applyFiltering : false, applySorting : false).ToListAsync(); result.Result = someTeachers.Select(teacher => new Dtos.TeacherInfo { CreatedAt = teacher.CreatedAt, Id = teacher.Id, UpdatedAt = teacher.UpdatedAt, TypeOfEmployment = teacher.TypeOfEmployment, ScientificDegree = teacher.ScientificDegree, Position = teacher.Position, DepartmentId = teacher.DepartmentId, AcademicRank = teacher.AcademicRank, DateOfBirth = teacher.UserInfo.DateOfBirth, Email = teacher.UserInfo.Email, FirstName = teacher.UserInfo.FirstName, FirstNameEng = teacher.UserInfo.FirstNameEng, LastName = teacher.UserInfo.LastName, LastNameEng = teacher.UserInfo.LastNameEng, Patronymic = teacher.UserInfo.Patronymic, PhoneNumber = teacher.UserInfo.PhoneNumber, DepartmentName = teacher.Department.FullName }); return(result); }
public async Task <SieveResult <ExamsGradesSpreadsheetInfo> > GetSomeWithInfoAsync(SieveModel model) { if (model == null) { return(null); } var examsGradesSpreadsheetsQuery = _context.Set <Entities.ExamsGradesSpreadsheet>().AsNoTracking(); examsGradesSpreadsheetsQuery = _sieveProcessor.Apply(model, examsGradesSpreadsheetsQuery, applyPagination: false); var result = new SieveResult <Dtos.ExamsGradesSpreadsheetInfo>(); result.TotalCount = await examsGradesSpreadsheetsQuery.CountAsync(); var someExamsGradesSpreadsheets = _sieveProcessor.Apply(model, examsGradesSpreadsheetsQuery, applyFiltering: false, applySorting: false); result.Result = someExamsGradesSpreadsheets.Select(egs => new Dtos.ExamsGradesSpreadsheetInfo { CreatedAt = egs.CreatedAt, StructuralUnitId = egs.StructuralUnitId, Id = egs.Id, UpdatedAt = egs.UpdatedAt, SpreadsheetNumber = egs.SpreadsheetNumber, SpecialtyId = egs.SpecialtyId, SemesterNumber = egs.SemesterNumber, FormOfEducationId = egs.FormOfEducationId, ExamsSpreadsheetType = egs.ExamsSpreadsheetType, ExamsSpreadsheetAttestationType = egs.ExamsSpreadsheetAttestationType, ExamDate = egs.ExamDate, EducationProgramId = egs.EducationProgramId, AcademicGroupId = egs.AcademicGroupId, AcademicDisciplineId = egs.AcademicDisciplineId, DisciplineName = egs.AcademicDiscipline.FullName, GroupCode = egs.AcademicGroup.Code, NameOfFormOfEducation = egs.FormOfEducation.Name, SpecialtyName = egs.Specialty.Name, StructuralUnitName = egs.StructuralUnit.FullName }); return(result); }
public async Task <SieveResult <EducationProgramInfo> > GetSomeWithInfoAsync(SieveModel model) { if (model == null) { return(null); } var educationProgramsQuery = _context.Set <Entities.EducationProgram>() .Include(ep => ep.Specialty) .Include(ep => ep.EducationLevel) .AsNoTracking(); educationProgramsQuery = _sieveProcessor.Apply(model, educationProgramsQuery, applyPagination: false); var result = new SieveResult <Dtos.EducationProgramInfo>(); result.TotalCount = await educationProgramsQuery.CountAsync(); var someEducationPrograms = _sieveProcessor.Apply(model, educationProgramsQuery, applyFiltering: false, applySorting: false); result.Result = someEducationPrograms.Select(ep => new Dtos.EducationProgramInfo { CreatedAt = ep.CreatedAt, Id = ep.Id, UpdatedAt = ep.UpdatedAt, SpecialtyId = ep.SpecialtyId, Language = ep.Language, Guarantor = ep.Guarantor, EducationLevelId = ep.EducationLevelId, DurationOfEducation = ep.DurationbOfEducation, ApprovalYear = ep.ApprovalYear, ShortName = $"{ ep.Specialty.GroupsCode } ({ ep.EducationLevel.Name }) { ep.DurationbOfEducation }" + (ep.ApprovalYear.HasValue ? ep.ApprovalYear.Value.ToString("yyyy.MM.dd") : ""), EducationLevel = ep.EducationLevel.Name, SpecialtyName = ep.Specialty.Name }); return(result); }
public async Task <SieveResult <RoleDto> > GetSomeAsync(SieveModel model) { if (model == null) { return(null); } var rolesQuery = _context.Set <Entities.Role>() .Include(r => r.RolePermissions) .ThenInclude(rp => rp.Permission) .Where(role => role.Name != AppRoles.SuperAdmin && role.Name != AppRoles.User) .AsNoTracking(); rolesQuery = _sieveProcessor.Apply(model, rolesQuery, applyPagination: false); var result = new SieveResult <RoleDto>(); result.TotalCount = await rolesQuery.CountAsync(); var someRoles = _sieveProcessor.Apply(model, rolesQuery, applyFiltering: false, applySorting: false); result.Result = someRoles.Select(role => new RoleDto { CreatedAt = role.CreatedAt, Id = role.Id, UpdatedAt = role.UpdatedAt, Name = role.Name, Permissions = role.RolePermissions .GroupBy(rp => rp.Permission) .Select(p => new Dtos.Permission { Id = p.Key.Id, AccessModifier = p.Key.AccessModifier, TargetModifier = p.Key.TargetModifier }) }); return(result); }
public async Task <SieveResult <Dtos.AcademicDiscipline> > GetSomeAsync(SieveModel model) { if (model == null) { return(null); } var disciplinesQuery = _context.Set <Entities.AcademicDiscipline>() .AsNoTracking(); disciplinesQuery = _sieveProcessor.Apply(model, disciplinesQuery, applyPagination: false); var result = new SieveResult <Dtos.AcademicDiscipline>(); result.TotalCount = await disciplinesQuery.CountAsync(); var someDisciplines = await _sieveProcessor.Apply(model, disciplinesQuery, applyFiltering : false, applySorting : false).ToListAsync(); result.Result = someDisciplines.Select(discipline => new Dtos.AcademicDiscipline { AssistantId = discipline.AssistantId, Attestation = discipline.Attestation, CreatedAt = discipline.CreatedAt, CurriculumId = discipline.CurriculumId, DepartmentId = discipline.DepartmentId, FullName = discipline.FullName, Id = discipline.Id, LecturerId = discipline.LecturerId, Semester = discipline.Semester, NumberOfCredits = discipline.NumberOfCredits, ShortName = discipline.ShortName, SpecialtyId = discipline.SpecialtyId, TypeOfIndividualWork = discipline.TypeOfIndividualWork, UpdatedAt = discipline.UpdatedAt }); return(result); }
public async Task <SieveResult <DepartmentInfo> > GetSomeWithInfoAsync(SieveModel model) { if (model == null) { return(null); } var departmentsQuery = _context.Set <Entities.Department>() .Include(d => d.StructuralUnit) .AsNoTracking(); departmentsQuery = _sieveProcessor.Apply(model, departmentsQuery, applyPagination: false); var result = new SieveResult <Dtos.DepartmentInfo>(); result.TotalCount = await departmentsQuery.CountAsync(); var someDepartments = _sieveProcessor.Apply(model, departmentsQuery, applyFiltering: false, applySorting: false); result.Result = someDepartments.Select(d => new Dtos.DepartmentInfo { CreatedAt = d.CreatedAt, StructuralUnitId = d.StructuralUnitId, Code = d.Code, Id = d.Id, UpdatedAt = d.UpdatedAt, ShortName = d.ShortName, FullNameEng = d.FullNameEng, FullName = d.FullName, Chief = d.Chief, StructuralUnitName = d.StructuralUnit.FullName }); return(result); }