/// <summary>
        /// Get Object List
        /// </summary>
        /// <param name="query">query model</param>
        /// <returns>object list</returns>
        public sealed override async Task <List <DT> > GetListAsync(IQuery query)
        {
            var datas = await GetDataListAsync(query).ConfigureAwait(false);

            QueryCallback(query, true, datas);
            RepositoryEventBus.PublishQuery <DT>(GetType(), datas, result =>
            {
                QueryEventResult <DT> queryResult = result as QueryEventResult <DT>;
                if (queryResult != null)
                {
                    datas = queryResult.Datas;
                }
            });
            return(datas ?? new List <DT>(0));
        }
Example #2
0
        /// <summary>
        /// Get data list
        /// </summary>
        /// <param name="query">Query object</param>
        /// <returns>Return data list</returns>
        public sealed override async Task <List <TModel> > GetListAsync(IQuery query)
        {
            var newQuery = RepositoryManager.HandleQueryObjectBeforeExecute(query, QueryUsageScene.Query, AppendQueryCondition);
            var datas    = await GetDataListAsync(newQuery).ConfigureAwait(false);

            QueryCallback(newQuery, true, datas);
            RepositoryEventBus.PublishQuery(GetType(), datas, newQuery, result =>
            {
                QueryEventResult <TModel> queryResult = result as QueryEventResult <TModel>;
                if (queryResult != null)
                {
                    datas = queryResult.Datas;
                }
            });
            RepositoryManager.HandleQueryObjectAfterExecute(query, newQuery, QueryUsageScene.Query);
            return(datas ?? new List <TModel>(0));
        }
        /// <summary>
        /// Get Object Paging
        /// </summary>
        /// <param name="query">query model</param>
        /// <returns>object paging</returns>
        public sealed override async Task <IPaging <DT> > GetPagingAsync(IQuery query)
        {
            var paging = await GetDataPagingAsync(query).ConfigureAwait(false);

            IEnumerable <DT> datas = paging;

            QueryCallback(query, true, datas);
            RepositoryEventBus.PublishQuery <DT>(GetType(), datas, result =>
            {
                QueryEventResult <DT> queryResult = result as QueryEventResult <DT>;
                if (queryResult != null)
                {
                    datas = queryResult.Datas;
                }
            });
            return(new Paging <DT>(paging.Page, paging.PageSize, paging.TotalCount, datas));
        }
Example #4
0
        /// <summary>
        /// Get data paging
        /// </summary>
        /// <param name="query">Query object</param>
        /// <returns>Return data paging</returns>
        public sealed override async Task <IPaging <TModel> > GetPagingAsync(IQuery query)
        {
            var newQuery = RepositoryManager.HandleQueryObjectBeforeExecute(query, QueryUsageScene.Query, AppendQueryCondition);
            var paging   = await GetDataPagingAsync(newQuery).ConfigureAwait(false);

            IEnumerable <TModel> datas = paging;

            QueryCallback(newQuery, true, datas);
            RepositoryEventBus.PublishQuery(GetType(), datas, newQuery, result =>
            {
                QueryEventResult <TModel> queryResult = result as QueryEventResult <TModel>;
                if (queryResult != null)
                {
                    datas = queryResult.Datas;
                }
            });
            RepositoryManager.HandleQueryObjectAfterExecute(query, newQuery, QueryUsageScene.Query);
            return(Pager.Create(paging.Page, paging.PageSize, paging.TotalCount, datas));
        }
        /// <summary>
        /// Get Object
        /// </summary>
        /// <param name="query">query model</param>
        /// <returns>Object</returns>
        public sealed override async Task <DT> GetAsync(IQuery query)
        {
            var data = await GetDataAsync(query).ConfigureAwait(false);

            var dataList = new List <DT>()
            {
                data
            };

            QueryCallback(query, false, dataList);
            RepositoryEventBus.PublishQuery <DT>(GetType(), dataList, result =>
            {
                QueryEventResult <DT> queryResult = result as QueryEventResult <DT>;
                if (queryResult != null)
                {
                    dataList = queryResult.Datas;
                }
            });
            return(dataList.IsNullOrEmpty() ? default(DT) : dataList.FirstOrDefault());
        }
Example #6
0
        /// <summary>
        /// Get data
        /// </summary>
        /// <param name="query">Query object</param>
        /// <returns>Return data</returns>
        public sealed override async Task <TModel> GetAsync(IQuery query)
        {
            var newQuery = RepositoryManager.HandleQueryObjectBeforeExecute(query, QueryUsageScene.Query, AppendQueryCondition);
            var data     = await GetDataAsync(newQuery).ConfigureAwait(false);

            var dataList = new List <TModel>(1)
            {
                data
            };

            QueryCallback(newQuery, false, dataList);
            RepositoryEventBus.PublishQuery(GetType(), dataList, newQuery, result =>
            {
                QueryEventResult <TModel> queryResult = result as QueryEventResult <TModel>;
                if (queryResult != null)
                {
                    dataList = queryResult.Datas;
                }
            });
            RepositoryManager.HandleQueryObjectAfterExecute(query, newQuery, QueryUsageScene.Query);

            return(dataList.IsNullOrEmpty() ? default : dataList.FirstOrDefault());
        }