public async Task Remind(int h, int m, [Remainder] string text)
{
await Context.Message.DeleteAsync();
DiscordWrapper.Log($"Lời nhắc của {Context.Message.Author.Username} ({Context.Message.Author.Id}) ở guild {Context.Guild.Name} ({h}:{m} / {text})");
try
{
WqlEventQuery query = new WqlEventQuery
("__InstanceModificationEvent", new TimeSpan(0, 0, 60),
$"TargetInstance isa 'Win32_LocalTime' AND TargetInstance.Hour={h} AND TargetInstance.Minute={m} AND TargetInstance.Second=0");
ManagementEventWatcher watcher = new ManagementEventWatcher(query);
watcher.EventArrived += async(object sender, EventArrivedEventArgs e) =>
{
await DiscordWrapper.SendMessage(Context, $"*Đây là lời nhắc dành cho {Context.Message.Author.Mention}:*\n{text}");
};
watcher.Start();
}
catch (Exception e)
{
DiscordWrapper.Log($"[log] ScheduledTask in Module: {e}");
DiscordWrapper.Log($"Lỗi {e} ở lời nhác của {Context.Message.Author.Id} ở guild {Context.Guild.Name} ({h}:{m} / {text})");
await DiscordWrapper.SendMessage(Context, $"Có lỗi xảy ra. Bạn nhắc lại giúp Mèo thời gian và lời nhắn với, {Context.Message.Author.Mention}.");
}
}
public async Task CancelFFmpeg()
{
Global.cts.Cancel();
DiscordWrapper.Log("[log] Playback terminated.");
await Task.Delay(TimeSpan.FromMilliseconds(1000));
}
private static bool SetControl(ref ChessBoard chess)
{
try
{
for (var i = 0; i < 8; i++)
{
for (var j = 0; j < 8; j++)
{
chess.Control[0, i, j] = chess.Control[1, i, j] = 0;
}
}
for (var i = 0; i < 8; i++)
{
for (var j = 0; j < 8; j++)
{
if (chess.Board[i, j] != ChessBoard.Empty &&
!SetControlPos(ref chess, i, j))
{
return(false);
}
}
}
return(true);
}
catch (Exception e)
{
DiscordWrapper.Log($"{log} {e}");
return(false);
}
}
public async Task New()
{
ulong UserId = Context.Message.Author.Id;
await DiscordWrapper.SendMessage(Context, $"{MentionUtils.MentionUser(UserId)}, bạn có chắc muốn tạo trò chơi mới? (Yes/No)");
string content = null;
SocketMessage msg;
Stopwatch s = new Stopwatch();
s.Start();
do
{
msg = await NextMessageAsync(fromSourceUser : true, inSourceChannel : true, timeout : TimeSpan.FromMinutes(5));
if (msg == null)
{
break;
}
content = msg.Content.ToLower();
if (content == "yes" || content == "no")
{
break;
}
} while (s.Elapsed < TimeSpan.FromMinutes(5));
if (msg == null)
{
await DiscordWrapper.SendMessage(Context, $"Mèo không nhận được phản hồi của {MentionUtils.MentionUser(UserId)}... :cry:");
return;
}
else if (content == "no")
{
await DiscordWrapper.SendMessage(Context, $"Trò chơi mới sẽ không được tạo.");
await Task.Delay(TimeSpan.FromSeconds(5));
await(Context.Channel as ITextChannel).DeleteMessagesAsync(await Context.Channel.GetMessagesAsync(4).FlattenAsync());
return;
}
await(Context.Channel as ITextChannel).DeleteMessagesAsync(await Context.Channel.GetMessagesAsync(2).FlattenAsync());
Puzzle puzzle = new Puzzle(UserId);
Save(ref puzzle);
DiscordWrapper.Log($"puzzle new | {Context.Message.Author.Username} ({Context.Message.Author.Id})");
if (!(await Host()))
{
var embed = new EmbedBuilder
{
Description = $"Trò chơi của {MentionUtils.MentionUser(puzzle.PlayerId) } đã tạm dừng.",
Color = Color.Blue
};
await DiscordWrapper.SendMessage(Context, embed : embed.Build());
}
}
public static async Task Main(string[] args)
{
var config = new ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile("appsettings.json", true)
.AddEnvironmentVariables()
.Build();
var configWrapper = new ConfigurationWrapper(config);
var topClipsModuleHelper = new TopClipsModuleHelper(configWrapper);
var botHelper = new BotHelper(configWrapper);
using (var functionWrapper = new FunctionWrapper(configWrapper))
using (var discordWrapper = new DiscordWrapper(configWrapper["BotToken"]))
using (var services = new ServiceCollection()
.AddSingleton <IDiscordWrapper>(discordWrapper)
.AddSingleton <IConfigurationWrapper>(configWrapper)
.AddSingleton <IFunctionWrapper>(functionWrapper)
.AddSingleton <ITopClipsModuleHelper>(topClipsModuleHelper)
.AddSingleton <IBotHelper>(botHelper)
.AddLogging(s => s.AddConsole())
.BuildServiceProvider())
{
var bot = new Bot(services);
await bot.RunAsync();
await Task.Delay(-1);
}
}
public static async Task Run([TimerTrigger("%PostGifsFunctionCron%")] TimerInfo myTimer, ILogger log)
{
var connectionString = Environment.GetEnvironmentVariable("TrendingGiphyBotConnectionString");
var botToken = Environment.GetEnvironmentVariable("BotToken");
var hourOffsetString = Environment.GetEnvironmentVariable("HourOffset");
var hourOffset = int.Parse(hourOffsetString);
var now = DateTime.Now.AddHours(-hourOffset);
var validMinutesString = Environment.GetEnvironmentVariable("ValidMinutes");
var validMinutes = validMinutesString.Split(',', options: StringSplitOptions.RemoveEmptyEntries).Select(int.Parse);
var validHoursString = Environment.GetEnvironmentVariable("ValidHours");
var validHours = validHoursString.Split(',', options: StringSplitOptions.RemoveEmptyEntries).Select(int.Parse);
var validHoursAsMinutes = validHours.Select(s => s * 60);
var allValidMinutes = validMinutes.Concat(validHoursAsMinutes).ToList();
var giphyRandomEndpoint = Environment.GetEnvironmentVariable("GiphyRandomEndpoint");
var warningResponses = Environment.GetEnvironmentVariable("WarningResponses").Split(',', options: StringSplitOptions.RemoveEmptyEntries).ToList();
var logWrapper = new LoggerWrapper(log);
using (var context = new TrendingGiphyBotContext(connectionString))
using (var giphyWrapper = new GiphyWrapper())
using (var discordWrapper = new DiscordWrapper(botToken))
{
var gifPostingHelper = new GifPostingHelper(logWrapper, context, giphyWrapper, discordWrapper, warningResponses);
var postGifsHelper = new PostGifsHelper(gifPostingHelper);
await postGifsHelper.RunAsync(now, allValidMinutes, giphyRandomEndpoint);
}
}
public async Task JoinAudio(IGuild guild, IVoiceChannel target)
{
try
{
if (isGuildAdded(guild).Result)
{
if (connectedVChannel(guild).Result != null)
{
return;
}
ConnectedChannels.Clear();
}
if (target.Guild.Id != guild.Id)
{
return;
}
var audioClient = await target.ConnectAsync();
if (ConnectedChannels.TryAdd(guild.Id, audioClient))
{
DiscordWrapper.Log($"[info][{LogSeverity.Info}] Connected to voice on {guild.Name}.");
}
}
catch (Exception ex)
{
DiscordWrapper.Log($"[log] {ex}");
}
}
public async Task Help()
{
//return;
var embed = new EmbedBuilder {
Description = "**>> Cùng điểm qua những câu lệnh Mèo có nào!**",
Color = Color.Magenta
};
embed.AddField("*'hi*",
"Cùng chào nhau nhé!")
.AddField("*'react <ID tin nhắn> <emoji_1> <emoji_2> ... <emoji_n>*",
"Mèo sẽ \"thả tym\" vào tin nhắn có ID đó!")
.AddField("*'say <true/false>(true nếu ẩn danh, mặc định là false) <thời gian chờ>(theo giây, mặc định là 0) <tin nhắn>*",
"Mèo sẽ giúp bạn gửi tin nhắn đó!")
.AddField("*'party*",
"Đến lúc quẩy rồi!!! :partying_face:")
.AddField("*'rmd <giờ>(0 - 23) <phút>(0 - 59) <lời nhắc>*",
"Mèo sẽ nhắc nhở bạn vào thời điểm đó!")
.AddField("*'wait <giây> <lời nhắn>*",
"Mèo sẽ gửi lời nhắn đó sau số giây nhất định!")
.AddField("Ngoài ra, bạn có thể thử *'join*, *'play*, *'stop* và *'leave*~ :notes:",
"Dùng *'help exam* để xem các lệnh về các bài kiểm tra~\n" +
"Dùng *'help game* để xem các lệnh về trò chơi~\n" +
"Dùng *'help CF* để xem các lệnh về Codeforces~\n" +
" *^^Chúc bạn một ngày tốt lành!^^*");
await DiscordWrapper.SendMessage(Context, embed : embed.Build());
}
public async Task Remove(int day)
{
await Context.Channel.TriggerTypingAsync();
try
{
var schedule = JsonSerializer.Deserialize <TestSchedule>(File.ReadAllText(_config.GetValue <string>("json:TestSchedule.json")));
schedule.Day[day - 2].Clear();
File.WriteAllText(_config.GetValue <string>("json:TestSchedule.json"), JsonSerializer.Serialize(schedule));
await LogDiscord($"remove {day}");
var msg = await ReplyAsync($"Đã xoá bài các kiểm tra thứ {day} thành công! :partying_face::tada::confetti_ball:");
await Task.Delay(TimeSpan.FromSeconds(3));
await msg.DeleteAsync();
}
catch (Exception e)
{
DiscordWrapper.Log($"[log] {e}");
var msg = await ReplyAsync("Có lỗi xảy ra. Hãy chắc chắn bạn đã nhập đúng cú pháp, với các thứ trong ngày là từ 2 đến 6.");
await Task.Delay(TimeSpan.FromSeconds(3));
await msg.DeleteAsync();
}
finally
{
await Context.Message.DeleteAsync();
}
}
public async Task Continue()
{
var chess = Load();
if (chess.IsOver)
{
var embed = new EmbedBuilder
{
Description = "Không có trận đấu nào chưa kết thúc.",
Color = Color.Blue
};
await Context.Channel.TriggerTypingAsync();
await ReplyAndDeleteAsync(content : null, embed : embed.Build(), timeout : TimeSpan.FromSeconds(5));
}
else if (!(await Host()))
{
var embed = new EmbedBuilder
{
Description = $"Trận đấu giữa {MentionUtils.MentionUser(chess.Player[ChessBoard.WhitePlayerIndex])} và {MentionUtils.MentionUser(chess.Player[ChessBoard.BlackPlayerIndex])} đã tạm dừng.",
Color = Color.Blue
};
//await ReplyAsync(embed: embed.Build());
await DiscordWrapper.SendMessage(Context, embed : embed.Build());
}
}
public VoiceManager(IGuildProvider guildProvider, DiscordWrapper discordWrapper,
IOptions <CustomVoiceOptions> options, ILogger <VoiceManager> logger)
{
_guildProvider = guildProvider;
_discordWrapper = discordWrapper;
_voiceConfig = options.Value;
_logger = logger;
}
private async Task HandleCommandAsync(SocketMessage messageParam)
{
var msg = messageParam as SocketUserMessage;
if (msg == null || msg.Author.Id == _config.GetValue <ulong>("discord:ClientID"))
{
return;
}
int argPos = 0;
var context = new SocketCommandContext(_client, msg);
// Attachments
if ((msg.Channel as SocketGuildChannel).Guild.Id == _config.GetValue <ulong>("guild:Lollipop:ID") &&
msg.Author.Id != _config.GetValue <ulong>("discord:AuthorID"))
{
Atachments(context);
}
// Prefix, Mention
if (!(msg.HasCharPrefix(_config.GetValue <string>("discord:CommandPrefix")[0], ref argPos)))
{
if (msg.Content.Contains($"<@!{_config.GetValue<ulong>("discord:ClientID")}>") ||
msg.Content.Contains($"<@{_config.GetValue<ulong>("discord:ClientID")}>"))
{
DiscordWrapper.Log($"{log_discord} Activity in guild {context.Guild.Name}");
await msg.Channel.TriggerTypingAsync();
await msg.Channel.SendMessageAsync($"*meo meoo*. Bạn cần gì nè, {msg.Author.Mention}?");
}
else if (msg.Content == "&party")
{
DiscordWrapper.Log($"{log_discord} Activity in guild {context.Guild.Name}");
Party_with_goat(context);
}
return;
}
// Execute command
DiscordWrapper.Log($"{log_discord} Activity in guild {context.Guild.Name}");
var result = await _commands.ExecuteAsync(
context : context,
argPos : argPos,
services : _services);
if (!result.IsSuccess)
{
if (result.ErrorReason == "Unknown command.")
{
await msg.Channel.TriggerTypingAsync();
await msg.Channel.SendMessageAsync($"Có phải bạn vừa gọi Mèo không, {msg.Author.Mention}?");
}
DiscordWrapper.Log($"{log} {result.ErrorReason}");
}
}
public async Task Say([Remainder] string text)
{
await Context.Message.DeleteAsync();
string author = Context.Message.Author.Mention;
if (text.StartsWith("||") && text.EndsWith("||"))
{
text = text.Substring(2, text.Length - 4);
}
await DiscordWrapper.SendMessage(Context, $"*Từ {author}:*\n{text}");
}
private bool Save(ref Puzzle puzzle)
{
try
{
File.WriteAllText(_config.GetValue <string>("json:Puzzle.json"), JsonConvert.SerializeObject(puzzle));
return(true);
}
catch (Exception e)
{
DiscordWrapper.Log($"{log} {e}");
return(false);
}
}
private async Task <bool> Host()
{
try
{
IEnumerable <IMessage> print;
Puzzle puzzle;
while (true)
{
puzzle = Load();
print = await Print();
IMessage msg = print.First();
int EnPos = puzzle.EmptySqrPos, StPos = await WaitForMove(msg);
//DiscordWrapper.Log($"move {StPos}");
if (StPos == -1)
{
break;
}
else if (!puzzle.Move(StPos, EnPos))
{
await Context.Channel.TriggerTypingAsync();
await ReplyAndDeleteAsync(content : $"{MentionUtils.MentionUser(puzzle.PlayerId)}, có lỗi xảy ra. Bạn vui lòng thử lại.", timeout : TimeSpan.FromSeconds(5));
}
else
{
Save(ref puzzle);
if (puzzle.IsOver)
{
await Print();
break;
}
}
await(Context.Channel as ITextChannel).DeleteMessagesAsync(print);
}
puzzle = Load();
return(puzzle.IsOver);
}
catch (Exception e)
{
DiscordWrapper.Log($"{log} {e}");
return(false);
}
}
public static async Task Run([TimerTrigger("%PostClipsFunctionCron%")] TimerInfo myTimer, ILogger log)
{
var config = new ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile("local.settings.json", true)
.AddEnvironmentVariables()
.Build();
var configWrapper = new ConfigurationWrapper(config);
//TODO use config wrapper
var topClipsEndpoint = Environment.GetEnvironmentVariable("TwitchTopClipsEndpoint");
var clientId = Environment.GetEnvironmentVariable("TwitchClientId");
var accept = Environment.GetEnvironmentVariable("TwitchAcceptHeaderValue");
var botToken = Environment.GetEnvironmentVariable("BotToken");
var connectionString = Environment.GetEnvironmentVariable("TopTwitchClipBotConnectionString");
var enableNumberOfClipsPerDay = bool.Parse(Environment.GetEnvironmentVariable("EnableNumberOfClipsPerDay"));
var clipOrderMappings = configWrapper.Get <List <ClipOrderMapping> >("ClipOrderMappings");
var now = DateTime.UtcNow;
var yesterday = now.AddDays(-1);
var logWrapper = new LoggerWrapper(log);
using (var twitchWrapper = new TwitchWrapper())
using (var discordWrapper = new DiscordWrapper(botToken))
using (var context = new TopTwitchClipBotContext(connectionString))
{
var helper = new PostClipsHelper(logWrapper, context, twitchWrapper, discordWrapper);
logWrapper.LogInformation("Posting clips.");
await discordWrapper.LogInAsync();
var containers = await context.GetPendingChannelConfigsAsync(now.Hour);
var afterTimeBetweenClipsContainers = helper.AfterTimeBetweenClips(containers, now);
var readyToPostContainers = helper.ReadyToPostContainers(afterTimeBetweenClipsContainers, yesterday, enableNumberOfClipsPerDay);
var pendingClipContainers = await helper.BuildClipContainers(topClipsEndpoint, clientId, accept, readyToPostContainers);
var clipsWithMinViews = helper.ClipsWithMinViews(pendingClipContainers);
var unseenClipContainers = helper.BuildUnseenClipContainers(clipsWithMinViews);
var results = helper.AtATimeContainers(unseenClipContainers, clipOrderMappings);
var unseenClips = results.SelectMany(s => s.UnseenClips).ToList();
await helper.InsertHistories(unseenClips);
var channelContainers = await helper.BuildChannelContainers(results);
foreach (var channelContainer in channelContainers)
{
await helper.SendMessagesAsync(channelContainer);
}
await discordWrapper.LogOutAsync();
logWrapper.LogInformation("Posted clips.");
}
}
private bool Save(TaskList taskList)
{
try
{
taskList.Unlock();
File.WriteAllText(_config.GetValue <string>("json:ReminderTaskList.json"), JsonConvert.SerializeObject(taskList));
return(true);
}
catch (Exception e)
{
DiscordWrapper.Log($"{log} {e}");
return(false);
}
}
public async Task PlayCmd([Remainder] string file_name)
{
if (!_service.isGuildAdded(Context.Guild).Result)
{
var channel = (Context.User as IGuildUser)?.VoiceChannel;
if (channel == null)
{
await Context.Channel.TriggerTypingAsync();
await Context.Channel.SendMessageAsync("Mèo cần ở trong một kênh thoại!");
return;
}
await _service.JoinAudio(Context.Guild, (Context.User as IVoiceState).VoiceChannel);
}
string Path = _config.GetValue <string>("config:songPath");
if (!File.Exists($"{Path}{file_name}"))
{
file_name = _songs.GetValue <string>($"filename:{file_name}");
}
if (file_name == null)
{
await Context.Channel.TriggerTypingAsync();
await ReplyAsync($"Tên bài hát không hợp lệ.");
return;
}
DiscordWrapper.Log("metadata.");
/*var metadata = TagLib.File.Create($"{Path}{file_name}");
* var embed = new EmbedBuilder {
* Title = "Hiện đang phát",
* Description = $"{metadata.Tag.Title} - {metadata.Tag.FirstPerformer}",
* Color = Color.Blue
* };
* embed.WithFooter(footer => footer.Text = $"[{Context.Message.Author.Username}]")
* .WithCurrentTimestamp();
* var msg = await ReplyAsync(embed: embed.Build());*/
DiscordWrapper.Log("set-up done.");
await _service.SendAudioAsync(Context.Guild, $"{Path}{file_name}");
DiscordWrapper.Log("playback done.");
//await msg.DeleteAsync();
}
public async Task Party()
{
string[] emotes = new string[4];
emotes[0] = "\uD83D\uDC08"; // cat2
emotes[1] = "\ud83e\udd73"; // partying_face
emotes[2] = "\uD83C\uDF89"; // tada
emotes[3] = "\uD83C\uDF8A"; // confetti_ball
var msg = await DiscordWrapper.SendMessage(Context, ":cat2::partying_face::tada::confetti_ball::confetti_ball::confetti_ball::tada::partying_face::cat2:");
foreach (var emote in emotes)
{
await msg.AddReactionAsync(new Emoji(emote));
}
}
private void Atachments(SocketCommandContext context)
{
var attachments = context.Message.Attachments;
if (attachments.Count > 0)
{
WebClient client = new WebClient();
foreach (var attachment in attachments)
{
client.DownloadFileAsync(new Uri(attachment.Url), $"{_config.GetValue<string>("config:downloadPath")}{attachment.Filename}");
}
DiscordWrapper.Log($"{log_discord} Downloaded {attachments.Count} file(s) from guild {context.Guild.Name}.");
}
}
public async Task Say(int wait_sec, [Remainder] string text)
{
await Context.Message.DeleteAsync();
string author = Context.Message.Author.Mention;
if (text.StartsWith("||") && text.EndsWith("||"))
{
text = text.Substring(2, text.Length - 4);
}
await Task.Delay(TimeSpan.FromMilliseconds(Math.Max(0, wait_sec * 1000 - 1900)));
await DiscordWrapper.SendMessage(Context, $"*Từ {author}:*\n{text}");
}
public async Task <IEnumerable <IMessage> > Print(ISocketMessageChannel Channel = null)
{
if (Channel == null)
{
Channel = Context.Channel;
}
Puzzle puzzle = Load();
if (puzzle.IsOver)
{
var embed = new EmbedBuilder
{
Description = $"*{ MentionUtils.MentionUser(puzzle.PlayerId) }* đã kết thúc trò chơi trong ***{puzzle.MoveCount}*** bước! :partying_face::tada::confetti_ball:",
Color = Color.Red
};
await DiscordWrapper.SendMessage(Context, embed : embed.Build(), Channel : Channel);
}
else
{
var embed = new EmbedBuilder
{
Description = $"*Người chơi: { MentionUtils.MentionUser(puzzle.PlayerId) }*\nSố bước đã đi: {puzzle.MoveCount}.",
Color = Color.Magenta
};
await DiscordWrapper.SendMessage(Context, embed : embed.Build(), Channel : Channel);
}
string output = "";
for (var i = 0; i < Puzzle.Size; i++)
{
for (var j = 0; j < Puzzle.Size; j++)
{
output += $"{puzzle.Board[i, j]} ";
}
if (i == 0)
{
output += $"{Puzzle.IconFull}\n";
}
else
{
output += ":black_large_square:\n";
}
}
await Channel.SendMessageAsync(output);
return(await Channel.GetMessagesAsync(2).FlattenAsync());
}
public async Task Remove(string s_name, int day, int duration, [Remainder] string note = null)
{
await Context.Channel.TriggerTypingAsync();
try
{
var schedule = JsonSerializer.Deserialize <TestSchedule>(File.ReadAllText(_config.GetValue <string>("json:TestSchedule.json")));
var idx = _subjects.GetValue <int>($"idx:{s_name}");
if (idx == default && s_name != "Toan")
{
throw new NullReferenceException("Subject name not found.");
}
if (note != null)
{
note = $" ({note})";
}
schedule.Day[day - 2].Remove($"{s_name} - {duration}'{note}");
schedule.Subject[idx].Remove($"Thứ {day} - {duration}'{note}");
File.WriteAllText(_config.GetValue <string>("json:TestSchedule.json"), JsonSerializer.Serialize(schedule));
await LogDiscord($"remove {s_name} {day} {duration}'{note}");
var msg = await ReplyAsync($"Đã xoá bài kiểm tra môn {s_name} thành công! :partying_face::tada::confetti_ball:");
await Task.Delay(TimeSpan.FromSeconds(3));
await msg.DeleteAsync();
}
catch (Exception e)
{
DiscordWrapper.Log($"[log] {e}");
var msg = await ReplyAsync("Có lỗi xảy ra. Hãy chắc chắn bạn đã nhập đúng cú pháp, với tên các môn học là: Toan, QP, TD, TCMN, CN, Tin, GDCD, Dia, Su, Anh, Van, Sinh, Hoa, Ly, và các thứ trong ngày là từ 2 đến 6.");
await Task.Delay(TimeSpan.FromSeconds(3));
await msg.DeleteAsync();
}
finally
{
await Context.Message.DeleteAsync();
}
}
public async Task HelpCF()
{
var embedCF = new EmbedBuilder {
Color = Color.Red
};
embedCF.AddField("*>> 'cf*",
"**>> Những lệnh liên quan Codeforces:**")
.AddField("*'cf contest <số lượng, mặc định là 0>",
"Mèo cho bạn danh sách các contest sắp diễn ra, ưu tiên contest diễn ra (nếu số lượng là 0 thì in tất cả).")
.AddField("*'cf user <handle>*",
"Mèo cho bạn thông tin về <handle>, gồm *rank*, *rating*, *maxRating*, *lastOnlineTime*.")
.AddField("Các lệnh có thể không thực hiện được nếu máy chủ Codeforces đang trong giờ cao điểm.",
"*^^Chúc bạn thi thật tốt và vui vẻ!^^*");
await DiscordWrapper.SendMessage(Context, embed : embedCF.Build());
}
public async Task KillFFmpeg()
{
Process killFFmpeg = new Process();
ProcessStartInfo taskkillStartInfo = new ProcessStartInfo
{
FileName = "taskkill",
Arguments = "/F /IM FFmpeg.exe",
UseShellExecute = false,
CreateNoWindow = true
};
killFFmpeg.StartInfo = taskkillStartInfo;
killFFmpeg.Start();
DiscordWrapper.Log("[log] Playback terminated.");
await Task.Delay(TimeSpan.FromMilliseconds(1000));
}
public async Task Get(string s_name)
{
await Context.Channel.TriggerTypingAsync();
try
{
var schedule = JsonSerializer.Deserialize <TestSchedule>(File.ReadAllText(_config.GetValue <string>("json:TestSchedule.json")));
var idx = _subjects.GetValue <int>($"idx:{s_name}");
if (idx == default && s_name != "Toan")
{
throw new NullReferenceException("Subject name not found.");
}
var embed = new EmbedBuilder
{
Color = Color.LightOrange
};
if (schedule.Subject[idx].Any())
{
embed.AddField($"*Môn {s_name}*", string.Join(", ", schedule.Subject[_subjects.GetValue <int>($"idx:{s_name}")]));
}
else
{
embed.AddField($"*Môn {s_name}*", $"Không có bài kiểm tra nào cho môn {s_name} 7 ngày tới cả! :partying_face:");
}
await ReplyAsync(embed : embed.Build());
}
catch (Exception e)
{
DiscordWrapper.Log($"[log] {e}");
await Context.Channel.TriggerTypingAsync();
var msg = await ReplyAsync("Có lỗi xảy ra. Hãy chắc chắn bạn đã nhập đúng cú pháp, với tên các môn học là: Toan, QP, TD, TCMN, CN, Tin, GDCD, Dia, Su, Anh, Van, Sinh, Hoa, Ly.");
await Task.Delay(TimeSpan.FromSeconds(3));
await msg.DeleteAsync();
}
finally
{
await Context.Message.DeleteAsync();
}
}
public async Task HelpExam()
{
var embedExam = new EmbedBuilder {
Color = Color.LightOrange
};
embedExam.AddField("*>> 'exam*", "**>> Những lệnh liên quan đến các bài kiểm tra trong lớp T.T:**")
.AddField("*'exam add <môn học> <thứ>(2 - 6) <thời lượng kiểm tra> <ghi chú>(nếu có)*", "Thêm bài kiểm tra vào danh sách của Mèo~")
.AddField("*'exam get <thứ>(2 - 6)*", "Xem tất cả các bài kiểm tra có trong ngày hôm đó.")
.AddField("*'exam get <môn học>*", "Xem tất cả các bài kiểm tra của môn học đó.")
.AddField("*'exam all*", "Xem tất cả các bài kiểm tra có trong 7 ngày tới!")
.AddField("*'exam rm <thứ>(2 - 6)*", "Xoá các bài kiểm tra của ngày đó trong danh sách của Mèo! :partying_face:")
.AddField("*'exam rm <môn học> <thứ>(2 - 6) <thời lượng kiểm tra> <ghi chú>(nếu có)*", "Xoá bài kiểm tra trong danh sách của Mèo! :partying_face:")
.AddField("*'exam clear*", "Xoá toàn bộ các bài kiểm tra trong danh sách của Mèo!!! :partying_face::tada::confetti_ball:")
.AddField("^^Cố gắng lên nào!^^ :fist::fist:", "*^^Chúc bạn làm bài thật tốt!^^*");
await DiscordWrapper.SendMessage(Context, embed : embedExam.Build());
}
public async Task <bool> StartupAsync()
{
var splash = new SplashScreen();
splash.Show();
_vm = new MainViewModel()
{
AddDropCommand = new RelayCommand(() => _vm.DiscordDrops.Insert(0, new DiscordDropViewModel())),
RemoveDropCommand = new RelayCommand <DiscordDropViewModel>(drop => _vm.DiscordDrops.Remove(drop))
};
HotkeyManager.HotkeyFired += OnHotkeyFired;
splash.DisplayTask(LoadingTask.LoadingSettings);
_settings = await Task.Factory.StartNew(_serializer.Deserialize) ?? new Settings();
splash.DisplayTask(LoadingTask.RegisteringHotkeys);
if (_settings?.DiscordDrops != null)
{
foreach (var drop in _settings.DiscordDrops)
{
if (HotkeyManager.Register(drop.HotKey, drop.Modifier, out int id))
{
drop.HotkeyId = id;
_vm.DiscordDrops.Add(drop);
}
}
}
splash.DisplayTask(LoadingTask.LaunchingSelfBot);
_discordWrapper = new DiscordWrapper(_settings.TargetChannelId);
_dropLimiter.FireDrop += (_, drop) => _discordWrapper.FireDrop(drop);
if (!await _discordWrapper.LoginAsync(_settings, splash))
{
return(false);
}
splash.DisplayTask(LoadingTask.LoadingTaskbarIcon);
_taskBarIcon = new TaskbarIcon(ShowHotkeyWindow);
_taskBarIcon.Show();
splash.Close();
return(true);
}
public async Task LeaveAudio(IGuild guild)
{
try
{
IAudioClient client;
if (ConnectedChannels.TryRemove(guild.Id, out client))
{
await CancelFFmpeg();
await client.StopAsync();
DiscordWrapper.Log($"[info][{LogSeverity.Info}] Disconnected from the voice on {guild.Name}.");
}
}
catch (Exception ex)
{
DiscordWrapper.Log($"[log] {ex}");
}
}
public async Task SendAudioAsync(IGuild guild, string path)
{
try
{
IAudioClient client;
if (ConnectedChannels.TryGetValue(guild.Id, out client))
{
var OutFormat = new WaveFormat(48000, 16, 2);
var reader = new Mp3FileReader(path);
var naudio = WaveFormatConversionStream.CreatePcmStream(reader);
byte[] buffer = new byte[naudio.Length];
int rest = (int)(naudio.Length - naudio.Position);
await naudio.ReadAsync(buffer, 0, rest);
using (var dstream = client.CreatePCMStream(AudioApplication.Music))
{
try
{
Global.cts = new CancellationTokenSource();
Global.streaming = true;
await dstream.WriteAsync(buffer, 0, rest, Global.cts.Token);
}
finally
{
await dstream.FlushAsync();
Global.streaming = false;
}
}
}
else
{
DiscordWrapper.Log("[log] Voice channel is not added.");
}
}
catch (Exception ex)
{
DiscordWrapper.Log($"[log] {ex}");
}
}
