public override TEntity Single(Expression <Func <TEntity, bool> > predicate)
        {
            IPredicate pg = DapperQueryFilterExecuter.ExecuteFilter <TEntity, TPrimaryKey>(predicate);

            return(GetConnection().GetList <TEntity>(pg, transaction: GetActiveTransaction(), commandTimeout: Timeout)
                   .Single());
        }
        public override IEnumerable <TEntity> GetAll(Expression <Func <TEntity, bool> > predicate)
        {
            IPredicate filteredPredicate = DapperQueryFilterExecuter.ExecuteFilter <TEntity, TPrimaryKey>(predicate);

            return(GetConnection().GetList <TEntity>(filteredPredicate, transaction: GetActiveTransaction(),
                                                     commandTimeout: Timeout));
        }
        public override IEnumerable <TEntity> GetAll()
        {
            PredicateGroup predicateGroup = DapperQueryFilterExecuter.ExecuteFilter <TEntity, TPrimaryKey>();

            return(GetConnection().GetList <TEntity>(predicateGroup, transaction: GetActiveTransaction(),
                                                     commandTimeout: Timeout));
        }
        public override IEnumerable <TEntity> GetSet(Expression <Func <TEntity, bool> > predicate, int firstResult,
                                                     int maxResults, bool ascending = true, params Expression <Func <TEntity, object> >[] sortingExpression)
        {
            IPredicate filteredPredicate = DapperQueryFilterExecuter.ExecuteFilter <TEntity, TPrimaryKey>(predicate);

            return(GetConnection().GetSet <TEntity>(filteredPredicate, sortingExpression.ToSortable(ascending),
                                                    firstResult, maxResults, GetActiveTransaction(), Timeout));
        }
        public override IEnumerable <TEntity> GetAllPaged(Expression <Func <TEntity, bool> > predicate, int pageNumber,
                                                          int itemsPerPage, bool ascending = true, params Expression <Func <TEntity, object> >[] sortingExpression)
        {
            IPredicate filteredPredicate = DapperQueryFilterExecuter.ExecuteFilter <TEntity, TPrimaryKey>(predicate);

            return(GetConnection().GetPage <TEntity>(filteredPredicate, sortingExpression.ToSortable(ascending),
                                                     pageNumber, itemsPerPage, GetActiveTransaction(), Timeout));
        }
        public override IEnumerable <TEntity> GetAllPaged(Expression <Func <TEntity, bool> > predicate, int pageNumber, int itemsPerPage, string sortingProperty, bool ascending = true)
        {
            IPredicate filteredPredicate = DapperQueryFilterExecuter.ExecuteFilter <TEntity, TPrimaryKey>(predicate);

            return(Connection.GetPage <TEntity>(
                       filteredPredicate,
                       new List <ISort> {
                new Sort {
                    Ascending = ascending, PropertyName = sortingProperty
                }
            },
                       pageNumber,
                       itemsPerPage,
                       ActiveTransaction));
        }
        public override IEnumerable <TEntity> GetSet(Expression <Func <TEntity, bool> > predicate, int firstResult, int maxResults, string sortingProperty, bool ascending = true)
        {
            IPredicate filteredPredicate = DapperQueryFilterExecuter.ExecuteFilter <TEntity, TPrimaryKey>(predicate);

            return(Connection.GetSet <TEntity>(
                       filteredPredicate,
                       new List <ISort> {
                new Sort {
                    Ascending = ascending, PropertyName = sortingProperty
                }
            },
                       firstResult,
                       maxResults,
                       ActiveTransaction
                       ));
        }
        public override TEntity FirstOrDefault(Expression <Func <TEntity, bool> > predicate)
        {
            IPredicate pg = DapperQueryFilterExecuter.ExecuteFilter <TEntity, TPrimaryKey>(predicate);

            return(Connection.GetList <TEntity>(pg, transaction: ActiveTransaction).FirstOrDefault());
        }
        public override int Count(Expression <Func <TEntity, bool> > predicate)
        {
            IPredicate filteredPredicate = DapperQueryFilterExecuter.ExecuteFilter <TEntity, TPrimaryKey>(predicate);

            return(Connection.Count <TEntity>(filteredPredicate, ActiveTransaction));
        }
        public override IEnumerable <TEntity> GetAll()
        {
            PredicateGroup predicateGroup = DapperQueryFilterExecuter.ExecuteFilter <TEntity, TPrimaryKey>();

            return(Connection.GetList <TEntity>(predicateGroup, transaction: ActiveTransaction));
        }
コード例 #11
0
        public IEnumerable <TEntity> GetAll(Expression <Func <TEntity, bool> > predicate)
        {
            IPredicate pg = DapperQueryFilterExecuter.ExecuteFilter <TEntity, TPrimaryKey>(predicate);

            return(Connection.GetList <TEntity>(pg, transaction: ActiveTransaction));
        }
コード例 #12
0
 public RepositoryBase(IActiveTransactionProvider provider)
 {
     _activeTransactionProvider = provider;
     DapperQueryFilterExecuter  = new DapperQueryFilterExecuter();
     DapperActionFilterExecuter = new DapperActionFilterExecuter();
 }
コード例 #13
0
        public IEnumerable <TEntity> GetSet(System.Linq.Expressions.Expression <Func <TEntity, bool> > predicate, int firstResult, int maxResults, bool ascending = true, params System.Linq.Expressions.Expression <Func <TEntity, object> >[] sortingExpression)
        {
            IPredicate filteredPredicate = DapperQueryFilterExecuter.ExecuteFilter <TEntity, TPrimaryKey>(predicate);

            return(Connection.GetSet <TEntity>(filteredPredicate, sortingExpression.ToSortable(ascending), firstResult, maxResults, ActiveTransaction));
        }
コード例 #14
0
        public override Task <IEnumerable <TEntity> > GetAllAsync(Expression <Func <TEntity, bool> > predicate)
        {
            IPredicate filteredPredicate = DapperQueryFilterExecuter.ExecuteFilter <TEntity, TPrimaryKey>(predicate);

            return(Connection.GetListAsync <TEntity>(filteredPredicate, transaction: ActiveTransaction));
        }