private async Task <string> CreateReminder(ICommandContext context, string message)
{
var result = FuzzyParsing.Moment(message);
string error = null;
if (!result.IsValid)
{
error = result.ErrorMessage;
}
else if (result.Value < DateTime.UtcNow)
{
error = PastValueErrorMessage.Replace("$moment$", result.Value.ToString(CultureInfo.InvariantCulture));
}
if (error != null)
{
return(error);
}
else
{
var triggerTime = result.Value;
var duration = triggerTime - DateTime.UtcNow;
//Add some context to the message
var prelude = $"{context.Message.Author.Mention} Reminder from {DateTime.UtcNow.Humanize(dateToCompareAgainst: triggerTime, culture: CultureInfo.GetCultureInfo("en-gn"))}...";
var msg = $"remind me {message}";
//Save to database
var n = await _reminders.Create(triggerTime, prelude, msg, context.Message.Channel.Id, context.User.Id);
var friendlyId = new FriendlyId32(n.ID);
return($"I will remind you in {duration.Humanize(2, maxUnit: TimeUnit.Year, minUnit: TimeUnit.Second, toWords: true)} (id: `{friendlyId}`)");
}
}
public void AllZero()
{
const uint a = 0;
var str = a.MeaninglessString();
Console.WriteLine(str);
var b = FriendlyId32.Parse(str);
Assert.IsNotNull(b);
Assert.AreEqual(a, b.Value.Value);
}
public void ParseInvalid()
{
Assert.IsNull(FriendlyId32.Parse("aaaryc-racnes"));
Assert.IsNull(FriendlyId32.Parse("molaaa-racnes"));
Assert.IsNull(FriendlyId32.Parse("molryc-aaanes"));
Assert.IsNull(FriendlyId32.Parse("molryc-racaaa"));
Assert.IsNull(FriendlyId32.Parse("molrycracten"));
Assert.IsNull(FriendlyId32.Parse("hello"));
Assert.IsNull(FriendlyId32.Parse("hello-world"));
Assert.IsNull(FriendlyId32.Parse("molryc-world"));
}
public void Parse()
{
var str = "lomryc-racnes";
var fid = FriendlyId32.Parse(str);
Assert.IsTrue(fid.HasValue);
Assert.AreEqual(str, fid.ToString());
Console.WriteLine(str);
Console.WriteLine(fid.Value.Value);
Console.WriteLine(fid.ToString());
}
public async Task CreatePendingPayment([NotNull] IUser user, decimal amount, [NotNull] string unit, [CanBeNull, Remainder] string note = null)
{
if (amount < 0)
{
await TypingReplyAsync("You cannot pay a negative amount!");
}
var id = await _pending.CreatePending(Context.User.Id, user.Id, amount, unit, note, DateTime.UtcNow);
var fid = new FriendlyId32(id).ToString();
await TypingReplyAsync($"{user.Mention} type `!confirm {fid}` to confirm that you have been paid this");
await TypingReplyAsync($"{user.Mention} type `!deny {fid}` to deny that you received this payment. Please talk to the other user about why!");
}
public async Task CancelReminder([NotNull] string id)
{
var parsed = FriendlyId32.Parse(id);
if (!parsed.HasValue)
{
await TypingReplyAsync("Invalid ID");
return;
}
if (await _reminders.Delete(parsed.Value.Value))
{
await TypingReplyAsync($"Deleted reminder `{id}`");
}
else
{
await TypingReplyAsync($"I can't find a reminder with id `{id}`");
}
}
private async Task PaginatedPending([NotNull] IAsyncEnumerable <IPendingTransaction> pending, string none, string paginatedHeader, bool mentionReceiver)
{
string FormatSinglePending(IPendingTransaction p, bool longForm)
{
var receiver = Name(p.ToId, mentionReceiver);
var payer = Name(p.FromId);
var note = string.IsNullOrEmpty(p.Note) ? "" : $"'{p.Note}'";
var amount = TransactionFormatting.FormatCurrency(p.Amount, p.Unit);
var fid = new FriendlyId32(p.Id).ToString();
if (longForm)
{
return($"{receiver} Type `!confirm {fid}` or `!deny {fid}` to confirm/deny transaction of {amount} from {payer} {note}");
}
else
{
return($"`{fid}`: {payer} paid {amount} to {receiver} {note}");
}
}
var pendingArr = await pending.ToArray();
if (pendingArr.Length == 0)
{
await TypingReplyAsync(none);
}
else if (pendingArr.Length < 5)
{
await ReplyAsync(string.Join("\n", pendingArr.Select(p => FormatSinglePending(p, true))));
}
else
{
await TypingReplyAsync(string.Format(paginatedHeader, pendingArr.Length));
await PagedReplyAsync(new PaginatedMessage { Pages = pendingArr.Batch(7).Select(d => string.Join("\n", d.Select(p => FormatSinglePending(p, false)))) });
}
}
public async Task Confirm([NotNull] string input)
{
var fid = FriendlyId32.Parse(input);
if (!fid.HasValue)
{
await TypingReplyAsync("Invalid ID `{id}`");
return;
}
var transactions = await(await _pending.Get(debtId: fid.Value.Value)).ToArray();
if (transactions.Length == 0)
{
await TypingReplyAsync($"Cannot find a transaction with ID `{fid}`");
return;
}
if (transactions.Length > 1)
{
await TypingReplyAsync($"Found multiple transactions with ID `{fid}`! This is probably an error, please report it.");
return;
}
var transaction = transactions[0];
if (transaction.ToId != Context.User.Id)
{
await TypingReplyAsync("You cannot confirm this transaction");
return;
}
var result = await _pending.ConfirmPending(fid.Value.Value);
switch (result)
{
case ConfirmResult.Confirmed:
await TypingReplyAsync($"Confirmed {TransactionFormatting.FormatTransaction(this, transaction)}");
break;
case ConfirmResult.AlreadyDenied:
await TypingReplyAsync("This transaction has already been denied and cannot be confirmed");
break;
case ConfirmResult.AlreadyConfirmed:
await TypingReplyAsync("This transaction has already been confirmed");
break;
case ConfirmResult.IdNotFound:
await TypingReplyAsync($"Cannot find a transaction with ID `{fid}`! This is probably an error, please report it.");
break;
default:
await TypingReplyAsync($"Unknown transaction state `{result}`! This is probably an error, please report it.");
throw new ArgumentOutOfRangeException();
}
}
