public SqlFromQuery OrderBy(Expression sortItem, SortType sortType)
{
SqlSortItem sort = new SqlSortItem(sortItem, sortType);
SortItems.Add(sort);
return(this);
}
public SongsPageViewModel(
ILibraryCollectionService libraryCollectionService,
ILibraryService libraryService,
ISettingsUtility settingsUtility,
IPlayerService playerService)
{
_libraryCollectionService = libraryCollectionService;
_settingsUtility = settingsUtility;
_playerService = playerService;
LibraryService = libraryService;
SortItems =
Enum.GetValues(typeof(TrackSort))
.Cast <TrackSort>()
.Select(sort => new ListBoxItem {
Content = sort.GetEnumText(), Tag = sort
})
.ToList();
SortChangedCommand = new DelegateCommand <ListBoxItem>(SortChangedExecute);
ShuffleAllCommand = new DelegateCommand(ShuffleAllExecute);
var defaultSort = _settingsUtility.Read(ApplicationSettingsConstants.SongSort,
TrackSort.DateAdded,
SettingsStrategy.Roam);
DefaultSort = SortItems.IndexOf(SortItems.FirstOrDefault(p => (TrackSort)p.Tag == defaultSort));
ChangeSort(defaultSort);
}
// helper
void Validate(string sort, int[] artist, double priceFrom, double priceThru, int page, int pageSize)
{
// validate incoming entries.
if (!SortItems.ContainsKey(sort))
{
throw new ArgumentException("Invalid sort");
}
foreach (var a in artist)
{
if (a <= 0)
{
throw new ArgumentException("Invalid artist");
}
}
if (priceFrom < 0 || priceThru > 500)
{
throw new ArgumentException("Invalid price range");
}
if (page < 0)
{
throw new ArgumentException("Invalid page");
}
if (pageSize < 0)
{
throw new ArgumentException("Invalid page size");
}
}
public void PrintBill(Item[] items, SortItems sort)
{
Item[] sortedItems = sort.ItemsSort(items);
foreach (var item in sortedItems)
{
Console.WriteLine("towar {0} : cena {1} + podatek {2}", item.Name, item.Price, taxCalc.CalculateTax(item.Price));
}
}
protected virtual IQueryable <T> GetSortQuery(IQueryable <T> query)
{
if (SortItems == null || !SortItems.Any())
{
return(query.OrderBy(x => x.Id));
}
return(SortItems
.OrderBy(x => x.Priotity ?? 0)
.Aggregate(query, (x, item) => item.GetQuery(x)));
}
public AggregatedConditionDto(SearchConditionDto search, SortConditionDto sort) : this()
{
if (search != null)
{
ConditionItems.AddRange(search.Items);
}
if (sort != null)
{
SortItems.AddRange(sort.Items);
}
}
private static List <ProjectsModel> SortAndOrderProjects(SortItems _headerValue, SortDirections sortDirection, IEnumerable <ProjectsModel> prjcts)
{
List <ProjectsModel> OrderedProjects;
switch (_headerValue)
{
default:
OrderedProjects = sortDirection ==
SortDirections.Ascending ?
prjcts.OrderBy(x => x.ProjectName).ToList() :
prjcts.OrderByDescending(x => x.ProjectName).ToList();
break;
case SortItems.Client:
OrderedProjects = sortDirection ==
SortDirections.Ascending ?
prjcts.OrderBy(x => x.ClientName).ToList() :
prjcts.OrderByDescending(x => x.ClientName).ToList();
break;
//=================================NOT CURRENTLY USED======================================//
case SortItems.Manager:
OrderedProjects = prjcts.OrderByDescending(x => x.ProjectManager).ToList();
break;
case SortItems.Developer:
OrderedProjects = prjcts.OrderByDescending(x => x.Developer).ToList();
break;
case SortItems.Designer:
OrderedProjects = prjcts.OrderByDescending(x => x.Designer).ToList();
break;
case SortItems.ProjectType:
OrderedProjects = prjcts.OrderByDescending(x => x.ProjectType).ToList();
break;
case SortItems.ProjectStatus:
OrderedProjects = prjcts.OrderByDescending(x => x.Status).ToList();
break;
case SortItems.BackupPlan:
OrderedProjects = prjcts.OrderByDescending(x => x.BackUp).ToList();
break;
case SortItems.Value:
OrderedProjects = prjcts.OrderByDescending(x => x.ProjectValue).ToList();
break;
}
return(OrderedProjects);
}
public SortIndicatorModel(Item sortSetting, SearchQuery searchQuery)
{
SortItems = sortSetting.GetMultiListValueItems(Templates.SortIndicator.Fields.SortFields);
DefaultText = sortSetting[Templates.SortIndicator.Fields.DefaultText];
if (SortItems.Any())
{
var sortItem = GetSortItem(searchQuery);
SortFieldName = sortItem?[Templates.SortField.Fields.FieldName];
SortDisplayName = sortItem?[Templates.SortField.Fields.DisplayName];
Direction = GetDirection(searchQuery);
}
}
public IHttpActionResult GetPaging(BaseCondition <RoomResult> condition)
{
List <FilterItems> FilterRules = condition.FilterRules;
List <SortItems> SortRules = condition.SortRules;
if (FilterRules != null && FilterRules.Count > 0)
{
foreach (var item in FilterRules.Select((value, i) => new { i, value }))
{
FilterItems e = item.value;
int Index = item.i;
if (e.field == "HotelName")
{
condition.FilterRules[Index].field = "H.Name";
}
else
{
condition.FilterRules[Index].field = "R." + e.field;
}
}
}
if (SortRules != null && SortRules.Count > 0)
{
foreach (var item in SortRules.Select((value, i) => new { i, value }))
{
SortItems e = item.value;
int Index = item.i;
if (e.field == "HotelName")
{
condition.FilterRules[Index].field = "H.Name";
}
else
{
condition.FilterRules[Index].field = "R." + e.field;
}
}
}
var req = roomDAL.GetPaging(condition);
if (req.Succeeded)
{
return(Ok(req));
}
else
{
return(Content(HttpStatusCode.BadRequest, req));
}
}
public IHttpActionResult GetPaging(BaseCondition <HotelPaging> condition)
{
string tokenCode = HttpContext.Current.Request.Headers["TokenCode"] != null ? HttpContext.Current.Request.Headers["TokenCode"].ToString() : "";
Models.UserResult UserInfo = null;
if (!string.IsNullOrEmpty(tokenCode))
{
UserInfo = CacheUtil.GetCacheObject(tokenCode);
}
int UserId = (UserInfo != null && UserInfo.Id > 0) ? UserInfo.Id : 0;
List <FilterItems> FilterRules = condition.FilterRules;
List <SortItems> SortRules = condition.SortRules;
if (SortRules != null && SortRules.Count > 0)
{
foreach (var item in SortRules.Select((value, i) => new { i, value }))
{
SortItems e = item.value;
int Index = item.i;
if (e.field.ToLower() == "minprice")
{
condition.SortRules[Index].field = "CAST(MinPrice as Int)";
continue;
}
}
}
var req = hotelDAL.GetPaging(condition, UserId);
if (req.Succeeded)
{
return(Ok(req));
}
else
{
return(Content(HttpStatusCode.BadRequest, req));
}
}
/// <summary>
/// ｺﾝｽﾄﾗｸﾀ
/// </summary>
public SearchByWordViewModel(SearchByWordModel model)
{
Source = model;
Items = Source.Videos.ToSyncedSynchronizationContextCollection(
id => new SearchByWordItemViewModel(id),
AnonymousSynchronizationContext.Current
);
SortItems = ComboSortVideoModel
.Instance
.Items
.ToSyncedSynchronizationContextCollection(m => m, AnonymousSynchronizationContext.Current);
SelectedSortItem = SortItems.First();
ThumbSizeItems = ComboThumbSizeModel
.Instance
.Items
.ToSyncedSynchronizationContextCollection(m => m, AnonymousSynchronizationContext.Current);
SelectedThumbSizeItem = ThumbSizeItems.First();
}
public SearchByMylistViewModel(SearchByMylistModel model)
{
Source = model;
this.MylistTitle = Source.MylistTitle;
this.MylistCreator = Source.MylistCreator;
this.MylistDescription = Source.MylistDescription;
this.UserId = Source.UserId;
//this.UserThumbnail = Source.UserThumbnail;
this.MylistDate = Source.MylistDate;
Items = Source.Videos.ToSyncedSynchronizationContextCollection(
id => new SearchByMylistItemViewModel(id),
AnonymousSynchronizationContext.Current
);
SortItems = ComboSortMylistModel
.Instance
.Items
.ToSyncedSynchronizationContextCollection(m => m, AnonymousSynchronizationContext.Current);
SelectedSortItem = SortItems.First();
}
public ArticleViewModel()
{
search = new SearchForm()
{
Page = 0
};
Items = new IncrementalLoadingCollection <Article>(count =>
{
return(Task.Run(async() =>
{
search.Page++;
var data = await App.Repository.Article.GetPageAsync(search);
if (data == null)
{
return Tuple.Create <IList <Article>, bool>(null, false);
}
return Tuple.Create(data.Data, data.Paging.More);
}));
});
SortItems.Add(new TabItem("new", Constants.GetString("article_tab_new")));
SortItems.Add(new TabItem("hot", Constants.GetString("article_tab_hot")));
SortItems.Add(new TabItem("recommend", Constants.GetString("article_tab_best")));
_ = LoadCategories();
}
public ActionResult Paging(int _pageNO, SortDirections _sortValue, SortItems _element, Guid _UserId)
{
return(GetSortedProjectsModel(_UserId, _sortValue, _element, _pageNO, 0));
}
public ActionResult sortTable(Guid userId, SortItems _headerValue, SortDirections sortDirection)
{
return(GetSortedProjectsModel(userId, sortDirection, _headerValue, 0, 0));
}
private void artistAscending_Click(object sender, EventArgs e)
{
SortItems.artistAscending(container);
}
private void albumDescending_Click(object sender, EventArgs e)
{
SortItems.albumDescending(container);
}
/// <summary>
/// Initializes a new instance of the <see cref="SortModel"/> class.
/// </summary>
/// <param name="filterItem">
/// </param>
/// <param name="skip"></param>
/// <param name="take"></param>
public SortModel(SortItemModel filterItem, int skip, int take)
{
SortItems.Add(filterItem);
Skip = skip;
Take = take;
}
private void descendingToolStripMenuItem_Click(object sender, EventArgs e)
{
SortItems.nameDescending(container);
}
private void playsDescending_Click(object sender, EventArgs e)
{
SortItems.playsDescending(container);
}
private void ratingDescending_Click(object sender, EventArgs e)
{
SortItems.ratingDescending(container);
}
private void songList_ColumnHeaderMouseClick(object sender, DataGridViewCellMouseEventArgs e)
{
SortItems.columnSortClick(container, e);
}
public void Add(SortItemModel filterItem)
{
SortItems.Add(filterItem);
}
/// <summary>
/// Initializes a new instance of the <see cref="SortModel"/> class.
/// </summary>
/// <param name="filterItems"></param>
/// <param name="skip"></param>
/// <param name="take"></param>
public SortModel(List <SortItemModel> filterItems, int skip, int take)
{
SortItems.AddRange(filterItems);
Skip = skip;
Take = take;
}
private void lengthDescending_Click(object sender, EventArgs e)
{
SortItems.lengthDescending(container);
}
private void genreDescending_Click(object sender, EventArgs e)
{
SortItems.genreDescending(container);
}
private ActionResult GetSortedProjectsModel(Guid _UserId, SortDirections _sortValue, SortItems _element, int pageNumber, int itemsPerPage)
{
ProjectsManager pm = new ProjectsManager();
//Obtaining values
List <string> _TypesOptions = pm.getProjectTypesOptions();
List <string> _StatusesOptions = pm.getProjectStatusOptions();
List <string> _BakupOptions = pm.getBackUpPlanOptions();
List <string> _PMOptions = pm.getPMOptions();
List <string> _DevOptions = pm.getDevsOptions();
List <string> _DesgnsOptions = pm.getDesgnsOptions();
var prjcts = GetProjectsFromDb(_UserId);
List <ProjectsModel> OrderedProjects = SortAndOrderProjects(_element, _sortValue, prjcts);
var pmd = new ProjectsModel
{
SortItem = _element,
SortDirection = _sortValue,
UserId = _UserId,
CampaignItems =
OrderedProjects
.Skip(((pageNumber == 0 ? 1 : pageNumber) - 1) * (itemsPerPage == 0 ? 10 : itemsPerPage))
.Take(itemsPerPage == 0 ? 10 : itemsPerPage).ToList(),
Devs = _DevOptions,
Desgns = _DesgnsOptions,
PMs = _PMOptions,
Types = _TypesOptions,
Statuses = _StatusesOptions,
BackUpOptions = _BakupOptions,
projectNo = prjcts.Count(),
PageNo = (pageNumber == 0 ? 1 : pageNumber),
NoPages = prjcts.Distinct().Count() / (itemsPerPage == 0 ? 10 : itemsPerPage) + (prjcts.Distinct().Count() % (itemsPerPage == 0 ? 10 : itemsPerPage) > 0 ? 1 : 0)
};
return(PartialView("_tablePartial", pmd));
}
private void yearAscending_Click(object sender, EventArgs e)
{
SortItems.yearAscending(container);
}
public void AddRange(List <SortItemModel> filterItems)
{
SortItems.AddRange(filterItems);
}
// Use this for initialization
private void Start()
{
_collect = Player.GetComponent <CollectItems>();
_sort = FindObjectsOfType <SortItems>().FirstOrDefault(p => p.Color == Player.Color);
}