public async Task SetKinkPreferenceAsync
(
string kinkName,
[OverrideTypeReader(typeof(HumanizerEnumTypeReader <KinkPreference>))]
KinkPreference preference
)
{
var getUserKinkResult = await _kinks.GetUserKinkByNameAsync(this.Context.User, kinkName);
if (!getUserKinkResult.IsSuccess)
{
await _feedback.SendErrorAsync(this.Context, getUserKinkResult.ErrorReason);
return;
}
var userKink = getUserKinkResult.Entity;
var setKinkPreferenceResult = await _kinks.SetKinkPreferenceAsync(userKink, preference);
if (!setKinkPreferenceResult.IsSuccess)
{
await _feedback.SendErrorAsync(this.Context, setKinkPreferenceResult.ErrorReason);
return;
}
await _feedback.SendConfirmationAsync(this.Context, "Preference set.");
}
/// <summary>
/// Initializes a new instance of the <see cref="UserKink"/> class.
/// </summary>
/// <param name="user">The user.</param>
/// <param name="kink">The user's kink.</param>
public UserKink([NotNull] User user, [NotNull] Kink kink)
{
this.User = user;
this.Kink = kink;
this.Preference = KinkPreference.NoPreference;
}
public async Task ShowKinksByPreferenceAsync
(
IUser otherUser,
[OverrideTypeReader(typeof(HumanizerEnumTypeReader <KinkPreference>))]
KinkPreference preference
)
{
var getUserKinksResult = await _kinks.GetUserKinksAsync(otherUser);
if (!getUserKinksResult.IsSuccess)
{
await _feedback.SendErrorAsync(this.Context, getUserKinksResult.ErrorReason);
return;
}
var userKinks = getUserKinksResult.Entity;
var withPreference = userKinks.Where(k => k.Preference == preference).ToList();
if (!withPreference.Any())
{
await _feedback.SendErrorAsync(this.Context, "The user doesn't have any kinks with that preference.");
return;
}
var paginatedKinkPages = _kinks.BuildPaginatedUserKinkEmbeds(withPreference);
var paginatedMessage = new PaginatedEmbed(_feedback, _interactivity, this.Context.User)
.WithPages(paginatedKinkPages);
await _interactivity.SendPrivateInteractiveMessageAsync(this.Context, _feedback, paginatedMessage);
}
/// <summary>
/// Initializes a new instance of the <see cref="UserKink"/> class.
/// </summary>
/// <param name="user">The user.</param>
/// <param name="kink">The user's kink.</param>
public UserKink(User user, Kink kink)
{
this.User = user;
this.Kink = kink;
this.Preference = KinkPreference.NoPreference;
}
/// <summary>
/// Sets the user's preference for the given kink.
/// </summary>
/// <param name="userKink">The user's kink.</param>
/// <param name="preference">The new preference.</param>
/// <returns>A modification result which may or may not have succeeded.</returns>
public async Task <ModifyEntityResult> SetKinkPreferenceAsync
(
UserKink userKink,
KinkPreference preference
)
{
userKink.Preference = preference;
await _database.SaveChangesAsync();
return(ModifyEntityResult.FromSuccess());
}
/// <summary>
/// Sets the user's preference for the given kink.
/// </summary>
/// <param name="userKink">The user's kink.</param>
/// <param name="preference">The new preference.</param>
/// <param name="ct">The cancellation token in use.</param>
/// <returns>A modification result which may or may not have succeeded.</returns>
public async Task <ModifyEntityResult> SetKinkPreferenceAsync
(
UserKink userKink,
KinkPreference preference,
CancellationToken ct = default
)
{
userKink.Preference = preference;
await _database.SaveChangesAsync(ct);
return(ModifyEntityResult.FromSuccess());
}
private async Task SetCurrentKinkPreference(KinkPreference preference)
{
var getUserKinkResult = await _kinks.GetUserKinkByFListIDAsync(_targetUser, _currentFListKinkID);
if (!getUserKinkResult.IsSuccess)
{
await _feedback.SendErrorAndDeleteAsync(this.MessageContext, getUserKinkResult.ErrorReason);
return;
}
var userKink = getUserKinkResult.Entity;
var setPreferenceResult = await _kinks.SetKinkPreferenceAsync(userKink, preference);
if (!setPreferenceResult.IsSuccess)
{
await _feedback.SendErrorAndDeleteAsync(this.MessageContext, setPreferenceResult.ErrorReason);
}
}
private async Task SetCurrentKinkPreference(KinkPreference preference)
{
var getUserKinkResult = await this.Kinks.GetUserKinkByFListIDAsync(this.Database, this.Context.User, this.CurrentFListKinkID);
if (!getUserKinkResult.IsSuccess)
{
await this.Feedback.SendErrorAndDeleteAsync(this.Context, this.Interactive, getUserKinkResult.ErrorReason);
return;
}
var userKink = getUserKinkResult.Entity;
var setPreferenceResult = await this.Kinks.SetKinkPreferenceAsync(this.Database, userKink, preference);
if (!setPreferenceResult.IsSuccess)
{
await this.Feedback.SendErrorAndDeleteAsync(this.Context, this.Interactive, setPreferenceResult.ErrorReason);
}
}
public async Task <Result <FeedbackMessage> > SetKinkPreferenceAsync
(
string kinkName,
KinkPreference preference
)
{
var getUserKinkResult = await _kinks.GetUserKinkByNameAsync(_context.User.ID, kinkName);
if (!getUserKinkResult.IsSuccess)
{
return(Result <FeedbackMessage> .FromError(getUserKinkResult));
}
var userKink = getUserKinkResult.Entity;
var setKinkPreferenceResult = await _kinks.SetKinkPreferenceAsync(userKink, preference);
return(setKinkPreferenceResult.IsSuccess
? new FeedbackMessage("Preference set.", _feedback.Theme.Secondary)
: Result <FeedbackMessage> .FromError(setKinkPreferenceResult));
}
public async Task ShowKinksByPreferenceAsync
(
[NotNull]
IUser otherUser,
[OverrideTypeReader(typeof(HumanizerEnumTypeReader <KinkPreference>))]
KinkPreference preference
)
{
var userKinks = await this.Kinks.GetUserKinksAsync(this.Database, otherUser);
var withPreference = userKinks.Where(k => k.Preference == preference).ToList();
if (!withPreference.Any())
{
await this.Feedback.SendErrorAsync(this.Context, "The user doesn't have any kinks with that preference.");
return;
}
var paginatedKinks = this.Kinks.BuildPaginatedUserKinkEmbed(withPreference);
await this.Interactive.SendPrivatePaginatedMessageAsync(this.Context, this.Feedback, paginatedKinks);
}
public async Task <IResult> ShowKinksByPreferenceAsync
(
KinkPreference preference,
IUser?user = null
)
{
user ??= _context.User;
var kinksWithPreference = await _kinks.QueryDatabaseAsync
(
q => q
.Where(k => k.User.DiscordID == user.ID)
.Where(k => k.Preference == preference)
);
if (!kinksWithPreference.Any())
{
return(Result <FeedbackMessage> .FromSuccess
(
new FeedbackMessage
(
"The user doesn't have any kinks with that preference.",
_feedback.Theme.Warning
)
));
}
var pages = _kinks.BuildPaginatedUserKinkEmbeds(kinksWithPreference);
return(await _feedback.SendContextualPaginatedMessageAsync
(
_context.User.ID,
pages,
ct : this.CancellationToken
));
}
public async Task <RuntimeResult> SetKinkPreferenceAsync
(
string kinkName,
[OverrideTypeReader(typeof(HumanizerEnumTypeReader <KinkPreference>))]
KinkPreference preference
)
{
var getUserKinkResult = await _kinks.GetUserKinkByNameAsync(this.Context.User, kinkName);
if (!getUserKinkResult.IsSuccess)
{
return(getUserKinkResult.ToRuntimeResult());
}
var userKink = getUserKinkResult.Entity;
var setKinkPreferenceResult = await _kinks.SetKinkPreferenceAsync(userKink, preference);
if (!setKinkPreferenceResult.IsSuccess)
{
return(setKinkPreferenceResult.ToRuntimeResult());
}
return(RuntimeCommandResult.FromSuccess("Preference set."));
}
public async Task ShowKinksByPreferenceAsync
(
[OverrideTypeReader(typeof(HumanizerEnumTypeReader <KinkPreference>))]
KinkPreference preference
)
=> await ShowKinksByPreferenceAsync(this.Context.User, preference);
/// <summary>
/// Sets the user's preference for the given kink.
/// </summary>
/// <param name="db">The database.</param>
/// <param name="userKink">The user's kink.</param>
/// <param name="preference">The new preference.</param>
/// <returns>A modification result which may or may not have succeeded.</returns>
public async Task <ModifyEntityResult> SetKinkPreferenceAsync([NotNull] GlobalInfoContext db, [NotNull] UserKink userKink, KinkPreference preference)
{
userKink.Preference = preference;
await db.SaveChangesAsync();
return(ModifyEntityResult.FromSuccess(ModifyEntityAction.Edited));
}
private async Task <Result> SetCurrentKinkPreference(KinkPreference preference)
{
var leaseData = await _dataService.LeaseDataAsync(_context.Message.Value.ID, this.CancellationToken);
if (!leaseData.IsSuccess)
{
return((Result)leaseData);
}
await using var lease = leaseData.Entity;
if (lease.Data.CurrentFListKinkID is null)
{
throw new InvalidOperationException();
}
var getUserKinkResult = await _kinks.GetUserKinkByFListIDAsync
(
lease.Data.SourceUserID,
lease.Data.CurrentFListKinkID.Value
);
if (!getUserKinkResult.IsSuccess)
{
return(Result.FromError(getUserKinkResult));
}
var userKink = getUserKinkResult.Entity;
var setPreference = await _kinks.SetKinkPreferenceAsync(userKink, preference);
if (!setPreference.IsSuccess)
{
return(setPreference);
}
var moveNext = await lease.Data.MoveToNextKinkInCategoryAsync(_kinks, this.CancellationToken);
if (!moveNext.IsDefined(out var hasMore))
{
return((Result)moveNext);
}
if (hasMore)
{
return(await UpdateAsync(lease.Data));
}
lease.Data.GoToCategorySelection();
var send = await _feedback.SendContextualNeutralAsync
(
"All done in that category!",
lease.Data.SourceUserID,
new FeedbackMessageOptions(MessageFlags : MessageFlags.Ephemeral),
ct : this.CancellationToken
);
return(send.IsSuccess
? await UpdateAsync(lease.Data)
: (Result)send);
}
