private ScheduleMasterFilter ConvertFilterDTOToFilterEntity(ScheduleMaster_ScheduleMasterFilterDTO ScheduleMaster_ScheduleMasterFilterDTO)
{
ScheduleMasterFilter ScheduleMasterFilter = new ScheduleMasterFilter();
ScheduleMasterFilter.Selects = ScheduleMasterSelect.ALL;
ScheduleMasterFilter.Skip = ScheduleMaster_ScheduleMasterFilterDTO.Skip;
ScheduleMasterFilter.Take = ScheduleMaster_ScheduleMasterFilterDTO.Take;
ScheduleMasterFilter.OrderBy = ScheduleMaster_ScheduleMasterFilterDTO.OrderBy;
ScheduleMasterFilter.OrderType = ScheduleMaster_ScheduleMasterFilterDTO.OrderType;
ScheduleMasterFilter.Id = ScheduleMaster_ScheduleMasterFilterDTO.Id;
ScheduleMasterFilter.ManagerId = ScheduleMaster_ScheduleMasterFilterDTO.ManagerId;
ScheduleMasterFilter.SalerId = ScheduleMaster_ScheduleMasterFilterDTO.SalerId;
ScheduleMasterFilter.Name = ScheduleMaster_ScheduleMasterFilterDTO.Name;
ScheduleMasterFilter.Code = ScheduleMaster_ScheduleMasterFilterDTO.Code;
ScheduleMasterFilter.StatusId = ScheduleMaster_ScheduleMasterFilterDTO.StatusId;
ScheduleMasterFilter.RecurDays = ScheduleMaster_ScheduleMasterFilterDTO.RecurDays;
ScheduleMasterFilter.StartDate = ScheduleMaster_ScheduleMasterFilterDTO.StartDate;
ScheduleMasterFilter.EndDate = ScheduleMaster_ScheduleMasterFilterDTO.EndDate;
ScheduleMasterFilter.StartDayOfWeek = ScheduleMaster_ScheduleMasterFilterDTO.StartDayOfWeek;
ScheduleMasterFilter.DisplayOrder = ScheduleMaster_ScheduleMasterFilterDTO.DisplayOrder;
ScheduleMasterFilter.Description = ScheduleMaster_ScheduleMasterFilterDTO.Description;
ScheduleMasterFilter.CreatedAt = ScheduleMaster_ScheduleMasterFilterDTO.CreatedAt;
ScheduleMasterFilter.UpdatedAt = ScheduleMaster_ScheduleMasterFilterDTO.UpdatedAt;
return(ScheduleMasterFilter);
}
public async Task <int> Count(ScheduleMasterFilter filter)
{
IQueryable <ScheduleMasterDAO> ScheduleMasters = DataContext.ScheduleMaster.AsNoTracking();
ScheduleMasters = DynamicFilter(ScheduleMasters, filter);
return(await ScheduleMasters.CountAsync());
}
public async Task <List <ScheduleMaster> > List(ScheduleMasterFilter filter)
{
if (filter == null)
{
return(new List <ScheduleMaster>());
}
IQueryable <ScheduleMasterDAO> ScheduleMasterDAOs = DataContext.ScheduleMaster.AsNoTracking();
ScheduleMasterDAOs = DynamicFilter(ScheduleMasterDAOs, filter);
ScheduleMasterDAOs = DynamicOrder(ScheduleMasterDAOs, filter);
List <ScheduleMaster> ScheduleMasters = await DynamicSelect(ScheduleMasterDAOs, filter);
return(ScheduleMasters);
}
public async Task <ActionResult <int> > Count([FromBody] ScheduleMaster_ScheduleMasterFilterDTO ScheduleMaster_ScheduleMasterFilterDTO)
{
if (!ModelState.IsValid)
{
throw new BindException(ModelState);
}
ScheduleMasterFilter ScheduleMasterFilter = ConvertFilterDTOToFilterEntity(ScheduleMaster_ScheduleMasterFilterDTO);
ScheduleMasterFilter = ScheduleMasterService.ToFilter(ScheduleMasterFilter);
int count = await ScheduleMasterService.Count(ScheduleMasterFilter);
return(count);
}
public async Task <ActionResult <List <ScheduleMaster_ScheduleMasterDTO> > > List([FromBody] ScheduleMaster_ScheduleMasterFilterDTO ScheduleMaster_ScheduleMasterFilterDTO)
{
if (!ModelState.IsValid)
{
throw new BindException(ModelState);
}
ScheduleMasterFilter ScheduleMasterFilter = ConvertFilterDTOToFilterEntity(ScheduleMaster_ScheduleMasterFilterDTO);
ScheduleMasterFilter = ScheduleMasterService.ToFilter(ScheduleMasterFilter);
List <ScheduleMaster> ScheduleMasters = await ScheduleMasterService.List(ScheduleMasterFilter);
List <ScheduleMaster_ScheduleMasterDTO> ScheduleMaster_ScheduleMasterDTOs = ScheduleMasters
.Select(c => new ScheduleMaster_ScheduleMasterDTO(c)).ToList();
return(ScheduleMaster_ScheduleMasterDTOs);
}
public ScheduleMasterFilter ToFilter(ScheduleMasterFilter filter)
{
if (filter.OrFilter == null)
{
filter.OrFilter = new List <ScheduleMasterFilter>();
}
if (CurrentContext.Filters == null || CurrentContext.Filters.Count == 0)
{
return(filter);
}
foreach (var currentFilter in CurrentContext.Filters)
{
ScheduleMasterFilter subFilter = new ScheduleMasterFilter();
filter.OrFilter.Add(subFilter);
List <FilterPermissionDefinition> FilterPermissionDefinitions = currentFilter.Value;
//foreach (FilterPermissionDefinition FilterPermissionDefinition in FilterPermissionDefinitions)
//{
// if (FilterPermissionDefinition.Name == nameof(subFilter.Id))
// subFilter.Id = Map(subFilter.Id, FilterPermissionDefinition);
// if (FilterPermissionDefinition.Name == nameof(subFilter.ManagerId))
// subFilter.ManagerId = Map(subFilter.ManagerId, FilterPermissionDefinition);
// if (FilterPermissionDefinition.Name == nameof(subFilter.SalerId))
// subFilter.SalerId = Map(subFilter.SalerId, FilterPermissionDefinition);
// if (FilterPermissionDefinition.Name == nameof(subFilter.Name))
// subFilter.Name = Map(subFilter.Name, FilterPermissionDefinition);
// if (FilterPermissionDefinition.Name == nameof(subFilter.Code))
// subFilter.Code = Map(subFilter.Code, FilterPermissionDefinition);
// if (FilterPermissionDefinition.Name == nameof(subFilter.StatusId))
// subFilter.StatusId = Map(subFilter.StatusId, FilterPermissionDefinition);
// if (FilterPermissionDefinition.Name == nameof(subFilter.RecurDays))
// subFilter.RecurDays = Map(subFilter.RecurDays, FilterPermissionDefinition);
// if (FilterPermissionDefinition.Name == nameof(subFilter.StartDate))
// subFilter.StartDate = Map(subFilter.StartDate, FilterPermissionDefinition);
// if (FilterPermissionDefinition.Name == nameof(subFilter.EndDate))
// subFilter.EndDate = Map(subFilter.EndDate, FilterPermissionDefinition);
// if (FilterPermissionDefinition.Name == nameof(subFilter.StartDayOfWeek))
// subFilter.StartDayOfWeek = Map(subFilter.StartDayOfWeek, FilterPermissionDefinition);
// if (FilterPermissionDefinition.Name == nameof(subFilter.DisplayOrder))
// subFilter.DisplayOrder = Map(subFilter.DisplayOrder, FilterPermissionDefinition);
// if (FilterPermissionDefinition.Name == nameof(subFilter.Description))
// subFilter.Description = Map(subFilter.Description, FilterPermissionDefinition);
//}
}
return(filter);
}
public async Task <bool> ValidateId(ScheduleMaster ScheduleMaster)
{
ScheduleMasterFilter ScheduleMasterFilter = new ScheduleMasterFilter
{
Skip = 0,
Take = 10,
Id = new IdFilter {
Equal = ScheduleMaster.Id
},
Selects = ScheduleMasterSelect.Id
};
int count = await UOW.ScheduleMasterRepository.Count(ScheduleMasterFilter);
if (count == 0)
{
ScheduleMaster.AddError(nameof(ScheduleMasterValidator), nameof(ScheduleMaster.Id), ErrorCode.IdNotExisted);
}
return(count == 1);
}
public async Task <List <ScheduleMaster> > List(ScheduleMasterFilter ScheduleMasterFilter)
{
try
{
List <ScheduleMaster> ScheduleMasters = await UOW.ScheduleMasterRepository.List(ScheduleMasterFilter);
return(ScheduleMasters);
}
catch (Exception ex)
{
await Logging.CreateSystemLog(ex.InnerException, nameof(ScheduleMasterService));
if (ex.InnerException == null)
{
throw new MessageException(ex);
}
else
{
throw new MessageException(ex.InnerException);
}
}
}
public async Task <int> Count(ScheduleMasterFilter ScheduleMasterFilter)
{
try
{
int result = await UOW.ScheduleMasterRepository.Count(ScheduleMasterFilter);
return(result);
}
catch (Exception ex)
{
await Logging.CreateSystemLog(ex.InnerException, nameof(ScheduleMasterService));
if (ex.InnerException == null)
{
throw new MessageException(ex);
}
else
{
throw new MessageException(ex.InnerException);
}
}
}
private async Task <bool> HasPermission(long Id)
{
ScheduleMasterFilter ScheduleMasterFilter = new ScheduleMasterFilter();
ScheduleMasterFilter = ScheduleMasterService.ToFilter(ScheduleMasterFilter);
if (Id == 0)
{
}
else
{
ScheduleMasterFilter.Id = new IdFilter {
Equal = Id
};
int count = await ScheduleMasterService.Count(ScheduleMasterFilter);
if (count == 0)
{
return(false);
}
}
return(true);
}
public async Task <ActionResult <bool> > BulkDelete([FromBody] List <long> Ids)
{
if (!ModelState.IsValid)
{
throw new BindException(ModelState);
}
ScheduleMasterFilter ScheduleMasterFilter = new ScheduleMasterFilter();
ScheduleMasterFilter = ScheduleMasterService.ToFilter(ScheduleMasterFilter);
ScheduleMasterFilter.Id = new IdFilter {
In = Ids
};
ScheduleMasterFilter.Selects = ScheduleMasterSelect.Id;
ScheduleMasterFilter.Skip = 0;
ScheduleMasterFilter.Take = int.MaxValue;
List <ScheduleMaster> ScheduleMasters = await ScheduleMasterService.List(ScheduleMasterFilter);
ScheduleMasters = await ScheduleMasterService.BulkDelete(ScheduleMasters);
return(true);
}
private IQueryable <ScheduleMasterDAO> OrFilter(IQueryable <ScheduleMasterDAO> query, ScheduleMasterFilter filter)
{
if (filter.OrFilter == null || filter.OrFilter.Count == 0)
{
return(query);
}
IQueryable <ScheduleMasterDAO> initQuery = query.Where(q => false);
foreach (ScheduleMasterFilter ScheduleMasterFilter in filter.OrFilter)
{
IQueryable <ScheduleMasterDAO> queryable = query;
if (filter.Id != null)
{
queryable = queryable.Where(q => q.Id, filter.Id);
}
if (filter.ManagerId != null)
{
queryable = queryable.Where(q => q.ManagerId, filter.ManagerId);
}
if (filter.SalerId != null)
{
queryable = queryable.Where(q => q.SalerId, filter.SalerId);
}
if (filter.Name != null)
{
queryable = queryable.Where(q => q.Name, filter.Name);
}
if (filter.Code != null)
{
queryable = queryable.Where(q => q.Code, filter.Code);
}
if (filter.StatusId != null)
{
queryable = queryable.Where(q => q.StatusId, filter.StatusId);
}
if (filter.RecurDays != null)
{
queryable = queryable.Where(q => q.RecurDays, filter.RecurDays);
}
if (filter.StartDate != null)
{
queryable = queryable.Where(q => q.StartDate, filter.StartDate);
}
if (filter.EndDate != null)
{
queryable = queryable.Where(q => q.EndDate, filter.EndDate);
}
if (filter.StartDayOfWeek != null)
{
queryable = queryable.Where(q => q.StartDayOfWeek, filter.StartDayOfWeek);
}
if (filter.DisplayOrder != null)
{
queryable = queryable.Where(q => q.DisplayOrder, filter.DisplayOrder);
}
if (filter.Description != null)
{
queryable = queryable.Where(q => q.Description, filter.Description);
}
initQuery = initQuery.Union(queryable);
}
return(initQuery);
}
private IQueryable <ScheduleMasterDAO> DynamicFilter(IQueryable <ScheduleMasterDAO> query, ScheduleMasterFilter filter)
{
if (filter == null)
{
return(query.Where(q => false));
}
query = query.Where(q => !q.DeletedAt.HasValue);
if (filter.CreatedAt != null)
{
query = query.Where(q => q.CreatedAt, filter.CreatedAt);
}
if (filter.UpdatedAt != null)
{
query = query.Where(q => q.UpdatedAt, filter.UpdatedAt);
}
if (filter.Id != null)
{
query = query.Where(q => q.Id, filter.Id);
}
if (filter.ManagerId != null)
{
query = query.Where(q => q.ManagerId, filter.ManagerId);
}
if (filter.SalerId != null)
{
query = query.Where(q => q.SalerId, filter.SalerId);
}
if (filter.Name != null)
{
query = query.Where(q => q.Name, filter.Name);
}
if (filter.Code != null)
{
query = query.Where(q => q.Code, filter.Code);
}
if (filter.StatusId != null)
{
query = query.Where(q => q.StatusId, filter.StatusId);
}
if (filter.RecurDays != null)
{
query = query.Where(q => q.RecurDays, filter.RecurDays);
}
if (filter.StartDate != null)
{
query = query.Where(q => q.StartDate, filter.StartDate);
}
if (filter.EndDate != null)
{
query = query.Where(q => q.EndDate, filter.EndDate);
}
if (filter.StartDayOfWeek != null)
{
query = query.Where(q => q.StartDayOfWeek, filter.StartDayOfWeek);
}
if (filter.DisplayOrder != null)
{
query = query.Where(q => q.DisplayOrder, filter.DisplayOrder);
}
if (filter.Description != null)
{
query = query.Where(q => q.Description, filter.Description);
}
query = OrFilter(query, filter);
return(query);
}
private async Task <List <ScheduleMaster> > DynamicSelect(IQueryable <ScheduleMasterDAO> query, ScheduleMasterFilter filter)
{
List <ScheduleMaster> ScheduleMasters = await query.Select(q => new ScheduleMaster()
{
Id = filter.Selects.Contains(ScheduleMasterSelect.Id) ? q.Id : default(long),
ManagerId = filter.Selects.Contains(ScheduleMasterSelect.Manager) ? q.ManagerId : default(long?),
SalerId = filter.Selects.Contains(ScheduleMasterSelect.Saler) ? q.SalerId : default(long?),
Name = filter.Selects.Contains(ScheduleMasterSelect.Name) ? q.Name : default(string),
Code = filter.Selects.Contains(ScheduleMasterSelect.Code) ? q.Code : default(string),
StatusId = filter.Selects.Contains(ScheduleMasterSelect.Status) ? q.StatusId : default(long?),
RecurDays = filter.Selects.Contains(ScheduleMasterSelect.RecurDays) ? q.RecurDays : default(DateTime?),
StartDate = filter.Selects.Contains(ScheduleMasterSelect.StartDate) ? q.StartDate : default(DateTime?),
EndDate = filter.Selects.Contains(ScheduleMasterSelect.EndDate) ? q.EndDate : default(DateTime?),
NoEndDate = filter.Selects.Contains(ScheduleMasterSelect.NoEndDate) ? q.NoEndDate : default(bool?),
StartDayOfWeek = filter.Selects.Contains(ScheduleMasterSelect.StartDayOfWeek) ? q.StartDayOfWeek : default(DateTime?),
DisplayOrder = filter.Selects.Contains(ScheduleMasterSelect.DisplayOrder) ? q.DisplayOrder : default(long?),
Description = filter.Selects.Contains(ScheduleMasterSelect.Description) ? q.Description : default(string),
Manager = filter.Selects.Contains(ScheduleMasterSelect.Manager) && q.Manager != null ? new AppUser
{
Id = q.Manager.Id,
Username = q.Manager.Username,
DisplayName = q.Manager.DisplayName,
Address = q.Manager.Address,
Email = q.Manager.Email,
Phone = q.Manager.Phone,
Department = q.Manager.Department,
OrganizationId = q.Manager.OrganizationId,
StatusId = q.Manager.StatusId,
Avatar = q.Manager.Avatar,
SexId = q.Manager.SexId,
Birthday = q.Manager.Birthday,
} : null,
Saler = filter.Selects.Contains(ScheduleMasterSelect.Saler) && q.Saler != null ? new AppUser
{
Id = q.Saler.Id,
Username = q.Saler.Username,
DisplayName = q.Saler.DisplayName,
Address = q.Saler.Address,
Email = q.Saler.Email,
Phone = q.Saler.Phone,
Department = q.Saler.Department,
OrganizationId = q.Saler.OrganizationId,
StatusId = q.Saler.StatusId,
Avatar = q.Saler.Avatar,
SexId = q.Saler.SexId,
Birthday = q.Saler.Birthday,
} : null,
Status = filter.Selects.Contains(ScheduleMasterSelect.Status) && q.Status != null ? new Status
{
Id = q.Status.Id,
Code = q.Status.Code,
Name = q.Status.Name,
} : null,
CreatedAt = q.CreatedAt,
UpdatedAt = q.UpdatedAt,
}).ToListAsync();
return(ScheduleMasters);
}
private IQueryable <ScheduleMasterDAO> DynamicOrder(IQueryable <ScheduleMasterDAO> query, ScheduleMasterFilter filter)
{
switch (filter.OrderType)
{
case OrderType.ASC:
switch (filter.OrderBy)
{
case ScheduleMasterOrder.Id:
query = query.OrderBy(q => q.Id);
break;
case ScheduleMasterOrder.Manager:
query = query.OrderBy(q => q.ManagerId);
break;
case ScheduleMasterOrder.Saler:
query = query.OrderBy(q => q.SalerId);
break;
case ScheduleMasterOrder.Name:
query = query.OrderBy(q => q.Name);
break;
case ScheduleMasterOrder.Code:
query = query.OrderBy(q => q.Code);
break;
case ScheduleMasterOrder.Status:
query = query.OrderBy(q => q.StatusId);
break;
case ScheduleMasterOrder.RecurDays:
query = query.OrderBy(q => q.RecurDays);
break;
case ScheduleMasterOrder.StartDate:
query = query.OrderBy(q => q.StartDate);
break;
case ScheduleMasterOrder.EndDate:
query = query.OrderBy(q => q.EndDate);
break;
case ScheduleMasterOrder.NoEndDate:
query = query.OrderBy(q => q.NoEndDate);
break;
case ScheduleMasterOrder.StartDayOfWeek:
query = query.OrderBy(q => q.StartDayOfWeek);
break;
case ScheduleMasterOrder.DisplayOrder:
query = query.OrderBy(q => q.DisplayOrder);
break;
case ScheduleMasterOrder.Description:
query = query.OrderBy(q => q.Description);
break;
}
break;
case OrderType.DESC:
switch (filter.OrderBy)
{
case ScheduleMasterOrder.Id:
query = query.OrderByDescending(q => q.Id);
break;
case ScheduleMasterOrder.Manager:
query = query.OrderByDescending(q => q.ManagerId);
break;
case ScheduleMasterOrder.Saler:
query = query.OrderByDescending(q => q.SalerId);
break;
case ScheduleMasterOrder.Name:
query = query.OrderByDescending(q => q.Name);
break;
case ScheduleMasterOrder.Code:
query = query.OrderByDescending(q => q.Code);
break;
case ScheduleMasterOrder.Status:
query = query.OrderByDescending(q => q.StatusId);
break;
case ScheduleMasterOrder.RecurDays:
query = query.OrderByDescending(q => q.RecurDays);
break;
case ScheduleMasterOrder.StartDate:
query = query.OrderByDescending(q => q.StartDate);
break;
case ScheduleMasterOrder.EndDate:
query = query.OrderByDescending(q => q.EndDate);
break;
case ScheduleMasterOrder.NoEndDate:
query = query.OrderByDescending(q => q.NoEndDate);
break;
case ScheduleMasterOrder.StartDayOfWeek:
query = query.OrderByDescending(q => q.StartDayOfWeek);
break;
case ScheduleMasterOrder.DisplayOrder:
query = query.OrderByDescending(q => q.DisplayOrder);
break;
case ScheduleMasterOrder.Description:
query = query.OrderByDescending(q => q.Description);
break;
}
break;
}
query = query.Skip(filter.Skip).Take(filter.Take);
return(query);
}
