public async Task <int> Count(SemesterFilter filter)
{
IQueryable <SemesterDAO> semesterDAOs = examRegContext.Semester.AsNoTracking();
semesterDAOs = DynamicFilter(semesterDAOs, filter);
return(await semesterDAOs.CountAsync());
}
public async Task <Term> GetSemesterId(Term term)
{
SemesterFilter filter = new SemesterFilter
{
Code = new StringFilter {
Equal = term.SemesterCode
}
};
Semester semester = await UOW.SemesterRepository.Get(filter);
term.SemesterId = semester.Id;
return(term);
}
public async Task <ExamProgram> GetSemesterId(ExamProgram examProgram)
{
SemesterFilter filter = new SemesterFilter
{
Code = new StringFilter {
Equal = examProgram.SemesterCode
}
};
Semester semester = await UOW.SemesterRepository.Get(filter);
examProgram.SemesterId = semester.Id;
return(examProgram);
}
private async Task <bool> ValidateId(Semester Semester)
{
SemesterFilter filter = new SemesterFilter
{
Id = new GuidFilter {
Equal = Semester.Id
}
};
int count = await UOW.SemesterRepository.Count(filter);
if (count == 0)
{
Semester.AddError(nameof(SemesterValidator), nameof(Semester), ERROR.IdNotFound);
}
return(count == 1);
}
private async Task <bool> ValidateNotExist(Semester semester)
{
SemesterFilter filter = new SemesterFilter
{
StartYear = new ShortFilter {
Equal = semester.StartYear
},
EndYear = new ShortFilter {
Equal = semester.EndYear
},
IsFirstHalf = semester.IsFirstHalf
};
int count = await UOW.SemesterRepository.Count(filter);
if (count > 0)
{
semester.AddError(nameof(SemesterValidator), nameof(semester), ERROR.SemesterExisted);
return(false);
}
return(true);
}
public async Task <Semester> Get(SemesterFilter filter)
{
if (filter == null)
{
return(null);
}
IQueryable <SemesterDAO> query = examRegContext.Semester.AsNoTracking();
query = DynamicFilter(query, filter);
List <Semester> list = await query.Select(s => new Semester()
{
Id = s.Id,
Code = string.Format(s.StartYear + "_" + s.EndYear + "_" + (s.IsFirstHalf ? 1 : 2)),
StartYear = s.StartYear,
EndYear = s.EndYear,
IsFirstHalf = s.IsFirstHalf
}).ToListAsync();
return(list.FirstOrDefault());
}
public async Task <List <Semester> > List(SemesterFilter filter)
{
return(await UOW.SemesterRepository.List(filter));
}
private IQueryable <SemesterDAO> DynamicOrder(IQueryable <SemesterDAO> query, SemesterFilter filter)
{
switch (filter.OrderType)
{
case OrderType.ASC:
switch (filter.OrderBy)
{
case SemesterOrder.Code:
query = query.OrderBy(q => q.StartYear);
break;
case SemesterOrder.IsFirstHalf:
query = query.OrderBy(q => q.IsFirstHalf);
break;
default:
query = query.OrderBy(q => q.CX);
break;
}
break;
case OrderType.DESC:
switch (filter.OrderBy)
{
case SemesterOrder.Code:
query = query.OrderByDescending(q => q.StartYear);
break;
case SemesterOrder.IsFirstHalf:
query = query.OrderByDescending(q => q.IsFirstHalf);
break;
default:
query = query.OrderByDescending(q => q.CX);
break;
}
break;
default:
query = query.OrderBy(q => q.CX);
break;
}
return(query.Skip(filter.Skip).Take(filter.Take));
}
private IQueryable <SemesterDAO> DynamicFilter(IQueryable <SemesterDAO> query, SemesterFilter filter)
{
if (filter == null)
{
return(query.Where(q => 1 == 0));
}
if (filter.Id != null)
{
query = query.Where(q => q.Id, filter.Id);
}
if (filter.Code != null)
{
string[] codeData = filter.Code.Equal.Split("_");
query = query.Where(q => q.StartYear, new ShortFilter {
Equal = short.Parse(codeData[0])
});
query = query.Where(q => q.EndYear, new ShortFilter {
Equal = short.Parse(codeData[1])
});
query = query.Where(q => q.IsFirstHalf == (codeData[2] == "1" ? true : false));
}
if (filter.StartYear != null)
{
query = query.Where(q => q.StartYear, filter.StartYear);
}
if (filter.EndYear != null)
{
query = query.Where(q => q.EndYear, filter.EndYear);
}
if (filter.IsFirstHalf != null)
{
query = query.Where(c => c.IsFirstHalf == filter.IsFirstHalf);
}
return(query);
}
public async Task <PagedList <SemesterModel> > GetSemestersAsync(ListOptions listOptions, SemesterFilter filter)
{
throw new NotImplementedException();
}
