Ejemplo n.º 1
0
        public async Task AddOCAsync(CommandContext e, [RemainingText] string charName)
        {
            string role = "";

            Wiki.Page page = new Wiki.Page(WikiSite, charName)
            {
                text = ""
            };

            var interactivity = e.Client.GetInteractivity();

            var embed = new DiscordEmbedBuilder()
            {
                Title = "Character Data",
                Color = DiscordColor.Red
            };


            var infoBoxEmbed = new DiscordEmbedBuilder()
            {
                Title = "Infobox",
                Color = DiscordColor.SpringGreen
            };

            DiscordMessage embedMessage = await e.RespondAsync(embed : embed);

            DiscordMessage infoBoxEmbedMessage = await e.RespondAsync(embed : infoBoxEmbed);

            DiscordMessage mainMessage = await e.RespondAsync("Okay, setting up!");


            foreach (var pair in WikiFields)
            {
                bool errored = false;
                await mainMessage.ModifyAsync(pair.Key[1]);

                string content = "";
AnotherMessage:
                var msg = await interactivity.WaitForMessageAsync(x => x.Author == e.Member, TimeSpan.FromSeconds(120));

                if (msg != null)
                {
                    content += msg.Message.Content.Replace("¬", "") + Environment.NewLine;

                    if (msg.Message.Content.Contains("¬"))
                    {
                        await msg.Message.DeleteAsync();

                        goto AnotherMessage;
                    }
                    else if (msg.Message.Content.ToLower() == "stop")
                    {
                        goto End;
                    }
Errored:
                    if (content.Length < 1024)
                    {
                        embed.AddField(pair.Key[0], content);
                    }
                    else
                    {
                        var strings = content.Split(1024);
                        foreach (var s in strings)
                        {
                            embed.AddField(pair.Key[0], new string(s.ToArray()));
                        }
                    }
                    pair.Value(content, page);

                    if (errored)
                    {
                        embedMessage = await e.RespondAsync(embed : embed);

                        await infoBoxEmbedMessage.DeleteAsync();

                        await mainMessage.DeleteAsync();

                        infoBoxEmbedMessage = await e.RespondAsync(embed : infoBoxEmbed);

                        mainMessage = await e.RespondAsync("Okay, setting up!");
                    }
                    else
                    {
                        try
                        {
                            await embedMessage.ModifyAsync(embed : embed.Build());
                        }
                        catch
                        {
                            embed.ClearFields();
                            errored = true;
                            goto Errored;
                        }
                    }
                    await mainMessage.ModifyAsync("Added field!");

                    await msg.Message.DeleteAsync();

                    await Task.Delay(1000);
                }
            }

            foreach (var infoBoxField in InfoBox.Fields)
            {
                await mainMessage.ModifyAsync(infoBoxField.Question + "\nSend `-` if the field should be omitted.");

Failed:
                var msg = await interactivity.WaitForMessageAsync(x => x.Author == e.Member, TimeSpan.FromSeconds(120));

                if (msg != null)
                {
                    if (infoBoxField.FieldId == "affiliation")
                    {
                        string message = msg.Message.Content.ToLower();
                        if (message.Contains("hero"))
                        {
                            role = "Heroes";
                            infoBoxField.FieldValue = "Pro Hero";
                        }
                        else if (message.Contains("rogue") || message.Contains("rouge"))
                        {
                            role = "Rogues";
                            infoBoxField.FieldValue = "Rogue";
                        }
                        else if (message.Contains("villain"))
                        {
                            role = "Villains";
                            infoBoxField.FieldValue = "Villain";
                        }
                        else if (message.Contains("academy student"))
                        {
                            role = "Academy Students";
                            infoBoxField.FieldValue = "Academy Student";
                        }
                        else
                        {
                            await msg.Message.DeleteAsync();

                            goto Failed;
                        }
                        infoBoxEmbed.AddField(infoBoxField.FieldId, infoBoxField.FieldValue);
                    }
                    else
                    {
                        if (msg.Message.Content.ToLower() == "stop")
                        {
                            goto End;
                        }
                        infoBoxField.FieldValue = msg.Message.Content;
                        try
                        {
                            if (infoBoxField.FieldValue.Length < 1024)
                            {
                                infoBoxEmbed.AddField(infoBoxField.FieldId, infoBoxField.FieldValue);
                            }
                            else
                            {
                                var strings = infoBoxField.FieldValue.Split(1024);
                                foreach (var s in strings)
                                {
                                    infoBoxEmbed.AddField(infoBoxField.FieldId, infoBoxField.FieldValue);
                                }
                            }
                        }
                        catch
                        {
                            await msg.Message.DeleteAsync();

                            goto Failed;
                        }
                    }
                    await infoBoxEmbedMessage.ModifyAsync(embed : infoBoxEmbed.Build());

                    await msg.Message.DeleteAsync();

                    await mainMessage.ModifyAsync("Added field!");

                    await Task.Delay(1000);
                }
            }

imageMessage:
            await mainMessage.ModifyAsync("Please link an image for the infobox.");

            var imageMessage = await interactivity.WaitForMessageAsync(x => x.Author == e.Member, TimeSpan.FromSeconds(120));

            if (imageMessage != null)
            {
                string imageName;
                if (imageMessage.Message.Content.ToLower() == "stop")
                {
                    goto End;
                }
                Regex ItemRegex = new Regex(@"\.(png|gif|jpg|jpeg|tiff|webp)");
                if (ItemRegex.IsMatch(imageMessage.Message.Content))
                {
                    imageName = imageMessage.Message.Content.Split('/').Last();

                    Wiki.Page p = new Wiki.Page(WikiSite, "File:" + imageName);
                    p.UploadImageFromWeb(imageMessage.Message.Content, "N/A", "N/A", "N/A");
                    infoBoxEmbed.ImageUrl = imageMessage.Message.Content;
                    await imageMessage.Message.DeleteAsync();

                    await infoBoxEmbedMessage.ModifyAsync(embed : infoBoxEmbed.Build());

                    await mainMessage.ModifyAsync("Added field!");

                    await Task.Delay(1000);
                }
                else
                {
                    await imageMessage.Message.DeleteAsync();

                    await mainMessage.ModifyAsync("That is invalid.");

                    goto imageMessage;
                }
                string infoboxStuff = InfoBox.BuildInfoBox("image = " + imageName + "|");
                page.text  = page.text.Insert(0, infoboxStuff);
                page.text += $"{Environment.NewLine}[[Category:OC]] [[Category:All Characters]] [[Category:OC {role}]] [[Category:{role}]]";

                if (role == "Academy Students")
                {
academyMessage:
                    await mainMessage.ModifyAsync("Please state which year the academy student is in: 1, 2, 3 or 4.");

                    var academyMessage = await interactivity.WaitForMessageAsync(x => x.Author == e.Member, TimeSpan.FromSeconds(120));

                    if (academyMessage != null)
                    {
                        if (academyMessage.Message.Content.ToLower() == "stop")
                        {
                            goto End;
                        }
                        switch (academyMessage.Message.Content)
                        {
                        case "1":
                            page.text += $"[[Category:1st Year Student]]";
                            break;

                        case "2":
                            page.text += $"[[Category:2nd Year Student]]";
                            break;

                        case "3":
                            page.text += $"[[Category:3rd Year Student]]";
                            break;

                        case "4":
                            page.text += $"[[Category:4th Year Student]]";
                            break;

                        default:
                            await mainMessage.ModifyAsync("That is invalid.");

                            goto academyMessage;
                        }
                        await academyMessage.Message.DeleteAsync();
                    }
                }
                page.Save();
                await mainMessage.ModifyAsync("Complete!");

                await e.RespondAsync($"http://roleplay-heroes-and-villains.wikia.com/wiki/{page.title}");

                return;
            }

End:
            await mainMessage.ModifyAsync("Action cancelled.");

            await Task.Delay(2000);

            await mainMessage.DeleteAsync();

            await infoBoxEmbedMessage.DeleteAsync();

            await embedMessage.DeleteAsync();
        }