/// <summary>
/// Returns the most popular command of all time, with how many uses it has.
/// </summary>
/// <returns></returns>
public static Dictionary <string, int> GetMostPopularCommandAsync()
{
var dic = new Dictionary <string, int>();
using (var db = new KaguyaDb())
{
IQueryable <CommandHistory> command = from h in db.GetTable <CommandHistory>() select h;
IQueryable <IGrouping <string, CommandHistory> > descending = command.GroupBy(x => x.Command);
descending = descending.OrderByDescending(x => x.Count());
string name = descending.FirstOrDefault()?.Key;
if (String.IsNullOrWhiteSpace(name))
{
return(new Dictionary <string, int>());
}
IQueryable <int> count = from c in db.GetTable <CommandHistory>()
group c by c.Command
into grp
orderby grp.Count() descending
select grp.Count();
dic.Add(name, count.Select(x => x).First());
return(dic);
}
}
/// <summary>
/// Returns all of the <see cref="T" /> objects from the database that match the given <see cref="Predicate{T}" />,
/// limited by the <see cref="limit" /> parameter. The <see cref="selector" /> will determine what variable to order
/// the results by. If the <see cref="selector" /> is provided, the results will be ordered based on the
/// <see cref="orderByDescending" /> parameter.
/// </summary>
/// <typeparam name="T">The type of object to return results of.</typeparam>
/// <typeparam name="TKey">The <see cref="TKey" /> to order our results by, assuming we want them ordered.</typeparam>
/// <param name="predicate"></param>
/// <param name="limit"></param>
/// <param name="selector"></param>
/// <param name="orderByDescending"></param>
/// <returns></returns>
public static async Task <List <T> > GetLimitAsync <T>(uint limit,
Expression <Func <T, bool> > predicate = null,
Expression <Func <T, object> > selector = null,
bool orderByDescending = false) where T : class, IKaguyaQueryable <T>
{
// ReSharper disable once PossibleInvalidOperationException
using (var db = new KaguyaDb())
{
IQueryable <T> baseQuery = db.GetTable <T>().AsQueryable();
baseQuery = predicate == null
? baseQuery
: baseQuery.Where(predicate);
if (selector != null)
{
baseQuery = orderByDescending
? baseQuery.OrderByDescending(selector)
: baseQuery.OrderBy(selector);
return(await baseQuery.Take((int)limit).ToListAsync());
}
if (orderByDescending)
{
throw new InvalidOperationException("Unable to apply descendant ordering with a null selector parameter.");
}
return(await baseQuery.Take((int)limit).ToListAsync());
}
}
/// <summary>
/// Returns the most recent set of statistics from the database.
/// </summary>
/// <returns></returns>
public static async Task <KaguyaStatistics> GetMostRecentStatsAsync()
{
using (var db = new KaguyaDb())
{
return(await(from t in db.GetTable <KaguyaStatistics>().OrderByDescending(x => x.TimeStamp)
select t).FirstOrDefaultAsync());
}
}
/// <summary>
/// Returns the first or default value from the database of a type that matches this <see cref="Predicate{T}" />.
/// </summary>
/// <typeparam name="T">The type of <see cref="IKaguyaQueryable{T}" /> object to return</typeparam>
/// <param name="predicate">
/// An expression that the returned object must match.
/// <code>
/// await GetFirstMatchAsync{User}(x => x.UserId == SomeId);
/// </code>
/// </param>
/// <returns></returns>
public static async Task <T> GetFirstMatchAsync <T>(Expression <Func <T, bool> > predicate) where T :
class, IKaguyaQueryable <T>
{
using (var db = new KaguyaDb())
{
return(await(from t in db.GetTable <T>().Where(predicate)
select t).FirstOrDefaultAsync());
}
}
/// <summary>
/// Returns a <see cref="List{T}" /> that match the given predicate.
/// </summary>
/// <typeparam name="T">The type of <see cref="List{T}" /> to return.</typeparam>
/// <param name="predicate">A condition that each returned object in the <see cref="List{T}" /> must match.</param>
/// <param name="limit">
/// The amount of objects to return. If this value is below zero, the function will
/// return all objects that match the <see cref="Predicate{T}" />
/// </param>
/// <returns></returns>
public static async Task <List <T> > GetAllAsync <T>(Expression <Func <T, bool> > predicate) where T :
class, IKaguyaQueryable <T>
{
using (var db = new KaguyaDb())
{
return(await(from t in db.GetTable <T>().Where(predicate)
select t).ToListAsync());
}
}
/// <summary>
/// Returns the FirstOrDefault <see cref="T" /> that matches the provided <see cref="userId" /> and <see cref="serverId" />
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="userId"></param>
/// <param name="serverId"></param>
/// <returns></returns>
public static async Task <T> GetForServerAndUserAsync <T>(ulong userId, ulong serverId) where T :
class, IKaguyaQueryable <T>, IUserSearchable <T>, IServerSearchable <T>
{
using (var db = new KaguyaDb())
{
return(await(from t in db.GetTable <T>()
where t.UserId == userId && t.ServerId == serverId
select t).FirstOrDefaultAsync());
}
}
/// <summary>
/// Deletes all of the <see cref="IServerSearchable{T}" /> objects from the database
/// where the serverId matches the provided <see cref="serverId" />
/// </summary>
/// <typeparam name="T">The <see cref="IServerSearchable{T}" /> to remove from the database.</typeparam>
/// <param name="serverId">The id of the server to clear the objects from.</param>
/// <returns></returns>
public static async Task DeleteAllForServerAsync <T>(ulong serverId) where T :
class, IKaguyaQueryable <T>, IServerSearchable <T>
{
using (var db = new KaguyaDb())
{
await(from t in db.GetTable <T>()
where t.ServerId == serverId
select t).DeleteAsync();
}
}
public static async Task <List <T> > GetAllForUserAsync <T>(ulong userId, Expression <Func <T, bool> > predicate) where T :
class, IKaguyaQueryable <T>, IUserSearchable <T>
{
using (var db = new KaguyaDb())
{
return(await(from t in db.GetTable <T>().Where(predicate)
where t.UserId == userId
select t).ToListAsync());
}
}
/// <summary>
/// Returns a <see cref="List{T}" /> of objects that match the given <see cref="serverId" />.
/// </summary>
/// <typeparam name="T">The <see cref="IServerSearchable{T}" /> that we want to get for this <see cref="serverId" />.</typeparam>
/// <param name="serverId">The Id of the server we are searching for.</param>
/// <returns></returns>
public static async Task <List <T> > GetAllForServerAsync <T>(ulong serverId) where T :
class,
IKaguyaQueryable <T>,
IServerSearchable <T>
{
using (var db = new KaguyaDb())
{
return(await(from t in db.GetTable <T>()
where t.ServerId == serverId
select t).ToListAsync());
}
}
/// <summary>
/// Inserts the object into the database. If it already exists, an exception will be thrown.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="arg">The object to insert, assuming it doesn't already exist.</param>
/// <param name="throwExceptionIfPresent">Whether to throw an exception if the object was found in the database already.</param>
/// <returns></returns>
public static async Task InsertIfNotExistsAsync <T>(T arg, bool throwExceptionIfPresent = true) where T : class, IKaguyaQueryable <T>
{
using (var db = new KaguyaDb())
{
if (await db.GetTable <T>().AnyAsync(x => x.Equals(arg)))
{
if (throwExceptionIfPresent)
{
throw new Exception("Item already exists in the database.");
}
}
await db.InsertAsync(arg);
}
}
public static async Task DeleteAllAsync <T>() where T : class, IKaguyaQueryable <T>
{
using (var db = new KaguyaDb())
{
List <T> records = await db.GetTable <T>().ToListAsync();
if (records.Count > 0)
{
foreach (T record in records)
{
await db.DeleteAsync(record);
}
}
await ConsoleLogger.LogAsync($"Deleted all records of type {typeof(T)}", LogLvl.WARN);
}
}
/// <summary>
/// Returns the number of objects that exist of type <see cref="T" /> matching the given <see cref="Predicate{T}" />
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="predicate"></param>
/// <returns></returns>
public static async Task <int> GetCountAsync <T>(Expression <Func <T, bool> > predicate)
where T : class, IKaguyaQueryable <T>
{
using (var db = new KaguyaDb())
return(await db.GetTable <T>().Where(predicate).CountAsync());
}
/// <summary>
/// Returns the number of objects that exist of type <see cref="T" />
/// </summary>
/// <typeparam name="T">The type of object to return the number of occurances of.</typeparam>
/// <returns></returns>
public static async Task <int> GetCountAsync <T>() where T : class, IKaguyaQueryable <T>
{
using (var db = new KaguyaDb())
return(await db.GetTable <T>().CountAsync());
}
public static async Task <bool> ItemExistsAsync <T>(IEnumerable <T> args, Expression <Func <T, bool> > predicate) where T :
class, IKaguyaQueryable <T>
{
using (var db = new KaguyaDb())
return(await db.GetTable <T>().Where(predicate).AnyAsync(x => args.Contains(x)));
}
/// <summary>
/// Returns a <see cref="bool" /> that determines whether the provided <see cref="arg" /> exists in the database.
/// If it does, this function will return true.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="arg">The object that we are checking to see exists in the database.</param>
/// <returns></returns>
public static async Task <bool> ItemExistsAsync <T>(T arg) where T :
class, IKaguyaQueryable <T>
{
using (var db = new KaguyaDb())
return(await db.GetTable <T>().AnyAsync(x => x.Equals(arg)));
}
/// <summary>
/// Returns ALL objects of type <see cref="T" /> that exist in the database.
/// </summary>
/// <typeparam name="T">The type of object to retreive ALL items of.</typeparam>
/// <returns></returns>
public static async Task <List <T> > GetAllAsync <T>() where T : class, IKaguyaQueryable <T>
{
using (var db = new KaguyaDb())
return(await db.GetTable <T>().ToListAsync());
}
