/// <summary>
/// Finds the entity by its prefix
/// </summary>
/// <typeparam name="T">The type of the entity</typeparam>
/// <param name="baseFilterDto">The filtering DTO to make the where part</param>
/// <param name="selector">The selector for select the attributes</param>
/// <returns>The list of the referencedDto for the appropriate search DTO</returns>
internal List <ReferenceDto> FindByPrefix <T>(BaseFilterDto baseFilterDto, Expression <Func <T, ReferenceDto> > selector) where T : BaseEntity
{
return(_modelContext.Set <T>()
.Where(ExpressionBuilder.BuildWhere <T>(baseFilterDto))
.Select(selector)
.ToList());
}
/// <summary>
/// Finds paged users.
/// </summary>
/// <param name="userFilterDto">The filtering DTO</param>
/// <returns>The User DTO page</returns>
internal IPagedList <RoleDto> FindPaged(BaseFilterDto baseFilterDto)
{
return(_modelContext.Set <Role>()
.OrderBy(x => x.Name)
.Select(x => new RoleDto()
{
Id = x.Id, Name = x.Name, CreateUpdateDeleteAll = x.CreateUpdateDeleteAll, DojoCreation = x.DojoCreation, MenuCreation = x.MenuCreation, RoleCreation = x.RoleCreation, UserCreation = x.UserCreation
})
.ToPagedList(baseFilterDto.Page, baseFilterDto.PageSize));
}
protected BaseListOrder(IQueryable <TEntity> query, BaseFilterDto dto,
string defaultSortColumn = "CreatedAt", SortType defaultSortType = SortType.Desc)
{
Query = query;
_defaultSortColumn = defaultSortColumn;
_defaultSortType = defaultSortType;
SortColumn = SetSortColumn(dto?.SortColumn ?? _defaultSortColumn);
SortType = SetSortType(dto?.SortType ?? _defaultSortType.ToString());
}
public Result ExecuteAction(BaseFilterDto dto)
{
var result = new Result().SetSuccess();
switch (dto.Action.NullSafeToLower())
{
case "delete": return(new AdminRoleDeleteAction(_adminRoleRepository, _unitOfWork).ExecuteAction(dto.Ids));
}
return(result);
}
public IPagedList <CollectionDto> FindPaged(BaseFilterDto baseFilterDto)
{
return(_modelContext.Set <Collection>()
.Where(ExpressionBuilder.BuildWhere <Collection>(baseFilterDto))
.OrderBy(x => x.Name)
.Select(x => new CollectionDto()
{
Id = x.Id,
Name = x.Name
})
.ToPagedList(baseFilterDto.Page, baseFilterDto.PageSize));
}
/// <summary>
/// Builds the where statement.
/// </summary>
/// <typeparam name="T">The Entity type</typeparam>
/// <param name="baseFilterDto">The filtering DTO</param>
/// <returns>The where statement</returns>
public static Expression <Func <T, bool> > BuildWhere <T>(BaseFilterDto baseFilterDto) where T : IBaseEntity
{
ParameterExpression parameterExpression = Expression.Parameter(typeof(T), EXPRESSION_PARAMETER);
List <Expression> whereParts = new List <Expression>();
foreach (IGrouping <string, PropertyInfo> searchPropertyGroup in GetGroupedSearchedPropertiesInfo(baseFilterDto))
{
List <Expression> expressionGroupedOrWhereParts = new List <Expression>();
List <Expression> expressionGroupedAndWhereParts = new List <Expression>();
foreach (PropertyInfo searchPropertyInfo in searchPropertyGroup)
{
FilterAttribute searchAttribute = (FilterAttribute)searchPropertyInfo.GetCustomAttribute(typeof(FilterAttribute));
object value = searchPropertyInfo.GetValue(baseFilterDto);
Expression expressionWherePart = null;
//if (value is bool && searchAttribute.EnumAttribute != null)
//{
// if ((bool)value == true)
// {
// expressionWherePart = BuildWherePart<T>(parameterExpression, searchAttribute, searchAttribute.EnumAttribute);
// if (expressionWherePart != null)
// {
// expressionGroupedOrWhereParts.Add(expressionWherePart);
// }
// }
//}
//else
{
expressionWherePart = BuildWherePart <T>(parameterExpression, searchAttribute, value);
if (expressionWherePart != null)
{
expressionGroupedAndWhereParts.Add(expressionWherePart);
}
}
}
Expression finalGroupedOrWhereParts = JoinOrWhereParts(expressionGroupedOrWhereParts);
Expression finalGroupedAndWhereParts = JoinAndWhereParts(expressionGroupedAndWhereParts);
if (finalGroupedOrWhereParts != null)
{
whereParts.Add(finalGroupedOrWhereParts);
}
if (finalGroupedAndWhereParts != null)
{
whereParts.Add(finalGroupedAndWhereParts);
}
}
if (whereParts.Count == 0)
{
return(x => true);
}
return(Expression.Lambda <Func <T, bool> >(JoinAndWhereParts(whereParts), parameterExpression));
}
internal ListReferenceDto FindAllReferences(BaseFilterDto baseFilterDto)
{
Dictionary <Guid, string> references = _modelContext.Set <Role>()
.Where(ExpressionQueryBuilder.BuildWhere <Role>(baseFilterDto))
.OrderBy(x => x.Name)
.Select(x => new { Id = x.Id, Name = x.Name })
.ToDictionary(x => x.Id, x => x.Name);
return(new ListReferenceDto()
{
References = references
});
}
/// <summary>
/// Get filtered entities
/// </summary>
/// <param name="filter"></param>
/// <returns></returns>
public virtual async Task <IEnumerable <TModel> > GetFiltered(BaseFilterDto filter)
{
var result = new SqlQueryAndBinds()
{
SqlQuery = GetBaseSelectQuery(),
Binds = new ExpandoObject()
};
result = ApplyFilter(result, filter);
result = ApplySort(result, filter.Sort);
result = ApplyPaging(result, filter.Paging);
using IDbConnection db = new NpgsqlConnection(ConnectionString);
return(await db.QueryAsync <TModel>(result.SqlQuery, (object)result.Binds));
}
public Result ExecuteAction(BaseFilterDto dto, int loggedInUserId)
{
var result = new Result().SetSuccess();
if (string.IsNullOrEmpty(dto?.Action))
{
return(new Result());
}
switch (dto.Action.NullSafeToLower())
{
case "active": return(new AdminUserActiveAction(_adminUserRepository, _unitOfWork).ExecuteAction(dto.Ids));
case "inactive": return(new AdminUserInactiveAction(_adminUserRepository, _unitOfWork).ExecuteAction(dto.Ids, loggedInUserId));
case "delete": return(new AdminUserDeleteAction(_adminUserRepository, _unitOfWork).ExecuteAction(dto.Ids, loggedInUserId));
}
return(result);
}
public static async Task <T> ApiCall <T>(string uri, BaseFilterDto filter = null)
{
var uriBuilder = new UriBuilder(uri);
if (filter != null)
{
uriBuilder.Query = filter.ParseQuery();
}
try
{
T result;
HttpResponseMessage httpResponse = await client.GetAsync(uriBuilder.Uri);
httpResponse.EnsureSuccessStatusCode();
result = JsonConvert.DeserializeObject <T>(httpResponse.Content.ToString());
return(result);
}
catch (Exception)
{
throw;
}
}
public static Expression <Func <T, bool> > BuildWhere <T>(BaseFilterDto baseFilterDto) where T : IBaseEntity
{
Parameter parameter = new Parameter(typeof(T));
List <Expression> whereParts = new List <Expression>();
foreach (IGrouping <string, PropertyInfo> groupedfilterProperties in GetFilterProperties(baseFilterDto))
{
List <Expression> expressionGroupedAndWhereParts = new List <Expression>();
List <Expression> expressionGroupedOrWhereParts = new List <Expression>();
foreach (PropertyInfo propertyInfo in groupedfilterProperties)
{
FilterAttribute filterAttribute = propertyInfo.GetCustomAttribute <FilterAttribute>();
object value = propertyInfo.GetValue(baseFilterDto);
Expression wherePartExpression = BuildWherePart <T>(parameter, filterAttribute, value);
if (wherePartExpression != null)
{
expressionGroupedAndWhereParts.Add(wherePartExpression);
}
}
Expression finalGroupedOrWhereParts = JoinOrWhereParts(expressionGroupedOrWhereParts);
Expression finalGroupedAndWhereParts = JoinAndWhereParts(expressionGroupedAndWhereParts);
if (finalGroupedOrWhereParts != null)
{
whereParts.Add(finalGroupedOrWhereParts);
}
if (finalGroupedAndWhereParts != null)
{
whereParts.Add(finalGroupedAndWhereParts);
}
}
if (whereParts.Count == 0)
{
return(x => true);
}
return(Expression.Lambda <Func <T, bool> >(JoinAndWhereParts(whereParts), parameter.GetExpression()));
}
public ContactUsInquiryAdminListOrder(IQueryable <ContactUsInquiry> query, BaseFilterDto dto) : base(query, dto)
{
}
/// <summary>
/// Gets the grouped searched properties by target property.
/// </summary>
/// <param name="baseFilterDto">The base filtering DTO</param>
/// <returns>The grouped searched properties</returns>
private static IEnumerable <IGrouping <string, PropertyInfo> > GetGroupedSearchedPropertiesInfo(BaseFilterDto baseFilterDto)
{
return(baseFilterDto.GetType().GetProperties()
.Where(x => x.GetCustomAttributes(typeof(FilterAttribute), true).Length > 0)
.GroupBy(x => ((FilterAttribute)x.GetCustomAttribute(typeof(FilterAttribute))).TargetProperty));
}
public AdminRoleListOrder(IQueryable <AdminRole> query, BaseFilterDto dto) : base(query, dto)
{
}
public ActionResult List(BaseFilterDto baseFilterDto)
{
return(PartialView(GetService().GetMenuItems(null)));
}
public AdminUserListOrder(IQueryable <AdminUser> query, BaseFilterDto dto) : base(query, dto)
{
}
public IPagedList <CollectionDto> ReadAdministrationPaged(BaseFilterDto baseFilterDto)
{
return(_collectionDao.FindPaged(baseFilterDto));
}
public QuizCategoryAdminListOrder(IQueryable <QuizCategory> query, BaseFilterDto dto) : base(query, dto)
{
}
public async Task <List <int> > GetBranchesForFilter(UserBranchesDto userBranchesDto, BaseFilterDto baseFilterDto = null)
{
var userBranches = _mapper.Map <UserBranches>(userBranchesDto);
BaseFilter baseFilter = new BaseFilter();
if (baseFilterDto != null)
{
baseFilter = _mapper.Map <BaseFilter>(baseFilterDto);
}
return(await _branchService.GetBranchesForFiltersAsync(userBranches, baseFilter));
}
// private readonly IPaymentTransactionRepository _paymentTransactionRepository;
public MemberDetailListOrder(IQueryable <Member> query, BaseFilterDto dto) : base(query, dto)
{
}
public MemberResultListOrder(IQueryable <MemberResult> query, BaseFilterDto dto) : base(query, dto)
{
}
public ActionResult PagedList(BaseFilterDto baseFilterDto)
{
ViewBag.FilterDto = baseFilterDto;
return(PartialView(WebConstants.VIEW_PAGED_LIST, GetService().ReadAdministrationPaged(baseFilterDto)));
}
public ActionResult GetAllRoleReferences(BaseFilterDto baseFilterDto)
{
return(Json(GetService().GetAllReferences(baseFilterDto).References.ToList()));
}
public ListReferenceDto GetAllReferences(BaseFilterDto baseFilterDto)
{
return(_roleDao.FindAllReferences(baseFilterDto));
}
public IPagedList <RoleDto> ReadAdministrationPaged(BaseFilterDto baseFilterDto)
{
return(_roleDao.FindPaged(baseFilterDto));
}
private static IEnumerable <IGrouping <string, PropertyInfo> > GetFilterProperties(BaseFilterDto baseFilterDto)
{
return(baseFilterDto.GetType().GetProperties()
.Where(x => Attribute.IsDefined(x, typeof(FilterAttribute)))
.GroupBy(x => x.GetCustomAttribute <FilterAttribute>().TargetProperty));
}
public QuizAnswerAdminListOrder(IQueryable <QuizAnswer> query, BaseFilterDto dto) : base(query, dto)
{
}
public ListReferenceDto GetAllReferences(BaseFilterDto baseFilterDto)
{
return(_collectionDao.FindAllReferences(baseFilterDto));
}
public QuizQuestionAdminListOrder(IQueryable <QuizQuestion> query, BaseFilterDto dto) : base(query, dto)
{
}
public SeoPageAdminListOrder(IQueryable <SeoPage> query, BaseFilterDto dto) : base(query, dto)
{
}
