public ListWorkflowInstancesRequest(int page, int pageSize = 50, string?workflowDefinitionId = default, WorkflowStatus?workflowStatus = default, OrderBy?orderBy = default, string?searchTerm = default)
{
Page = page;
PageSize = pageSize;
WorkflowDefinitionId = workflowDefinitionId;
WorkflowStatus = workflowStatus;
OrderBy = orderBy;
SearchTerm = searchTerm;
}
private async Task <ContentResponse> SubBrowseApiAsync(string id, ContentSource source, BrowseItemType browseType, ExtraDetails extra, OrderBy?orderBy = null, int?maxItems = null, int?page = null, string language = null, string country = null, string continuationToken = null)
{
Dictionary <string, string> requestParameters = await FormatRequestParametersAsync(continuationToken, language, country);
if (orderBy.HasValue)
{
requestParameters.Add("orderby", orderBy.ToString());
}
if (maxItems.HasValue)
{
requestParameters.Add("maxitems", maxItems.ToString());
}
if (page.HasValue)
{
requestParameters.Add("page", page.ToString());
}
return(await GetWithRetryOnExpiredTokenAsync <ContentResponse>(
"/1/content/" + id + "/" + source + "/" + browseType + "/" + extra + "/browse",
new CancellationToken(false), requestParameters));
}
private IEnumerable <CompletedEvent> GetOrderedCompletedEvents(IEnumerable <CompletedEvent> completedEvents, OrderBy?orderBy, OrderDirection?orderDirection)
{
switch (orderBy)
{
case OrderBy.PatientName:
return(GetOrderedCompletedEventsByDirection(completedEvents, orderDirection, e => e.Period.Pathway.Patient.Name));
case OrderBy.EventDescription:
return(GetOrderedCompletedEventsByDirection(completedEvents, orderDirection, e => e.Name.Description));
case OrderBy.Specialty:
return(GetOrderedCompletedEventsByDirection(completedEvents, orderDirection, e => e.Clinician.Specialty.Name));
case OrderBy.Clinician:
return(GetOrderedCompletedEventsByDirection(completedEvents, orderDirection, e => e.Clinician.Name));
case OrderBy.DaysInPeriod:
return(GetOrderedCompletedEventsByDirection(completedEvents, orderDirection, e => e.Period.GetDaysSpentAt(_clock.Today)));
case OrderBy.DaysRemainingInPeriod:
return(GetOrderedCompletedEventsByDirection(completedEvents, orderDirection, e => e.Period.GetDaysRemainingAt(_clock.Today)));
}
return(completedEvents.ToArray());
}
public async Task <ActionResult> Archieve([Range(2010, 2099)] int yyyy, [Range(1, 12)] int mm, [Range(1, 31)] int dd, [Optional] OrderBy?orderBy, int page = 1, [Range(1, 50, ErrorMessage = "页大小必须在0到50之间")] int size = 15, string mode = nameof(Models.Entity.Post.ModifyDate))
{
page = Math.Max(1, page);
if (!DateTime.TryParse(yyyy + "-" + mm + "-" + dd, out var date))
{
date = DateTime.Today;
}
var where = PostBaseWhere().And(p => p.Status == Status.Published);
where = mode switch
{
nameof(Models.Entity.Post.PostDate) => where.And(p => p.PostDate.Date == date),
_ => where.And(p => p.ModifyDate.Date == date),
};
var queryable = PostService.GetQuery(where);
var h24 = DateTime.Today.AddDays(-1);
var posts = orderBy switch
{
OrderBy.Trending => await queryable.OrderByDescending(p => p.PostVisitRecordStats.Where(e => e.Date >= h24).Sum(e => e.Count)).ToCachedPagedListAsync <Post, PostDto>(page, size, MapperConfig),
_ => await queryable.OrderBy($"{nameof(PostDto.IsFixedTop)} desc,{(orderBy ?? OrderBy.ModifyDate).GetDisplay()} desc").ToCachedPagedListAsync <Post, PostDto>(page, size, MapperConfig)
};
var viewModel = await GetIndexPageViewModel();
viewModel.Posts = posts;
viewModel.PageParams = new Pagination(page, size, posts.TotalCount, orderBy);
viewModel.SidebarAds = AdsService.GetsByWeightedPrice(2, AdvertiseType.SideBar, Request.Location());
viewModel.ListAdvertisement = AdsService.GetByWeightedPrice(AdvertiseType.ListItem, Request.Location());
PostService.SolvePostsCategory(posts.Data);
foreach (var item in posts.Data)
{
item.ModifyDate = item.ModifyDate.ToTimeZone(HttpContext.Session.Get <string>(SessionKey.TimeZone));
}
return(View(viewModel));
}
public async Task <XCommasResponse <SmartTrade[]> > GetSmartTradesAsync(int?accountId = null, string pair = null, SmartTradeType?type = null, SmartTradeStatus?status = null, OrderBy?orderBy = null, OrderDirection?orderDirection = null, int?page = null, int?perPage = null)
{
var param = new Dictionary <string, string>();
if (accountId.HasValue)
{
param.Add("accountId", accountId.Value.ToString());
}
AddIfHasValue(param, "pair", pair);
AddIfHasValue(param, "type", type?.GetEnumMemberAttrValue());
AddIfHasValue(param, "status", status?.GetEnumMemberAttrValue());
AddIfHasValue(param, "order_by", orderBy?.GetEnumMemberAttrValue());
AddIfHasValue(param, "order_direction", orderDirection?.GetEnumMemberAttrValue());
AddIfHasValue(param, "page", page.ToString());
AddIfHasValue(param, "per_page", perPage.ToString());
var qString = BuildQueryString(param);
var path = $"{BaseAddress}/v2/smart_trades{qString}";
using (var request = XCommasRequest.Get(path).Force(UserMode).Sign(this))
{
return(await this.GetResponse <SmartTrade[]>(request).ConfigureAwait(false));
}
}
/// <summary>
/// Gets products by an artist.
/// </summary>
/// <param name="id">The artist id.</param>
/// <param name="category">The category.</param>
/// <param name="orderBy">The field to sort the items by.</param>
/// <param name="sortOrder">The sort order of the items to fetch.</param>
/// <param name="startIndex">The zero-based start index to fetch items from (e.g. to get the second page of 10 items, pass in 10).</param>
/// <param name="itemsPerPage">The number of items to fetch.</param>
/// <returns>
/// A ListResponse containing Products or an Error
/// </returns>
public Task <ListResponse <Product> > GetArtistProductsAsync(string id, Category?category = null, OrderBy?orderBy = null, SortOrder?sortOrder = null, int startIndex = MusicClient.DefaultStartIndex, int itemsPerPage = MusicClient.DefaultItemsPerPage)
{
var cmd = this.CreateCommand <ArtistProductsCommand>();
cmd.ArtistId = id;
cmd.Category = category;
cmd.OrderBy = orderBy;
cmd.SortOrder = sortOrder;
cmd.StartIndex = startIndex;
cmd.ItemsPerPage = itemsPerPage;
return(cmd.InvokeAsync());
}
/// <summary>
/// Searches Nokia Music
/// </summary>
/// <param name="searchTerm">Optional search term.</param>
/// <param name="category">Optional category.</param>
/// <param name="genreId">Optional genre id</param>
/// <param name="orderBy">The field to sort the items by.</param>
/// <param name="sortOrder">The sort order of the items to fetch.</param>
/// <param name="startIndex">The zero-based start index to fetch items from (e.g. to get the second page of 10 items, pass in 10).</param>
/// <param name="itemsPerPage">The number of items to fetch.</param>
/// <param name="requestId">Id of the request.</param>
/// <remarks>A searchTerm or genreId should be supplied</remarks>
/// <returns>A ListResponse containing MusicItems or an Error</returns>
public Task <ListResponse <MusicItem> > SearchAsync(string searchTerm = null, Category?category = null, string genreId = null, OrderBy?orderBy = null, SortOrder?sortOrder = null, int startIndex = MusicClient.DefaultStartIndex, int itemsPerPage = MusicClient.DefaultItemsPerPage, Guid?requestId = null)
{
var cmd = this.CreateCommand <SearchCommand>();
cmd.SearchTerm = searchTerm;
cmd.Category = category;
cmd.GenreId = genreId;
cmd.OrderBy = orderBy;
cmd.SortOrder = sortOrder;
cmd.StartIndex = startIndex;
cmd.ItemsPerPage = itemsPerPage;
this.SetRequestId(cmd, requestId);
return(cmd.InvokeAsync());
}
public static ServiceProviderGridVm GetServiceProviderGridVm(int?pageNumber, int?pageSize, ServiceProviderGridSortByOption?sortBy, OrderBy?orderBy, ServiceProviderGridFilter filter)
{
ServiceProviderGridVm serviceProviderGrid = new ServiceProviderGridVm();
int totalCount;
List <ServiceProvider> serviceProviders = ServiceProviderBc.Instance.GetAll(pageNumber, pageSize, sortBy, orderBy, filter, out totalCount);
serviceProviderGrid.List = serviceProviders.MapToServiceProviderForGridVmList();
if (pageNumber.HasValue)
{
serviceProviderGrid.PageNumber = pageNumber.Value;
}
if (pageSize.HasValue)
{
serviceProviderGrid.PageSize = pageSize.Value;
}
serviceProviderGrid.SortBy = sortBy;
serviceProviderGrid.OrderBy = orderBy;
serviceProviderGrid.TotalCount = totalCount;
serviceProviderGrid.GridUrl = MSLivingChoices.Mvc.Uipc.Legacy.MslcUrlBuilder.GetRouteUrl("iList", new
{
Controller = "ServiceProvider",
Action = "Grid"
});
serviceProviderGrid.JsonGridUrl = MSLivingChoices.Mvc.Uipc.Legacy.MslcUrlBuilder.GetRouteUrl("iList", new
{
Controller = "ServiceProvider",
Action = "JsonGrid"
});
serviceProviderGrid.ChangePackageTypeUrl = MSLivingChoices.Mvc.Uipc.Legacy.MslcUrlBuilder.GetRouteUrl("iList", new
{
Controller = "ServiceProvider",
Action = "ChangePackageType"
});
serviceProviderGrid.ChangeSeniorHousingAndCareCategoriesUrl = MSLivingChoices.Mvc.Uipc.Legacy.MslcUrlBuilder.GetRouteUrl("iList", new
{
Controller = "ServiceProvider",
Action = "ChangeSeniorHousingAndCareCategories"
});
serviceProviderGrid.ChangeFeatureDatesUrl = MSLivingChoices.Mvc.Uipc.Legacy.MslcUrlBuilder.GetRouteUrl("iList", new
{
Controller = "ServiceProvider",
Action = "ChangeFeatureDates"
});
serviceProviderGrid.ChangePublishDatesUrl = MSLivingChoices.Mvc.Uipc.Legacy.MslcUrlBuilder.GetRouteUrl("iList", new
{
Controller = "ServiceProvider",
Action = "ChangePublishDates"
});
serviceProviderGrid.Filter = filter.MapToFilterForServiceProviderGridVm();
return(serviceProviderGrid);
}
/// <summary>
/// Gets products by an artist.
/// </summary>
/// <param name="id">The artist id.</param>
/// <param name="category">The category.</param>
/// <param name="orderBy">The field to sort the items by.</param>
/// <param name="sortOrder">The sort order of the items.</param>
/// <param name="startIndex">The zero-based start index to fetch items from (e.g. to get the second page of 10 items, pass in 10).</param>
/// <param name="itemsPerPage">The number of items to fetch.</param>
/// <param name="cancellationToken">The cancellation token to cancel operation</param>
/// <returns>
/// A ListResponse containing Products or an Error
/// </returns>
public async Task <ListResponse <Product> > GetArtistProductsAsync(string id, Category?category = null, OrderBy?orderBy = null, SortOrder?sortOrder = null, int startIndex = MusicClient.DefaultStartIndex, int itemsPerPage = MusicClient.DefaultItemsPerPage, CancellationToken?cancellationToken = null)
{
var cmd = this.CreateCommand <ArtistProductsCommand>();
cmd.ArtistId = id;
cmd.Category = category;
cmd.OrderBy = orderBy;
cmd.SortOrder = sortOrder;
cmd.StartIndex = startIndex;
cmd.ItemsPerPage = itemsPerPage;
return(await cmd.ExecuteAsync(cancellationToken).ConfigureAwait(false));
}
public static CommunityForGridVm GetLastCommunityForGrid(int?pageNumber, int?pageSize, CommunityGridSortByOption?sortBy, OrderBy?orderBy, CommunityGridFilter filter)
{
int totalCount;
return(CommunityBc.Instance.GetAll(pageNumber * pageSize, 1, sortBy, orderBy, filter, out totalCount).FirstOrDefault().MapToCommunityForGridVm());
}
public static CommunityGridVm GetCommunityGridVm(int?pageNumber, int?pageSize, CommunityGridSortByOption?sortBy, OrderBy?orderBy, CommunityGridFilter filter)
{
CommunityGridVm communityGrid = new CommunityGridVm();
communityGrid.IsAdmin = true;
int totalCount;
List <Community> communities = CommunityBc.Instance.GetAll(pageNumber, pageSize, sortBy, orderBy, filter, out totalCount);
communityGrid.List = communities.MapToCommunityForGridVmList();
if (pageNumber.HasValue)
{
communityGrid.PageNumber = pageNumber.Value;
}
if (pageSize.HasValue)
{
communityGrid.PageSize = pageSize.Value;
}
communityGrid.TotalCount = totalCount;
communityGrid.SortBy = sortBy;
communityGrid.OrderBy = orderBy;
communityGrid.GridUrl = MSLivingChoices.Mvc.Uipc.Legacy.MslcUrlBuilder.GetRouteUrl("iList", new
{
Controller = "Community",
Action = "Grid"
});
communityGrid.JsonGridUrl = MSLivingChoices.Mvc.Uipc.Legacy.MslcUrlBuilder.GetRouteUrl("iList", new
{
Controller = "Community",
Action = "JsonGrid"
});
communityGrid.ChangeListingTypeStateUrl = MSLivingChoices.Mvc.Uipc.Legacy.MslcUrlBuilder.GetRouteUrl("iList", new
{
Controller = "Community",
Action = "ChangeListingTypeState"
});
communityGrid.ChangePackageTypeUrl = MSLivingChoices.Mvc.Uipc.Legacy.MslcUrlBuilder.GetRouteUrl("iList", new
{
Controller = "Community",
Action = "ChangePackageType"
});
communityGrid.ChangeSeniorHousingAndCareCategoriesUrl = MSLivingChoices.Mvc.Uipc.Legacy.MslcUrlBuilder.GetRouteUrl("iList", new
{
Controller = "Community",
Action = "ChangeSeniorHousingAndCareCategories"
});
communityGrid.ChangeShowcaseDatesUrl = MSLivingChoices.Mvc.Uipc.Legacy.MslcUrlBuilder.GetRouteUrl("iList", new
{
Controller = "Community",
Action = "ChangeShowcaseDates"
});
communityGrid.ChangePublishDatesUrl = MSLivingChoices.Mvc.Uipc.Legacy.MslcUrlBuilder.GetRouteUrl("iList", new
{
Controller = "Community",
Action = "ChangePublishDates"
});
communityGrid.DeleteCommunityUrl = MSLivingChoices.Mvc.Uipc.Legacy.MslcUrlBuilder.GetRouteUrl("iList", new
{
Controller = "Community",
Action = "Delete"
});
communityGrid.Filter = filter.MapToFilterForCommunityGridVm();
return(communityGrid);
}
public List <Community> GetAll(List <Book> books, int?pageNumber, int?pageSize, CommunityGridSortByOption?sortBy, OrderBy?orderBy, CommunityGridFilter filter, out int totalCount)
{
pageNumber = pageNumber ?? ConfigurationManager.Instance.DefaultGridPageNumber;
pageSize = pageSize ?? ConfigurationManager.Instance.DefaultGridPageSize;
GetCommunityGridCommand command = new GetCommunityGridCommand(books, pageNumber.Value, pageSize.Value, sortBy, orderBy, filter);
command.Execute();
totalCount = command.GetTotalCount();
return(command.CommandResult);
}
public GetCommunityGridCommand(List <Book> books, int pageNumber, int pageSize, CommunityGridSortByOption?sortBy, OrderBy?orderBy, CommunityGridFilter filter)
{
base.StoredProcedureName = AdminStoredProcedures.SpGetCommunityGridWithPaging;
this._books = books;
this._pageNumber = pageNumber;
this._pageSize = pageSize;
this._sortBy = sortBy;
this._orderBy = orderBy;
this._filter = filter;
}
private async Task <ContentResponse> BrowseApiAsync(
MediaNamespace mediaNamespace,
ContentSource source,
ItemType type,
string genre = null,
string mood = null,
string activity = null,
OrderBy?orderBy = null,
int?maxItems = null,
int?page = null,
string country = null,
string language = null,
string continuationToken = null)
{
Dictionary <string, string> requestParameters = await FormatRequestParametersAsync(continuationToken, language, country);
if (genre != null)
{
requestParameters.Add("genre", genre);
}
if (mood != null)
{
requestParameters.Add("mood", genre);
}
if (activity != null)
{
requestParameters.Add("activity", genre);
}
if (orderBy.HasValue)
{
requestParameters.Add("orderby", orderBy.ToString());
}
if (maxItems.HasValue)
{
requestParameters.Add("maxitems", maxItems.ToString());
}
if (page.HasValue)
{
requestParameters.Add("page", page.ToString());
}
if (_userTokenManager?.UserIsSignedIn == true)
{
return(await ApiCallWithUserAuthorizationHeaderRefreshAsync(
headers => GetAsync <ContentResponse>(
Hostname,
$"/1/content/{mediaNamespace}/{source}/{type}/browse",
new CancellationToken(false),
requestParameters,
headers)));
}
else
{
Dictionary <string, string> requestHeaders = await FormatRequestHeadersAsync(null);
return(await GetAsync <ContentResponse>(
Hostname,
$"/1/content/{mediaNamespace}/{source}/{type}/browse",
new CancellationToken(false),
requestParameters,
requestHeaders));
}
}
/// <summary>
/// Sort the result by the <paramref name="column"/> in descending order.
/// </summary>
/// <param name="column">The column name.</param>
/// <returns>The <see cref="ThenOrderByBuilder"/>.</returns>
public ThenOrderByBuilder ByDescending(string column)
{
OrderBy = new OrderBy(Table, column, SortDirection.Descending);
return(new ThenOrderByBuilder(Table, OrderBy));
}
/// <summary>
/// Searches for tracks with a Beats per Minute range.
/// </summary>
/// <param name="minBpm">The minimum BPM.</param>
/// <param name="maxBpm">The maximum BPM.</param>
/// <param name="genreId">The genre identifier.</param>
/// <param name="orderBy">The order by.</param>
/// <param name="sortOrder">The sort order.</param>
/// <param name="startIndex">The start index.</param>
/// <param name="itemsPerPage">The items per page.</param>
/// <param name="requestId">The request identifier.</param>
/// <param name="cancellationToken">The cancellation token to cancel operation</param>
/// <returns>
/// A list of tracks
/// </returns>
public async Task <ListResponse <MusicItem> > SearchBpmAsync(int minBpm, int maxBpm, string genreId = null, OrderBy?orderBy = null, SortOrder?sortOrder = null, int startIndex = MusicClient.DefaultStartIndex, int itemsPerPage = MusicClient.DefaultItemsPerPage, Guid?requestId = null, CancellationToken?cancellationToken = null)
{
var cmd = this.CreateCommand <SearchCommand>();
cmd.MinBpm = minBpm;
cmd.MaxBpm = maxBpm;
cmd.Category = Category.Track;
cmd.GenreId = genreId;
cmd.OrderBy = orderBy;
cmd.SortOrder = sortOrder;
cmd.StartIndex = startIndex;
cmd.ItemsPerPage = itemsPerPage;
this.SetRequestId(cmd, requestId);
return(await cmd.ExecuteAsync(cancellationToken).ConfigureAwait(false));
}
/// <summary> Gets all issues for the specified project. </summary>
/// <param name="projectId"> The ID of the project. </param>
/// <param name="state"> Limit the results to the specified state. (opened/closed) </param>
/// <param name="labels"> Limit the results to only issues with the specified labels. </param>
/// <param name="milestone"> Limit the results to only issues for the specified milestone. </param>
/// <param name="orderBy"> Order the results by created_at or updated_at. Default is created_at. </param>
/// <param name="sort"> Sort results in ascending or descending order. (asc/desc) </param>
/// <returns> A <see cref="PaginatedResult{Issue}" /> representing the results of the request. </returns>
public async Task <PaginatedResult <Issue> > GetByProject(uint projectId, IssueState?state = null,
string[] labels = null, string milestone = null, OrderBy?orderBy = null, SortOrder?sort = null)
{
var stateValue = state != null?Enum.GetName(typeof(IssueState), state)?.ToLower() : null;
var orderByValue = orderBy?.GetDescription();
var sortValue = sort != null?Enum.GetName(typeof(SortOrder), sort)?.ToLower() : null;
var request = RequestFactory.Create("projects/{projectId}/issues", Method.Get);
request.AddUrlSegment("projectId", projectId);
request.AddParameterIfNotNull("state", stateValue);
request.AddParameterIfNotNull("labels", labels.ToCommaSeparated());
request.AddParameterIfNotNull("milestone", milestone);
request.AddParameterIfNotNull("order_by", orderByValue);
request.AddParameterIfNotNull("sort", sortValue);
return(await request.ExecutePaginated <Issue>());
}
public async Task <IActionResult> Handle(
[FromQuery(Name = "workflow")] string?workflowDefinitionId = default,
[FromQuery(Name = "status")] WorkflowStatus?workflowStatus = default,
[FromQuery] string?correlationId = default,
[FromQuery] OrderBy?orderBy = default,
[FromQuery] string?searchTerm = default,
int page = 0,
int pageSize = 25,
CancellationToken cancellationToken = default)
{
_stopwatch.Restart();
var specification = Specification <WorkflowInstance> .Identity;
if (!string.IsNullOrWhiteSpace(workflowDefinitionId))
{
specification = specification.WithWorkflowDefinition(workflowDefinitionId);
}
if (!string.IsNullOrWhiteSpace(correlationId))
{
specification = specification.WithCorrelationId(correlationId);
}
if (workflowStatus != null)
{
specification = specification.WithStatus(workflowStatus.Value);
}
if (!string.IsNullOrWhiteSpace(searchTerm))
{
specification = specification.WithSearchTerm(searchTerm);
}
var tenantId = await _tenantAccessor.GetTenantIdAsync(cancellationToken);
specification = specification.And(new TenantSpecification <WorkflowInstance>(tenantId));
var orderBySpecification = default(OrderBy <WorkflowInstance>);
if (orderBy != null)
{
orderBySpecification = orderBy switch
{
OrderBy.Started => OrderBySpecification.OrderByDescending <WorkflowInstance>(x => x.CreatedAt),
OrderBy.LastExecuted => OrderBySpecification.OrderByDescending <WorkflowInstance>(x => x.LastExecutedAt !),
OrderBy.Finished => OrderBySpecification.OrderByDescending <WorkflowInstance>(x => x.FinishedAt !),
_ => OrderBySpecification.OrderByDescending <WorkflowInstance>(x => x.FinishedAt !)
};
}
var totalCount = await _workflowInstanceStore.CountAsync(specification, cancellationToken : cancellationToken);
var paging = Paging.Page(page, pageSize);
var workflowInstances = await _workflowInstanceStore.FindManyAsync(specification, orderBySpecification, paging, cancellationToken).ToList();
var items = _mapper.Map <ICollection <WorkflowInstanceSummaryModel> >(workflowInstances);
_stopwatch.Stop();
_logger.LogDebug("Handle took {TimeElapsed}", _stopwatch.Elapsed);
var model = new PagedList <WorkflowInstanceSummaryModel>(items, page, pageSize, totalCount);
return(Json(model, _contentSerializer.GetSettings()));
}
}
/// <summary>
/// Gets products by an artist.
/// </summary>
/// <param name="artist">The artist.</param>
/// <param name="category">The category.</param>
/// <param name="orderBy">The field to sort the items by.</param>
/// <param name="sortOrder">The sort order of the items to fetch.</param>
/// <param name="startIndex">The zero-based start index to fetch items from (e.g. to get the second page of 10 items, pass in 10).</param>
/// <param name="itemsPerPage">The number of items to fetch.</param>
/// <returns>
/// A ListResponse containing Products or an Error
/// </returns>
/// <exception cref="System.ArgumentNullException">artist;Artist cannot be null</exception>
public Task <ListResponse <Product> > GetArtistProductsAsync(Artist artist, Category?category = null, OrderBy?orderBy = null, SortOrder?sortOrder = null, int startIndex = MusicClient.DefaultStartIndex, int itemsPerPage = MusicClient.DefaultItemsPerPage)
{
if (artist == null)
{
throw new ArgumentNullException("artist", "Artist cannot be null");
}
return(this.GetArtistProductsAsync(artist.Id, category, orderBy, sortOrder, startIndex, itemsPerPage));
}
/// <summary>
/// 获取页面视图模型
/// </summary>
/// <param name="page"></param>
/// <param name="size"></param>
/// <param name="orderBy"></param>
/// <param name="user"></param>
/// <returns></returns>
private IndexPageViewModel GetIndexPageViewModel(int page, int size, OrderBy?orderBy, UserInfoOutputDto user)
{
var postsQuery = PostService.GetQuery <PostOutputDto>(p => (p.Status == Status.Pended || user.IsAdmin)); //准备文章的查询
var notices = NoticeService.GetPagesFromCache <DateTime, NoticeOutputDto>(1, 5, out int _, n => (n.Status == Status.Display || user.IsAdmin), n => n.ModifyDate, false).ToList(); //加载前5条公告
var cats = CategoryService.GetQueryFromCache <string, CategoryOutputDto>(c => c.Status == Status.Available, c => c.Name).ToList(); //加载分类目录
var hotSearches = RedisHelper.Get <List <KeywordsRankOutputDto> >("SearchRank:Week").Take(10).ToList(); //热词统计
Expression <Func <PostOutputDto, double> > order = p => p.TotalViewCount;
switch (new Random().Next() % 3)
{
case 1:
order = p => p.VoteUpCount;
break;
case 2:
order = p => p.AverageViewCount;
break;
}
var hot6Post = postsQuery.OrderByDescending(order).Skip(0).Take(5).Cacheable().ToList(); //热门文章
var newdic = new Dictionary <string, int>(); //标签云最终结果
var tagdic = postsQuery.Where(p => !string.IsNullOrEmpty(p.Label)).Select(p => p.Label).Cacheable().AsEnumerable().SelectMany(s => s.Split(',', '，')).GroupBy(s => s).ToDictionary(g => g.Key, g => g.Count()); //统计标签
if (tagdic.Any())
{
int min = tagdic.Values.Min();
tagdic.ForEach(kv =>
{
var fontsize = (int)Math.Floor(kv.Value * 1.0 / (min * 1.0) + 12.0);
newdic.Add(kv.Key, fontsize >= 36 ? 36 : fontsize);
});
}
IList <PostOutputDto> posts;
switch (orderBy) //文章排序
{
case OrderBy.CommentCount:
posts = postsQuery.Where(p => !p.IsFixedTop).OrderByDescending(p => p.CommentCount).Skip(size * (page - 1)).Take(size).Cacheable().ToList();
break;
case OrderBy.PostDate:
posts = postsQuery.Where(p => !p.IsFixedTop).OrderByDescending(p => p.PostDate).Skip(size * (page - 1)).Take(size).Cacheable().ToList();
break;
case OrderBy.ViewCount:
posts = postsQuery.Where(p => !p.IsFixedTop).OrderByDescending(p => p.TotalViewCount).Skip(size * (page - 1)).Take(size).Cacheable().ToList();
break;
case OrderBy.VoteCount:
posts = postsQuery.Where(p => !p.IsFixedTop).OrderByDescending(p => p.VoteUpCount).Skip(size * (page - 1)).Take(size).Cacheable().ToList();
break;
case OrderBy.AverageViewCount:
posts = postsQuery.Where(p => !p.IsFixedTop).OrderByDescending(p => p.AverageViewCount).Skip(size * (page - 1)).Take(size).Cacheable().ToList();
break;
default:
posts = postsQuery.Where(p => !p.IsFixedTop).OrderByDescending(p => p.ModifyDate).Skip(size * (page - 1)).Take(size).Cacheable().ToList();
break;
}
if (page == 1)
{
posts = postsQuery.Where(p => p.IsFixedTop).OrderByDescending(p => p.ModifyDate).AsEnumerable().Union(posts).ToList();
}
return(new IndexPageViewModel()
{
Categories = cats,
HotSearch = hotSearches,
Notices = notices,
Posts = posts,
Tags = newdic,
Top6Post = hot6Post,
PostsQueryable = postsQuery,
SidebarAds = AdsService.GetsByWeightedPrice(2, AdvertiseType.SideBar),
ListAdvertisement = AdsService.GetByWeightedPrice(AdvertiseType.PostList)
});
}
public List <Community> GetAll(int?pageNumber, int?pageSize, CommunityGridSortByOption?sortBy, OrderBy?orderBy, CommunityGridFilter filter, out int totalCount)
{
List <Book> books = new List <Book>();
if (!AccountBc.Instance.IsUserInRole(UmsRoles.Admin))
{
books = AccountBc.Instance.GetBooks().ConvertAll <Book>((Publication p) => new Book()
{
Id = new long?((long)p.Id)
});
}
else
{
books.Add(new Book()
{
Id = new long?((long)-1)
});
}
return(this._communityDac.GetAll(books, pageNumber, pageSize, sortBy, orderBy, filter, out totalCount));
}
/// <summary>
/// Searches for items
/// </summary>
/// <typeparam name="T">The type to return</typeparam>
/// <param name="searchTerm">The search term.</param>
/// <param name="genreId">The genre to filter the results by.</param>
/// <param name="id">An artist or product id.</param>
/// <param name="category">The category to filter the results by.</param>
/// <param name="location">The location to filter the results by.</param>
/// <param name="maxdistance">The max distance from the location to to filter the results by.</param>
/// <param name="orderBy">The field to sort the items by.</param>
/// <param name="sortOrder">The sort order of the items to fetch.</param>
/// <param name="startIndex">The zero-based start index to fetch items from (e.g. to get the second page of 10 items, pass in 10).</param>
/// <param name="itemsPerPage">The number of items to fetch.</param>
/// <param name="converter">The object creation method to use</param>
/// <param name="callback">The callback to use when the API call has completed</param>
protected void InternalSearch <T>(string searchTerm, string genreId, string id, Category?category, string location, string maxdistance, OrderBy?orderBy, SortOrder?sortOrder, int startIndex, int itemsPerPage, JTokenConversionDelegate <T> converter, Action <ListResponse <T> > callback)
{
// Build querystring parameters...
var parameters = new List <KeyValuePair <string, string> >
{
new KeyValuePair <string, string>(PagingStartIndex, startIndex.ToString(CultureInfo.InvariantCulture)),
new KeyValuePair <string, string>(PagingItemsPerPage, itemsPerPage.ToString(CultureInfo.InvariantCulture))
};
if (!string.IsNullOrEmpty(searchTerm))
{
parameters.Add(new KeyValuePair <string, string>(ParamSearchTerm, searchTerm));
}
if (!string.IsNullOrEmpty(genreId))
{
parameters.Add(new KeyValuePair <string, string>(ParamGenre, genreId));
}
if (!string.IsNullOrEmpty(id))
{
parameters.Add(new KeyValuePair <string, string>(ParamId, id));
}
if (category != null && category.Value != Types.Category.Unknown)
{
parameters.Add(new KeyValuePair <string, string>(ParamCategory, category.Value.ToString().ToLowerInvariant()));
}
if (orderBy != null && orderBy.HasValue)
{
parameters.Add(new KeyValuePair <string, string>(ParamOrderBy, orderBy.Value.ToString().ToLowerInvariant()));
}
if (sortOrder != null && sortOrder.HasValue)
{
parameters.Add(new KeyValuePair <string, string>(ParamSortOrder, sortOrder.Value.ToString().ToLowerInvariant()));
}
if (!string.IsNullOrEmpty(location))
{
parameters.Add(new KeyValuePair <string, string>(ParamLocation, location));
}
if (!string.IsNullOrEmpty(maxdistance))
{
parameters.Add(new KeyValuePair <string, string>(ParamMaxDistance, maxdistance));
}
this.RequestHandler.SendRequestAsync(
this,
this.ClientSettings,
parameters,
new JsonResponseCallback(rawResult => this.ListItemResponseHandler <T>(rawResult, ArrayNameItems, converter, callback)));
}
public XCommasResponse <SmartTrade[]> GetSmartTrades(int?accountId = null, string pair = null, SmartTradeType?type = null, SmartTradeStatus?status = null, OrderBy?orderBy = null, OrderDirection?orderDirection = null, int?page = null, int?perPage = null) => this.GetSmartTradesAsync(accountId, pair, type, status, orderBy, orderDirection, page, perPage).Result;
private static RestAPIResponse Push(DataSiftClient client, string command)
{
RestAPIResponse response = null;
OrderDirection tmpOrderDir;
OrderDirection?orderDir = null;
OrderBy tmpOrderBy;
OrderBy? orderBy = null;
if (Enum.TryParse(_argsParser.GetParameter <string>("order_dir"), out tmpOrderDir))
{
orderDir = tmpOrderDir;
}
if (Enum.TryParse(_argsParser.GetParameter <string>("order_by"), out tmpOrderBy))
{
orderBy = tmpOrderBy;
}
switch (command)
{
case "validate":
response = client.Push.Validate(_argsParser.GetParameter <string>("output_type"),
_argsParser.GetParameter <ExpandoObject>("output_params"));
break;
case "create":
PushStatus statusTemp;
PushStatus?status = null;
if (Enum.TryParse(_argsParser.GetParameter <string>("initial_status"), out statusTemp))
{
status = statusTemp;
}
response = client.Push.Create(_argsParser.GetParameter <string>("name"), _argsParser.GetParameter <string>("output_type"),
_argsParser.GetParameter <ExpandoObject>("output_params"), hash: _argsParser.GetParameter <string>("hash"), historicsId: _argsParser.GetParameter <string>("historics_id"),
initialStatus: status, start: _argsParser.GetParameter <DateTimeOffset?>("start"), end: _argsParser.GetParameter <DateTimeOffset?>("end"));
break;
case "update":
if (_argsParser.Contains("output_params"))
{
response = client.Push.Update(_argsParser.GetParameter <string>("id"), _argsParser.GetParameter <ExpandoObject>("output_params"), name: _argsParser.GetParameter <string>("name"));
}
else
{
response = client.Push.Update(_argsParser.GetParameter <string>("id"), name: _argsParser.GetParameter <string>("name"));
}
break;
case "pause":
response = client.Push.Pause(_argsParser.GetParameter <string>("id"));
break;
case "resume":
response = client.Push.Resume(_argsParser.GetParameter <string>("id"));
break;
case "delete":
response = client.Push.Delete(_argsParser.GetParameter <string>("id"));
break;
case "stop":
response = client.Push.Stop(_argsParser.GetParameter <string>("id"));
break;
case "log":
response = client.Push.Log(_argsParser.GetParameter <string>("id"), _argsParser.GetParameter <int?>("page"),
_argsParser.GetParameter <int?>("per_page"), orderDir);
break;
case "get":
response = client.Push.Get(id: _argsParser.GetParameter <string>("id"), hash: _argsParser.GetParameter <string>("hash"),
historicsId: _argsParser.GetParameter <string>("historics_id"), page: _argsParser.GetParameter <int?>("page"),
perPage: _argsParser.GetParameter <int?>("per_page"), orderBy: orderBy, orderDirection: orderDir, includeFinished: _argsParser.GetParameter <bool?>("include_finished"));
break;
default:
throw new ApplicationException("Unrecognised command: " + command);
}
return(response);
}
public Task <ContentResponse> BrowseAsync(Namespace mediaNamespace, ContentSource source, ItemType type,
string genre = null, OrderBy?orderBy = null, int?maxItems = null, int?page = null, string language = null,
string country = null)
{
return(BrowseApiAsync(mediaNamespace, source, type, genre, orderBy, maxItems, page, language, country));
}
public static IQueryable<T> SortBy<T>(this IQueryable<T> query, string attributeName, OrderBy? orderBy)
{
Type type = typeof(T);
ParameterExpression param = Expression.Parameter(type, "x");
Type lambdaType = type.GetProperty(attributeName).PropertyType;
MethodCallExpression expression = Expression.Call(typeof(Queryable),
GetOrderByMethodName(orderBy),
new Type[] {type, lambdaType},
query.Expression,
Expression.Lambda(Expression.Property(param, type.GetProperty(attributeName)), param));
return query.Provider.CreateQuery<T>(expression);
}
public Task <ContentResponse> SubBrowseAsync(string id, ContentSource source, BrowseItemType browseType, ExtraDetails extra, OrderBy?orderBy = null, int?maxItems = null, int?page = null, string language = null, string country = null)
{
return(SubBrowseApiAsync(id, source, browseType, extra, orderBy, maxItems, page, language, country));
}
public static IQueryable<T> SortBy<T>(this IQueryable<T> query, Expression<Func<T, object>> attribute, OrderBy? orderBy)
{
Type type = typeof(T);
ParameterExpression param = Expression.Parameter(type, "x");
var body = attribute.Body as MemberExpression;
Type lambdaType = type.GetProperty(body.Member.Name).PropertyType;
MethodCallExpression expression = Expression.Call(typeof(Queryable),
GetOrderByMethodName(orderBy),
new Type[] { type, lambdaType},
query.Expression,
Expression.Lambda(Expression.Property(param, type.GetProperty(body.Member.Name)), param));
return query.Provider.CreateQuery<T>(expression);
}
public CurrentOrderSummaryReport listCurrentOrders(ISet <String> betIds, ISet <String> marketIds, OrderProjection?orderProjection = null, TimeRange placedDateRange = null, OrderBy?orderBy = null, SortDir?sortDir = null, int?fromRecord = null, int?recordCount = null)
{
var args = new Dictionary <string, object>();
args[BET_IDS] = betIds;
args[MARKET_IDS] = marketIds;
args[ORDER_PROJECTION] = orderProjection;
args[PLACED_DATE_RANGE] = placedDateRange;
args[ORDER_BY] = orderBy;
args[SORT_DIR] = sortDir;
args[FROM_RECORD] = fromRecord;
args[RECORD_COUNT] = recordCount;
return(Invoke <CurrentOrderSummaryReport>(LIST_CURRENT_ORDERS_METHOD, args));
}
public void ReturnTheCollectionOfArticlesOrderedByAscending_WhenUserIdIsEmptyAndOrderIsAscendingOrNull(OrderBy?order)
{
// Arrange
IQueryable <Article> expectedArticles = new List <Article>()
{
new Article()
{
CreatedOn = DateTime.UtcNow
},
new Article()
{
CreatedOn = DateTime.Now
}
}.OrderBy(x => x.CreatedOn)
.AsQueryable();
this.dbSetWrapperMock.Setup(x => x.All).Returns(expectedArticles);
// Act
IQueryable <Article> actualArticles = this.service.GetAllOrderedByCreatedOn(order, string.Empty);
// Assert
CollectionAssert.AreEqual(expectedArticles, actualArticles);
}
