DiscordClient/DiscordDelete/Program.cs

using CommandLine;
using DiscordClient;
using DiscordClient.Data;
using DiscordDelete;

string? token = Environment.GetEnvironmentVariable("DISCORD_TOKEN");

if (token == null)
{
    // Exit.
    Console.WriteLine("Token is null. Make sure you set the DISCORD_TOKEN environmental variable.");
    return;
}

DiscordContext db = new DiscordContext();
DiscordUserClient client = new DiscordUserClient(token);

int finalCode = await CommandLine
    .Parser.Default.ParseArguments<DeleteOptions, ScanOptions>(args)
    .MapResult(
        async (DeleteOptions opt) =>
        {
            foreach (Message message in db.Messages.Where(message => message.LastHttpCode != 204))
            {
                // If required data is null, continue to next message.
                if (message.MessageId is null || message.ChannelId is null)
                    continue;

                HttpResponseMessage response = await client.DeleteMessage(
                    message.ChannelId,
                    message.MessageId
                );
                message.LastHttpCode = (int)response.StatusCode;
                Console.WriteLine(
                    $"{message.Id} - Deleting {message.MessageId} - {response.StatusCode}"
                );

                if (response.StatusCode == System.Net.HttpStatusCode.TooManyRequests)
                {
                    Console.WriteLine("Too many requests. Sleeping for extra 20 seconds.");
                    await Task.Delay(TimeSpan.FromSeconds(20));
                }

                db.Update(message);
                await db.SaveChangesAsync();

                await Task.Delay(TimeSpan.FromSeconds(2));
            }

            return 0;
        },
        async (ScanOptions opt) =>
        {
            // This should never happen author required.
            if (opt.Author is null)
            {
                Console.WriteLine("Author ID is null.");
                return 1;
            }

            int totalMessages = 1;
            int offset = 0;

            if (opt.GuildId is null)
            {
                Console.WriteLine("Scanning DM messages.");
                while (true)
                {
                    // Scanning direct messages.
                    ChannelMessagesResponse[]? messages = await client.GetChannelMessages(
                        opt.ChannelId,
                        offset,
                        opt.Author
                    );

                    if (messages is null)
                        return 2;

                    IEnumerable<Message> newMessages = messages.Select(message => new Message
                    {
                        ChannelId = message.ChannelId,
                        MessageId = message.Id,
                        Content = message.Content
                    });

                    foreach (var newMessage in newMessages)
                    {
                        if (!db.Messages.Any(message => message.MessageId == newMessage.MessageId))
                            await db.AddAsync(newMessage);
                    }

                    await db.SaveChangesAsync();
                    Console.WriteLine($"Written {messages.Length} messages.");
                    offset += 50;

                    await Task.Delay(TimeSpan.FromSeconds(2));
                }
            }
            else
            {
                Console.WriteLine("Scanning guild messages.");
                while (offset < totalMessages)
                {
                    // Scanning guild messages.
                    GuildMessageSearchResponse? response = await client.SearchGuildMessages(
                        opt.GuildId,
                        offset,
                        opt.Author
                    );

                    if (response is null || response.Messages is null)
                        return 3;

                    totalMessages = response.TotalMessages;

                    IEnumerable<Message> newMessages = response.Messages.SelectMany(message =>
                        message.Select(messagePart => new Message
                        {
                            ChannelId = messagePart.ChannelId,
                            MessageId = messagePart.Id,
                            Content = messagePart.Content
                        })
                    );

                    foreach (var newMessage in newMessages)
                    {
                        if (!db.Messages.Any(message => message.MessageId == newMessage.MessageId))
                            await db.AddAsync(newMessage);
                    }

                    await db.SaveChangesAsync();
                    Console.WriteLine($"Written {response.Messages.Length} messages.");
                    offset += response.Messages.Count();

                    await Task.Delay(TimeSpan.FromSeconds(2));
                }
            }

            return 0;
        },
        errs => Task.FromResult(0)
    );