private async Task <bool> VerificarAsync(DiscordChannel channel, DiscordUser autor, int time = 30)
{
DiscordMessage verificacion = await channel.SendMessageAsync(EasyDualLanguageFormatting("¿Estas seguro?", "Are you sure?"));
await WoteAsync(verificacion, false);
HelperMethods.Delay(1000);
for (int i = 0; i < time; i++)
{
IReadOnlyList <DiscordUser> reaccionesOK = await verificacion.GetReactionsAsync(DiscordEmoji.FromName(Client, ":white_check_mark:"));
IReadOnlyList <DiscordUser> reaccionesNOPE = await verificacion.GetReactionsAsync(DiscordEmoji.FromName(Client, ":x:"));
if (reaccionesOK.Contains(autor))
{
await verificacion.DeleteAsync();
return(true);
}
if (reaccionesNOPE.Contains(autor))
{
await verificacion.DeleteAsync();
return(false);
}
HelperMethods.Delay(1000);
}
await verificacion.DeleteAsync();
return(false);
}
/// <summary>
/// Envia una palabra del dia a la hora y minuto estimados (CEST)
/// </summary>
/// <param name="hora">Hora del dia a la que se envia la WOTD</param>
/// <param name="minuto">Minuto de la hora a la que se envia la WOTD</param>
/// <param name="segundo">Segundo de la hora la que se envia la WOTD</param>
public void SetUpTimer(int hora, int minuto, int segundo = 15)
{
while (true)
{
DateTime now = DateTime.Now; //Legibilidad
DateTime proximoWOTD;
bool isTodayEndOfMonth = (now.Day == DateTime.DaysInMonth(now.Year, now.Month));
bool isTodayEndOfYear = (now.DayOfYear == (DateTime.IsLeapYear(now.Year) ? 366 : 365));
bool isAfterSendTime = (DateTime.Compare(
now,
new DateTime(now.Year, now.Month, now.Day, hora, minuto, segundo)
) >= 1);
proximoWOTD = new DateTime( //?:!?:!?:!?:!?:!
(isAfterSendTime ? (isTodayEndOfYear ? now.Year + 1 : now.Year) : now.Year),
(isAfterSendTime ? (isTodayEndOfMonth ? (isTodayEndOfYear ? 1 : now.Month + 1) : now.Month) : now.Month),
(isAfterSendTime ? (isTodayEndOfYear || isTodayEndOfMonth ? 1 : now.Day + 1) : now.Day),
hora,
minuto,
segundo);
TimeSpan diff = proximoWOTD - now;
HelperMethods.Delay((int)diff.TotalMilliseconds);
UpdateUserCountChannel();
SendWOTDAsync();
}
}
private Task WoteAsync(DiscordMessage message, bool dunno = false)
{
message.CreateReactionAsync(DiscordEmoji.FromName(Client, ":white_check_mark:"));
HelperMethods.Delay();
message.CreateReactionAsync(DiscordEmoji.FromName(Client, ":x:"));
if (dunno)
{
HelperMethods.Delay();
message.CreateReactionAsync(DiscordEmoji.FromGuildEmote(Client, 614346797141458974));
}
return(Task.CompletedTask);
}
public async Task RunBotAsync()
{
//Abrir JSON file
string jsonConfString = "";
using (FileStream fs = File.OpenRead("config.json"))
using (StreamReader sr = new StreamReader(fs, new UTF8Encoding(false)))
jsonConfString = await sr.ReadToEndAsync();
ConfigJson cfgjson = JsonConvert.DeserializeObject <ConfigJson>(jsonConfString);
DiscordConfiguration cfg = new DiscordConfiguration
{
Token = cfgjson.Token,
TokenType = TokenType.Bot,
AutoReconnect = true,
MinimumLogLevel = LogLevel.Information,
Intents = DiscordIntents.All
};
this.Client = new DiscordClient(cfg);
this.Client.Ready += Client_Ready;
this.Client.GuildAvailable += Client_GuildAvailable;
this.Client.ClientErrored += Client_ClientError;
this.Client.MessageCreated += Client_MessageCreated;
this.Client.GuildMemberUpdated += Client_GuildMemberUpdated;
this.Client.MessageReactionAdded += Client_MessageReactionAdded;
this.Client.MessageReactionRemoved += Client_MessageReactionRemoved;
this.Client.GuildMemberAdded += Client_GuildMemberAdded;
this.Client.VoiceStateUpdated += Client_VoiceStateUpdated;
await this.Client.ConnectAsync();
ReactionRole = JsonConvert.DeserializeObject <Dictionary <ulong, Dictionary <String, ulong> > >(File.ReadAllText("RR.Json"));
languagechannel = await Client.GetChannelAsync(ulong.Parse(cfgjson.WOTDChannel)); //Channel which recieves updates
languageServer = await Client.GetGuildAsync(ulong.Parse(cfgjson.LanguageServer)); //Server
introductions = await Client.GetChannelAsync(ulong.Parse(cfgjson.Introductions));
EnglishNative = languageServer.GetRole(ulong.Parse(cfgjson.EnglishNative));
SpanishNative = languageServer.GetRole(ulong.Parse(cfgjson.SpanishNative));
OtherNative = languageServer.GetRole(ulong.Parse(cfgjson.OtherNative));
WOTDrole = languageServer.GetRole(ulong.Parse(cfgjson.WOTDRole)); //WOTD role
CorrectMeRole = languageServer.GetRole(ulong.Parse(cfgjson.CorrectMeRole)); //CorrectMe Role
onVC = languageServer.GetRole(ulong.Parse(cfgjson.OnVC));
suggestions = await Client.GetChannelAsync(ulong.Parse(cfgjson.Suggestions)); //Channel which recieves updates
adminSuggestions = await Client.GetChannelAsync(ulong.Parse(cfgjson.AdminSuggestions));
conelBot = await Client.GetChannelAsync(ulong.Parse(cfgjson.ConElBot));
modlog = await Client.GetChannelAsync(ulong.Parse(cfgjson.ModLog));
roles = await Client.GetChannelAsync(ulong.Parse(cfgjson.RolesChannel)); //Channel which users get their roles from.
usercount = await Client.GetChannelAsync(ulong.Parse(cfgjson.UserCountChannel));
botupdates = await Client.GetChannelAsync(ulong.Parse(cfgjson.BotUpdates));
StudyRole = languageServer.GetRole(ulong.Parse(cfgjson.StudyRole));
admin = languageServer.GetRole(ulong.Parse(cfgjson.Admin));
yoshi = await Client.GetUserAsync(ulong.Parse(cfgjson.Yoshi));
await Client.UpdateStatusAsync(new DiscordActivity("-help"), UserStatus.Online);
if (!(lastException is null) && (lastExceptionDatetime != DateTime.MinValue))
{
//Programar sin dormir es !bien
DiscordEmbedBuilder builder = new DiscordEmbedBuilder();
builder
.WithTitle("Bot Breaking Exception")
.WithColor(new DiscordColor("#FF0000"))
.WithFooter(
"A Yoshi's Bot",
"https://i.imgur.com/rT9YocG.jpg"
);
if (lastException.HelpLink != null)
{
builder.WithUrl(lastException.HelpLink);
}
if (lastException.StackTrace != null)
{
builder.AddField("StackTrace", lastException.StackTrace);
}
if (lastException.Message != null)
{
builder.AddField("Mensaje", lastException.Message);
}
if (lastException.InnerException != null)
{
builder.AddField("**INNER EXCEPTION**", "**——————————————————————————————————————**");
if (lastException.InnerException.HelpLink != null)
{
builder.WithUrl(lastException.InnerException.HelpLink);
}
if (lastException.InnerException.Message != null)
{
builder.AddField("Mensaje", lastException.InnerException.Message);
}
}
if (lastExceptionDatetime != null)
{
builder.WithTimestamp(lastExceptionDatetime);
}
;
await botupdates.SendMessageAsync(
new DiscordMessageBuilder()
.WithContent(
"**Bot Breaking Exception** - " + lastExceptionDatetime.ToString("yyyy-mm-dd HH_mm_ss") + " - " + yoshi.Mention
)
.WithFile(
lastExceptionDatetime.ToString("s") + "WOTD_EX_StackTrace.txt",
new MemoryStream(Encoding.UTF8.GetBytes(lastException.InnerException.StackTrace))
)
.WithEmbed(
builder.Build()
)
);
HelperMethods.Delay();
}
this.Client.UseInteractivity(new InteractivityConfiguration
{
PaginationBehaviour = DSharpPlus.Interactivity.Enums.PaginationBehaviour.Ignore,
Timeout = TimeSpan.FromMinutes(2)
});
commands = Client.UseCommandsNext(new CommandsNextConfiguration
{
StringPrefixes = new[] { "-" },
EnableDefaultHelp = false,
DmHelp = false,
IgnoreExtraArguments = true
});
//commands.RegisterCommands<StudyCommands>();
commands.RegisterCommands <WOTDCommands>();
commands.CommandExecuted += this.Commands_CommandExecuted;
commands.CommandErrored += this.Commands_CommandErrored;
Thread WOTD = new Thread(() => SetUpTimer(14, 00));
WOTD.Start();
await Task.Delay(-1);
}
private async Task <Task> Client_MessageCreated(DiscordClient sender, MessageCreateEventArgs e)
{
if (e.Author.IsBot || e.Author.IsCurrent)
{
return(Task.CompletedTask);
}
//Esto es horrible pero bueno
string mensaje = e.Message.Content.ToLower();
if (mensaje.StartsWith("-wote") ||
mensaje.StartsWith("wote") ||
e.Message.ChannelId == suggestions.Id ||
e.Message.ChannelId == adminSuggestions.Id)
{
await WoteAsync(e.Message, true);
}
if (e.Channel == introductions)
{
DiscordMember member = (DiscordMember)e.Author;
bool hasroles = checkroles(member);
if (!hasroles)
{
await member.SendMessageAsync(EasyDualLanguageFormatting(
"Nos hemos dado cuenta que no tienes los roles de nativo, puedes obtenerlos en #roles.\n" +
"**Necesitas un rol de nativo para interactuar en el servidor.**\n" +
"Si tienes algun problema puedes preguntar a algun miembro del staff.",
"We've noticed that you don't have any native roles, you can grab them in #roles.\n" +
"**You need a native role to interact on the server.**\n" +
"If You're having trouble feel free to ask anyone from the staff team."));
}
bool checkroles(DiscordMember member)
{
return(member.Roles.Where(
role => role == EnglishNative || role == SpanishNative || role == OtherNative
).Any());
}
}
if (!mensaje.StartsWith("-"))
{
return(Task.CompletedTask); //OPTIMIZAAAAAAR
}
string[] content = mensaje.Trim().Split(' ');
bool isAdmin = IsAdmin(e.Author);
if (mensaje.StartsWith("-roles"))
{
await e.Channel.SendMessageAsync(
$"{DiscordEmoji.FromName(Client, ":flag_es:")} Por favor ponte los roles adecuados en {roles.Mention} ¡No te olvides el rol de nativo!\n" +
$"{DiscordEmoji.FromName(Client, ":flag_gb:")} Please set up your roles in {roles.Mention} Don't forget the native role!"
);
return(Task.CompletedTask);
}
if (mensaje.StartsWith("-ping"))
{
await e.Message.RespondAsync("Pong! " + Client.Ping + "ms");
return(Task.CompletedTask);
}
if (mensaje.StartsWith("-help"))
{
DiscordMember member = (DiscordMember)e.Author;
await member.SendMessageAsync(GenerateHelp(member));
e.Message.CreateReactionAsync(DiscordEmoji.FromName(Client, ":white_check_mark:"));
return(Task.CompletedTask);
}
if (mensaje.StartsWith("-sendwotd") && isAdmin)
{
bool confirmacion = await VerificarAsync(e.Channel, e.Author, 15);
if (confirmacion)
{
await SendWOTDAsync();
e.Message.CreateReactionAsync(DiscordEmoji.FromName(Client, ":white_check_mark:"));
}
return(Task.CompletedTask);
}
if (mensaje.StartsWith("-version"))
{
await e.Channel.SendMessageAsync(GetVersionEmbed());
return(Task.CompletedTask);
}
if (mensaje.StartsWith("-checkusers") && isAdmin)
{
_ = Task.Run(async() =>
{
IEnumerable <DiscordMember> members = await languageServer.GetAllMembersAsync();
int i = 0;
int max = members.Count();
DiscordMessage msg = await e.Channel.SendMessageAsync(
HelperMethods.QuickEmbed($"Checking Users... This is going to take a while", $"{i}/{max}\n{HelperMethods.GenerateProgressBar(0)}"));
DateTime lastEdit = DateTime.Now;
foreach (DiscordMember member in members)
{
if (CheckUser(member))
{
HelperMethods.Delay(100);
}
else
{
HelperMethods.Delay(50);
}
i++;
if (DateTime.Now - lastEdit > TimeSpan.FromSeconds(8))
{
lastEdit = DateTime.Now;
msg.ModifyAsync(null, HelperMethods.QuickEmbed($"Checking Users...{i}/{max}", HelperMethods.GenerateProgressBar(((double)i / max))));
}
}
msg.ModifyAsync(null, HelperMethods.QuickEmbed("All users have been checked"));
});
return(Task.CompletedTask);
}
if (mensaje.StartsWith("-isblocked") && isAdmin)
{
DiscordMember senderMember = (DiscordMember)e.Author;
string nickname = "";
try
{
ulong userid = ulong.Parse(mensaje.Substring(10));
DiscordUser objUser = await Client.GetUserAsync(userid);
DiscordMember objMember = await languageServer.GetMemberAsync(userid);
nickname = objMember.Nickname;
IReadOnlyList <DiscordMessage> mensajes = await conelBot.GetMessagesAsync(250);
bool ischecked = false;
foreach (DiscordMessage MensajeLocal in mensajes)
{
if (MensajeLocal.Author == objMember && !ischecked)
{
ischecked = true;
await MensajeLocal.CreateReactionAsync(DiscordEmoji.FromName(Client, ":thinking:"));
HelperMethods.Delay();
await MensajeLocal.DeleteOwnReactionAsync(DiscordEmoji.FromName(Client, ":thinking:"));
await senderMember.SendMessageAsync($"El usuario {nickname} **No** ha bloqueado al bot");
}
}
}
catch (Exception ex)
{
if (ex is ArgumentNullException || ex is FormatException || ex is OverflowException)
{
await senderMember.SendMessageAsync("Excepcion no controlada. Es posible que no hayas puesto bien el ID");
}
if (ex.Message == "Unauthorized: 403")
{
await senderMember.SendMessageAsync($"El usuario {nickname} ha bloqueado al bot");
}
}
return(Task.CompletedTask);
}
if (mensaje.StartsWith("-gimmiadmin") && e.Author == yoshi)
{
//await e.Message.DeleteAsync();
DiscordMember member = (DiscordMember)e.Author;
await member.GrantRoleAsync(admin);
await member.SendMessageAsync("Admin == true");
return(Task.CompletedTask);
}
if (mensaje.StartsWith("-dletadmin") && e.Author == yoshi)
{
await e.Message.DeleteAsync();
DiscordMember member = (DiscordMember)e.Author;
await member.SendMessageAsync("Admin == false");
await member.RevokeRoleAsync(admin);
return(Task.CompletedTask);
}
if (mensaje.StartsWith("-restart") && isAdmin)
{
bool confirmacion = await VerificarAsync(e.Channel, e.Author, 15);
if (confirmacion)
{
e.Message.CreateReactionAsync(DiscordEmoji.FromName(Client, ":white_check_mark:"));
HelperMethods.Delay(1500);
Environment.Exit(0);
}
else
{
await e.Message.DeleteAsync();
}
}
if (mensaje.StartsWith("-embed") && isAdmin)
{
String message = e.Message.Content.Substring(6);
DiscordMember member = (DiscordMember)e.Author;
bool hasfile = e.Message.Attachments.Count > 0;
bool isfilenamevaild = false;
String filecontent = "";
if (hasfile)
{
DiscordAttachment file = e.Message.Attachments[0];
isfilenamevaild = file.FileName.Equals("message.txt");
string FileName = DateTime.Now.Ticks.ToString("X16") + @".txt"; //https://stackoverflow.com/questions/7874111/convert-datetime-now-to-a-valid-windows-filename => I hate the world
using (WebClient client = new WebClient())
{
client.DownloadFile(file.Url, FileName);
}
filecontent = File.ReadAllText(FileName);
File.Delete(FileName);
}
HelperMethods.Delay(350);
await e.Message.DeleteAsync();
try
{
if (!hasfile)
{
await e.Channel.SendMessageAsync(HelperMethods.QuickEmbed($"Embed de {member.Nickname ?? member.DisplayName: member.Nickname}", message, false));
}
else if (hasfile && isfilenamevaild)
{
await e.Channel.SendMessageAsync(HelperMethods.QuickEmbed($"Embed de {member.Nickname ?? member.DisplayName: member.Nickname}", filecontent, false));
}
}
catch (Exception ex)
{
await botupdates.SendMessageAsync(new DiscordMessageBuilder()
.WithContent("Excepcion con un Embed")
.WithEmbed(GenerateErrorEmbed(ex))
);
DiscordMessage errorembed = await e.Channel.SendMessageAsync(HelperMethods.QuickEmbed(":warning: Error :warning:",
EasyDualLanguageFormatting("Mensaje demasiado largo o contiene caracteres no validos", "Message too large or has invalid characters"), false, "#FF0000"));
HelperMethods.Delay(5000);
await errorembed.DeleteAsync();
}
return(Task.CompletedTask);
}
if (mensaje.StartsWith("-https://cdn.discordapp.com/attachments/479257969427611649/803398998710681690/b.png") && isAdmin)
{
String[] imageformats = { "png", "jpg", "gif", "WebP" };
if (content.Length >= 2 &&
Uri.IsWellFormedUriString(content[1], UriKind.Absolute) &&
imageformats.Contains(content[1].Split('.').Last().Substring(0, 3)))
{
using (WebClient wc = new WebClient())
{
string currentformat = content[1].Split('.').Last().Substring(0, 3);
string filepath = DateTime.Now.Ticks.ToString("X16") + "." + currentformat;
wc.DownloadFile(content[1], filepath);
DiscordGuildEmoji guildEmoji = await e.Guild.CreateEmojiAsync(content[2], File.OpenRead(filepath));
await e.Channel.SendMessageAsync(guildEmoji.ToString());
File.Delete(filepath);
}
}
else
{
await e.Message.DeleteAsync();
await e.Channel.SendMessageAsync(HelperMethods.QuickEmbed("No se puedo añadir el emoji", "Puede que no tenga el formato correcto[png, jpg, gif, WebP]\nUso:-Addemoji<URL> < Nombre_emoji >", false, "#ff0000"));
}
}
if (mensaje.StartsWith("-usercount") && isAdmin)
{
UpdateUserCountChannel();
e.Message.CreateReactionAsync(DiscordEmoji.FromName(Client, ":white_check_mark:"));
}
//END OF IF WALL
return(Task.CompletedTask);
}
