/// <summary>
/// 定义是否允许点击列表头进行排序
/// </summary>
/// <param name = "sortable"></param>
/// <param name = "sortType">当datatype为local时有效。定义适当的排序类型。</param>
public Column SetSortable(bool sortable, SortType sortType = SortType.Text, SortOrder firstSortOrder = SortOrder.Asc)
{
_sortable = sortable;
_sortType = sortType;
_firstSortOrder = firstSortOrder;
return this;
}
/// <inheritdoc cref="ISort.Order" /> public virtual TDescriptor Order(SortOrder?order) => Assign(order, (a, v) => a.Order = v);
public async Task OnGetAsync(SortOrder?sort, int teamId, PuzzleStateFilter?stateFilter)
{
TeamID = teamId;
Team myTeam = await UserEventHelper.GetTeamForPlayer(_context, Event, LoggedInUser);
if (myTeam != null)
{
TeamID = myTeam.ID;
TeamPassword = myTeam.Password;
await PuzzleStateHelper.CheckForTimedUnlocksAsync(_context, Event, myTeam);
}
else
{
throw new Exception("Not currently registered for a team");
}
this.Sort = sort;
this.StateFilter = stateFilter;
ShowAnswers = Event.AnswersAvailableBegin <= DateTime.UtcNow;
AllowFeedback = Event.AllowFeedback;
// all puzzles for this event that are real puzzles
var puzzlesInEventQ = _context.Puzzles.Where(puzzle => puzzle.Event.ID == this.Event.ID && puzzle.IsPuzzle);
// unless we're in a global lockout, then filter to those!
var puzzlesCausingGlobalLockoutQ = PuzzleStateHelper.PuzzlesCausingGlobalLockout(_context, Event, myTeam);
if (await puzzlesCausingGlobalLockoutQ.AnyAsync())
{
puzzlesInEventQ = puzzlesCausingGlobalLockoutQ;
}
// all puzzle states for this team that are unlocked (note: IsUnlocked bool is going to harm perf, just null check the time here)
// Note that it's OK if some puzzles do not yet have a state record; those puzzles are clearly still locked and hence invisible.
// All puzzles will show if all answers have been released)
var stateForTeamQ = _context.PuzzleStatePerTeam.Where(state => state.TeamID == this.TeamID && (ShowAnswers || state.UnlockedTime != null));
// join 'em (note: just getting all properties for max flexibility, can pick and choose columns for perf later)
// Note: EF gotcha is that you have to join into anonymous types in order to not lose valuable stuff
var visiblePuzzlesQ = from Puzzle puzzle in puzzlesInEventQ
join PuzzleStatePerTeam pspt in stateForTeamQ on puzzle.ID equals pspt.PuzzleID
select new PuzzleView {
ID = puzzle.ID, Group = puzzle.Group, OrderInGroup = puzzle.OrderInGroup, Name = puzzle.Name, CustomUrl = puzzle.CustomURL, Errata = puzzle.Errata, SolvedTime = pspt.SolvedTime, PieceMetaUsage = puzzle.PieceMetaUsage
};
switch (sort ?? DefaultSort)
{
case SortOrder.PuzzleAscending:
visiblePuzzlesQ = visiblePuzzlesQ.OrderBy(pv => pv.Name);
break;
case SortOrder.PuzzleDescending:
visiblePuzzlesQ = visiblePuzzlesQ.OrderByDescending(pv => pv.Name);
break;
case SortOrder.GroupAscending:
visiblePuzzlesQ = visiblePuzzlesQ.OrderBy(pv => pv.Group).ThenBy(pv => pv.OrderInGroup).ThenBy(pv => pv.Name);
break;
case SortOrder.GroupDescending:
visiblePuzzlesQ = visiblePuzzlesQ.OrderByDescending(pv => pv.Group).ThenByDescending(pv => pv.OrderInGroup).ThenByDescending(pv => pv.Name);
break;
case SortOrder.SolveAscending:
visiblePuzzlesQ = visiblePuzzlesQ.OrderBy(pv => pv.SolvedTime ?? DateTime.MaxValue);
break;
case SortOrder.SolveDescending:
visiblePuzzlesQ = visiblePuzzlesQ.OrderByDescending(pv => pv.SolvedTime ?? DateTime.MaxValue);
break;
default:
throw new ArgumentException($"unknown sort: {sort}");
}
if (this.StateFilter == PuzzleStateFilter.Unsolved)
{
visiblePuzzlesQ = visiblePuzzlesQ.Where(puzzles => puzzles.SolvedTime == null);
}
PuzzleViews = await visiblePuzzlesQ.ToListAsync();
Dictionary <int, ContentFile> files = await(from file in _context.ContentFiles
where file.Event == Event && file.FileType == ContentFileType.Puzzle
select file).ToDictionaryAsync(file => file.PuzzleID);
foreach (var puzzleView in PuzzleViews)
{
files.TryGetValue(puzzleView.ID, out ContentFile content);
puzzleView.Content = content;
}
if (ShowAnswers)
{
Dictionary <int, ContentFile> answers = await(from file in _context.ContentFiles
where file.Event == Event && file.FileType == ContentFileType.Answer
select file).ToDictionaryAsync(file => file.PuzzleID);
foreach (var puzzleView in PuzzleViews)
{
answers.TryGetValue(puzzleView.ID, out ContentFile answer);
puzzleView.Answer = answer;
}
}
}
private static string GetQuery(List <FolderFilter> filters, int?limit, int?offset, SortBy?sortBy, SortOrder?sortOrder)
{
var uri = new UriBuilder(SkyDriveBaseUrl + SkyDriveConstants.GetFiles);
var filterString = ParseFilters(filters);
uri.SetQueryParam(SkyDriveConstants.Filters, filterString);
if (limit.HasValue)
{
uri.SetQueryParam(LiveSdkConstants.Limit, limit.Value.ToString());
}
if (offset.HasValue)
{
uri.SetQueryParam(LiveSdkConstants.Offset, offset.Value.ToString());
}
if (sortBy.HasValue)
{
uri.SetQueryParam(SkyDriveConstants.SortBy, sortBy.ToString().ToLower());
}
if (sortOrder.HasValue)
{
uri.SetQueryParam(SkyDriveConstants.SortOrder, sortBy.ToString().ToLower());
}
return(uri.Query);
}
/// <summary>
/// If set to asc or desc, the column will be sorted in that direction on first
/// sort.Subsequent sorts of the column will toggle as usual (default: null)
/// </summary>
/// <param name = "firstSortOrder">First sort order</param>
public Column SetFirstSortOrder(SortOrder firstSortOrder)
{
_firstSortOrder = firstSortOrder;
return(this);
}
public void Filter(int?idGroup, int?idYear, string lastname, string activeGroups, int?privilege, DateTime dtStart, DateTime dtEnd, string column, SortOrder?sortOrder)
{
try
{
listStudents = from enroll in db.Enrollments
join privileges in db.Privileges on enroll.PrivilegeId equals privileges.Id into g
from privileges in g.DefaultIfEmpty()
join groups in db.Groups on enroll.GroupId equals groups.Id
join activity in db.ActivityGroups on groups.ActivityId equals activity.Id
join students in db.Students on enroll.StudentId equals students.Id
join statuses in db.Statuses on students.StatusId equals statuses.Id
join years in db.Years on groups.YearId equals years.Id
where enroll.DateExclusion == null && enroll.ExclusionId == null
select new Finance
{
StudentId = students.Id,
GroupId = groups.Id,
SchoolId = students.SchoolId,
EnrollId = enroll.Id,
PrivilegeId = enroll.PrivilegeId,
ActivityId = activity.Id,
YearId = years.Id,
Activity = activity.Name,
StatusId = students.StatusId,
Lastname = students.Lastname,
Firstname = students.Firstname,
Middlename = students.Middlename,
Sex = students.Sex,
NameGroup = groups.Name,
Year = years.Name,
Status = statuses.Name,
School = students.School.Name,
Class = students.Class,
Privilege = privileges.Name,
Accrual = (from scheds in db.Schedules
where scheds.Source == 2 && scheds.EnrollmentId == enroll.Id && scheds.DateBegin >= dtpStart.Value && scheds.DateBegin <= dtpEnd.Value
select new { SchedsSum = scheds.Value }).Sum(s => (double?)(s.SchedsSum)) ?? 0,
AccrualDiscount = (from scheds in db.Schedules
where scheds.Source == 2 && scheds.EnrollmentId == enroll.Id && scheds.DateBegin >= dtpStart.Value && scheds.DateBegin <= dtpEnd.Value
select new { SchedSum = scheds.Value - scheds.Discount }).Sum(s => (double?)(s.SchedSum)) ?? 0,
Payment = (from pays in db.Payments
where pays.EnrollmentId == enroll.Id && pays.DatePayment >= dtpStart.Value &&
pays.DatePayment <= dtpEnd.Value && pays.IsDeleted == false && pays.AdditionalPay == false
select new { PaySum = pays.ValuePayment }).Sum(s => (double?)(s.PaySum)) ?? 0,
};
if (idGroup != null)
{
listStudents = listStudents.Where(d => d.GroupId == idGroup);
}
if (lastname != null && lastname != "")
{
listStudents = listStudents.Where(e => e.Lastname.StartsWith(lastname));
}
if (privilege != null)
{
listStudents = listStudents.Where(e => e.PrivilegeId == privilege);
}
if (idYear != null)
{
listStudents = listStudents.Where(e => e.YearId == idYear);
}
if (activeGroups == "Активные")
{
listStudents = listStudents.Where(a => a.Activity != "Закрытые");
}
else
{
listStudents = listStudents.Where(a => a.Activity == activeGroups);
}
//сортировка
if (column != null)
{
switch (column)
{
case "Lastname":
{
if (sortOrder == SortOrder.Ascending)
{
listStudents = listStudents.OrderBy(x => x.Lastname);
}
else
{
listStudents = listStudents.OrderByDescending(x => x.Lastname);
}
break;
}
case "Firstname":
{
if (sortOrder == SortOrder.Ascending)
{
listStudents = listStudents.OrderBy(x => x.Firstname);
}
else
{
listStudents = listStudents.OrderByDescending(x => x.Firstname);
}
break;
}
case "Middlename":
{
if (sortOrder == SortOrder.Ascending)
{
listStudents = listStudents.OrderBy(x => x.Middlename);
}
else
{
listStudents = listStudents.OrderByDescending(x => x.Middlename);
}
break;
}
case "Status":
{
if (sortOrder == SortOrder.Ascending)
{
listStudents = listStudents.OrderBy(x => x.Status);
}
else
{
listStudents = listStudents.OrderByDescending(x => x.Status);
}
break;
}
case "NameGroup":
{
if (sortOrder == SortOrder.Ascending)
{
listStudents = listStudents.OrderBy(x => x.NameGroup);
}
else
{
listStudents = listStudents.OrderByDescending(x => x.NameGroup);
}
break;
}
case "Privilege":
{
if (sortOrder == SortOrder.Ascending)
{
listStudents = listStudents.OrderBy(x => x.Privilege);
}
else
{
listStudents = listStudents.OrderByDescending(x => x.Privilege);
}
break;
}
case "School":
{
if (sortOrder == SortOrder.Ascending)
{
listStudents = listStudents.OrderBy(x => x.School);
}
else
{
listStudents = listStudents.OrderByDescending(x => x.School);
}
break;
}
case "Class":
{
if (sortOrder == SortOrder.Ascending)
{
listStudents = listStudents.OrderBy(x => x.Class);
}
else
{
listStudents = listStudents.OrderByDescending(x => x.Class);
}
break;
}
case "Sex":
{
if (sortOrder == SortOrder.Ascending)
{
listStudents = listStudents.OrderBy(x => x.Sex);
}
else
{
listStudents = listStudents.OrderByDescending(x => x.Sex);
}
break;
}
case "Payment":
{
if (sortOrder == SortOrder.Ascending)
{
listStudents = listStudents.OrderBy(x => x.Payment);
}
else
{
listStudents = listStudents.OrderByDescending(x => x.Payment);
}
break;
}
case "AccrualDiscount":
{
if (sortOrder == SortOrder.Ascending)
{
listStudents = listStudents.OrderBy(x => x.AccrualDiscount);
}
else
{
listStudents = listStudents.OrderByDescending(x => x.AccrualDiscount);
}
break;
}
case "Accrual":
{
if (sortOrder == SortOrder.Ascending)
{
listStudents = listStudents.OrderBy(x => x.Accrual);
}
else
{
listStudents = listStudents.OrderByDescending(x => x.Accrual);
}
break;
}
}
}
else
{
listStudents = listStudents.OrderBy(f => f.Lastname);
}
dgvStudents.DataSource = listStudents.ToList();
///////////////////////расчет итогов/////////////////////////////
//количество групп
toolStripStatusLabel2.Text = dgvStudents.Rows.Count.ToString();
double summScheds = 0;
double summPays = 0;
double summDebt = 0;
double summPrepayment = 0;
foreach (DataGridViewRow row in dgvStudents.Rows)
{
//итого начислено со скидкой
summScheds += (double)row.Cells["AccrualDiscount"].Value;
//итого платежей
summPays += (double)row.Cells["Payment"].Value;
//итого долг
summDebt += ((double)row.Cells["Saldo"].Value > 0) ? (double)row.Cells["Saldo"].Value : 0;
//итого аванс
summPrepayment += ((double)row.Cells["Saldo"].Value < 0) ? (double)row.Cells["Saldo"].Value : 0;
}
if (sortOrder != SortOrder.None)
{
dgvStudents.Columns[sortColumn].HeaderCell.SortGlyphDirection = (SortOrder)sortOrder;
}
toolStripStatusLabel5.Text = summScheds.ToString("C", CultureInfo.CurrentCulture);
toolStripStatusLabel8.Text = summPays.ToString("C", CultureInfo.CurrentCulture);
toolStripStatusLabel9.Text = summDebt.ToString("C", CultureInfo.CurrentCulture);
toolStripStatusLabel11.Text = (-summPrepayment).ToString("C", CultureInfo.CurrentCulture);
}
catch (Exception ex)
{
var m = new System.Diagnostics.StackTrace(false).GetFrame(0).GetMethod();
string methodName = m.DeclaringType.ToString() + ";" + m.Name;
CurrentSession.ReportError(methodName, ex.Message);
MessageBox.Show(ex.Message, "Ошибка", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
public async Task OnGetAsync(SortOrder?sort)
{
Sort = sort;
var puzzleData = await _context.Puzzles
.Where(p => p.Event == Event && p.IsPuzzle)
.ToDictionaryAsync(p => p.ID, p => new { p.SolveValue, p.IsCheatCode, p.IsFinalPuzzle });
DateTime submissionEnd = Event.AnswerSubmissionEnd;
var stateData = await PuzzleStateHelper.GetSparseQuery(_context, this.Event, null, null)
.Where(pspt => pspt.SolvedTime != null && pspt.SolvedTime <= submissionEnd)
.Select(pspt => new { pspt.PuzzleID, pspt.TeamID, pspt.SolvedTime })
.ToListAsync();
var teams = await _context.Teams
.Where(t => t.Event == Event)
.ToListAsync();
Dictionary <int, TeamStats> teamStats = new Dictionary <int, TeamStats>(teams.Count);
foreach (var t in teams)
{
teamStats[t.ID] = new TeamStats {
Team = t, FinalMetaSolveTime = DateTime.MaxValue
};
}
foreach (var s in stateData)
{
if (!puzzleData.TryGetValue(s.PuzzleID, out var p) || !teamStats.TryGetValue(s.TeamID, out var ts))
{
continue;
}
ts.Score += p.SolveValue;
ts.SolveCount++;
if (p.IsCheatCode)
{
ts.Cheated = true;
ts.FinalMetaSolveTime = DateTime.MaxValue;
}
if (p.IsFinalPuzzle && !ts.Cheated)
{
ts.FinalMetaSolveTime = s.SolvedTime.Value;
}
}
var teamsFinal = teamStats.Values.OrderBy(t => t.FinalMetaSolveTime).ThenByDescending(t => t.Score).ThenBy(t => t.Team.Name).ToList();
TeamStats prevStats = null;
for (int i = 0; i < teamsFinal.Count; i++)
{
var stats = teamsFinal[i];
if (prevStats == null || stats.FinalMetaSolveTime != prevStats.FinalMetaSolveTime || stats.Score != prevStats.Score)
{
stats.Rank = i + 1;
}
else
{
stats.Rank = prevStats.Rank;
}
prevStats = stats;
}
switch (sort)
{
case SortOrder.RankAscending:
break;
case SortOrder.RankDescending:
teamsFinal.Reverse();
break;
case SortOrder.NameAscending:
teamsFinal = teamsFinal.OrderBy(ts => ts.Team.Name).ToList();
break;
case SortOrder.NameDescending:
teamsFinal = teamsFinal.OrderByDescending(ts => ts.Team.Name).ToList();
break;
case SortOrder.PuzzlesAscending:
teamsFinal = teamsFinal.OrderBy(ts => ts.SolveCount).ThenBy(ts => ts.Rank).ThenBy(ts => ts.Team.Name).ToList();
break;
case SortOrder.PuzzlesDescending:
teamsFinal = teamsFinal.OrderByDescending(ts => ts.SolveCount).ThenByDescending(ts => ts.Rank).ThenByDescending(ts => ts.Team.Name).ToList();
break;
case SortOrder.ScoreAscending:
teamsFinal = teamsFinal.OrderBy(ts => ts.Score).ThenBy(ts => ts.Rank).ThenBy(ts => ts.Team.Name).ToList();
break;
case SortOrder.ScoreDescending:
teamsFinal = teamsFinal.OrderByDescending(ts => ts.Score).ThenByDescending(ts => ts.Rank).ThenByDescending(ts => ts.Team.Name).ToList();
break;
case SortOrder.HintsUsedAscending:
teamsFinal = teamsFinal.OrderBy(ts => ts.Team.HintCoinsUsed).ThenBy(ts => ts.Rank).ThenBy(ts => ts.Team.Name).ToList();
break;
case SortOrder.HintsUsedDescending:
teamsFinal = teamsFinal.OrderByDescending(ts => ts.Team.HintCoinsUsed).ThenByDescending(ts => ts.Rank).ThenByDescending(ts => ts.Team.Name).ToList();
break;
}
this.Teams = teamsFinal;
}
public Grid SetDefaultSorting(string sortField, SortOrder sortOrder)
{
_sortField = sortField;
_sortOrder = sortOrder;
return(this);
}
/// <summary>
/// Searches for items
/// </summary>
/// <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>
/// <returns>A response</returns>
protected List <KeyValuePair <string, string> > BuildQueryStringParams(string searchTerm, string genreId, string id, Category?category, string location, string maxdistance, OrderBy?orderBy, SortOrder?sortOrder, int startIndex, int itemsPerPage)
{
// Build querystring parameters...
var parameters = this.GetPagingParams();
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.HasValue && category != Types.Category.Unknown)
{
foreach (var value in Enum.GetValues(typeof(Category)))
{
var availableCategory = (Category)value;
if (availableCategory == Types.Category.Unknown)
{
continue;
}
if ((category & availableCategory) == availableCategory)
{
parameters.Add(new KeyValuePair <string, string>(
ParamCategory,
availableCategory.ToString().ToLowerInvariant()));
}
}
}
if (orderBy.HasValue)
{
parameters.Add(new KeyValuePair <string, string>(ParamOrderBy, orderBy.Value.ToString().ToLowerInvariant()));
}
if (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));
}
return(parameters);
}
public static SortOrder Invert(this SortOrder?sortOrder, SortOrder @default = SortOrder.Asc)
{
return(sortOrder.GetValueOrDefault(@default) == SortOrder.Asc
? SortOrder.Desc
: SortOrder.Asc);
}
public IEnumerable <T> GetAll <T1>(Expression <Func <T, bool> > filterExpression,
Expression <Func <T, T1> > sortExpression,
SortOrder?sortOrder = null)
{
return(this.GetAll <T1, T>(filterExpression, sortExpression, sortOrder, null));
}
public void Filter(string lastname, int?idGroup, DateTime?dateEnrollment, DateTime?dateExclusion, int?typeId, string column, bool transfer, SortOrder?sortOrder)
{
listStudents = from enroll in db.Enrollments
join groups in db.Groups on enroll.GroupId equals groups.Id
join activity in db.ActivityGroups on groups.ActivityId equals activity.Id
join students in db.Students on enroll.StudentId equals students.Id
join schools in db.Schools on students.SchoolId equals schools.Id into outer2
from schools in outer2.DefaultIfEmpty()
join causes in db.Causes on enroll.CauseId equals causes.Id into outer1
from causes in outer1.DefaultIfEmpty()
join months in db.Months on enroll.MonthExclusionId equals months.Id into outer
from months in outer.DefaultIfEmpty()
join teachers in db.Workers on groups.TeacherId equals teachers.Id into outer3
from teachers in outer3.DefaultIfEmpty()
join years in db.Years on groups.YearId equals years.Id into outer4
from years in outer4.DefaultIfEmpty()
where enroll.Group.ActivityId == 1 || enroll.ExclusionId != null
select new Archive
{
StudentId = students.Id,
GroupId = groups.Id,
SchoolId = students.SchoolId,
EnrollId = enroll.Id,
YearId = years.Id,
ActivityId = activity.Id,
Lastname = students.Lastname,
Firstname = students.Firstname,
Middlename = students.Middlename,
NameGroup = groups.Name,
Year = years.Name,
Status = activity.Name,
Teacher = teachers.Lastname + " " + teachers.Firstname.Substring(0, 1) + "." + teachers.Middlename.Substring(0, 1) + ".",
DateEnrollment = enroll.DateEnrollment,
DateExclusion = enroll.DateExclusion,
Cause = causes.Name,
Transfer = enroll.Transfer,
Note = enroll.Note,
Phone1 = students.StudentPhone,
Phone2 = students.StudentPhone2,
ParentPhone = students.ParentsPhone,
Sex = students.Sex,
BirthDate = students.DateOfBirth,
School = schools.Name,
Class = students.Class
};
if (typeId != null)
{
listStudents = listStudents.Where(d => d.YearId == typeId);
}
if (idGroup != null)
{
listStudents = listStudents.Where(d => d.GroupId == idGroup);
}
if (lastname != null && lastname != "")
{
listStudents = listStudents.Where(e => e.Lastname.StartsWith(lastname));
}
if (dateBegin)
{
listStudents = listStudents.Where(a => a.DateExclusion.Value >= dtpDateBegin.Value.Date);
}
if (dateEnd)
{
listStudents = listStudents.Where(a => a.DateExclusion.Value <= dtpDateEnd.Value.Date);
}
if (transfer)
{
listStudents = listStudents.Where(a => a.Transfer == true);
}
else
{
listStudents = listStudents.Where(a => a.Transfer == false);
}
//сортировка
if (column != null)
{
switch (column)
{
case "Lastname":
{
if (sortOrder == SortOrder.Ascending)
{
listStudents = listStudents.OrderBy(x => x.Lastname);
}
else
{
listStudents = listStudents.OrderByDescending(x => x.Lastname);
}
break;
}
case "Firstname":
{
if (sortOrder == SortOrder.Ascending)
{
listStudents = listStudents.OrderBy(x => x.Firstname);
}
else
{
listStudents = listStudents.OrderByDescending(x => x.Firstname);
}
break;
}
case "Middlename":
{
if (sortOrder == SortOrder.Ascending)
{
listStudents = listStudents.OrderBy(x => x.Middlename);
}
else
{
listStudents = listStudents.OrderByDescending(x => x.Middlename);
}
break;
}
case "Status":
{
if (sortOrder == SortOrder.Ascending)
{
listStudents = listStudents.OrderBy(x => x.Status);
}
else
{
listStudents = listStudents.OrderByDescending(x => x.Status);
}
break;
}
case "NameGroup":
{
if (sortOrder == SortOrder.Ascending)
{
listStudents = listStudents.OrderBy(x => x.NameGroup);
}
else
{
listStudents = listStudents.OrderByDescending(x => x.NameGroup);
}
break;
}
case "Teacher":
{
if (sortOrder == SortOrder.Ascending)
{
listStudents = listStudents.OrderBy(x => x.Teacher);
}
else
{
listStudents = listStudents.OrderByDescending(x => x.Teacher);
}
break;
}
case "Phone1":
{
if (sortOrder == SortOrder.Ascending)
{
listStudents = listStudents.OrderBy(x => x.Phone1);
}
else
{
listStudents = listStudents.OrderByDescending(x => x.Phone1);
}
break;
}
case "Phone2":
{
if (sortOrder == SortOrder.Ascending)
{
listStudents = listStudents.OrderBy(x => x.Phone2);
}
else
{
listStudents = listStudents.OrderByDescending(x => x.Phone2);
}
break;
}
case "ParentPhone":
{
if (sortOrder == SortOrder.Ascending)
{
listStudents = listStudents.OrderBy(x => x.ParentPhone);
}
else
{
listStudents = listStudents.OrderByDescending(x => x.ParentPhone);
}
break;
}
case "BirthDate":
{
if (sortOrder == SortOrder.Ascending)
{
listStudents = listStudents.OrderBy(x => x.BirthDate);
}
else
{
listStudents = listStudents.OrderByDescending(x => x.BirthDate);
}
break;
}
case "School":
{
if (sortOrder == SortOrder.Ascending)
{
listStudents = listStudents.OrderBy(x => x.School);
}
else
{
listStudents = listStudents.OrderByDescending(x => x.School);
}
break;
}
case "Class":
{
if (sortOrder == SortOrder.Ascending)
{
listStudents = listStudents.OrderBy(x => x.Class);
}
else
{
listStudents = listStudents.OrderByDescending(x => x.Class);
}
break;
}
case "Transfer":
{
if (sortOrder == SortOrder.Ascending)
{
listStudents = listStudents.OrderBy(x => x.Transfer);
}
else
{
listStudents = listStudents.OrderByDescending(x => x.Transfer);
}
break;
}
case "Note":
{
if (sortOrder == SortOrder.Ascending)
{
listStudents = listStudents.OrderBy(x => x.Note);
}
else
{
listStudents = listStudents.OrderByDescending(x => x.Note);
}
break;
}
case "DateExclusion":
{
if (sortOrder == SortOrder.Ascending)
{
listStudents = listStudents.OrderBy(x => x.DateExclusion);
}
else
{
listStudents = listStudents.OrderByDescending(x => x.DateExclusion);
}
break;
}
case "DateEnrollment":
{
if (sortOrder == SortOrder.Ascending)
{
listStudents = listStudents.OrderBy(x => x.DateEnrollment);
}
else
{
listStudents = listStudents.OrderByDescending(x => x.DateEnrollment);
}
break;
}
case "Cause":
{
if (sortOrder == SortOrder.Ascending)
{
listStudents = listStudents.OrderBy(x => x.Cause);
}
else
{
listStudents = listStudents.OrderByDescending(x => x.Cause);
}
break;
}
case "Sex":
{
if (sortOrder == SortOrder.Ascending)
{
listStudents = listStudents.OrderBy(x => x.Sex);
}
else
{
listStudents = listStudents.OrderByDescending(x => x.Sex);
}
break;
}
}
}
else
{
listStudents = listStudents.OrderBy(f => f.Lastname);
}
dgvStudents.DataSource = listStudents.ToList();
if (sortOrder != SortOrder.None)
{
dgvStudents.Columns[sortColumn].HeaderCell.SortGlyphDirection = (SortOrder)sortOrder;
}
}
public async Task <IActionResult> Get(int?pageNumber, int?pageSize, string?sortBy, SortOrder?sortDirection)
{
this.logger.LogInformation("Getting all search queries...");
var pageRequest = new PageRequest
{
PageNumber = pageNumber ?? 1,
PageSize = pageSize ?? 10,
Sort = new Sort {
Property = sortBy ?? "id", Order = sortDirection ?? SortOrder.Ascending
}
};
var queryable = this.queries.GetSummaries();
if (pageRequest.Sort != null)
{
queryable = queryable.OrderBy(new[] { pageRequest.Sort });
}
queryable = queryable
.Skip((pageRequest.PageNumber - 1) * pageRequest.PageSize)
.Take(pageRequest.PageSize);
var page = new Page <SearchQuerySummary>
{
PageNumber = pageRequest.PageNumber,
PageSize = pageRequest.PageSize,
TotalItems = await this.queries.GetSummaries().CountAsync(),
Items = await queryable.ToListAsync(),
Sort = pageRequest.Sort ?? new Sort
{
Property = "id"
}
};
return(this.Ok(page));
}
public IReadOnlyList <TModel> GetAllByFilterAndPage(Specification <TModel, bool> specification, Specification <TModel, object> orderSpecification = null, SortOrder?sortOrder = null, int?pageNumber = 0)
{
if (orderSpecification == null || sortOrder == null)
{
return(DbContext.Set <TModel>()
.Where(specification?.ToExpression() ?? throw new InvalidOperationException())
.OrderBy("CreatedDate")
.Skip(PageSize * pageNumber ?? 0)
.Take(PageSize)?
.ToList() as List <TModel>);
}
else
{
if (sortOrder == SortOrder.Asc)
{
return(DbContext.Set <TModel>()
.Where(specification?.ToExpression() ?? throw new InvalidOperationException())
.OrderBy(orderSpecification?.ToExpression() ?? throw new InvalidOperationException())
.Skip(PageSize * pageNumber ?? 0)
.Take(PageSize)?
.ToList() as List <TModel>);
}
else
{
return(DbContext.Set <TModel>()
.Where(specification?.ToExpression() ?? throw new InvalidOperationException())
.OrderByDescending(orderSpecification?.ToExpression() ?? throw new InvalidOperationException())
.Skip(PageSize * pageNumber ?? 0)
.Take(PageSize)?
.ToList() as List <TModel>);
}
}
}
/// <summary>
/// The initial sorting order when we use datatypes xml or json (data returned from server).
/// This parameter is added to the url. Two possible values - asc or desc. (default: asc)
/// </summary>
/// <param name="sortOrder">Sortorder</param>
public Grid SetSortOrder(SortOrder sortOrder)
{
this.sortOrder = sortOrder;
return this;
}
private void Filter(int?directionId, string name, int?type, string activeGroupsName, string column, DateTime dtStart, DateTime dtEnd, SortOrder?sortOrder)
{
try
{
var listGroups = from groups in db.Groups
join courses in db.Courses on groups.CourseId equals courses.Id
join directions in db.Directions on courses.DirectionId equals directions.Id
join teachers in db.Workers on groups.TeacherId equals teachers.Id into outerTeacher
from teachers in outerTeacher.DefaultIfEmpty()
join activities in db.ActivityGroups on groups.ActivityId equals activities.Id
join years in db.Years on groups.YearId equals years.Id into outer
from years in outer.DefaultIfEmpty()
select new FinanceGroups
{
GroupId = groups.Id,
DirectionId = directions.Id,
Direction = directions.Name,
ActivityId = activities.Id,
YearId = years.Id,
CourseName = courses.Name,
Name = groups.Name,
Year = years.Name,
StudentsP = groups.PlanEnroll,
StudentsF = db.Enrollments.Where(a => a.GroupId == groups.Id && a.DateExclusion == null).Count(),
Activity = activities.Name,
Price = db.Schedules.Where(a => a.GroupId == groups.Id && a.Source == 2 && a.EnrollmentId == null && a.DateBegin >= dtpStart.Value.Date &&
a.DateBegin <= dtpEnd.Value.Date).Select(a => new { a.Value }).Sum(s => (double?)(s.Value)) ?? 0,
Accrual = (from scheds in db.Schedules
join enrolls in db.Enrollments on scheds.EnrollmentId equals enrolls.Id
where scheds.Source == 2 && scheds.EnrollmentId != null && scheds.GroupId == groups.Id && enrolls.DateExclusion == null &&
scheds.DateBegin >= dtpStart.Value.Date && scheds.DateBegin <= dtpEnd.Value.Date
select new { SchedSum = scheds.Value }).Sum(s => (double?)(s.SchedSum)) ?? 0,
AccrualDiscount = (Double?)(from scheds in db.Schedules
join enrolls in db.Enrollments on scheds.EnrollmentId equals enrolls.Id
where scheds.Source == 2 && scheds.EnrollmentId != null && scheds.GroupId == groups.Id && enrolls.DateExclusion == null &&
scheds.DateBegin >= dtpStart.Value.Date && scheds.DateBegin <= dtpEnd.Value.Date
select new { SchedSum = scheds.Value - scheds.Discount }).Sum(s => (double?)(s.SchedSum)) ?? 0,
Payment = (Double?)(from pays in db.Payments
join enrolls in db.Enrollments on pays.EnrollmentId equals enrolls.Id
where enrolls.GroupId == groups.Id && enrolls.DateExclusion == null && pays.IsDeleted == false && pays.AdditionalPay == false &&
pays.DatePayment >= dtpStart.Value && pays.DatePayment <= dtpEnd.Value
select new { PaySum = pays.ValuePayment }).Sum(s => (double?)(s.PaySum)) ?? 0,
};
if (directionId != null)
{
listGroups = listGroups.Where(d => d.DirectionId == directionId);
}
if (name != null && name != "")
{
listGroups = listGroups.Where(e => e.Name.StartsWith(name));
}
if (type != null)
{
listGroups = listGroups.Where(d => d.YearId == type);
}
if (activeGroupsName == "Активные")
{
listGroups = listGroups.Where(a => a.Activity != "Закрытые");
}
else
{
listGroups = listGroups.Where(a => a.Activity == activeGroupsName);
}
//сортировка
if (column != null)
{
switch (column)
{
case "Direction":
{
if (sortOrder == SortOrder.Ascending)
{
listGroups = listGroups.OrderBy(x => x.Direction);
}
else
{
listGroups = listGroups.OrderByDescending(x => x.Direction);
}
break;
}
case "Name":
{
if (sortOrder == SortOrder.Ascending)
{
listGroups = listGroups.OrderBy(x => x.Name);
}
else
{
listGroups = listGroups.OrderByDescending(x => x.Name);
}
break;
}
case "Year":
{
if (sortOrder == SortOrder.Ascending)
{
listGroups = listGroups.OrderBy(x => x.Year);
}
else
{
listGroups = listGroups.OrderByDescending(x => x.Year);
}
break;
}
case "StudentsF":
{
if (sortOrder == SortOrder.Ascending)
{
listGroups = listGroups.OrderBy(x => x.StudentsF);
}
else
{
listGroups = listGroups.OrderByDescending(x => x.StudentsF);
}
break;
}
}
}
else
{
listGroups = listGroups.OrderBy(f => f.Direction);
}
dgvListGroups.DataSource = listGroups.ToList();
///////////////////////расчет итогов/////////////////////////////
//количество групп
toolStripStatusLabel2.Text = dgvListGroups.Rows.Count.ToString();
double summScheds = 0;
double summPays = 0;
double summDebt = 0;
double summPrepayment = 0;
foreach (DataGridViewRow row in dgvListGroups.Rows)
{
//итого начислено со скидкой
summScheds += (double)row.Cells["AccrualDiscount"].Value;
//итого платежей
summPays += (double)row.Cells["Payment"].Value;
//итого долг
summDebt += ((double)row.Cells["Saldo"].Value > 0) ? (double)row.Cells["Saldo"].Value : 0;
//итого аванс
summPrepayment += ((double)row.Cells["Saldo"].Value < 0) ? (double)row.Cells["Saldo"].Value : 0;
}
if (sortOrder != SortOrder.None)
{
dgvListGroups.Columns[sortColumn].HeaderCell.SortGlyphDirection = (SortOrder)sortOrder;
}
toolStripStatusLabel4.Text = summScheds.ToString("C", CultureInfo.CurrentCulture);
toolStripStatusLabel6.Text = summPays.ToString("C", CultureInfo.CurrentCulture);
toolStripStatusLabel9.Text = summDebt.ToString("C", CultureInfo.CurrentCulture);
toolStripStatusLabel11.Text = (-summPrepayment).ToString("C", CultureInfo.CurrentCulture);
}
catch (Exception ex)
{
var m = new System.Diagnostics.StackTrace(false).GetFrame(0).GetMethod();
string methodName = m.DeclaringType.ToString() + ";" + m.Name;
CurrentSession.ReportError(methodName, ex.Message);
MessageBox.Show(ex.Message, "Ошибка", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
public IReadOnlyList <TModel> GetAllByFilter(Specification <TModel, bool> specification, Specification <TModel, object> orderSpecification = null, SortOrder?sortOrder = null)
{
if (orderSpecification == null || sortOrder == null)
{
return(DbContext.Set <TModel>()?
.Where(specification?.ToExpression() ?? throw new InvalidOperationException())?
.OrderBy("CreatedDate")
.ToList() as List <TModel>);
}
else
{
return(DbContext.Set <TModel>()
.Where(specification?.ToExpression() ?? throw new InvalidOperationException())
.OrderBy(orderSpecification?.ToExpression() ?? throw new InvalidOperationException())
.ToList() as List <TModel>);
}
}
public GridTasksSortSettings(TaskFieldsUI firstColumn, SortOrder firstColumnSortOrder, TaskFieldsUI?secondColumn, SortOrder?secondColumnOrder)
{
FirstColumn = firstColumn;
FirstColumnSortOrder = firstColumnSortOrder;
SecondColumn = secondColumn;
SecondColumnSortOrder = secondColumnOrder;
}
public async Task OnGetAsync(SortOrder?sort)
{
Sort = sort;
var teamsData = await PuzzleStateHelper.GetSparseQuery(_context, this.Event, null, null)
.Where(s => s.SolvedTime != null && s.Puzzle.IsPuzzle)
.GroupBy(state => state.Team)
.Select(g => new {
Team = g.Key,
SolveCount = g.Count(),
Score = g.Sum(s => s.Puzzle.SolveValue),
FinalMetaSolveTime = g.Where(s => s.Puzzle.IsCheatCode).Any() ?
DateTime.MaxValue :
(g.Where(s => s.Puzzle.IsFinalPuzzle).Select(s => s.SolvedTime).FirstOrDefault() ?? DateTime.MaxValue)
})
.OrderBy(t => t.FinalMetaSolveTime).ThenByDescending(t => t.Score).ThenBy(t => t.Team.Name)
.ToListAsync();
var teams = new List <TeamStats>(teamsData.Count);
TeamStats prevStats = null;
for (int i = 0; i < teamsData.Count; i++)
{
var data = teamsData[i];
var stats = new TeamStats()
{
Team = data.Team,
SolveCount = data.SolveCount,
Score = data.Score,
FinalMetaSolveTime = data.FinalMetaSolveTime
};
if (prevStats == null || stats.FinalMetaSolveTime != prevStats.FinalMetaSolveTime || stats.Score != prevStats.Score)
{
stats.Rank = i + 1;
}
else
{
stats.Rank = prevStats.Rank;
}
teams.Add(stats);
prevStats = stats;
}
switch (sort)
{
case SortOrder.RankAscending:
break;
case SortOrder.RankDescending:
teams.Reverse();
break;
case SortOrder.NameAscending:
teams.Sort((a, b) => a.Team.Name.CompareTo(b.Team.Name));
break;
case SortOrder.NameDescending:
teams.Sort((a, b) => - a.Team.Name.CompareTo(b.Team.Name));
break;
case SortOrder.PuzzlesAscending:
teams.Sort((a, b) => a.SolveCount.CompareTo(b.SolveCount));
break;
case SortOrder.PuzzlesDescending:
teams.Sort((a, b) => - a.SolveCount.CompareTo(b.SolveCount));
break;
case SortOrder.ScoreAscending:
teams.Sort((a, b) => a.Score.CompareTo(b.Score));
break;
case SortOrder.ScoreDescending:
teams.Sort((a, b) => - a.Score.CompareTo(b.Score));
break;
case SortOrder.HintsUsedAscending:
teams.Sort((a, b) => a.Score.CompareTo(b.Team.HintCoinsUsed));
break;
case SortOrder.HintsUsedDescending:
teams.Sort((a, b) => - a.Score.CompareTo(b.Team.HintCoinsUsed));
break;
}
this.Teams = teams;
}
public static CustomResponse WithGridResponse(this CustomResponse customResponse, int totalMatches, int currentPage, int count, string sortBy = null, SortOrder?sortOrder = null)
{
if (currentPage < 1)
{
currentPage = 1;
}
count = Math.Min(count, totalMatches);
var r = customResponse.With("current", currentPage)
.With("rowCount", count)
.With("rangeStart", (currentPage - 1) * count + 1)
.With("rangeEnd", currentPage * count)
.With("total", totalMatches);
if (!sortBy.IsNullEmptyOrWhiteSpace())
{
r.With("sortBy", sortBy);
}
if (sortOrder.HasValue)
{
r.With("sortOrder", sortOrder.Value);
}
return(r);
}
/// <summary>
/// Gets the files for folder.
/// </summary>
/// <param name="folderId">The folder id.</param>
/// <param name="filters">The filters.</param>
/// <param name="limit">The limit.</param>
/// <param name="offset">The offset.</param>
/// <param name="sortBy">The sort by.</param>
/// <param name="sortOrder">The sort order.</param>
/// <returns></returns>
/// <exception cref="System.ArgumentNullException"></exception>
public static string GetFilesForFolder(string folderId, List <FolderFilter> filters = null, int?limit = null, int?offset = null, SortBy?sortBy = null, SortOrder?sortOrder = null)
{
if (string.IsNullOrEmpty(folderId))
{
throw new ArgumentNullException(folderId);
}
var query = GetQuery(filters, limit, offset, sortBy, sortOrder);
return(string.Format("{0}/{1}{2}", folderId, SkyDriveConstants.GetFiles, query));
}
public GridIssuesSortSettings(IssueFieldsUI firstColumn, SortOrder firstColumnSortOrder, IssueFieldsUI?secondColumn, SortOrder?secondColumnOrder)
{
FirstColumn = firstColumn;
FirstColumnSortOrder = firstColumnSortOrder;
SecondColumn = secondColumn;
SecondColumnSortOrder = secondColumnOrder;
}
// GET: Advanced Song Search
public ActionResult SongAdvancedSearchResults(string SongSearchString, string ArtistSearchString, string AlbumSearchString, int[] SelectedGenres, decimal?SongRatingDec, Operation?SelectedSongRatingOperation, SortOrder?SelectedSortOrder)
{
// create the list of songs with no data
List <Song> SelectedSongList = new List <Song>();
foreach (var item in db.Songs)
{
item.SongAverage = GetSongAverage(item.SongID);
}
var query = from c in db.Songs
select c;
//code to find songs by name
if (SongSearchString != null && SongSearchString != "")
{
query = query.Where(c => c.SongName.Contains(SongSearchString));
}
//code to find songs by artist
if (ArtistSearchString != null && ArtistSearchString != "")
{
query = query.Where(c => c.SongArtists.Any(g => g.ArtistName.Contains(ArtistSearchString)));
}
//code to find songs by album
if (AlbumSearchString != null && AlbumSearchString != "")
{
query = query.Where(c => c.SongAlbums.Any(g => g.AlbumName.Contains(AlbumSearchString)));
}
//code to find songs by rating
if (SongRatingDec != null && SelectedSongRatingOperation != null)
{
//if the user entered a number <1 or >5
if (SongRatingDec < 1 || SongRatingDec > 5)
{
ViewBag.ErrorMessage = "Please specify a number between 1.0 and 5.0 inclusive.";
return(View("SongAdvancedSearch"));
}
Decimal AverageRatingsSearch;
try
{
AverageRatingsSearch = Convert.ToDecimal(SongRatingDec);
if (SelectedSongRatingOperation == Operation.LessThan)
{
query = query.Where(c => c.SongAverage < AverageRatingsSearch);
}
else
{
query = query.Where(c => c.SongAverage < AverageRatingsSearch);
}
}
catch // will display when something is wrong
{
//Add error message to viewbag
ViewBag.ErrorMessage = "Please specify a valid rating number";
return(View("SongAdvancedSearch"));
}
}
//code to find songss by genre
if (SelectedGenres != null)
{
List <Song> SongGenreList = new List <Song>();
foreach (var item in SelectedGenres)
{
foreach (var item2 in query.Where(c => c.SongGenres.Any(g => g.GenreID == item)).ToList())
{
SongGenreList.Add(item2);
}
}
//select disctinct item in list
var distinctNames = (from d in SongGenreList select d).Distinct();
//if they selected a sort order
if (SelectedSortOrder != null)
{
if (SelectedSortOrder == SortOrder.AscendingName)
{
distinctNames = distinctNames.OrderBy(d => d.SongName);
}
else if (SelectedSortOrder == SortOrder.DescendingName)
{
distinctNames = distinctNames.OrderByDescending(d => d.SongName);
}
else if (SelectedSortOrder == SortOrder.AscendingArtist)
{
distinctNames = distinctNames.OrderBy(d => d.SongArtists.First().ArtistName);
}
else if (SelectedSortOrder == SortOrder.DescendingArtist)
{
distinctNames = distinctNames.OrderByDescending(d => d.SongArtists.First().ArtistName);
}
else if (SelectedSortOrder == SortOrder.AscendingRating)
{
distinctNames = distinctNames.OrderBy(d => d.SongAverage);
}
else if (SelectedSortOrder == SortOrder.DescendingRating)
{
distinctNames = distinctNames.OrderByDescending(d => d.SongAverage);
}
}
ViewBag.TotalCount = db.Songs.Count();
ViewBag.ResultsCount = distinctNames.Count();
return(View("SongSearchIndex", distinctNames));
}
//if they selected a sort order
if (SelectedSortOrder != null)
{
if (SelectedSortOrder == SortOrder.AscendingName)
{
query = query.OrderBy(d => d.SongName);
}
else if (SelectedSortOrder == SortOrder.DescendingName)
{
query = query.OrderByDescending(d => d.SongName);
}
else if (SelectedSortOrder == SortOrder.AscendingArtist)
{
query = query.OrderBy(d => d.SongArtists.First().ArtistName);
}
else if (SelectedSortOrder == SortOrder.DescendingArtist)
{
query = query.OrderByDescending(d => d.SongArtists.First().ArtistName);
}
else if (SelectedSortOrder == SortOrder.AscendingRating)
{
query = query.OrderBy(d => d.SongAverage);
}
else if (SelectedSortOrder == SortOrder.DescendingRating)
{
query = query.OrderByDescending(d => d.SongAverage);
}
}
SelectedSongList = query.ToList();
ViewBag.TotalCount = db.Songs.Count();
ViewBag.ResultsCount = SelectedSongList.Count();
return(View("SongSearchIndex", SelectedSongList));
}
public async Task OnGetAsync(SortOrder?sort, PuzzleStateFilter?stateFilter)
{
this.Sort = sort;
this.StateFilter = stateFilter;
this.CurrentTeam = (await UserEventHelper.GetTeamForPlayer(_context, Event, LoggedInUser));
Dictionary <int, string> teamNameLookup = new Dictionary <int, string>();
// build an ID-to-name mapping to improve perf
var names = await _context.Teams.Where(t => t.Event == Event)
.Select(t => new { t.ID, t.Name })
.ToListAsync();
names.ForEach(t => teamNameLookup[t.ID] = t.Name);
DateTime submissionEnd = Event.AnswerSubmissionEnd;
// get the page data: puzzle, solve count, top three fastest
var puzzlesData = await PuzzleStateHelper.GetSparseQuery(_context, this.Event, null, null)
.Where(s => s.SolvedTime != null && s.Puzzle.IsPuzzle && s.SolvedTime <= submissionEnd)
.GroupBy(state => state.Puzzle)
.Select(g => new {
Puzzle = g.Key,
SolveCount = g.Count(),
Fastest = g.OrderBy(s => s.SolvedTime - s.UnlockedTime).Take(3).Select(s => new { s.Team.ID, Time = s.SolvedTime - s.UnlockedTime }),
IsSolvedByUserTeam = g.Where(s => s.Team == this.CurrentTeam).Any()
})
.OrderByDescending(p => p.SolveCount).ThenBy(p => p.Puzzle.Name)
.ToListAsync();
var unlockedData = this.CurrentTeam == null ? null : (new HashSet <int>(
await PuzzleStateHelper.GetSparseQuery(_context, this.Event, null, null)
.Where(state => state.Team == this.CurrentTeam && state.UnlockedTime != null)
.Select(s => s.PuzzleID)
.ToListAsync()));
var puzzles = new List <PuzzleStats>(puzzlesData.Count);
for (int i = 0; i < puzzlesData.Count; i++)
{
var data = puzzlesData[i];
// For players, we will hide puzzles they have not unlocked yet.
if (EventRole == EventRole.play &&
(unlockedData == null ||
!unlockedData.Contains(data.Puzzle.ID)))
{
continue;
}
var stats = new PuzzleStats()
{
Puzzle = data.Puzzle,
SolveCount = data.SolveCount,
SortOrder = i,
Fastest = data.Fastest.Select(f => new FastRecord()
{
ID = f.ID, Name = teamNameLookup[f.ID], Time = f.Time
}).ToArray(),
IsSolved = data.IsSolvedByUserTeam
};
puzzles.Add(stats);
}
if (this.StateFilter == PuzzleStateFilter.Unsolved)
{
puzzles = puzzles.Where(stats => !stats.IsSolved).ToList();
}
switch (sort ?? DefaultSort)
{
case SortOrder.RankAscending:
puzzles.Sort((rhs, lhs) => (rhs.SortOrder - lhs.SortOrder));
break;
case SortOrder.RankDescending:
puzzles.Sort((rhs, lhs) => (lhs.SortOrder - rhs.SortOrder));
break;
case SortOrder.CountAscending:
puzzles.Sort((rhs, lhs) => (rhs.SolveCount - lhs.SolveCount));
break;
case SortOrder.CountDescending:
puzzles.Sort((rhs, lhs) => (lhs.SolveCount - rhs.SolveCount));
break;
case SortOrder.PuzzleAscending:
puzzles.Sort((rhs, lhs) => (String.Compare(rhs.Puzzle.Name,
lhs.Puzzle.Name,
StringComparison.OrdinalIgnoreCase)));
break;
case SortOrder.PuzzleDescending:
puzzles.Sort((rhs, lhs) => (String.Compare(lhs.Puzzle.Name,
rhs.Puzzle.Name,
StringComparison.OrdinalIgnoreCase)));
break;
default:
throw new ArgumentException($"unknown sort: {sort}");
}
this.Puzzles = puzzles;
}
public ActionResult Index(string SearchNum, string SearchString, int?daysBack, DateTime?startDate, DateTime?endDate, int?price, decimal?priceFloor, decimal?priceCap, TransactionType?SelectedType, TransactionStatus?ApprovalStatus, SortOrder?SelectedSortOrder)
{
if ((SearchNum == null || SearchNum == "") && (SearchString == null || SearchNum == "") && (daysBack == null) && (startDate == null) && (endDate == null) && (price == null) && (priceFloor == null) && (priceCap == null) && (SelectedType == null))
{
//ViewBag.NumberAllTransactions = db.Transactions.ToList().Count();
//ViewBag.NumberSelectedTransactions = db.Transactions.ToList().Count();
var queryA = from t in db.Transactions
select t;
queryA = queryA.Where(t => t.ApprovalStatus == TransactionStatus.Approved);
List <Transaction> ApprovedTransactions = queryA.ToList();
ViewBag.NumberAllTransactions = db.Transactions.ToList().Count();
ViewBag.NumberSelectedTransactions = ApprovedTransactions.Count;
return(View(ApprovedTransactions));
//return View(db.Transactions);
}
var query = from t in db.Transactions
select t;
// Search by number
if (SearchNum == null || SearchNum == "")
{
query = query;
}
else
{
query = query.Where(t => t.TransactionID.ToString().Contains(SearchNum));
}
// Search by name
if (SearchString == null || SearchString == "")
{
query = query;
}
else
{
query = query.Where(t => t.TransactionDescription.Contains(SearchString));
}
// Filter by date
if (daysBack == 0)
{
query = query;
}
else
{
if (daysBack == 696969)
{
query = query.Where(t => t.TransactionDate >= startDate && t.TransactionDate <= endDate);
}
else
{
var oldestDate = (DateTime.Today).AddDays(Convert.ToDouble(daysBack) * -1);
query = query.Where(t => t.TransactionDate >= oldestDate);
}
}
// Filter by price
if (price == 707070)
{
query = query;
}
else
{
if (price == 696969)
{
query = query.Where(t => t.TransactionAmount >= priceFloor && t.TransactionAmount <= priceCap);
}
else
{
if (price == 300)
{
query = query.Where(t => t.TransactionAmount >= price);
}
else
{
var rangeCap = price + 100;
query = query.Where(t => t.TransactionAmount >= price && t.TransactionAmount <= rangeCap);
}
}
}
// Filter by type
if (SelectedType == null)
{
query = query;
}
else
{
query = query.Where(t => t.TypeOfTransaction == SelectedType);
}
if (SelectedSortOrder == SortOrder.AscTransactionNumber)
{
query = query.OrderBy(t => t.TransactionID);
}
if (SelectedSortOrder == SortOrder.DescTransactionNumber)
{
query = query.OrderByDescending(t => t.TransactionID);
}
if (SelectedSortOrder == SortOrder.AscTransactionType)
{
query = query.OrderBy(t => t.TypeOfTransaction.ToString());
}
if (SelectedSortOrder == SortOrder.DescTransactionType)
{
query = query.OrderByDescending(t => t.TypeOfTransaction.ToString());
}
if (SelectedSortOrder == SortOrder.AscTransactionDescription)
{
query = query.OrderBy(t => t.TransactionDescription);
}
if (SelectedSortOrder == SortOrder.DescTransactionDescription)
{
query = query.OrderByDescending(t => t.TransactionDescription);
}
if (SelectedSortOrder == SortOrder.AscTransactionAmount)
{
query = query.OrderBy(t => t.TransactionAmount);
}
if (SelectedSortOrder == SortOrder.DescTransactionAmount)
{
query = query.OrderByDescending(t => t.TransactionAmount);
}
if (SelectedSortOrder == SortOrder.AscTransactionDate)
{
query = query.OrderBy(t => t.TransactionDate);
}
if (SelectedSortOrder == SortOrder.DescTransactionDate)
{
query = query.OrderByDescending(t => t.TransactionDate);
}
List <Transaction> SelectedTransactions = query.ToList();
ViewBag.NumberAllTransactions = db.Transactions.ToList().Count();
ViewBag.NumberSelectedTransactions = SelectedTransactions.Count;
return(View(SelectedTransactions));
}
public async Task <IActionResult> OnGetAsync(int?puzzleId, int?teamId, SortOrder?sort)
{
Sort = sort;
IQueryable <Submission> submissionsQ = null;
if (puzzleId == null)
{
if (EventRole == EventRole.admin)
{
if (teamId == null)
{
submissionsQ = _context.Submissions.Where((s) => s.Puzzle.Event == Event);
}
else
{
submissionsQ = _context.Submissions.Where((s) => s.Team.ID == teamId);
}
}
else
{
if (teamId == null)
{
submissionsQ = UserEventHelper.GetPuzzlesForAuthorAndEvent(_context, Event, LoggedInUser)
.SelectMany((p) => p.Submissions);
}
else
{
submissionsQ = UserEventHelper.GetPuzzlesForAuthorAndEvent(_context, Event, LoggedInUser)
.SelectMany((p) => p.Submissions.Where((s) => s.Team.ID == teamId));
}
}
}
else
{
Puzzle = await _context.Puzzles.Where(m => m.ID == puzzleId).FirstOrDefaultAsync();
if (EventRole == EventRole.author && !await UserEventHelper.IsAuthorOfPuzzle(_context, Puzzle, LoggedInUser))
{
return(Forbid());
}
if (teamId == null)
{
submissionsQ = _context.Submissions.Where((s) => s.Puzzle != null && s.Puzzle.ID == puzzleId);
}
else
{
submissionsQ = _context.Submissions.Where((s) => s.Puzzle != null && s.Puzzle.ID == puzzleId && s.Team.ID == teamId);
}
}
IQueryable <SubmissionView> submissionViewQ = submissionsQ
.Select((s) => new SubmissionView
{
SubmitterName = s.Submitter.Name,
PuzzleID = s.Puzzle.ID,
PuzzleName = s.Puzzle.Name,
TeamID = s.Team.ID,
TeamName = s.Team.Name,
SubmissionText = s.SubmissionText,
ResponseText = s.Response == null ? null : s.Response.ResponseText,
TimeSubmitted = s.TimeSubmitted
});
if (teamId != null)
{
Team = await _context.Teams.Where(m => m.ID == teamId).FirstOrDefaultAsync();
}
switch (sort ?? DefaultSort)
{
case SortOrder.PlayerAscending:
submissionViewQ.OrderBy(submission => submission.SubmitterName);
break;
case SortOrder.PlayerDescending:
submissionViewQ.OrderByDescending(submission => submission.SubmitterName);
break;
case SortOrder.TeamAscending:
submissionViewQ.OrderBy(submission => submission.TeamName);
break;
case SortOrder.TeamDescending:
submissionViewQ.OrderByDescending(submission => submission.TeamName);
break;
case SortOrder.PuzzleAscending:
submissionViewQ.OrderBy(submission => submission.PuzzleName);
break;
case SortOrder.PuzzleDescending:
submissionViewQ.OrderByDescending(submission => submission.PuzzleName);
break;
case SortOrder.ResponseAscending:
submissionViewQ.OrderBy(submission => submission.ResponseText);
break;
case SortOrder.ResponseDescending:
submissionViewQ.OrderByDescending(submission => submission.ResponseText);
break;
case SortOrder.SubmissionAscending:
submissionViewQ.OrderBy(submission => submission.SubmissionText);
break;
case SortOrder.SubmissionDescending:
submissionViewQ.OrderByDescending(submission => submission.SubmissionText);
break;
case SortOrder.TimeAscending:
submissionViewQ.OrderBy(submission => submission.TimeSubmitted);
break;
case SortOrder.TimeDescending:
submissionViewQ.OrderByDescending(submission => submission.TimeSubmitted);
break;
}
Submissions = await submissionViewQ.ToListAsync();
return(Page());
}
private void Filter(int?directionId, string name, int?typeId, int?teacherId, string activeGroupsName, string column, SortOrder?sortOrder)
{
try
{
var listGroups = from groups in db.Groups
join courses in db.Courses on groups.CourseId equals courses.Id
join directions in db.Directions on courses.DirectionId equals directions.Id
join teachers in db.Workers on groups.TeacherId equals teachers.Id into outerTeacher
from teachers in outerTeacher.DefaultIfEmpty()
join activities in db.ActivityGroups on groups.ActivityId equals activities.Id
join classes in db.Classes on groups.ClassId equals classes.Id into outerClass
from classes in outerClass.DefaultIfEmpty()
join branches in db.Housings on classes.HousingId equals branches.Id into outerBranch
from branches in outerBranch.DefaultIfEmpty()
join years in db.Years on groups.YearId equals years.Id into outer
from years in outer.DefaultIfEmpty()
select new ListGroups
{
GroupId = groups.Id,
DirectionId = directions.Id,
Direction = directions.Name,
TeacherId = teachers.Id,
ActivityId = activities.Id,
YearId = years.Id,
Name = groups.Name,
Branch = branches.Name,
Class = classes.Name,
Days = groups.Days,
Begin = groups.Begin,
DurationLesson = groups.DurationLesson,
Year = years.Name,
Teacher = teachers.Lastname + " " + teachers.Firstname.Substring(0, 1) + "." + teachers.Middlename.Substring(0, 1) + ".",
TwoTeachers = groups.TwoTeachers,
Students = db.Enrollments.Where(a => a.GroupId == groups.Id && a.DateExclusion == null).Count(),
Note = groups.Note,
Activity = activities.Name
};
if (directionId != null)
{
listGroups = listGroups.Where(d => d.DirectionId == directionId);
}
if (teacherId != null)
{
listGroups = listGroups.Where(d => d.TeacherId == teacherId);
}
if (name != null && name != "")
{
listGroups = listGroups.Where(e => e.Name.StartsWith(name));
}
if (typeId != null)
{
listGroups = listGroups.Where(d => d.YearId == typeId);
}
if (activeGroupsName == "Активные")
{
listGroups = listGroups.Where(a => a.Activity != "Закрытые");
}
else
{
listGroups = listGroups.Where(a => a.Activity == activeGroupsName);
}
//фильтрация по праву доступа к группам
if (!CurrentSession.CurrentUser.AllAccessGroups)
{
var listOpenGroups = db.AccessGroups.Where(a => a.WorkerId == CurrentSession.CurrentUser.Id).Select(a => a.GroupId).ToList();
listGroups = listGroups.Where(a => listOpenGroups.Contains(a.GroupId));
}
//сортировка
if (column != null)
{
switch (column)
{
case "Direction":
{
if (sortOrder == SortOrder.Ascending)
{
listGroups = listGroups.OrderBy(x => x.Direction);
}
else
{
listGroups = listGroups.OrderByDescending(x => x.Direction);
}
break;
}
case "Name":
{
if (sortOrder == SortOrder.Ascending)
{
listGroups = listGroups.OrderBy(x => x.Name);
}
else
{
listGroups = listGroups.OrderByDescending(x => x.Name);
}
break;
}
case "Days":
{
if (sortOrder == SortOrder.Ascending)
{
listGroups = listGroups.OrderBy(x => x.Days);
}
else
{
listGroups = listGroups.OrderByDescending(x => x.Days);
}
break;
}
case "DurationLesson":
{
if (sortOrder == SortOrder.Ascending)
{
listGroups = listGroups.OrderBy(x => x.DurationLesson);
}
else
{
listGroups = listGroups.OrderByDescending(x => x.DurationLesson);
}
break;
}
case "Year":
{
if (sortOrder == SortOrder.Ascending)
{
listGroups = listGroups.OrderBy(x => x.Year);
}
else
{
listGroups = listGroups.OrderByDescending(x => x.Year);
}
break;
}
case "Teacher":
{
if (sortOrder == SortOrder.Ascending)
{
listGroups = listGroups.OrderBy(x => x.Teacher);
}
else
{
listGroups = listGroups.OrderByDescending(x => x.Teacher);
}
break;
}
case "TwoTeachers":
{
if (sortOrder == SortOrder.Ascending)
{
listGroups = listGroups.OrderBy(x => x.TwoTeachers);
}
else
{
listGroups = listGroups.OrderByDescending(x => x.TwoTeachers);
}
break;
}
case "Note":
{
if (sortOrder == SortOrder.Ascending)
{
listGroups = listGroups.OrderBy(x => x.Note);
}
else
{
listGroups = listGroups.OrderByDescending(x => x.Note);
}
break;
}
case "Students":
{
if (sortOrder == SortOrder.Ascending)
{
listGroups = listGroups.OrderBy(x => x.Students);
}
else
{
listGroups = listGroups.OrderByDescending(x => x.Students);
}
break;
}
}
}
else
{
listGroups = listGroups.OrderBy(f => f.Direction);
}
dgvListGroups.DataSource = listGroups.ToList();
if (sortOrder != SortOrder.None)
{
dgvListGroups.Columns[sortColumn].HeaderCell.SortGlyphDirection = (SortOrder)sortOrder;
}
}
catch (Exception ex)
{
var m = new System.Diagnostics.StackTrace(false).GetFrame(0).GetMethod();
string methodName = m.DeclaringType.ToString() + ";" + m.Name;
CurrentSession.ReportError(methodName, ex.Message);
MessageBox.Show(ex.Message, "Ошибка", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
public async Task ProperlyParsesOrderBy(string queryString, SortOrder?expected)
{
await TestOrderBy(queryString, expected);
}
public static T Sort <T>(this T query, Field field, SortOrder?order = null) where T : IRepositoryQuery
{
return(query.AddCollectionOptionValue <T, IFieldSort>(SortsKey, new SortField {
Field = field, Order = order
}));
}
/// <summary>
/// <param>If set to asc or desc, the column will be sorted in that direction on first </param>
/// <param>sort.Subsequent sorts of the column will toggle as usual (default: null)</param>
/// </summary>
/// <param name="firstSortOrder">First sort order</param>
public Column setFirstSortOrder(SortOrder firstSortOrder)
{
this._firstSortOrder = firstSortOrder;
return(this);
}
/// <summary>
/// <para>The initial sorting order when we use datatypes xml or json (data returned from server).</para>
/// <para>This parameter is added to the url. Two possible values - asc or desc. (default: asc)</para>
/// </summary>
/// <param name="sortOrder">Sortorder</param>
public jqGrid setSortOrder(SortOrder sortOrder)
{
this._sortOrder = sortOrder;
return this;
}
public static Sql OrderByOptional(this Sql sql, string column, SortOrder?order)
{
return(order.HasValue ? sql.OrderBy($"{column} {order}") : sql);
}
/// <summary>
/// If set to asc or desc, the column will be sorted in that direction on first
/// sort.Subsequent sorts of the column will toggle as usual (default: null)
/// </summary>
/// <param name="firstSortOrder">First sort order</param>
public Column SetFirstSortOrder(SortOrder firstSortOrder)
{
this.firstSortOrder = firstSortOrder;
return this;
}
public IList <WebRecordingBasic> GetRecordingsByRange(int start, int end, SortField?sort = SortField.Name, SortOrder?order = SortOrder.Asc)
{
return(Recording.ListAll().Select(rec => rec.ToWebRecording()).SortRecordingList(sort, order).TakeRange(start, end).ToList());
}
