public async Task <ActionResult <bool> > BulkDelete([FromBody] List <long> Ids)
{
if (!ModelState.IsValid)
{
throw new BindException(ModelState);
}
KnowledgeGroupFilter KnowledgeGroupFilter = new KnowledgeGroupFilter();
KnowledgeGroupFilter = KnowledgeGroupService.ToFilter(KnowledgeGroupFilter);
KnowledgeGroupFilter.Id = new IdFilter {
In = Ids
};
KnowledgeGroupFilter.Selects = KnowledgeGroupSelect.Id;
KnowledgeGroupFilter.Skip = 0;
KnowledgeGroupFilter.Take = int.MaxValue;
List <KnowledgeGroup> KnowledgeGroups = await KnowledgeGroupService.List(KnowledgeGroupFilter);
KnowledgeGroups = await KnowledgeGroupService.BulkDelete(KnowledgeGroups);
if (KnowledgeGroups.Any(x => !x.IsValidated))
{
return(BadRequest(KnowledgeGroups.Where(x => !x.IsValidated)));
}
return(true);
}
public async Task <List <Role_KnowledgeGroupDTO> > SingleListKnowledgeGroup([FromBody] Role_KnowledgeGroupFilterDTO Role_KnowledgeGroupFilterDTO)
{
if (!ModelState.IsValid)
{
throw new BindException(ModelState);
}
KnowledgeGroupFilter KnowledgeGroupFilter = new KnowledgeGroupFilter();
KnowledgeGroupFilter.Skip = 0;
KnowledgeGroupFilter.Take = 20;
KnowledgeGroupFilter.OrderBy = KnowledgeGroupOrder.Id;
KnowledgeGroupFilter.OrderType = OrderType.ASC;
KnowledgeGroupFilter.StatusId = new IdFilter {
Equal = StatusEnum.ACTIVE.Id
};
KnowledgeGroupFilter.Selects = KnowledgeGroupSelect.ALL;
KnowledgeGroupFilter.Id = Role_KnowledgeGroupFilterDTO.Id;
KnowledgeGroupFilter.Name = Role_KnowledgeGroupFilterDTO.Name;
KnowledgeGroupFilter.Code = Role_KnowledgeGroupFilterDTO.Code;
KnowledgeGroupFilter.DisplayOrder = Role_KnowledgeGroupFilterDTO.DisplayOrder;
KnowledgeGroupFilter.Description = Role_KnowledgeGroupFilterDTO.Description;
List <KnowledgeGroup> KnowledgeGroups = await KnowledgeGroupService.List(KnowledgeGroupFilter);
List <Role_KnowledgeGroupDTO> Role_KnowledgeGroupDTOs = KnowledgeGroups
.Select(x => new Role_KnowledgeGroupDTO(x)).ToList();
return(Role_KnowledgeGroupDTOs);
}
public async Task <int> Count(KnowledgeGroupFilter filter)
{
IQueryable <KnowledgeGroupDAO> KnowledgeGroups = DataContext.KnowledgeGroup.AsNoTracking();
KnowledgeGroups = DynamicFilter(KnowledgeGroups, filter);
return(await KnowledgeGroups.CountAsync());
}
public async Task <List <KnowledgeArticle_KnowledgeGroupDTO> > FilterListKnowledgeGroup([FromBody] KnowledgeArticle_KnowledgeGroupFilterDTO KnowledgeArticle_KnowledgeGroupFilterDTO)
{
if (!ModelState.IsValid)
{
throw new BindException(ModelState);
}
KnowledgeGroupFilter KnowledgeGroupFilter = new KnowledgeGroupFilter();
KnowledgeGroupFilter.Skip = 0;
KnowledgeGroupFilter.Take = 20;
KnowledgeGroupFilter.OrderBy = KnowledgeGroupOrder.Id;
KnowledgeGroupFilter.OrderType = OrderType.ASC;
KnowledgeGroupFilter.Selects = KnowledgeGroupSelect.ALL;
KnowledgeGroupFilter.Id = KnowledgeArticle_KnowledgeGroupFilterDTO.Id;
KnowledgeGroupFilter.Name = KnowledgeArticle_KnowledgeGroupFilterDTO.Name;
KnowledgeGroupFilter.Code = KnowledgeArticle_KnowledgeGroupFilterDTO.Code;
KnowledgeGroupFilter.StatusId = KnowledgeArticle_KnowledgeGroupFilterDTO.StatusId;
KnowledgeGroupFilter.DisplayOrder = KnowledgeArticle_KnowledgeGroupFilterDTO.DisplayOrder;
KnowledgeGroupFilter.Description = KnowledgeArticle_KnowledgeGroupFilterDTO.Description;
List <KnowledgeGroup> KnowledgeGroups = await KnowledgeGroupService.List(KnowledgeGroupFilter);
List <KnowledgeArticle_KnowledgeGroupDTO> KnowledgeArticle_KnowledgeGroupDTOs = KnowledgeGroups
.Select(x => new KnowledgeArticle_KnowledgeGroupDTO(x)).ToList();
return(KnowledgeArticle_KnowledgeGroupDTOs);
}
public async Task <List <KnowledgeGroup> > List(KnowledgeGroupFilter filter)
{
if (filter == null)
{
return(new List <KnowledgeGroup>());
}
IQueryable <KnowledgeGroupDAO> KnowledgeGroupDAOs = DataContext.KnowledgeGroup.AsNoTracking();
KnowledgeGroupDAOs = DynamicFilter(KnowledgeGroupDAOs, filter);
KnowledgeGroupDAOs = DynamicOrder(KnowledgeGroupDAOs, filter);
List <KnowledgeGroup> KnowledgeGroups = await DynamicSelect(KnowledgeGroupDAOs, filter);
return(KnowledgeGroups);
}
public KnowledgeGroupFilter ToFilter(KnowledgeGroupFilter filter)
{
if (filter.OrFilter == null)
{
filter.OrFilter = new List <KnowledgeGroupFilter>();
}
if (CurrentContext.Filters == null || CurrentContext.Filters.Count == 0)
{
return(filter);
}
foreach (var currentFilter in CurrentContext.Filters)
{
KnowledgeGroupFilter subFilter = new KnowledgeGroupFilter();
filter.OrFilter.Add(subFilter);
List <FilterPermissionDefinition> FilterPermissionDefinitions = currentFilter.Value;
foreach (FilterPermissionDefinition FilterPermissionDefinition in FilterPermissionDefinitions)
{
if (FilterPermissionDefinition.Name == nameof(subFilter.Id))
{
subFilter.Id = FilterPermissionDefinition.IdFilter;
}
if (FilterPermissionDefinition.Name == nameof(subFilter.Name))
{
subFilter.Name = FilterPermissionDefinition.StringFilter;
}
if (FilterPermissionDefinition.Name == nameof(subFilter.Code))
{
subFilter.Code = FilterPermissionDefinition.StringFilter;
}
if (FilterPermissionDefinition.Name == nameof(subFilter.StatusId))
{
subFilter.StatusId = FilterPermissionDefinition.IdFilter;
}
if (FilterPermissionDefinition.Name == nameof(subFilter.DisplayOrder))
{
subFilter.DisplayOrder = FilterPermissionDefinition.LongFilter;
}
if (FilterPermissionDefinition.Name == nameof(subFilter.Description))
{
subFilter.Description = FilterPermissionDefinition.StringFilter;
}
}
}
return(filter);
}
public async Task <ActionResult <int> > Count([FromBody] KnowledgeGroup_KnowledgeGroupFilterDTO KnowledgeGroup_KnowledgeGroupFilterDTO)
{
if (UnAuthorization)
{
return(Forbid());
}
if (!ModelState.IsValid)
{
throw new BindException(ModelState);
}
KnowledgeGroupFilter KnowledgeGroupFilter = ConvertFilterDTOToFilterEntity(KnowledgeGroup_KnowledgeGroupFilterDTO);
KnowledgeGroupFilter = KnowledgeGroupService.ToFilter(KnowledgeGroupFilter);
int count = await KnowledgeGroupService.Count(KnowledgeGroupFilter);
return(count);
}
private KnowledgeGroupFilter ConvertFilterDTOToFilterEntity(KnowledgeGroup_KnowledgeGroupFilterDTO KnowledgeGroup_KnowledgeGroupFilterDTO)
{
KnowledgeGroupFilter KnowledgeGroupFilter = new KnowledgeGroupFilter();
KnowledgeGroupFilter.Selects = KnowledgeGroupSelect.ALL;
KnowledgeGroupFilter.Skip = KnowledgeGroup_KnowledgeGroupFilterDTO.Skip;
KnowledgeGroupFilter.Take = KnowledgeGroup_KnowledgeGroupFilterDTO.Take;
KnowledgeGroupFilter.OrderBy = KnowledgeGroup_KnowledgeGroupFilterDTO.OrderBy;
KnowledgeGroupFilter.OrderType = KnowledgeGroup_KnowledgeGroupFilterDTO.OrderType;
KnowledgeGroupFilter.Id = KnowledgeGroup_KnowledgeGroupFilterDTO.Id;
KnowledgeGroupFilter.Name = KnowledgeGroup_KnowledgeGroupFilterDTO.Name;
KnowledgeGroupFilter.Code = KnowledgeGroup_KnowledgeGroupFilterDTO.Code;
KnowledgeGroupFilter.StatusId = KnowledgeGroup_KnowledgeGroupFilterDTO.StatusId;
KnowledgeGroupFilter.DisplayOrder = KnowledgeGroup_KnowledgeGroupFilterDTO.DisplayOrder;
KnowledgeGroupFilter.Description = KnowledgeGroup_KnowledgeGroupFilterDTO.Description;
KnowledgeGroupFilter.CreatedAt = KnowledgeGroup_KnowledgeGroupFilterDTO.CreatedAt;
KnowledgeGroupFilter.UpdatedAt = KnowledgeGroup_KnowledgeGroupFilterDTO.UpdatedAt;
return(KnowledgeGroupFilter);
}
public async Task <bool> ValidateId(KnowledgeGroup KnowledgeGroup)
{
KnowledgeGroupFilter KnowledgeGroupFilter = new KnowledgeGroupFilter
{
Skip = 0,
Take = 10,
Id = new IdFilter {
Equal = KnowledgeGroup.Id
},
Selects = KnowledgeGroupSelect.Id
};
int count = await UOW.KnowledgeGroupRepository.Count(KnowledgeGroupFilter);
if (count == 0)
{
KnowledgeGroup.AddError(nameof(KnowledgeGroupValidator), nameof(KnowledgeGroup.Id), ErrorCode.IdNotExisted);
}
return(count == 1);
}
public async Task <ActionResult <List <KnowledgeGroup_KnowledgeGroupDTO> > > List([FromBody] KnowledgeGroup_KnowledgeGroupFilterDTO KnowledgeGroup_KnowledgeGroupFilterDTO)
{
if (UnAuthorization)
{
return(Forbid());
}
if (!ModelState.IsValid)
{
throw new BindException(ModelState);
}
KnowledgeGroupFilter KnowledgeGroupFilter = ConvertFilterDTOToFilterEntity(KnowledgeGroup_KnowledgeGroupFilterDTO);
KnowledgeGroupFilter = KnowledgeGroupService.ToFilter(KnowledgeGroupFilter);
List <KnowledgeGroup> KnowledgeGroups = await KnowledgeGroupService.List(KnowledgeGroupFilter);
List <KnowledgeGroup_KnowledgeGroupDTO> KnowledgeGroup_KnowledgeGroupDTOs = KnowledgeGroups
.Select(c => new KnowledgeGroup_KnowledgeGroupDTO(c)).ToList();
return(KnowledgeGroup_KnowledgeGroupDTOs);
}
private async Task <bool> HasPermission(long Id)
{
KnowledgeGroupFilter KnowledgeGroupFilter = new KnowledgeGroupFilter();
KnowledgeGroupFilter = KnowledgeGroupService.ToFilter(KnowledgeGroupFilter);
if (Id == 0)
{
}
else
{
KnowledgeGroupFilter.Id = new IdFilter {
Equal = Id
};
int count = await KnowledgeGroupService.Count(KnowledgeGroupFilter);
if (count == 0)
{
return(false);
}
}
return(true);
}
public async Task <List <KnowledgeGroup> > List(KnowledgeGroupFilter KnowledgeGroupFilter)
{
try
{
List <KnowledgeGroup> KnowledgeGroups = await UOW.KnowledgeGroupRepository.List(KnowledgeGroupFilter);
return(KnowledgeGroups);
}
catch (Exception ex)
{
if (ex.InnerException == null)
{
await Logging.CreateSystemLog(ex, nameof(KnowledgeGroupService));
throw new MessageException(ex);
}
else
{
await Logging.CreateSystemLog(ex.InnerException, nameof(KnowledgeGroupService));
throw new MessageException(ex.InnerException);
}
}
}
public async Task <bool> ValidateCode(KnowledgeGroup KnowledgeGroup)
{
if (string.IsNullOrWhiteSpace(KnowledgeGroup.Code))
{
KnowledgeGroup.AddError(nameof(KnowledgeGroupValidator), nameof(KnowledgeGroup.Code), ErrorCode.CodeEmpty);
}
else
{
var Code = KnowledgeGroup.Code;
if (KnowledgeGroup.Code.Contains(" ") || !FilterExtension.ChangeToEnglishChar(Code).Equals(KnowledgeGroup.Code))
{
KnowledgeGroup.AddError(nameof(KnowledgeGroupValidator), nameof(KnowledgeGroup.Code), ErrorCode.CodeHasSpecialCharacter);
}
KnowledgeGroupFilter KnowledgeGroupFilter = new KnowledgeGroupFilter
{
Skip = 0,
Take = 10,
Id = new IdFilter {
NotEqual = KnowledgeGroup.Id
},
Code = new StringFilter {
Equal = KnowledgeGroup.Code
},
Selects = KnowledgeGroupSelect.Code
};
int count = await UOW.KnowledgeGroupRepository.Count(KnowledgeGroupFilter);
if (count != 0)
{
KnowledgeGroup.AddError(nameof(KnowledgeGroupValidator), nameof(KnowledgeGroup.Code), ErrorCode.CodeExisted);
}
}
return(KnowledgeGroup.IsValidated);
}
public async Task <int> Count(KnowledgeGroupFilter KnowledgeGroupFilter)
{
try
{
int result = await UOW.KnowledgeGroupRepository.Count(KnowledgeGroupFilter);
return(result);
}
catch (Exception ex)
{
if (ex.InnerException == null)
{
await Logging.CreateSystemLog(ex, nameof(KnowledgeGroupService));
throw new MessageException(ex);
}
else
{
await Logging.CreateSystemLog(ex.InnerException, nameof(KnowledgeGroupService));
throw new MessageException(ex.InnerException);
}
}
}
public async Task <ActionResult> ExportTemplate([FromBody] KnowledgeArticle_KnowledgeArticleFilterDTO KnowledgeArticle_KnowledgeArticleFilterDTO)
{
if (UnAuthorization)
{
return(Forbid());
}
if (!ModelState.IsValid)
{
throw new BindException(ModelState);
}
MemoryStream memoryStream = new MemoryStream();
using (ExcelPackage excel = new ExcelPackage(memoryStream))
{
#region KnowledgeArticle
var KnowledgeArticleHeaders = new List <string[]>()
{
new string[] {
"Id",
"Title",
"Detail",
"StatusId",
"GroupId",
"CreatorId",
"DisplayOrder",
}
};
List <object[]> KnowledgeArticleData = new List <object[]>();
excel.GenerateWorksheet("KnowledgeArticle", KnowledgeArticleHeaders, KnowledgeArticleData);
#endregion
#region AppUser
var AppUserFilter = new AppUserFilter();
AppUserFilter.Selects = AppUserSelect.ALL;
AppUserFilter.OrderBy = AppUserOrder.Id;
AppUserFilter.OrderType = OrderType.ASC;
AppUserFilter.Skip = 0;
AppUserFilter.Take = int.MaxValue;
List <AppUser> AppUsers = await AppUserService.List(AppUserFilter);
var AppUserHeaders = new List <string[]>()
{
new string[] {
"Id",
"Username",
"DisplayName",
"Address",
"Email",
"Phone",
"SexId",
"Birthday",
"Avatar",
"PositionId",
"Department",
"OrganizationId",
"ProvinceId",
"Longitude",
"Latitude",
"StatusId",
}
};
List <object[]> AppUserData = new List <object[]>();
for (int i = 0; i < AppUsers.Count; i++)
{
var AppUser = AppUsers[i];
AppUserData.Add(new Object[]
{
AppUser.Id,
AppUser.Username,
AppUser.DisplayName,
AppUser.Address,
AppUser.Email,
AppUser.Phone,
AppUser.SexId,
AppUser.Birthday,
AppUser.Avatar,
AppUser.PositionId,
AppUser.Department,
AppUser.OrganizationId,
AppUser.ProvinceId,
AppUser.Longitude,
AppUser.Latitude,
AppUser.StatusId,
});
}
excel.GenerateWorksheet("AppUser", AppUserHeaders, AppUserData);
#endregion
#region KnowledgeGroup
var KnowledgeGroupFilter = new KnowledgeGroupFilter();
KnowledgeGroupFilter.Selects = KnowledgeGroupSelect.ALL;
KnowledgeGroupFilter.OrderBy = KnowledgeGroupOrder.Id;
KnowledgeGroupFilter.OrderType = OrderType.ASC;
KnowledgeGroupFilter.Skip = 0;
KnowledgeGroupFilter.Take = int.MaxValue;
List <KnowledgeGroup> KnowledgeGroups = await KnowledgeGroupService.List(KnowledgeGroupFilter);
var KnowledgeGroupHeaders = new List <string[]>()
{
new string[] {
"Id",
"Name",
"Code",
"StatusId",
"DisplayOrder",
"Description",
}
};
List <object[]> KnowledgeGroupData = new List <object[]>();
for (int i = 0; i < KnowledgeGroups.Count; i++)
{
var KnowledgeGroup = KnowledgeGroups[i];
KnowledgeGroupData.Add(new Object[]
{
KnowledgeGroup.Id,
KnowledgeGroup.Name,
KnowledgeGroup.Code,
KnowledgeGroup.StatusId,
KnowledgeGroup.DisplayOrder,
KnowledgeGroup.Description,
});
}
excel.GenerateWorksheet("KnowledgeGroup", KnowledgeGroupHeaders, KnowledgeGroupData);
#endregion
#region Status
var StatusFilter = new StatusFilter();
StatusFilter.Selects = StatusSelect.ALL;
StatusFilter.OrderBy = StatusOrder.Id;
StatusFilter.OrderType = OrderType.ASC;
StatusFilter.Skip = 0;
StatusFilter.Take = int.MaxValue;
List <Status> Statuses = await StatusService.List(StatusFilter);
var StatusHeaders = new List <string[]>()
{
new string[] {
"Id",
"Code",
"Name",
}
};
List <object[]> StatusData = new List <object[]>();
for (int i = 0; i < Statuses.Count; i++)
{
var Status = Statuses[i];
StatusData.Add(new Object[]
{
Status.Id,
Status.Code,
Status.Name,
});
}
excel.GenerateWorksheet("Status", StatusHeaders, StatusData);
#endregion
excel.Save();
}
return(File(memoryStream.ToArray(), "application/octet-stream", "KnowledgeArticle.xlsx"));
}
public async Task <ActionResult> Import(IFormFile file)
{
if (UnAuthorization)
{
return(Forbid());
}
if (!ModelState.IsValid)
{
throw new BindException(ModelState);
}
AppUserFilter CreatorFilter = new AppUserFilter
{
Skip = 0,
Take = int.MaxValue,
Selects = AppUserSelect.ALL
};
List <AppUser> Creators = await AppUserService.List(CreatorFilter);
KnowledgeGroupFilter GroupFilter = new KnowledgeGroupFilter
{
Skip = 0,
Take = int.MaxValue,
Selects = KnowledgeGroupSelect.ALL
};
List <KnowledgeGroup> Groups = await KnowledgeGroupService.List(GroupFilter);
StatusFilter StatusFilter = new StatusFilter
{
Skip = 0,
Take = int.MaxValue,
Selects = StatusSelect.ALL
};
List <Status> Statuses = await StatusService.List(StatusFilter);
List <KnowledgeArticle> KnowledgeArticles = new List <KnowledgeArticle>();
using (ExcelPackage excelPackage = new ExcelPackage(file.OpenReadStream()))
{
ExcelWorksheet worksheet = excelPackage.Workbook.Worksheets.FirstOrDefault();
if (worksheet == null)
{
return(Ok(KnowledgeArticles));
}
int StartColumn = 1;
int StartRow = 1;
int IdColumn = 0 + StartColumn;
int TitleColumn = 1 + StartColumn;
int DetailColumn = 2 + StartColumn;
int StatusIdColumn = 3 + StartColumn;
int GroupIdColumn = 4 + StartColumn;
int CreatorIdColumn = 5 + StartColumn;
int DisplayOrderColumn = 6 + StartColumn;
for (int i = StartRow; i <= worksheet.Dimension.End.Row; i++)
{
if (string.IsNullOrEmpty(worksheet.Cells[i + StartRow, StartColumn].Value?.ToString()))
{
break;
}
string IdValue = worksheet.Cells[i + StartRow, IdColumn].Value?.ToString();
string TitleValue = worksheet.Cells[i + StartRow, TitleColumn].Value?.ToString();
string DetailValue = worksheet.Cells[i + StartRow, DetailColumn].Value?.ToString();
string StatusIdValue = worksheet.Cells[i + StartRow, StatusIdColumn].Value?.ToString();
string GroupIdValue = worksheet.Cells[i + StartRow, GroupIdColumn].Value?.ToString();
string CreatorIdValue = worksheet.Cells[i + StartRow, CreatorIdColumn].Value?.ToString();
string DisplayOrderValue = worksheet.Cells[i + StartRow, DisplayOrderColumn].Value?.ToString();
KnowledgeArticle KnowledgeArticle = new KnowledgeArticle();
KnowledgeArticle.Title = TitleValue;
KnowledgeArticle.Detail = DetailValue;
KnowledgeArticle.DisplayOrder = long.TryParse(DisplayOrderValue, out long DisplayOrder) ? DisplayOrder : 0;
AppUser Creator = Creators.Where(x => x.Id.ToString() == CreatorIdValue).FirstOrDefault();
KnowledgeArticle.CreatorId = Creator == null ? 0 : Creator.Id;
KnowledgeArticle.Creator = Creator;
KnowledgeGroup Group = Groups.Where(x => x.Id.ToString() == GroupIdValue).FirstOrDefault();
KnowledgeArticle.GroupId = Group == null ? 0 : Group.Id;
KnowledgeArticle.Group = Group;
Status Status = Statuses.Where(x => x.Id.ToString() == StatusIdValue).FirstOrDefault();
KnowledgeArticle.StatusId = Status == null ? 0 : Status.Id;
KnowledgeArticle.Status = Status;
KnowledgeArticles.Add(KnowledgeArticle);
}
}
KnowledgeArticles = await KnowledgeArticleService.Import(KnowledgeArticles);
if (KnowledgeArticles.All(x => x.IsValidated))
{
return(Ok(true));
}
else
{
List <string> Errors = new List <string>();
for (int i = 0; i < KnowledgeArticles.Count; i++)
{
KnowledgeArticle KnowledgeArticle = KnowledgeArticles[i];
if (!KnowledgeArticle.IsValidated)
{
string Error = $"Dòng {i + 2} có lỗi:";
if (KnowledgeArticle.Errors.ContainsKey(nameof(KnowledgeArticle.Id)))
{
Error += KnowledgeArticle.Errors[nameof(KnowledgeArticle.Id)];
}
if (KnowledgeArticle.Errors.ContainsKey(nameof(KnowledgeArticle.Title)))
{
Error += KnowledgeArticle.Errors[nameof(KnowledgeArticle.Title)];
}
if (KnowledgeArticle.Errors.ContainsKey(nameof(KnowledgeArticle.Detail)))
{
Error += KnowledgeArticle.Errors[nameof(KnowledgeArticle.Detail)];
}
if (KnowledgeArticle.Errors.ContainsKey(nameof(KnowledgeArticle.StatusId)))
{
Error += KnowledgeArticle.Errors[nameof(KnowledgeArticle.StatusId)];
}
if (KnowledgeArticle.Errors.ContainsKey(nameof(KnowledgeArticle.GroupId)))
{
Error += KnowledgeArticle.Errors[nameof(KnowledgeArticle.GroupId)];
}
if (KnowledgeArticle.Errors.ContainsKey(nameof(KnowledgeArticle.CreatorId)))
{
Error += KnowledgeArticle.Errors[nameof(KnowledgeArticle.CreatorId)];
}
if (KnowledgeArticle.Errors.ContainsKey(nameof(KnowledgeArticle.DisplayOrder)))
{
Error += KnowledgeArticle.Errors[nameof(KnowledgeArticle.DisplayOrder)];
}
Errors.Add(Error);
}
}
return(BadRequest(Errors));
}
}
private IQueryable <KnowledgeGroupDAO> DynamicOrder(IQueryable <KnowledgeGroupDAO> query, KnowledgeGroupFilter filter)
{
switch (filter.OrderType)
{
case OrderType.ASC:
switch (filter.OrderBy)
{
case KnowledgeGroupOrder.Id:
query = query.OrderBy(q => q.Id);
break;
case KnowledgeGroupOrder.Name:
query = query.OrderBy(q => q.Name);
break;
case KnowledgeGroupOrder.Code:
query = query.OrderBy(q => q.Code);
break;
case KnowledgeGroupOrder.Status:
query = query.OrderBy(q => q.StatusId);
break;
case KnowledgeGroupOrder.DisplayOrder:
query = query.OrderBy(q => q.DisplayOrder);
break;
case KnowledgeGroupOrder.Description:
query = query.OrderBy(q => q.Description);
break;
}
break;
case OrderType.DESC:
switch (filter.OrderBy)
{
case KnowledgeGroupOrder.Id:
query = query.OrderByDescending(q => q.Id);
break;
case KnowledgeGroupOrder.Name:
query = query.OrderByDescending(q => q.Name);
break;
case KnowledgeGroupOrder.Code:
query = query.OrderByDescending(q => q.Code);
break;
case KnowledgeGroupOrder.Status:
query = query.OrderByDescending(q => q.StatusId);
break;
case KnowledgeGroupOrder.DisplayOrder:
query = query.OrderByDescending(q => q.DisplayOrder);
break;
case KnowledgeGroupOrder.Description:
query = query.OrderByDescending(q => q.Description);
break;
}
break;
}
query = query.Skip(filter.Skip).Take(filter.Take);
return(query);
}
private IQueryable <KnowledgeGroupDAO> OrFilter(IQueryable <KnowledgeGroupDAO> query, KnowledgeGroupFilter filter)
{
if (filter.OrFilter == null || filter.OrFilter.Count == 0)
{
return(query);
}
IQueryable <KnowledgeGroupDAO> initQuery = query.Where(q => false);
foreach (KnowledgeGroupFilter KnowledgeGroupFilter in filter.OrFilter)
{
IQueryable <KnowledgeGroupDAO> queryable = query;
if (KnowledgeGroupFilter.Id != null)
{
queryable = queryable.Where(q => q.Id, KnowledgeGroupFilter.Id);
}
if (KnowledgeGroupFilter.Name != null)
{
queryable = queryable.Where(q => q.Name, KnowledgeGroupFilter.Name);
}
if (KnowledgeGroupFilter.Code != null)
{
queryable = queryable.Where(q => q.Code, KnowledgeGroupFilter.Code);
}
if (KnowledgeGroupFilter.StatusId != null)
{
queryable = queryable.Where(q => q.StatusId.HasValue).Where(q => q.StatusId, KnowledgeGroupFilter.StatusId);
}
if (KnowledgeGroupFilter.DisplayOrder != null)
{
queryable = queryable.Where(q => q.DisplayOrder.HasValue).Where(q => q.DisplayOrder, KnowledgeGroupFilter.DisplayOrder);
}
if (KnowledgeGroupFilter.Description != null)
{
queryable = queryable.Where(q => q.Description, KnowledgeGroupFilter.Description);
}
initQuery = initQuery.Union(queryable);
}
return(initQuery);
}
private IQueryable <KnowledgeGroupDAO> DynamicFilter(IQueryable <KnowledgeGroupDAO> query, KnowledgeGroupFilter 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.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.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 <KnowledgeGroup> > DynamicSelect(IQueryable <KnowledgeGroupDAO> query, KnowledgeGroupFilter filter)
{
List <KnowledgeGroup> KnowledgeGroups = await query.Select(q => new KnowledgeGroup()
{
Id = filter.Selects.Contains(KnowledgeGroupSelect.Id) ? q.Id : default(long),
Name = filter.Selects.Contains(KnowledgeGroupSelect.Name) ? q.Name : default(string),
Code = filter.Selects.Contains(KnowledgeGroupSelect.Code) ? q.Code : default(string),
StatusId = filter.Selects.Contains(KnowledgeGroupSelect.Status) ? q.StatusId : default(long?),
DisplayOrder = filter.Selects.Contains(KnowledgeGroupSelect.DisplayOrder) ? q.DisplayOrder : default(long?),
Description = filter.Selects.Contains(KnowledgeGroupSelect.Description) ? q.Description : default(string),
Status = filter.Selects.Contains(KnowledgeGroupSelect.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(KnowledgeGroups);
}
