public static List<SearchBoardGameResult> SortSearchResults(this List<SearchBoardGameResult> searchResults, string searchText, int maxResultsToReturn =10)
{
var queryable = searchResults.AsQueryable();
var results = new List<SearchBoardGameResult>();
//first add exact matches
results.AddRange(queryable.Where(result => result.BoardGameName.Equals(searchText, StringComparison.InvariantCultureIgnoreCase))
.OrderByDescending(result => result.YearPublished)
.Take(maxResultsToReturn));
if (results.Count >= maxResultsToReturn)
{
return results;
}
//then add anything that starts with but isn't an exact match
results.AddRange(queryable.Where(result => result.BoardGameName.StartsWith(searchText, StringComparison.InvariantCultureIgnoreCase)
&& !result.BoardGameName.Equals(searchText, StringComparison.InvariantCultureIgnoreCase))
.OrderBy(result => result.BoardGameName.Length)
.ThenByDescending(result => result.YearPublished)
.Take(maxResultsToReturn));
if (results.Count >= maxResultsToReturn)
{
return results;
}
//then add everything else
results.AddRange(queryable.Where(result => !result.BoardGameName.StartsWith(searchText, StringComparison.InvariantCultureIgnoreCase)
&& !result.BoardGameName.Equals(searchText, StringComparison.InvariantCultureIgnoreCase))
.OrderByDescending(result => result.YearPublished)
.Take(maxResultsToReturn));
return results;
}
public static async Task<ApiKey> GetByKeyAsync(this IMongoCollection<ApiKey> keys,
string key)
{
if (key.Empty())
return null;
return await keys.AsQueryable().FirstOrDefaultAsync(x => x.Key == key);
}
public static async Task<IEnumerable<ApiKey>> GetAllForUserAsync(this IMongoCollection<ApiKey> keys,
Guid userId)
{
if (userId == Guid.Empty)
return Enumerable.Empty<ApiKey>();
return await keys.AsQueryable()
.Where(x => x.UserId == userId)
.ToListAsync();
}
internal static GridModel ToGridModel(this GridDataTableWrapper enumerable, int page, int pageSize, IList<SortDescriptor> sortDescriptors, IEnumerable<IFilterDescriptor> filterDescriptors,
IEnumerable<GroupDescriptor> groupDescriptors)
{
if (filterDescriptors.Any())
{
var dataTable = enumerable.Table;
filterDescriptors.SelectMemberDescriptors()
.Each(f => f.MemberType = GetFieldByTypeFromDataColumn(dataTable, f.Member));
}
if (groupDescriptors.Any())
{
var dataTable = enumerable.Table;
groupDescriptors.Each(g => g.MemberType = GetFieldByTypeFromDataColumn(dataTable, g.Member));
}
return enumerable.AsQueryable().ToGridModel(page, pageSize, sortDescriptors, filterDescriptors, groupDescriptors);
}
public static List<OrderDto> GetLastOrders(this MongoCollection<OrderDto> mongoCollection, string userName)
{
var lastOrders = mongoCollection
.AsQueryable()
.Where(order => order.UserName.ToLowerInvariant() == userName.ToLowerInvariant())
.OrderByDescending(order => order.OrderDate)
.Take(5)
.Select(order => new OrderDto
{
OrderId = order.OrderId,
OrderDate = order.OrderDate,
Items = order.Items,
Total = order.Total
})
.ToList();
return lastOrders;
}
/// <summary>
/// Gets the first item from a non-generic enumerable, executing the query if the enumerable
/// represents a query.
/// </summary>
/// <param name="enumerable">The enumerable</param>
/// <returns>The first element in the enumerable, or NULL if the enumerable has no elements</returns>
public static object GetFirst(this IEnumerable enumerable)
{
if (enumerable == null)
{
throw new ArgumentNullException("enumerable");
}
// Use take to get the first item in the enumerable.
enumerable = enumerable.AsQueryable().Take(1);
object entity = null;
// Use foreach to execute the query, when the enumerable represents one.
foreach (var item in enumerable)
{
entity = item;
}
return entity;
}
/// <summary>
/// Creates a list from a non-generic enumerable, executing the query if the enumerable
/// represents one.
/// </summary>
/// <param name="enumerable">The enumerable to get the list from</param>
/// <returns>The list</returns>
public static IList GetList(this IEnumerable enumerable)
{
if (enumerable == null)
{
throw new ArgumentNullException("enumerable");
}
var listType = enumerable.AsQueryable().ElementType;
if (typeof(IList<>).IsAssignableFrom(listType))
{
return enumerable as IList;
}
var list = Helpers.CreateGenericList(listType, enumerable.Length());
var addMethod = list.GetType().GetMethod("Add");
foreach (var entry in enumerable)
{
addMethod.Invoke(list, new object[] { entry });
}
return list;
}
public static Task<User> ByNameAsync(this IEnumerable<User> set, string name, bool allowNull = true)
{
return set.AsQueryable().ByNameAsync(name, allowNull);
}
public static IEnumerable<Pushpin> ToFilteredPushPinList(this IEnumerable<Post> list, Expression<Func<Post, bool>> filter)
{
return list.AsQueryable()
.Where( filter )
.Select( p => (new Pushpin( p.Latitude.Randomize(), p.Longitude.Randomize(), HttpUtility.HtmlEncode( p.Title ), "<a href=\'" + string.Format( "/post/{0}/{1}", p.PostId, p.Title.ToFriendlyUrlEncode() ) + "\'>" + HttpUtility.HtmlEncode( p.Title ) + "</a>" )) );
}
public static LocalMembership ByUserLoginInfo(this IEnumerable<LocalMembership> set, UserLoginInfo userLoginInfo, bool allowNull = true)
{
return set.AsQueryable().ByUserLoginInfo(userLoginInfo, allowNull);
}
public static Task<LocalMembership> ByUserNameAsync(this IEnumerable<LocalMembership> set, string userName, bool allowNull = true)
{
return set.AsQueryable().ByUserNameAsync(userName, allowNull);
}
public static IEnumerable<EmailVerification> ByEmailAddressId(this IEnumerable<EmailVerification> set, int emailAddressId)
{
return set.AsQueryable().ByEmailAddressId(emailAddressId);
}
public static IEnumerable<EmailAddress> ByUserId(this IEnumerable<EmailAddress> set, int userId)
{
return set.AsQueryable().ByUserId(userId);
}
public static RemoteMembership ByUserIdAndLoginInfo(this IEnumerable<RemoteMembership> set,
int userId, UserLoginInfo userLoginInfo, bool allowNull = true)
{
return set.AsQueryable().ByUserIdAndLoginInfo(userId, userLoginInfo, allowNull);
}
public static IEnumerable<RemoteMembership> ByUserName(this IEnumerable<RemoteMembership> set, string userName)
{
return set.AsQueryable().ByUserName(userName);
}
public static IEnumerable<RemoteMembership> ByUserId(this IEnumerable<RemoteMembership> set, int userId)
{
return set.AsQueryable().ByUserId(userId);
}
public static Task<RemoteMembership> ByUserNameAndLoginInfoAsync(this IEnumerable<RemoteMembership> set,
string userName, UserLoginInfo userLoginInfo, bool allowNull = true)
{
return set.AsQueryable().ByUserNameAndLoginInfoAsync(userName, userLoginInfo, allowNull);
}
public static Task<User> ByUserLoginInfoAsync(this IEnumerable<User> set, UserLoginInfo userLoginInfo, bool allowNull = true)
{
return set.AsQueryable().ByUserLoginInfoAsync(userLoginInfo, allowNull);
}
public static IEnumerable<Preference> ByKey(this IEnumerable<Preference> enumerable, Enum key)
{
return enumerable.AsQueryable().ByKey(key);
}
public static bool Contains(this string[] values, string sought, bool caseSensitive)
{
return caseSensitive
? values.AsQueryable().Any(s => s == sought)
: values.AsQueryable().Any(s => s.Equals(sought, StringComparison.OrdinalIgnoreCase));
}
public static Task<LocalMembership> ByVerifiedEmailAsync(this IEnumerable<LocalMembership> set, string emailAddress, bool allowNull = true)
{
return set.AsQueryable().ByVerifiedEmailAsync(emailAddress, allowNull);
}
public static Task<EmailAddress> ByValueAsync(this IEnumerable<EmailAddress> set, string value, bool allowNull = true)
{
return set.AsQueryable().ByValueAsync(value, allowNull);
}
public static async Task<bool> ExistsAsync(this IMongoCollection<ApiKey> keys,
string key) => await keys.AsQueryable().AnyAsync(x => x.Key == key);
public static Task<LocalMembership> ByUserIdAsync(this IEnumerable<LocalMembership> set, int userId, bool allowNull = true)
{
return set.AsQueryable().ByUserIdAsync(userId, allowNull);
}
public static Basket CurrentBasket(this IEnumerable<Basket> baskets)
{
return baskets.AsQueryable().CurrentBasket();
}
public static Task<EmailVerification> ByTicketAsync(this IEnumerable<EmailVerification> set, string ticket, bool allowNull = true)
{
return set.AsQueryable().ByTicketAsync(ticket, allowNull);
}
