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