public IQueryable <T> GetQueryableEntities <T>(object additionalQueryData) where T : class
{
var cast = (IQueryable <TEntity>)QueryableRepository.GetQueryableEntities <T>(additionalQueryData);
var result = Queryable.Where(cast, SatisfiedBy(additionalQueryData));
return((IQueryable <T>)result);
}
public virtual void InsertOrUpdate(TEntity entity)
{
ValidateBusinessRules(entity);
QueryableRepository.InsertOrUpdate(entity);
Repository.Commit();
}
public override IQueryable <T> GetQueryableEntities <T>(object additionalQueryData)
{
return(DynamicContains <T>(
QueryableRepository.GetQueryableEntities <T>(additionalQueryData),
PropertyInfo <TEntity> .GetMemberName(PropertyExpression),
Ids));
}
public override IQueryable <T> GetQueryableEntities <T>(object additionalQueryData)
{
var query = (IQueryable <T>)_GenericMethod.Invoke(null,
new object[] { QueryableRepository.GetQueryableEntities <T>(additionalQueryData) });
return(query);
}
public virtual IList <TEntity> GetAscending <TOrderby>(Expression <Func <TEntity, bool> > filter, Expression <Func <TEntity, TOrderby> > order, bool isNoTracking = false,
params Expression <Func <TEntity, object> >[] includeExpressions)
{
var result = QueryableRepository.GetAscending(filter, order, isNoTracking, includeExpressions);
return(result);
}
public virtual IPagedList <TEntity> GetPagedAscending <TOrderby>(Expression <Func <TEntity, TOrderby> > order, PageInfo pageinfo, bool isNoTracking = false,
params Expression <Func <TEntity, object> >[] includeExpressions)
{
var result = QueryableRepository.GetPagedAscending(order, pageinfo, isNoTracking,
includeExpressions);
return(result);
}
public virtual IPagedList <TEntity> GetPaged <TOrderby>(PageInfo pageInfo, Expression <Func <TEntity, bool> > filter = null, bool isDescending = false,
Expression <Func <TEntity, TOrderby> > order = null, bool isNoTracking = false, params Expression <Func <TEntity, object> >[] includeExpressions)
{
var result = QueryableRepository.GetPaged(pageInfo, filter, isDescending, order,
isNoTracking, includeExpressions);
return(result);
}
public override IQueryable <TEntity> GetQueryableEntities <TEntity>(object additionalQueryData)
{
var query = QueryableRepository.GetQueryableEntities <TEntity>(additionalQueryData);
foreach (var include in _Includes)
{
query = query.Include(include);
}
return(query);
}
public override IQueryable <T> GetQueryableEntities <T>(object additionalQueryData)
{
if (!typeof(ISoftDelete).IsAssignableFrom(typeof(T)))
{
throw new ContosoUniversityException("Only types derived from ISoftDelete can be used with this strategy: " + GetType().Name);
}
var query = QueryableRepository.GetQueryableEntities <T>(additionalQueryData);
var filteredQuery = ((IQueryable <ISoftDelete>)query).Where(p => !p.IsDeleted).Cast <T>();
return(filteredQuery);
}
public override IQueryable <TEntity> GetQueryableEntities <TEntity>(object additionalQueryData)
{
if (!_Properties.Any())
{
return(QueryableRepository.GetQueryableEntities <TEntity>(additionalQueryData));
}
var query = QueryableRepository.GetQueryableEntities <TEntity>(additionalQueryData);
for (int i = 1; i < _Properties.Count; i++)
{
query = ThenByDescending(query, _Properties[i]);
}
return(query);
}
public override IQueryable <T> GetQueryableEntities <T>(object additionalQueryData)
{
var query = QueryableRepository.GetQueryableEntities <T>(additionalQueryData);
if (_Includes != null)
{
foreach (var include in _Includes)
{
if (include != null)
{
query = query.Include(include);
}
}
}
return(query);
}
public override IQueryable <T> GetQueryableEntities <T>(object additionalQueryData)
{
Debug.Assert(QueryableRepository != null);
var query = default(IOrderedQueryable <T>);
foreach (var propName in PropertyNames)
{
if (query == null)
{
query = ThenByDescending(QueryableRepository.GetQueryableEntities <T>(additionalQueryData), propName);
}
else
{
query = ThenByDescending(query, propName);
}
}
return(query);
}
public override IQueryable <T> GetQueryableEntities <T>(object additionalQueryData)
{
var query = QueryableRepository.GetQueryableEntities <T>(additionalQueryData);
if (GetRowCount)
{
if (_isReentrent)
{
return(query);
}
_isReentrent = true;
query = (IQueryable <T>)QueryableRepository.GetQueryableEntities <T>(additionalQueryData).ToArray().AsQueryable();
RowCount = query.Count();
}
var skip = Page < 1 ? 0 : (Page - 1) * PageSize;
var filteredQuery = query.Skip(skip).Take(PageSize);
return(filteredQuery);
}
public override IQueryable <T> GetQueryableEntities <T>(object additionalQueryData)
{
if (!_Aggregates.Any())
{
return(QueryableRepository.GetQueryableEntities <T>(additionalQueryData));
}
if (!isReentrant)
{
_Aggregates.First().QueryableRepository = this;
for (int i = 1; i < _Aggregates.Count(); i++)
{
_Aggregates[i].QueryableRepository = _Aggregates[i - 1];
}
isReentrant = true;
return(_Aggregates.Last().GetQueryableEntities <T>(additionalQueryData));
}
// Reset to allow reuse,
isReentrant = false;
return(this.QueryableRepository.GetQueryableEntities <T>(additionalQueryData));
}
public virtual PagedList <TEntity> Get(IQueryOption <TEntity> queryOption, PageInfo pageInfo)
{
var result = QueryableRepository.Get(queryOption, pageInfo);
return(result);
}
public virtual TResult Query <TResult>(Func <IQueryable <TEntity>, TResult> resultTransformer, IQueryOption <TEntity> queryOption)
{
var result = QueryableRepository.Query(resultTransformer, queryOption);
return(result);
}
public virtual IList <TEntity> Get(IQueryOption <TEntity> queryOption)
{
var result = QueryableRepository.Get(queryOption);
return(result);
}
public virtual bool CheckExist(Expression <Func <TEntity, bool> > @where = null)
{
var result = QueryableRepository.CheckExist(@where);
return(result);
}
public override IQueryable <T> GetQueryableEntities <T>(object additionalQueryData)
{
return(QueryableRepository.GetQueryableEntities <T>(additionalQueryData));
}
public virtual List <LookupItemVo> GetLookup(LookupQuery query, Func <TEntity, LookupItemVo> selector)
{
var result = QueryableRepository.GetLookup(query, selector);
return(result);
}
public virtual void DeleteAll(Expression <Func <TEntity, bool> > @where = null)
{
QueryableRepository.DeleteAll(@where);
Repository.Commit();
}
public virtual void DeleteAll(IEnumerable <TEntity> entities)
{
QueryableRepository.DeleteAll(entities);
Repository.Commit();
}
public virtual IList <TEntity> ListAll()
{
var allEntities = QueryableRepository.ListAll();
return(allEntities);
}
public virtual List <TEntity> GetByPage(QueryInfo queryInfo, out int totalRowCount, Expression <Func <TEntity, bool> > filter = null, Expression <Func <TEntity, object> > orderBy = null)
{
var result = QueryableRepository.GetByPage(queryInfo, out totalRowCount, filter, orderBy);
return(result);
}
public virtual TEntity FirstOrDefault(Expression <Func <TEntity, bool> > predicate = null)
{
var result = QueryableRepository.FirstOrDefault(predicate);
return(result);
}
public virtual TEntity Single(Expression <Func <TEntity, bool> > predicate)
{
var entity = QueryableRepository.Single(predicate);
return(entity);
}
public virtual LookupItemVo GetLookupItem(LookupItem lookupItem, Func <TEntity, LookupItemVo> selector)
{
return(QueryableRepository.GetLookupItem(lookupItem, selector));
}
public virtual dynamic GetDataForGridMasterfile(IQueryInfo queryInfo)
{
var result = QueryableRepository.GetDataForGridMasterfile(queryInfo);
return(result);
}
public virtual List <int> DeleteById(IEnumerable <int> ids)
{
return(QueryableRepository.DeleteById(ids));
}
public virtual IList <TEntity> Get(Expression <Func <TEntity, bool> > predicate)
{
var result = QueryableRepository.Get(predicate);
return(result);
}
