public async Task <int> Count(AdministratorFilter filter)
{
IQueryable <AdministratorDAO> AdministratorDAOs = DataContext.Administrator;
AdministratorDAOs = DynamicFilter(AdministratorDAOs, filter);
return(await AdministratorDAOs.CountAsync());
}
public async Task <int> Count([FromBody] AdministratorMaster_AdministratorFilterDTO AdministratorMaster_AdministratorFilterDTO)
{
if (!ModelState.IsValid)
{
throw new MessageException(ModelState);
}
AdministratorFilter AdministratorFilter = ConvertFilterDTOToFilterEntity(AdministratorMaster_AdministratorFilterDTO);
return(await AdministratorService.Count(AdministratorFilter));
}
public async Task <List <AdministratorMaster_AdministratorDTO> > List([FromBody] AdministratorMaster_AdministratorFilterDTO AdministratorMaster_AdministratorFilterDTO)
{
if (!ModelState.IsValid)
{
throw new MessageException(ModelState);
}
AdministratorFilter AdministratorFilter = ConvertFilterDTOToFilterEntity(AdministratorMaster_AdministratorFilterDTO);
List <Administrator> Administrators = await AdministratorService.List(AdministratorFilter);
return(Administrators.Select(c => new AdministratorMaster_AdministratorDTO(c)).ToList());
}
public async Task <List <Administrator> > List(AdministratorFilter filter)
{
if (filter == null)
{
return(new List <Administrator>());
}
IQueryable <AdministratorDAO> AdministratorDAOs = DataContext.Administrator;
AdministratorDAOs = DynamicFilter(AdministratorDAOs, filter);
AdministratorDAOs = DynamicOrder(AdministratorDAOs, filter);
var Administrators = await DynamicSelect(AdministratorDAOs, filter);
return(Administrators);
}
public AdministratorFilter ConvertFilterDTOToFilterEntity(AdministratorMaster_AdministratorFilterDTO AdministratorMaster_AdministratorFilterDTO)
{
AdministratorFilter AdministratorFilter = new AdministratorFilter();
AdministratorFilter.Selects = AdministratorSelect.ALL;
AdministratorFilter.Id = new LongFilter {
Equal = AdministratorMaster_AdministratorFilterDTO.Id
};
AdministratorFilter.Username = new StringFilter {
StartsWith = AdministratorMaster_AdministratorFilterDTO.Username
};
AdministratorFilter.DisplayName = new StringFilter {
StartsWith = AdministratorMaster_AdministratorFilterDTO.DisplayName
};
return(AdministratorFilter);
}
public async Task <bool> ValidateId(Administrator Administrator)
{
AdministratorFilter AdministratorFilter = new AdministratorFilter
{
Skip = 0,
Take = 10,
Id = new LongFilter {
Equal = Administrator.Id
},
Selects = AdministratorSelect.Id
};
int count = await UOW.AdministratorRepository.Count(AdministratorFilter);
if (count == 0)
{
Administrator.AddError(nameof(AdministratorValidator), nameof(Administrator.Id), ErrorCode.IdNotExisted);
}
return(count == 1);
}
public async Task <List <Administrator> > List(AdministratorFilter AdministratorFilter)
{
List <Administrator> Administrators = await UOW.AdministratorRepository.List(AdministratorFilter);
return(Administrators);
}
public async Task <int> Count(AdministratorFilter AdministratorFilter)
{
int result = await UOW.AdministratorRepository.Count(AdministratorFilter);
return(result);
}
private IQueryable <AdministratorDAO> DynamicOrder(IQueryable <AdministratorDAO> query, AdministratorFilter filter)
{
switch (filter.OrderType)
{
case OrderType.ASC:
switch (filter.OrderBy)
{
case AdministratorOrder.Id:
query = query.OrderBy(q => q.Id);
break;
case AdministratorOrder.Username:
query = query.OrderBy(q => q.Username);
break;
case AdministratorOrder.DisplayName:
query = query.OrderBy(q => q.DisplayName);
break;
}
break;
case OrderType.DESC:
switch (filter.OrderBy)
{
case AdministratorOrder.Id:
query = query.OrderByDescending(q => q.Id);
break;
case AdministratorOrder.Username:
query = query.OrderByDescending(q => q.Username);
break;
case AdministratorOrder.DisplayName:
query = query.OrderByDescending(q => q.DisplayName);
break;
}
break;
}
query = query.Skip(filter.Skip).Take(filter.Take);
return(query);
}
private IQueryable <AdministratorDAO> DynamicFilter(IQueryable <AdministratorDAO> query, AdministratorFilter filter)
{
if (filter == null)
{
return(query.Where(q => false));
}
if (filter.Id != null)
{
query = query.Where(q => q.Id, filter.Id);
}
if (filter.Username != null)
{
query = query.Where(q => q.Username, filter.Username);
}
if (filter.DisplayName != null)
{
query = query.Where(q => q.DisplayName, filter.DisplayName);
}
if (filter.Ids != null)
{
query = query.Where(q => filter.Ids.Contains(q.Id));
}
if (filter.ExceptIds != null)
{
query = query.Where(q => !filter.ExceptIds.Contains(q.Id));
}
return(query);
}
private async Task <List <Administrator> > DynamicSelect(IQueryable <AdministratorDAO> query, AdministratorFilter filter)
{
List <Administrator> Administrators = await query.Select(q => new Administrator()
{
Id = filter.Selects.Contains(AdministratorSelect.Id) ? q.Id : default(long),
Username = filter.Selects.Contains(AdministratorSelect.Username) ? q.Username : default(string),
DisplayName = filter.Selects.Contains(AdministratorSelect.DisplayName) ? q.DisplayName : default(string),
}).ToListAsync();
return(Administrators);
}
