public async Task <University_MajorsDTO> Get([FromBody] University_MajorsDTO university_MajorsDTO)
        {
            if (!ModelState.IsValid)
            {
                throw new MessageException(ModelState);
            }
            var university_Majors = await university_MajorsService.Get(university_MajorsDTO.Id);

            if (university_Majors == null)
            {
                return(null);
            }

            var university_Majors_SubjectGroups = await university_Majors_SubjectGroupService.List(new University_Majors_SubjectGroupFilter
            {
                UniversityId = new IdFilter {
                    Equal = university_MajorsDTO.UniversityId
                },
                MajorsId = new IdFilter {
                    Equal = university_MajorsDTO.MajorsId
                },
                Year = university_MajorsDTO.Year
            });

            university_MajorsDTO = new University_MajorsDTO(university_Majors);
            university_MajorsDTO.university_Majors_SubjectGroupDTO = university_Majors_SubjectGroups.Select(u => new University_Majors_SubjectGroupDTO(u)).ToList();
            return(university_MajorsDTO);
        }
Esempio n. 2
0
        public async Task <List <University_Majors_SubjectGroupDTO> > List([FromBody] University_Majors_SubjectGroupFilterDTO University_Majors_SubjectFilterDTO)
        {
            University_Majors_SubjectGroupFilter University_Majors_SubjectFilter = new University_Majors_SubjectGroupFilter
            {
                University_MajorsId = University_Majors_SubjectFilterDTO.University_MajorsId,
                UniversityId        = University_Majors_SubjectFilterDTO.UniversityId,
                UniversityCode      = University_Majors_SubjectFilterDTO.UniversityCode,
                UniversityName      = University_Majors_SubjectFilterDTO.UniversityName,
                MajorsId            = University_Majors_SubjectFilterDTO.MajorsId,
                MajorsCode          = University_Majors_SubjectFilterDTO.MajorsCode,
                MajorsName          = University_Majors_SubjectFilterDTO.MajorsName,
                SubjectGroupId      = University_Majors_SubjectFilterDTO.SubjectGroupId,
                SubjectGroupCode    = University_Majors_SubjectFilterDTO.SubjectGroupCode,
                Benchmark           = University_Majors_SubjectFilterDTO.Benchmark,
                Year      = University_Majors_SubjectFilterDTO.Year,
                Skip      = University_Majors_SubjectFilterDTO.Skip,
                Take      = University_Majors_SubjectFilterDTO.Take,
                OrderType = University_Majors_SubjectFilterDTO.OrderType,
                OrderBy   = University_Majors_SubjectFilterDTO.OrderBy
            };

            List <University_Majors_SubjectGroup> University_Majors_Subjects = await University_Majors_SubjectGroupService.List(University_Majors_SubjectFilter);

            List <University_Majors_SubjectGroupDTO> University_Majors_SubjectDTOs = University_Majors_Subjects.Select(u => new University_Majors_SubjectGroupDTO(u)).ToList();

            return(University_Majors_SubjectDTOs);
        }
Esempio n. 3
0
        public async Task <List <University_Majors_SubjectGroupDTO> > List([FromBody] University_Majors_SubjectGroupFilterDTO University_Majors_SubjectFilterDTO)
        {
            University_Majors_SubjectGroupFilter University_Majors_SubjectFilter = new University_Majors_SubjectGroupFilter
            {
                University_MajorsId = University_Majors_SubjectFilterDTO.University_MajorsId,
                UniversityId        = University_Majors_SubjectFilterDTO.UniversityId,
                UniversityCode      = new StringFilter {
                    StartsWith = University_Majors_SubjectFilterDTO.UniversityCode
                },
                UniversityName = new StringFilter {
                    Contains = University_Majors_SubjectFilterDTO.UniversityName
                },
                MajorsId   = University_Majors_SubjectFilterDTO.MajorsId,
                MajorsCode = new StringFilter {
                    StartsWith = University_Majors_SubjectFilterDTO.MajorsCode
                },
                MajorsName = new StringFilter {
                    Contains = University_Majors_SubjectFilterDTO.MajorsName
                },
                SubjectGroupId   = University_Majors_SubjectFilterDTO.SubjectGroupId,
                SubjectGroupCode = new StringFilter {
                    StartsWith = University_Majors_SubjectFilterDTO.SubjectGroupCode
                },
                Benchmark = new DoubleFilter {
                    LessEqual = University_Majors_SubjectFilterDTO.Benchmark
                },
                Year = new StringFilter {
                    Equal = University_Majors_SubjectFilterDTO.Year
                },
                Skip      = University_Majors_SubjectFilterDTO.Skip,
                Take      = int.MaxValue,
                OrderType = OrderType.DESC,
                OrderBy   = University_Majors_SubjectGroupOrder.Benchmark
            };

            List <University_Majors_SubjectGroup> University_Majors_Subjects = await University_Majors_SubjectGroupService.List(University_Majors_SubjectFilter);

            List <University_Majors_SubjectGroupDTO> University_Majors_SubjectDTOs = University_Majors_Subjects.Select(u => new University_Majors_SubjectGroupDTO
            {
                Id                  = u.Id,
                MajorsId            = u.MajorsId,
                MajorsCode          = u.MajorsCode,
                MajorsName          = u.MajorsName,
                UniversityId        = u.UniversityId,
                UniversityCode      = u.UniversityCode,
                UniversityName      = u.UniversityName,
                University_MajorsId = u.University_MajorsId,
                SubjectGroupId      = u.SubjectGroupId,
                SubjectGroupCode    = u.SubjectGroupCode,
                SubjectGroupName    = u.SubjectGroupName,
                Benchmark           = u.Benchmark,
                Quantity            = u.Quantity,
                Note                = u.Note,
                Year                = u.Year
            }).ToList();

            return(University_Majors_SubjectDTOs);
        }
        public async Task <UniversityDTO> Get([FromBody] UniversityFilterDTO universityFilterDTO)
        {
            if (universityFilterDTO == null)
            {
                universityFilterDTO = new UniversityFilterDTO();
            }

            University university = new University {
                Id = universityFilterDTO.Id ?? default
            };

            university = await UniversityService.Get(university.Id);

            List <University_Majors_SubjectGroup> listUniversity_Majors_SubjectGroup = await University_Majors_SubjectGroupService.List(new University_Majors_SubjectGroupFilter
            {
                UniversityId = university.Id,
                Year         = string.IsNullOrEmpty(universityFilterDTO.Year)? null : new StringFilter {
                    Equal = universityFilterDTO.Year
                },
                Skip    = universityFilterDTO.Skip,
                Take    = int.MaxValue,
                OrderBy = University_Majors_SubjectGroupOrder.MajorsCode
            });

            return(university == null ? null : new UniversityDTO()
            {
                Id = university.Id,
                Code = university.Code,
                Name = university.Name,
                Address = university.Address,
                Website = university.Website,
                University_Majors_SubjectGroups = listUniversity_Majors_SubjectGroup.Select(u => new University_Majors_SubjectGroupDTO
                {
                    Id = u.Id,
                    MajorsId = u.MajorsId,
                    MajorsCode = u.MajorsCode,
                    MajorsName = u.MajorsName,
                    UniversityId = u.UniversityId,
                    UniversityCode = u.UniversityCode,
                    UniversityName = u.UniversityName,
                    SubjectGroupId = u.SubjectGroupId,
                    SubjectGroupCode = u.SubjectGroupCode,
                    SubjectGroupName = u.SubjectGroupName,
                    Benchmark = u.Benchmark,
                    Note = u.Note,
                    Quantity = u.Quantity,
                    Year = u.Year
                }).OrderByDescending(u => u.Year).ToList(),
                Errors = university.Errors
            });
        }
        public async Task <UniversityDTO> Get([FromBody] UniversityFilterDTO universityFilterDTO)
        {
            if (!ModelState.IsValid)
            {
                throw new MessageException(ModelState);
            }

            var univer = await UniversityService.Get(universityFilterDTO.Id);

            List <University_Majors_SubjectGroup> listUniversity_Majors_SubjectGroup = await University_Majors_SubjectGroupService.List(new University_Majors_SubjectGroupFilter
            {
                UniversityId = new IdFilter {
                    Equal = universityFilterDTO.Id
                },
                Year = universityFilterDTO.Year,
            });

            var listUniversity_Majors_SubjectGroupDTO = listUniversity_Majors_SubjectGroup.Select(u => new University_Majors_SubjectGroupDTO(u)).OrderByDescending(u => u.Year).ToList();

            if (univer == null)
            {
                return(null);
            }
            else
            {
                var univerDTO = new UniversityDTO(univer);
                univerDTO.University_Majors_SubjectGroups = listUniversity_Majors_SubjectGroupDTO;
                return(univerDTO);
            }
        }