/// <summary>
/// Sorts IQueryable source according to provided sort criteria
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="source">Source IQueryable to sort</param>
/// <param name="sortCriteria">IEnumerable of SortCriterias</param>
/// <returns><see cref="IOrderedQueryable<typeparamref name="T"/>"/></returns>
public static IOrderedQueryable <T> DoSorting <T>(this IQueryable <T> source, IEnumerable <SortCriteria> sortCriteria)
{
if (source == null)
{
throw new ArgumentNullException("source");
}
IOrderedQueryable <T> ordered = source.OrderBy(p => 0);
if (!ordered.Any() || sortCriteria == null)
{
return(ordered);
}
int index = 0;
using (var sequenceEnum = sortCriteria.OrderBy(x => x.Priority).GetEnumerator())
{
while (sequenceEnum.MoveNext())
{
if (index == 0)
{
ordered = (sequenceEnum.Current.Order == SortOrder.Ascending) ? source.OrderBy(sequenceEnum.Current.ColumnName) : source.OrderByDescending(sequenceEnum.Current.ColumnName);
}
else
{
ordered = (sequenceEnum.Current.Order == SortOrder.Ascending) ? ordered.ThenBy(sequenceEnum.Current.ColumnName) : ordered.ThenByDescending(sequenceEnum.Current.ColumnName);
}
index++;
}
}
return(ordered);
}
public void SearchByName(ref IOrderedQueryable <Employee> employees, string employeeName)
{
if (!employees.Any() || string.IsNullOrWhiteSpace(employeeName))
{
return;
}
employees = employees.Where(o => o.FullName.ToLower().Contains(employeeName.Trim().ToLower())).OrderBy(att => att.BranchId);
}
public void SearchByName(ref IOrderedQueryable <Company> companies, string branchName)
{
if (!companies.Any() || string.IsNullOrWhiteSpace(branchName))
{
return;
}
companies = companies.Where(o => o.BranchName.ToLower().Contains(branchName.Trim().ToLower())).OrderBy(att => att.BranchId);
}
private void SearchByName(ref IOrderedQueryable <User> users, string userName)
{
if (!users.Any() || string.IsNullOrWhiteSpace(userName))
{
return;
}
users = (IOrderedQueryable <User>)users.Where(o => o.Name.ToLower().Contains(userName.Trim().ToLower()));
}
private void SearchByName(ref IOrderedQueryable <Course> courses, string courseName)
{
if (!courses.Any() || string.IsNullOrWhiteSpace(courseName))
{
return;
}
courses = (IOrderedQueryable <Course>)courses.Where(o => o.Name.ToLower().Contains(courseName.Trim().ToLower()));
}
private string GetStudentText(IOrderedQueryable <Models.Student> students)
{
if (!students.Any())
{
return("NONE");
}
return(string.Join(",", students.Select(x => x.Name).ToArray()));
}
/// <summary>
/// Get next available BaseNoteOrdinal
/// </summary>
/// <param name="db">ApplicationDbContext</param>
/// <param name="noteFileId">NoteFileID</param>
/// <returns></returns>
public static async Task <int> NextBaseNoteOrdinal(ApplicationDbContext db, int noteFileId, int arcId)
{
IOrderedQueryable <NoteHeader> bnhq = GetBaseNoteHeaderByIdRev(db, noteFileId, arcId);
if (bnhq == null || !bnhq.Any())
{
return(1);
}
NoteHeader bnh = await bnhq.FirstAsync();
return(bnh.NoteOrdinal + 1);
}
private IEnumerable <ListIngrediente> ConvertList(IOrderedQueryable <Domain.Ingrediente.Entity.Ingrediente> list)
{
ICollection <ListIngrediente> result = new List <ListIngrediente>();
if (list.Any())
{
foreach (var item in list)
{
result.Add(item);
}
}
return(result);
}
public static bool AnyNoLock <T>(this IOrderedQueryable <T> query)
{
using (
var scope = new TransactionScope(TransactionScopeOption.Required,
new TransactionOptions()
{
IsolationLevel = IsolationLevel.ReadUncommitted
},
TransactionScopeAsyncFlowOption.Enabled))
{
var toReturn = query.Any();
scope.Complete();
return(toReturn);
}
}
public static bool AnyNoLock <T>(this IOrderedQueryable <T> query, Expression <Func <T, bool> > predicate)
{
using (
var scope = new TransactionScope(TransactionScopeOption.Required,
new TransactionOptions()
{
IsolationLevel = System.Transactions.IsolationLevel.ReadUncommitted
},
TransactionScopeAsyncFlowOption.Enabled))
{
var toReturn = query.Any(predicate);
scope.Complete();
return(toReturn);
}
}
private static AnalyticsPrice CalculateAnalyticsPrice(IOrderedQueryable <HourlyShareRate> ratesOrderedByTimestamp)
{
if (!ratesOrderedByTimestamp.Any())
{
return(null);
}
return(new AnalyticsPrice
{
High = ratesOrderedByTimestamp.Max(r => r.Rate),
Low = ratesOrderedByTimestamp.Min(r => r.Rate),
Open = ratesOrderedByTimestamp.First().Rate,
Close = ratesOrderedByTimestamp.Last().Rate,
});
}
private void ApplySort(ref IOrderedQueryable <Owner> owners, string orderByQueryString)
{
if (!owners.Any())
{
return;
}
if (string.IsNullOrWhiteSpace(orderByQueryString))
{
owners = owners.OrderBy(x => x.Name);
return;
}
var orderParams = orderByQueryString.Trim().Split(',');
var propertyInfos = typeof(Owner).GetProperties(BindingFlags.Public | BindingFlags.Instance);
var orderQueryBuilder = new StringBuilder();
foreach (var param in orderParams)
{
if (string.IsNullOrWhiteSpace(param))
{
continue;
}
var propertyFromQueryName = param.Split(" ")[0];
var objectProperty = propertyInfos.FirstOrDefault(pi => pi.Name.Equals(propertyFromQueryName, StringComparison.InvariantCultureIgnoreCase));
if (objectProperty == null)
{
continue;
}
var sortingOrder = param.EndsWith(" desc") ? "descending" : "ascending";
orderQueryBuilder.Append($"{objectProperty.Name.ToString()} {sortingOrder}, ");
}
var orderQuery = orderQueryBuilder.ToString().TrimEnd(',', ' ');
if (string.IsNullOrWhiteSpace(orderQuery))
{
owners = owners.OrderBy(x => x.Name);
return;
}
owners = owners.OrderBy(orderQuery);
}
public static IQueryable <T> Pagination <T>(this IOrderedQueryable <T> items, IPaging pagination)
{
if (pagination == null)
{
return(items);
}
pagination.Length = 0;
if (items == null || !items.Any())
{
return(items);
}
var skip = pagination.Page == 0 ? 0 : pagination.Page;
pagination.Length = items.Count();
return(items.Skip(skip * pagination.PageSize).Take(pagination.PageSize));
}
public virtual IActionResult GaleriPictureAdd(int pictureId, int displayOrder,
string overrideAltAttribute, string overrideTitleAttribute, string url, int galeriId)
{
if (pictureId == 0)
{
throw new ArgumentException();
}
Slider galeri = _sliderRepository.GetById(galeriId)
?? throw new ArgumentException("No product found with the specified id");
IOrderedQueryable <SliderPictureMapping> query = from pg in _sliderPicturRepository.Table
where pg.SliderId == galeriId
orderby pg.DisplayOrder, pg.Id
select pg;
if (query.Any(p => p.PictureId == pictureId))
{
return(Json(new { Result = false }));
}
Picture picture = _pictureService.GetPictureById(pictureId)
?? throw new ArgumentNullException("No Picture found with th spec id");
_pictureService.UpdatePicture(picture.Id,
_pictureService.LoadPictureBinary(picture),
picture.MimeType,
picture.SeoFilename,
overrideAltAttribute,
overrideTitleAttribute
);
_pictureService.SetSeoFilename(picture.Id, _pictureService.GetPictureSeName(galeri.Name));
_sliderPicturRepository.Insert(new SliderPictureMapping
{
SliderId = galeriId,
DisplayOrder = displayOrder,
PictureId = pictureId,
Url = url,
PictureTitle = overrideTitleAttribute,
Title = overrideAltAttribute
});
return(Json(new { Result = true }));
}
public void Entities_Page()
{
//Arrange
const int total = 33;
const int page = 2;
const int pageSize = 10;
PopulateTestData(total, 0);
//Act
var expected = _context.Blogs.OrderBy(b => b.BlogId).Page(page, pageSize).ToArray();
IOrderedQueryable queryable = _context.Blogs.Select("it").OrderBy("BlogId");
bool any = queryable.Any();
var count = queryable.Count();
var result = queryable.Page(page, pageSize).ToDynamicArray <Blog>();
//Assert
Assert.Equal(true, any);
Assert.Equal(total, count);
Assert.Equal(expected, result);
}
/// <summary>
/// Gets the entries.
/// </summary>
/// <param name="from">From.</param>
/// <param name="to">To.</param>
/// <param name="so">The so.</param>
/// <returns>TimeData[][].</returns>
public static TimeData[] GetEntries(DateTime @from, DateTime to, SortOrder so)
{
using (var db = new TimeDataContext(TimeDataContext.DBConnectionString)) {
@from = new DateTime(@from.Year, @from.Month, @from.Day, 0, 0, 0);
to = new DateTime(to.Year, to.Month, to.Day, 0, 0, 0).AddDays(1);
IOrderedQueryable <TimeDataItem> entries = from x in db.TimeDataItems
where x.Date >= @from && x.Date < to
orderby x.Date
select x;
if (entries.Any())
{
IEnumerable <TimeDataItem> e = so == SortOrder.DateNewestToOldest ? entries.ToArray().Reverse() : entries.ToArray();
return(e.Select(tdi => new TimeData
{
BibleStudies = tdi.BibleStudies, Books = tdi.Books, Brochures = tdi.Brochures, Date = tdi.Date, ItemId = tdi.ItemId, Magazines = tdi.Magazines, Minutes = tdi.Minutes, Notes = tdi.Notes, ReturnVisits = tdi.ReturnVisits, Tracts = tdi.Tracts ?? 0
}).ToArray());
}
return(new TimeData[0]);
}
}
public PagedList(IOrderedQueryable <EntityType> source, int pageNumber, int pageSize)
{
Items = Enumerable.Empty <EntityType>();
PageSize = pageSize;
PageNumber = pageNumber;
if (source == null || !source.Any())
{
return;
}
IEnumerable <EntityType> paged = source;
if (pageSize > 0)
{
var start = PageSize * (PageNumber - 1);
paged = source.Skip(start).Take(PageSize);
}
Items = paged;
RecordCount = source.Count();
}
/// <summary>
/// Gets the previous visits.
/// </summary>
/// <param name="rvItemId">The rv item id.</param>
/// <param name="so">The Sort Order.</param>
/// <returns>RvPreviousVisitData[].</returns>
public static RvPreviousVisitData[] GetPreviousVisits(int rvItemId, SortOrder so)
{
var rvVists = new List <RvPreviousVisitData>();
using (var db = new RvPreviousVisitsContext(RvPreviousVisitsContext.DBConnectionString)) {
IOrderedQueryable <RvPreviousVisitItem> qry = from x in db.RvPreviousVisitItems
where x.RvItemId == rvItemId
orderby x.Date
select x;
if (qry.Any())
{
IEnumerable <RvPreviousVisitItem> visits = so == SortOrder.DateNewestToOldest ? qry.ToArray().Reverse() : qry.ToArray();
foreach (RvPreviousVisitItem v in visits)
{
rvVists.Add(RvPreviousVisitData.Copy(v));
}
return(rvVists.ToArray());
}
return(new RvPreviousVisitData[0]);
}
}
private void LoadItemAuditTrailDetails(string ItemID)
{
SCAuditLogsDataContext scAuditLogsDataContext =
new SCAuditLogsDataContext();
IOrderedQueryable <Log> logs =
scAuditLogsDataContext.Logs.Where(x =>
x.SCItemId == ItemID).
OrderByDescending(x => x.Date);
if (logs == null && !logs.Any())
{
ShowMessage("No audit trail records found, it seems that you haven't configured SCAuditTrail or no actions recorded yet.",
"Error");
lblMessage.Visible = true;
tblSCAuditTrailForItem.Visible = false;
}
else
{
foreach (Log aLog in logs)
{
if (aLog != null)
{
TableRow tableRow = new TableRow();
tableRow.ID = "row" + aLog.ID.ToString();
tableRow.TableSection = TableRowSection.TableBody;
//Action
SCBasics.AuditTrail.Utils.UIControlUtil.AddTableCell(tableRow,
aLog.SCAction,
SCBasics.AuditTrail.Utils.SourceTextType.Text);
//UserName
SCBasics.AuditTrail.Utils.UIControlUtil.AddTableCell(tableRow,
aLog.SCUser,
SCBasics.AuditTrail.Utils.SourceTextType.Text);
//Date
SCBasics.AuditTrail.Utils.UIControlUtil.AddTableCell(tableRow,
aLog.Date.ToUniversalTime().ToString(),
SCBasics.AuditTrail.Utils.SourceTextType.DateTime);
//ItemLanguage
SCBasics.AuditTrail.Utils.UIControlUtil.AddTableCell(tableRow,
aLog.SCLanguage,
SCBasics.AuditTrail.Utils.SourceTextType.Text);
// ItemVersion
SCBasics.AuditTrail.Utils.UIControlUtil.AddTableCell(tableRow,
aLog.SCVersion,
SCBasics.AuditTrail.Utils.SourceTextType.Text);
tblSCAuditTrailForItem.Rows.Add(tableRow);
}
}
lblMessage.Visible = true;
tblSCAuditTrailForItem.Visible = true;
}
}