Esempio n. 1
0
        public async Task <int> Count(University_Majors_SubjectGroupFilter university_Majors_SubjectGroupFilter)
        {
            IQueryable <University_Majors_SubjectGroupDAO> university_Majors_SubjectGroupDAOs = eMSContext.University_Majors_SubjectGroup;

            university_Majors_SubjectGroupDAOs = DynamicFilter(university_Majors_SubjectGroupDAOs, university_Majors_SubjectGroupFilter);
            return(await university_Majors_SubjectGroupDAOs.CountAsync());
        }
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);
        }
Esempio n. 4
0
        public async Task <List <University_Majors_SubjectGroup> > List(University_Majors_SubjectGroupFilter university_Majors_SubjectGroupFilter)
        {
            if (university_Majors_SubjectGroupFilter == null)
            {
                return(new List <University_Majors_SubjectGroup>());
            }
            IQueryable <University_Majors_SubjectGroupDAO> university_Majors_SubjectGroupDAOs = eMSContext.University_Majors_SubjectGroup;

            university_Majors_SubjectGroupDAOs = DynamicFilter(university_Majors_SubjectGroupDAOs, university_Majors_SubjectGroupFilter);
            university_Majors_SubjectGroupDAOs = DynamicOrder(university_Majors_SubjectGroupDAOs, university_Majors_SubjectGroupFilter);
            var university_Majors_SubjectGroups = await DynamicSelect(university_Majors_SubjectGroupDAOs);

            return(university_Majors_SubjectGroups);
        }
Esempio n. 5
0
        private async Task <bool> DuplicateValidation(University_Majors_SubjectGroup university_Majors_SubjectGroup)
        {
            University_Majors_SubjectGroupFilter filter = new University_Majors_SubjectGroupFilter
            {
                SubjectGroupId      = university_Majors_SubjectGroup.SubjectGroupId,
                University_MajorsId = university_Majors_SubjectGroup.University_MajorsId
            };

            if (await UOW.University_Majors_SubjectGroupRepository.Count(filter) > 0)
            {
                university_Majors_SubjectGroup.AddError(nameof(University_Majors_SubjectGroupValidator), nameof(university_Majors_SubjectGroup), ErrorCode.Duplicate);
            }

            return(university_Majors_SubjectGroup.IsValidated);
        }
 public async Task <List <University_Majors_SubjectGroup> > List(University_Majors_SubjectGroupFilter university_Majors_SubjectGroupFilter)
 {
     return(await UOW.University_Majors_SubjectGroupRepository.List(university_Majors_SubjectGroupFilter));
 }
Esempio n. 7
0
        private IQueryable <University_Majors_SubjectGroupDAO> DynamicOrder(IQueryable <University_Majors_SubjectGroupDAO> query, University_Majors_SubjectGroupFilter university_Majors_SubjectGroupFilter)
        {
            switch (university_Majors_SubjectGroupFilter.OrderType)
            {
            case OrderType.ASC:
                switch (university_Majors_SubjectGroupFilter.OrderBy)
                {
                case University_Majors_SubjectGroupOrder.SubjectGroupCode:
                    query = query.OrderBy(q => q.SubjectGroup.Code);
                    break;

                case University_Majors_SubjectGroupOrder.Benchmark:
                    query = query.OrderBy(q => q.Benchmark);
                    break;

                case University_Majors_SubjectGroupOrder.MajorsCode:
                    query = query.OrderBy(q => q.University_Majors.Majors.Code);
                    break;

                default:
                    query = query.OrderBy(q => q.Id);
                    break;
                }
                break;

            case OrderType.DESC:
                switch (university_Majors_SubjectGroupFilter.OrderBy)
                {
                case University_Majors_SubjectGroupOrder.SubjectGroupCode:
                    query = query.OrderByDescending(q => q.SubjectGroup.Code);
                    break;

                case University_Majors_SubjectGroupOrder.Benchmark:
                    query = query.OrderByDescending(q => q.Benchmark);
                    break;

                case University_Majors_SubjectGroupOrder.MajorsCode:
                    query = query.OrderByDescending(q => q.University_Majors.Majors.Code);
                    break;

                default:
                    query = query.OrderByDescending(q => q.Id);
                    break;
                }
                break;

            default:
                query = query.OrderBy(q => q.Id);
                break;
            }
            query = query.Skip(university_Majors_SubjectGroupFilter.Skip).Take(university_Majors_SubjectGroupFilter.Take);
            return(query);
        }
Esempio n. 8
0
        private IQueryable <University_Majors_SubjectGroupDAO> DynamicFilter(IQueryable <University_Majors_SubjectGroupDAO> query, University_Majors_SubjectGroupFilter university_Majors_SubjectGroupFilter)
        {
            if (university_Majors_SubjectGroupFilter == null)
            {
                return(query.Where(q => 1 == 0));
            }
            if (university_Majors_SubjectGroupFilter.University_MajorsId != null)
            {
                query = query.Where(q => q.University_MajorsId, university_Majors_SubjectGroupFilter.University_MajorsId);
            }

            if (university_Majors_SubjectGroupFilter.UniversityId != null)
            {
                query = query.Where(q => q.University_Majors.UniversityId, university_Majors_SubjectGroupFilter.UniversityId);
            }
            if (university_Majors_SubjectGroupFilter.MajorsId != null)
            {
                query = query.Where(q => q.University_Majors.MajorsId, university_Majors_SubjectGroupFilter.MajorsId);
            }
            if (university_Majors_SubjectGroupFilter.SubjectGroupId != null)
            {
                query = query.Where(q => q.SubjectGroupId, university_Majors_SubjectGroupFilter.SubjectGroupId);
            }

            if (university_Majors_SubjectGroupFilter.UniversityCode != null)
            {
                query = query.Where(q => q.University_Majors.University.Code, university_Majors_SubjectGroupFilter.UniversityCode);
            }
            if (university_Majors_SubjectGroupFilter.UniversityName != null)
            {
                query = query.Where(q => q.University_Majors.University.Name, university_Majors_SubjectGroupFilter.UniversityName);
            }
            if (university_Majors_SubjectGroupFilter.MajorsCode != null)
            {
                query = query.Where(q => q.University_Majors.Majors.Code, university_Majors_SubjectGroupFilter.MajorsCode);
            }
            if (university_Majors_SubjectGroupFilter.MajorsName != null)
            {
                query = query.Where(q => q.University_Majors.Majors.Name, university_Majors_SubjectGroupFilter.MajorsName);
            }

            if (university_Majors_SubjectGroupFilter.SubjectGroupCode != null)
            {
                query = query.Where(q => q.SubjectGroup.Code, university_Majors_SubjectGroupFilter.SubjectGroupCode);
            }
            if (university_Majors_SubjectGroupFilter.Benchmark != null)
            {
                query = query.Where(q => q.Benchmark, university_Majors_SubjectGroupFilter.Benchmark);
            }
            if (university_Majors_SubjectGroupFilter.Year != null)
            {
                query = query.Where(q => q.University_Majors.Year.Equals(university_Majors_SubjectGroupFilter.Year));
            }
            return(query);
        }