Esempio n. 1
0
        // GET: Settings/Places
        public ActionResult Index(SearchCountryViewModel searchModel)
        {
            PagedEntity <CountryViewModel> result = _placesService.GetCountries(searchModel);

            searchModel.Items = new PagedList.StaticPagedList <CountryViewModel>(result.Items
                                                                                 , searchModel.PageIndex + 1, searchModel.PageSize, result.TotalCount);
            return(View(searchModel));
        }
Esempio n. 2
0
        public async Task <PagedEntity <IReadOnlyCollection <WarLog> > > GetWarLogAsync(string clanTag, int?limit = null,
                                                                                        string before             = null, string after = null)
        {
            if (string.IsNullOrWhiteSpace(clanTag))
            {
                throw new ArgumentNullException(clanTag);
            }

            if (limit < 0)
            {
                throw new ArgumentOutOfRangeException(nameof(limit));
            }

            clanTag = clanTag[0] == '#' ? clanTag.Replace("#", "%23") : clanTag;

            var sb = new StringBuilder();

            sb.Append($"/v1/clans/{clanTag}/warlog?");

            if (limit.HasValue)
            {
                sb.Append($"limit={limit.Value}&");
            }

            if (!string.IsNullOrWhiteSpace(before))
            {
                sb.Append($"before={before}&");
            }

            if (!string.IsNullOrWhiteSpace(after))
            {
                sb.Append($"after={after}&");
            }

            var model = await _request.SendAsync <PagedWarlogModel>(sb.ToString()).ConfigureAwait(false);

            if (model is null)
            {
                var empty = ReadOnlyCollection <WarLog> .EmptyCollection();

                return(new PagedEntity <IReadOnlyCollection <WarLog> >
                {
                    Entity = empty
                });
            }

            var collection = new ReadOnlyCollection <WarLog>(model.WarLogs.Select(x => new WarLog(x)),
                                                             () => model.WarLogs.First().TeamSize);

            var paged = new PagedEntity <IReadOnlyCollection <WarLog> >
            {
                After  = model.Paging.Cursors.After,
                Before = model.Paging.Cursors.Before,
                Entity = collection
            };

            return(paged);
        }
Esempio n. 3
0
        public async Task <PagedEntity <T> > GetAllPagedAsync(int page, int size, int filter, bool order, Expression <Func <T, bool> > predicate)
        {
            var pagedEntity = new PagedEntity <T>();
            var skipCount   = getSkipCount(page, size);
            var result      = _table.Where(predicate);

            pagedEntity.Count = await result.CountAsync();

            pagedEntity.Entities = await result.Skip(skipCount).Take(size).ToListAsync();

            return(pagedEntity);
        }
Esempio n. 4
0
        public PagedEntity <T2> GetPaged <T2>(int pageIndex, int pageSize, string orderBy, ICollection <Tuple <string, string, object> > parameters, string conditionKey = "and", string sqlNoValue = "")
        {
            var tableName = SqlMapperExtensions.GetTableName(typeof(T2));

            var baseSelectSql = $"select * from {tableName}";
            var countsql      = $"select count(1) from {tableName}  ";

            var sql = new StringBuilder();
            var dynamicParameters = new DynamicParameters();

            if (parameters != null)
            {
                for (var i = 0; i < parameters.Count; i++)
                {
                    var parameter     = parameters.ElementAt(i);
                    var parameterName = $"{parameter.Item1}";
                    if (i == 0)
                    {
                        sql.AppendFormat(" where {0} {1} @{2}", parameter.Item1, parameter.Item2, parameterName);
                    }
                    else
                    {
                        sql.AppendFormat(" {0} {1} {2} @{3}", conditionKey, parameter.Item1, parameter.Item2, parameterName);
                    }

                    dynamicParameters.Add(parameterName, parameter.Item3);
                }
            }

            if (!string.IsNullOrEmpty(sqlNoValue))
            {
                sql.Append(parameters != null && parameters.Count > 0 ? sqlNoValue : $" where 1=1 {sqlNoValue}");
            }

            var entities = new PagedEntity <T2> {
                Items = new List <T2>()
            };

            OpenSlaveConnection(conn =>
            {
                entities.TotalItems = conn.Query <int>($"{countsql}{sql.ToString()}", dynamicParameters).FirstOrDefault();
                if (entities.TotalItems == 0)
                {
                    return;
                }
                sql.AppendFormat(" order by {0} limit @pageIndex,@pageSize", orderBy);
                dynamicParameters.Add("pageIndex", pageIndex * pageSize);
                dynamicParameters.Add("pageSize", pageSize);
                entities.Items = conn.Query <T2>($"{baseSelectSql}{sql.ToString()}", dynamicParameters).ToList();
            });
            return(entities);
        }
Esempio n. 5
0
        public virtual PagedEntity <T2> GetPagedEntity <T2>(int pageIndex, int pageSize, string orderBy, ICollection <Tuple <string, string, object> > parameters)
        {
            var  baseSelectSql               = GetBaseSelectSqlForNoStatus(typeof(T2));
            var  tableName                   = SqlMapperExtensions.GetTableName(typeof(T2));
            var  allProperties               = SqlMapperExtensions.TypePropertiesCache(typeof(T2));
            var  computedProperties          = SqlMapperExtensions.ComputedPropertiesCache(typeof(T2));
            var  allPropertiesExceptComputed = allProperties.Except(computedProperties);
            bool status    = false;
            var  hasStatus = allPropertiesExceptComputed.FirstOrDefault(o => o.Name == "Status");

            if (hasStatus != null)
            {
                status = !SqlMapperExtensions.ExcludeStatus(hasStatus);
            }
            var countsql = string.Format("select count(1) from {0} where 1 = 1", tableName);

            var sql = new StringBuilder();
            var dynamicParameters = new DynamicParameters();

            if (parameters != null)
            {
                for (var i = 0; i < parameters.Count; i++)
                {
                    var parameter     = parameters.ElementAt(i);
                    var parameterName = string.Format("{0}{1}", parameter.Item1, i);
                    sql.AppendFormat(" and {0} {1} @{2}", parameter.Item1, parameter.Item2, parameterName);
                    dynamicParameters.Add(parameterName, parameter.Item3);
                }
            }

            if (status)
            {
                sql.Append(" and Status = 1");
            }

            var entities = new PagedEntity <T2>();

            entities.Items = new List <T2>();
            OpenSlaveConnection(conn =>
            {
                entities.TotalItems = conn.Query <int>(string.Format("{0}{1}", countsql, sql.ToString()), dynamicParameters).FirstOrDefault();
                if (entities.TotalItems == 0)
                {
                    return;
                }
                sql.AppendFormat(" order by {0} limit @pageIndex,@pageSize", orderBy);
                dynamicParameters.Add("pageIndex", pageIndex * pageSize);
                dynamicParameters.Add("pageSize", pageSize);
                entities.Items = conn.Query <T2>(string.Format("{0}{1}", baseSelectSql, sql.ToString()), dynamicParameters).ToList();
            });
            return(entities);
        }
Esempio n. 6
0
        public PagedEntity <ViewUserViewModel> SearchUser(SearchUsersViewModel searchUserModel)
        {
            if (searchUserModel == null)
            {
                throw new ArgumentNullException("searchUserModel");
            }

            PagedEntity <User> result = _securityUnitOfWork.UserRepository.SearchUsers(searchUserModel.UserName, searchUserModel.Email
                                                                                       , searchUserModel.FullName
                                                                                       , searchUserModel.PageIndex, searchUserModel.PageSize);

            return(new PagedEntity <ViewUserViewModel>(result.Items.Select(c => GetViewUserViewModel(c)), result.TotalCount));
        }
        public async Task <PagedEntity <T> > GetAllPagedAsync(int page, int size)
        {
            var skipCount   = GetSkipCount(page, size);
            var pagedEntity = new PagedEntity <T>();

            var result = _table.AsQueryable();

            pagedEntity.Count = await result.CountAsync();

            pagedEntity.Entities = await result.Skip(skipCount).Take(size).ToListAsync();

            return(pagedEntity);
        }
        public BaseDtoPaged(IMapper mapper, PagedEntity <W> entities, int page, int size)
        {
            this.Page  = page;
            this.Size  = size;
            this.Count = entities.Count;

            var entitiyList = new List <T> ();

            foreach (var e in entities.Entities)
            {
                entitiyList.Add(mapper.Map <W, T>(e));
            }

            this.Entities = entitiyList;
        }
Esempio n. 9
0
        // GET: Settings/Places
        public ActionResult Index(SearchCountryViewModel searchModel)
        {
            PagedEntity <CountryViewModel> result = _placesService.GetCountries(searchModel);
            var pagedList = new PagedList.StaticPagedList <CountryViewModel>(result.Items
                                                                             , searchModel.PageIndex + 1, searchModel.PageSize, result.TotalCount);

            if (pagedList.Count == 0 && pagedList.TotalItemCount > 0)
            {
                searchModel.PageIndex = pagedList.HasPreviousPage ?
                                        pagedList.PageNumber - 2 : 0;
                return(RedirectToAction("Index", searchModel));
            }

            searchModel.Items = pagedList;
            return(View(searchModel));
        }
Esempio n. 10
0
        public PagedEntity <T2> GetPagedEntity <T2>(int pageIndex, int pageSize, string orderBy, ICollection <Tuple <string, string, object> > parameters)
        {
            var entities   = new PagedEntity <T2>();
            var collection = MongoDataBase.GetCollection <T2>(DataBase);

            var queries = new List <IMongoQuery>();

            if (parameters != null)
            {
                foreach (var parameter in parameters)
                {
                    queries.Add(Query.EQ(parameter.Item1, BsonValue.Create(parameter.Item3)));
                }
            }
            MongoCursor <T2> cursor;

            if (queries.Count > 0)
            {
                cursor = collection.Find(Query.And(queries));
            }
            else
            {
                cursor = collection.FindAll();
            }
            IMongoSortBy sortBy;
            var          value = orderBy.Split(' ');

            if (value.Length == 2)
            {
                if (value[1] == "asc")
                {
                    sortBy = SortBy.Ascending(value[0]);
                }
                else
                {
                    sortBy = SortBy.Descending(value[0]);
                }
            }
            else
            {
                sortBy = SortBy.Descending(orderBy);
            }
            //CreateTime
            entities.Items      = cursor.SetSortOrder(sortBy).SetSkip(pageIndex * pageSize).SetLimit(pageSize).ToList();
            entities.TotalItems = (int)cursor.Count();
            return(entities);
        }
Esempio n. 11
0
        private FileDtoPaged GetFilesPaged(PagedEntity <File> pagedEntity, FileDtoPagedQuery fileQuery)
        {
            var result          = new FileDtoPaged();
            var entitiesDtoList = new List <FileDto>();
            var files           = pagedEntity.Entities;

            result.Size  = fileQuery.Size;
            result.Count = pagedEntity.Count;

            result.Page = fileQuery.Page;

            foreach (var file in files)
            {
                var fileDto = _mapper.Map <File, FileDto>(file);
                entitiesDtoList.Add(fileDto);
            }
            result.Entities = entitiesDtoList;

            return(result);
        }
        public async Task <PagedEntity <PostWithAuthor> > GetAllPagedPostsAsyncWithAuthor(int page, int size, int filter, bool order, Expression <Func <Post, bool> > predicate)
        {
            var skipCount   = GetSkipCount(page, size);
            var pagedEntity = new PagedEntity <PostWithAuthor>();

            var result = _table.Where(predicate);

            result = _postSortable.Sort(result, filter, order).Skip(skipCount).Take(size);

            var joinedResult = result.Include(post => post.Comments).Join(
                _context.Users,
                post => post.Blog.UserId,
                user => user.Id,
                (post, user) => new PostWithAuthor(post, user)
                );

            pagedEntity.Count = await result.CountAsync();

            var enitites = await joinedResult.ToListAsync();

            pagedEntity.Entities = enitites;
            return(pagedEntity);
        }
Esempio n. 13
0
        /// <summary>
        /// 分页查询
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public ResultWithCodeEntity <PagedEntity <TourUserListDTO> > PageList(TourUserRequest request)
        {
            var result = new PagedEntity <TourUserListDTO>()
            {
                Items = new List <TourUserListDTO>()
            };

            try
            {
                var pageResult = tourUserRepository.PageList(request);
                if (pageResult != null)
                {
                    result.TotalItems = pageResult.TotalItems;
                    result.Items      = Mapper.Map <List <TourUserListDTO> >(pageResult.Items);
                }

                return(Result.Success <PagedEntity <TourUserListDTO> >(result));
            }
            catch (Exception ex)
            {
                return(Result.Error <PagedEntity <TourUserListDTO> >(ResultCode.ExceptionError));
            }
        }
Esempio n. 14
0
        public async Task <PagedEntity <CaseViewModel> > GetCases(SearchCaseViewModel searchViewModel)
        {
            if (searchViewModel == null)
            {
                throw new ArgumentNullException(nameof(searchViewModel));
            }

            var caseSearch = new CaseSearch
            {
                CaseName   = searchViewModel.CaseName,
                CaseStatus = (Sanable.Cases.Domain.Model.CaseStatus)searchViewModel.CaseStatus,
                CaseType   = (Sanable.Cases.Domain.Model.CaseTypes)searchViewModel.CaseType,
                CityId     = searchViewModel.CityId,
                CountryId  = searchViewModel.CountryId,
                DistrictId = searchViewModel.DistrictId,
                Phone      = searchViewModel.Phone,
            };

            PagedEntity <Case> result = await _caseUnitOfWork.CaseRepository
                                        .SearchCases(caseSearch
                                                     , searchViewModel.PageIndex, searchViewModel.PageSize);

            return(new PagedEntity <CaseViewModel>(result.Items.Select(c => GetCaseViewModel(c)), result.TotalCount));
        }
Esempio n. 15
0
        public PagedEntity <Question> GetAll(int page = 1, int pageSize = 10)
        {
            if (pageSize < 1)
            {
                pageSize = 10;
            }

            if (page < 1)
            {
                page = 1;
            }

            var totalRecords = repository.Get().Count();
            var pagedEntity  = new PagedEntity <Question>()
            {
                TotalRecords = totalRecords,
                CurrentPage  = page,
                TotalPages   = Convert.ToInt32(Math.Ceiling((double)totalRecords / pageSize)),
                PageSize     = pageSize,
                PagedData    = repository.Get(page: page, pageSize: pageSize).ToList()
            };

            return(pagedEntity);
        }
 public PostDtoPagedWithAuthor(IMapper mapper, PagedEntity <PostWithAuthor> entities, int page, int size)
     : base(mapper, entities, page, size)
 {
 }
 public BlogDtoPaged(IMapper mapper, PagedEntity <BlogEntity> entities, int page, int size) : base(mapper, entities, page, size)
 {
 }
 public PostDtoPaged(IMapper mapper, PagedEntity <Post> entities, int page, int size) : base(mapper, entities, page, size)
 {
 }