// called whenever .sync command is used, and at first program launch
public async Task <bool> ManualSync(DiscordServer server = null, SocketCommandContext context = null)
{
// if server is null, context is not null - we're calling via command, so get the right server via context
if (server == null && context != null)
{
server = Servers.ServerList.Find(x => x.DiscordServerObject == context.Guild);
}
// check if we're authenticated and have a calendar id to sync from
var syncStatus = CheckIfSyncPossible(server);
if (syncStatus != CalendarSyncStatus.OK)
{
if (server == null && context != null)
{
await context.Channel.SendMessageAsync($"Sync failed: {SyncFailedReason(syncStatus)}");
}
else
{
await server.ConfigChannel.SendMessageAsync($"Sync failed: {SyncFailedReason(syncStatus)}");
}
return(false);
}
// perform the actual sync
var success = SyncFromGoogleCalendar(server);
// handle sync success or failure
if (success)
{
// send message reporting we've synced calendar events
string resultMessage = $":calendar: Synced {server.Events.Count} calendar events.";
if (context != null) // we only want to send a message announcing sync success if the user sent the command
{
await _interactiveService.ReplyAndDeleteAsync(context, resultMessage);
}
}
else
{
// send message reporting there were no calendar events to sync
string resultMessage = ":calendar: No events found in calendar.";
if (context != null)
{
await _interactiveService.ReplyAndDeleteAsync(context, resultMessage);
}
}
// send/modify events embed in reminders to reflect newly synced values
await _scheduleService.SendEvents(server);
return(true);
}
/// <summary>
/// Sends an embed, and deletes it after a specified timeout.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="interactivity">The interactivity service.</param>
/// <param name="colour">The colour of the embed.</param>
/// <param name="contents">The contents of the message.</param>
/// <param name="timeout">The timeout after which the message should be deleted.</param>
public async Task SendEmbedAndDeleteAsync
(
[NotNull] SocketCommandContext context,
[NotNull] InteractiveService interactivity,
Color colour,
[NotNull] string contents,
[CanBeNull] TimeSpan?timeout = null
)
{
var eb = CreateFeedbackEmbed(context.User, colour, contents);
await interactivity.ReplyAndDeleteAsync(context, string.Empty, false, eb, timeout);
}
public async Task Help()
{
await _interactiveService.ReplyAndDeleteAsync(Context, "Sending you list of my commands now!", timeout : TimeSpan.FromSeconds(10));
await _help.HelpAsync(Context);
}
async Task <IUserMessage> ReplyAndDelete(SocketUserMessage original, string response, double seconds)
{
SocketCommandContext newContext = new SocketCommandContext(discord, original);
return(await interactive.ReplyAndDeleteAsync(newContext, response, timeout : TimeSpan.FromSeconds(seconds)));
}
/// <summary>
/// Interactively builds an embed by prompting the user.
/// <para>
/// Shows an embed layout guide, a preview of the embed being built, and instructions for the current prompt. The user is
/// first prompted for an action. Then, if applicable, the user is prompted again to enter a value for the action. The
/// builder is cancelled if it times out before an initial response is received. Otherwise, it listens indefinitely for
/// a response.
/// </para>
/// <para>See <see cref="_Instructions"/> and <see cref="BuilderAction.Actions"/> for supported actions.</para>
/// </summary>
/// <returns>The built embed.</returns>
public async Task <Discord.Embed> BuildAsync()
{
await InitAsync();
while (true)
{
SocketMessage input = await _interactive.NextMessageAsync(_context);
if (input == null)
{
await _context.Channel.SendMessageAsync("```The announcement builder has timed out after 120 seconds.```");
await RemoveAsync();
return(null);
}
if (BuilderAction.Actions.TryGetValue(input.Content, out BuilderAction action))
{
await input.DeleteAsync();
await _instructionsMsg.ModifyAsync(m => m.Content = action.Instructions);
input = await _interactive.NextMessageAsync(_context);
if (input == null)
{
continue;
}
// Displays an error if the callback failed and the action has an error message.
if (!action.Callback(input.Content, _embed) && !string.IsNullOrWhiteSpace(action.Error))
{
await _interactive.ReplyAndDeleteAsync(
_context,
$"```Input: {input.Content}\nError: {action.Error}```",
timeout : TimeSpan.FromSeconds(5));
}
await input.DeleteAsync();
}
else if (input.Content.Equals("field", StringComparison.OrdinalIgnoreCase))
{
await input.DeleteAsync();
await HandleFieldAsync();
}
else if (input.Content.Equals("submit", StringComparison.OrdinalIgnoreCase))
{
await input.DeleteAsync();
await RemoveAsync();
return(_embed.Build());
}
else if (input.Content.Equals("cancel", StringComparison.OrdinalIgnoreCase))
{
await input.DeleteAsync();
await RemoveAsync();
return(null);
}
else
{
await input.DeleteAsync();
await _interactive.ReplyAndDeleteAsync(
_context,
$"```Unknown action '{input.Content}'.```",
timeout : TimeSpan.FromSeconds(5));
continue;
}
await _previewMsg.ModifyAsync(m => m.Embed = _embed.Build());
await _instructionsMsg.ModifyAsync(m => m.Content = _Instructions);
}
}