public async Task <int> Count(KpiGeneralContentFilter filter)
{
IQueryable <KpiGeneralContentDAO> KpiGeneralContents = DataContext.KpiGeneralContent.AsNoTracking();
KpiGeneralContents = DynamicFilter(KpiGeneralContents, filter);
return(await KpiGeneralContents.CountAsync());
}
public async Task <List <KpiGeneralContent> > List(KpiGeneralContentFilter filter)
{
if (filter == null)
{
return(new List <KpiGeneralContent>());
}
IQueryable <KpiGeneralContentDAO> KpiGeneralContentDAOs = DataContext.KpiGeneralContent.AsNoTracking();
KpiGeneralContentDAOs = DynamicFilter(KpiGeneralContentDAOs, filter);
KpiGeneralContentDAOs = DynamicOrder(KpiGeneralContentDAOs, filter);
List <KpiGeneralContent> KpiGeneralContents = await DynamicSelect(KpiGeneralContentDAOs, filter);
return(KpiGeneralContents);
}
public async Task <KpiGeneralContentFilter> ToFilter(KpiGeneralContentFilter filter)
{
if (filter.OrFilter == null)
{
filter.OrFilter = new List <KpiGeneralContentFilter>();
}
if (CurrentContext.Filters == null || CurrentContext.Filters.Count == 0)
{
return(filter);
}
foreach (var currentFilter in CurrentContext.Filters)
{
KpiGeneralContentFilter subFilter = new KpiGeneralContentFilter();
filter.OrFilter.Add(subFilter);
List <FilterPermissionDefinition> FilterPermissionDefinitions = currentFilter.Value;
foreach (FilterPermissionDefinition FilterPermissionDefinition in FilterPermissionDefinitions)
{
if (FilterPermissionDefinition.Name == nameof(subFilter.Id))
{
subFilter.Id = FilterBuilder.Merge(subFilter.Id, FilterPermissionDefinition.IdFilter);
}
if (FilterPermissionDefinition.Name == nameof(subFilter.KpiGeneralId))
{
subFilter.KpiGeneralId = FilterBuilder.Merge(subFilter.KpiGeneralId, FilterPermissionDefinition.IdFilter);
}
if (FilterPermissionDefinition.Name == nameof(subFilter.KpiCriteriaGeneralId))
{
subFilter.KpiCriteriaGeneralId = FilterBuilder.Merge(subFilter.KpiCriteriaGeneralId, FilterPermissionDefinition.IdFilter);
}
if (FilterPermissionDefinition.Name == nameof(subFilter.StatusId))
{
subFilter.StatusId = FilterBuilder.Merge(subFilter.StatusId, FilterPermissionDefinition.IdFilter);
}
if (FilterPermissionDefinition.Name == nameof(CurrentContext.UserId) && FilterPermissionDefinition.IdFilter != null)
{
if (FilterPermissionDefinition.IdFilter.Equal.HasValue && FilterPermissionDefinition.IdFilter.Equal.Value == CurrentUserEnum.IS.Id)
{
}
if (FilterPermissionDefinition.IdFilter.Equal.HasValue && FilterPermissionDefinition.IdFilter.Equal.Value == CurrentUserEnum.ISNT.Id)
{
}
}
}
}
return(filter);
}
public async Task <bool> ValidateId(KpiGeneralContent KpiGeneralContent)
{
KpiGeneralContentFilter KpiGeneralContentFilter = new KpiGeneralContentFilter
{
Skip = 0,
Take = 10,
Id = new IdFilter {
Equal = KpiGeneralContent.Id
},
Selects = KpiGeneralContentSelect.Id
};
int count = await UOW.KpiGeneralContentRepository.Count(KpiGeneralContentFilter);
if (count == 0)
{
KpiGeneralContent.AddError(nameof(KpiGeneralContentValidator), nameof(KpiGeneralContent.Id), ErrorCode.IdNotExisted);
}
return(count == 1);
}
public async Task <List <KpiGeneralContent> > List(KpiGeneralContentFilter KpiGeneralContentFilter)
{
try
{
List <KpiGeneralContent> KpiGeneralContents = await UOW.KpiGeneralContentRepository.List(KpiGeneralContentFilter);
return(KpiGeneralContents);
}
catch (Exception ex)
{
if (ex.InnerException == null)
{
await Logging.CreateSystemLog(ex, nameof(KpiGeneralContentService));
throw new MessageException(ex);
}
else
{
await Logging.CreateSystemLog(ex.InnerException, nameof(KpiGeneralContentService));
throw new MessageException(ex.InnerException);
}
}
}
private IQueryable <KpiGeneralContentDAO> DynamicOrder(IQueryable <KpiGeneralContentDAO> query, KpiGeneralContentFilter filter)
{
switch (filter.OrderType)
{
case OrderType.ASC:
switch (filter.OrderBy)
{
case KpiGeneralContentOrder.Id:
query = query.OrderBy(q => q.Id);
break;
case KpiGeneralContentOrder.KpiGeneral:
query = query.OrderBy(q => q.KpiGeneralId);
break;
case KpiGeneralContentOrder.KpiCriteriaGeneral:
query = query.OrderBy(q => q.KpiCriteriaGeneralId);
break;
case KpiGeneralContentOrder.Status:
query = query.OrderBy(q => q.StatusId);
break;
}
break;
case OrderType.DESC:
switch (filter.OrderBy)
{
case KpiGeneralContentOrder.Id:
query = query.OrderByDescending(q => q.Id);
break;
case KpiGeneralContentOrder.KpiGeneral:
query = query.OrderByDescending(q => q.KpiGeneralId);
break;
case KpiGeneralContentOrder.KpiCriteriaGeneral:
query = query.OrderByDescending(q => q.KpiCriteriaGeneralId);
break;
case KpiGeneralContentOrder.Status:
query = query.OrderByDescending(q => q.StatusId);
break;
}
break;
}
query = query.Skip(filter.Skip).Take(filter.Take);
return(query);
}
private IQueryable <KpiGeneralContentDAO> OrFilter(IQueryable <KpiGeneralContentDAO> query, KpiGeneralContentFilter filter)
{
if (filter.OrFilter == null || filter.OrFilter.Count == 0)
{
return(query);
}
IQueryable <KpiGeneralContentDAO> initQuery = query.Where(q => false);
foreach (KpiGeneralContentFilter KpiGeneralContentFilter in filter.OrFilter)
{
IQueryable <KpiGeneralContentDAO> queryable = query;
if (KpiGeneralContentFilter.Id != null)
{
queryable = queryable.Where(q => q.Id, KpiGeneralContentFilter.Id);
}
if (KpiGeneralContentFilter.KpiGeneralId != null)
{
queryable = queryable.Where(q => q.KpiGeneralId, KpiGeneralContentFilter.KpiGeneralId);
}
if (KpiGeneralContentFilter.KpiCriteriaGeneralId != null)
{
queryable = queryable.Where(q => q.KpiCriteriaGeneralId, KpiGeneralContentFilter.KpiCriteriaGeneralId);
}
if (KpiGeneralContentFilter.StatusId != null)
{
queryable = queryable.Where(q => q.StatusId, KpiGeneralContentFilter.StatusId);
}
initQuery = initQuery.Union(queryable);
}
return(initQuery);
}
private IQueryable <KpiGeneralContentDAO> DynamicFilter(IQueryable <KpiGeneralContentDAO> query, KpiGeneralContentFilter filter)
{
if (filter == null)
{
return(query.Where(q => false));
}
if (filter.Id != null)
{
query = query.Where(q => q.Id, filter.Id);
}
if (filter.KpiGeneralId != null)
{
query = query.Where(q => q.KpiGeneralId, filter.KpiGeneralId);
}
if (filter.KpiCriteriaGeneralId != null)
{
query = query.Where(q => q.KpiCriteriaGeneralId, filter.KpiCriteriaGeneralId);
}
if (filter.StatusId != null)
{
query = query.Where(q => q.StatusId, filter.StatusId);
}
query = OrFilter(query, filter);
return(query);
}
private async Task <List <KpiGeneralContent> > DynamicSelect(IQueryable <KpiGeneralContentDAO> query, KpiGeneralContentFilter filter)
{
List <KpiGeneralContent> KpiGeneralContents = await query.Select(q => new KpiGeneralContent()
{
Id = filter.Selects.Contains(KpiGeneralContentSelect.Id) ? q.Id : default(long),
KpiGeneralId = filter.Selects.Contains(KpiGeneralContentSelect.KpiGeneral) ? q.KpiGeneralId : default(long),
KpiCriteriaGeneralId = filter.Selects.Contains(KpiGeneralContentSelect.KpiCriteriaGeneral) ? q.KpiCriteriaGeneralId : default(long),
StatusId = filter.Selects.Contains(KpiGeneralContentSelect.Status) ? q.StatusId : default(long),
KpiCriteriaGeneral = filter.Selects.Contains(KpiGeneralContentSelect.KpiCriteriaGeneral) && q.KpiCriteriaGeneral != null ? new KpiCriteriaGeneral
{
Id = q.KpiCriteriaGeneral.Id,
Code = q.KpiCriteriaGeneral.Code,
Name = q.KpiCriteriaGeneral.Name,
} : null,
KpiGeneral = filter.Selects.Contains(KpiGeneralContentSelect.KpiGeneral) && q.KpiGeneral != null ? new KpiGeneral
{
Id = q.KpiGeneral.Id,
OrganizationId = q.KpiGeneral.OrganizationId,
EmployeeId = q.KpiGeneral.EmployeeId,
KpiYearId = q.KpiGeneral.KpiYearId,
StatusId = q.KpiGeneral.StatusId,
CreatorId = q.KpiGeneral.CreatorId,
} : null,
Status = filter.Selects.Contains(KpiGeneralContentSelect.Status) && q.Status != null ? new Status
{
Id = q.Status.Id,
Code = q.Status.Code,
Name = q.Status.Name,
} : null,
}).ToListAsync();
var KpiGeneralContentIds = KpiGeneralContents.Select(x => x.Id).ToList();
List <KpiGeneralContentKpiPeriodMapping> KpiGeneralContentKpiPeriodMappings = await DataContext.KpiGeneralContentKpiPeriodMapping
.Where(x => KpiGeneralContentIds.Contains(x.KpiGeneralContentId))
.Select(x => new KpiGeneralContentKpiPeriodMapping
{
KpiGeneralContentId = x.KpiGeneralContentId,
KpiPeriodId = x.KpiPeriodId,
Value = x.Value,
KpiGeneralContent = x.KpiGeneralContent == null ? null : new KpiGeneralContent
{
Id = x.KpiGeneralContent.Id,
KpiCriteriaGeneralId = x.KpiGeneralContent.KpiCriteriaGeneralId,
}
}).ToListAsync();
foreach (KpiGeneralContent KpiGeneralContent in KpiGeneralContents)
{
KpiGeneralContent.KpiGeneralContentKpiPeriodMappings = KpiGeneralContentKpiPeriodMappings.Where(x => x.KpiGeneralContentId == KpiGeneralContent.Id).ToList();
}
return(KpiGeneralContents);
}
