/// <summary>
/// Initializes a new instance of the <see cref="Kink"/> class.
/// </summary>
/// <param name="name">The name of the kink.</param>
/// <param name="description">The kink's description.</param>
/// <param name="fListID">The F-List ID of the kink.</param>
/// <param name="category">The kink's category.</param>
public Kink(string name, string description, long fListID, KinkCategory category)
{
this.Name = name;
this.Description = description;
this.FListID = fListID;
this.Category = category;
}
public async Task <RetrieveEntityResult <IEnumerable <UserKink> > > GetUserKinksByCategoryAsync
(
IUser user,
KinkCategory category,
CancellationToken ct = default
)
{
var getUserKinksResult = await GetUserKinksAsync(user, ct : ct);
if (!getUserKinksResult.IsSuccess)
{
return(RetrieveEntityResult <IEnumerable <UserKink> > .FromError(getUserKinksResult));
}
var userKinks = getUserKinksResult.Entity;
var group = userKinks.Where(k => k.Kink.Category == category).ToList();
if (!group.Any())
{
return(RetrieveEntityResult <IEnumerable <UserKink> > .FromSuccess(new UserKink[] { }));
}
return(RetrieveEntityResult <IEnumerable <UserKink> > .FromSuccess(group.OrderBy(uk => uk.Kink.ToString())));
}
public async Task <RetrieveEntityResult <IEnumerable <Kink> > > GetKinksByCategoryAsync
(
KinkCategory category,
CancellationToken ct = default
)
{
var kinks = await _database.Kinks.ServersideQueryAsync
(
q => q
.Where(k => k.Category == category),
ct
);
var enumeratedKinks = kinks
.OrderBy(g => g.Category.ToString())
.ToList();
if (!enumeratedKinks.Any())
{
return(RetrieveEntityResult <IEnumerable <Kink> > .FromError
(
"There are no kinks in that category."
));
}
return(enumeratedKinks);
}
public async Task <RetrieveEntityResult <IEnumerable <UserKink> > > GetUserKinksByCategoryAsync
(
[NotNull] IUser user,
KinkCategory category
)
{
var getUserKinksResult = await GetUserKinksAsync(user);
if (!getUserKinksResult.IsSuccess)
{
return(RetrieveEntityResult <IEnumerable <UserKink> > .FromError(getUserKinksResult));
}
var userKinks = getUserKinksResult.Entity;
var groups = userKinks.GroupBy(k => k.Kink.Category).ToList();
var first = groups.FirstOrDefault(g => g.Key == category);
if (first is null)
{
return(RetrieveEntityResult <IEnumerable <UserKink> > .FromSuccess(new UserKink[] { }));
}
return(RetrieveEntityResult <IEnumerable <UserKink> > .FromSuccess(first.OrderBy(uk => uk.Kink.ToString())));
}
public async Task <RetrieveEntityResult <Kink> > GetFirstKinkInCategoryAsync(KinkCategory category)
{
var getKinksResult = await GetKinksByCategoryAsync(category);
if (!getKinksResult.IsSuccess)
{
return(RetrieveEntityResult <Kink> .FromError(getKinksResult));
}
return(RetrieveEntityResult <Kink> .FromSuccess(getKinksResult.Entity.First()));
}
public async Task <RetrieveEntityResult <Kink> > GetFirstKinkWithoutPreferenceInCategoryAsync
(
IUser user,
KinkCategory category,
CancellationToken ct = default
)
{
var getKinksResult = await GetKinksByCategoryAsync(category, ct);
if (!getKinksResult.IsSuccess)
{
return(RetrieveEntityResult <Kink> .FromError(getKinksResult));
}
var kinks = getKinksResult.Entity;
var getKinksByCategoryResult = await GetUserKinksByCategoryAsync(user, category, ct);
if (!getKinksByCategoryResult.IsSuccess)
{
return(RetrieveEntityResult <Kink> .FromError(getKinksByCategoryResult));
}
var userKinks = getKinksByCategoryResult.Entity.ToList();
// Find the first kink that the user either has in their list with no preference, or does not exist
// in their list
var kinkWithoutPreference = kinks.FirstOrDefault
(
k =>
userKinks.Any
(
uk =>
k.FListID == uk.Kink.FListID && uk.Preference == KinkPreference.NoPreference
) ||
userKinks.All
(
uk =>
k.FListID != uk.Kink.FListID
)
);
if (kinkWithoutPreference is null)
{
return(RetrieveEntityResult <Kink> .FromError("No kink without a set preference found."));
}
return(RetrieveEntityResult <Kink> .FromSuccess(kinkWithoutPreference));
}
/// <summary>
/// Gets the first kink in the given category.
/// </summary>
/// <param name="db">The database.</param>
/// <param name="category">The category.</param>
/// <returns>A retrieval result which may or may not have succeeded.</returns>
public async Task <RetrieveEntityResult <Kink> > GetFirstKinkInCategoryAsync([NotNull] GlobalInfoContext db, KinkCategory category)
{
var getKinksResult = await GetKinksByCategoryAsync(db, category);
if (!getKinksResult.IsSuccess)
{
return(RetrieveEntityResult <Kink> .FromError(getKinksResult));
}
return(RetrieveEntityResult <Kink> .FromSuccess(getKinksResult.Entity.First()));
}
/// <summary>
/// Gets the first kink that the given uses does not have a set preference for in the given category.
/// </summary>
/// <param name="db">The database.</param>
/// <param name="user">The user.</param>
/// <param name="category">The category.</param>
/// <returns>A retrieval result which may or may not have succeeded.</returns>
public async Task <RetrieveEntityResult <Kink> > GetFirstKinkWithoutPreferenceInCategoryAsync([NotNull] GlobalInfoContext db, IUser user, KinkCategory category)
{
var getKinksResult = await GetKinksByCategoryAsync(db, category);
if (!getKinksResult.IsSuccess)
{
return(RetrieveEntityResult <Kink> .FromError(getKinksResult));
}
var kinks = getKinksResult.Entity;
var userKinks = (await GetUserKinksByCategoryAsync(db, user, category)).ToList();
// Find the first kink that the user either has in their list with no preference, or does not exist
// in their list
var kinkWithoutPreference = kinks.FirstOrDefault
(
k =>
userKinks.Any
(
uk =>
k.FListID == uk.Kink.FListID && uk.Preference == KinkPreference.NoPreference
) ||
userKinks.All
(
uk =>
k.FListID != uk.Kink.FListID
)
);
if (kinkWithoutPreference is null)
{
return(RetrieveEntityResult <Kink> .FromError(CommandError.ObjectNotFound, "No kink without a set preference found."));
}
return(RetrieveEntityResult <Kink> .FromSuccess(kinkWithoutPreference));
}
public async Task <IEnumerable <UserKink> > GetUserKinksByCategoryAsync([NotNull] GlobalInfoContext db, [NotNull] IUser user, KinkCategory category)
{
var userKinks = await GetUserKinksAsync(db, user);
var group = userKinks.GroupBy(k => k.Kink.Category).FirstOrDefault(g => g.Key == category);
if (group is null)
{
return(new UserKink[] { });
}
return(group);
}
/// <summary>
/// Gets a list of all kinks in a given category.
/// </summary>
/// <param name="db">The database.</param>
/// <param name="category">The category.</param>
/// <returns>A retrieval result which may or may not have succeeded.</returns>
public async Task <RetrieveEntityResult <IEnumerable <Kink> > > GetKinksByCategoryAsync([NotNull] GlobalInfoContext db, KinkCategory category)
{
var group = await db.Kinks.GroupBy(k => k.Category).FirstOrDefaultAsync(g => g.Key == category);
if (group is null)
{
return(RetrieveEntityResult <IEnumerable <Kink> > .FromError
(
CommandError.ObjectNotFound,
"There are no kinks in that category."
));
}
return(RetrieveEntityResult <IEnumerable <Kink> > .FromSuccess(group));
}
public async Task <RetrieveEntityResult <IEnumerable <Kink> > > GetKinksByCategoryAsync(KinkCategory category)
{
var group = await _database.Kinks.AsQueryable().Where(k => k.Category == category).ToListAsync();
if (group is null || !group.Any())
{
return(RetrieveEntityResult <IEnumerable <Kink> > .FromError
(
"There are no kinks in that category."
));
}
return(RetrieveEntityResult <IEnumerable <Kink> > .FromSuccess(group.OrderBy(g => g.Category.ToString())));
}
public async Task <RetrieveEntityResult <IEnumerable <Kink> > > GetKinksByCategoryAsync(KinkCategory category)
{
var group = await _database.Kinks.GroupBy(k => k.Category).FirstOrDefaultAsync(g => g.Key == category);
if (group is null)
{
return(RetrieveEntityResult <IEnumerable <Kink> > .FromError
(
"There are no kinks in that category."
));
}
return(RetrieveEntityResult <IEnumerable <Kink> > .FromSuccess(group.OrderBy(g => g.Category.ToString())));
}
