public async Task GetYouTube(string unused = null)
{
YouTubeRecord record;
YouTubeToCheck youtube;
using (var db = new DggContext())
{
record = await db.YouTubeRecords.FirstOrDefaultAsync(y => y.ChannelId == "UC554eY5jNUfDq3yDOJYirOQ");
youtube = await db.YouTubesToCheck.FirstOrDefaultAsync(y => y.ChannelId == "UC554eY5jNUfDq3yDOJYirOQ");
}
if (record == null)
{
await ReplyAsync("Bot is on FIRE. Go Tell Thing");
return;
}
record.PublishedAt = DateTime.SpecifyKind(record.PublishedAt, DateTimeKind.Utc);
var embed = CreateEmbed(record, youtube);
await ReplyAsync("", embed : embed);
}
public async Task GetTweet()
{
TweetRecord record;
TwitterToCheck twitter;
using (var db = new DggContext())
{
twitter = await db.TwittersToCheck.FirstOrDefaultAsync(x => x.UserId == 4726147296);
record = await db.TweetRecords.FirstOrDefaultAsync(x => x.UserId == twitter.UserId);
}
if (record == null)
{
await ReplyAsync("Bot is on FIRE. Go Tell Thing");
return;
}
record.CreatedAt = DateTime.SpecifyKind(record.CreatedAt, DateTimeKind.Utc);
var embed = CreateEmbed(record, twitter);
await ReplyAsync("", embed : embed);
}
//todo make this search id instead of name
public override async Task <PreconditionResult> CheckPermissions(ICommandContext context,
CommandInfo command,
IServiceProvider services)
{
if ((await context.Client.GetApplicationInfoAsync()).Owner.Username == context.User.Username)
{
return(PreconditionResult.FromSuccess());
}
var user = context.User as IGuildUser;
if (user.GuildPermissions.Administrator)
{
return(PreconditionResult.FromSuccess());
}
using (var dggContext = new DggContext())
{
var throttle = await dggContext.Throttles.FirstOrDefaultAsync(x => x.DiscordChannelId == context.Channel.Id && x.CommandName == command.Name);
if (throttle != null)
{
Log.Information("{user} was throttled in {channel} for {commandName} command", user.Username, context.Channel.Name, command.Name);
return(PreconditionResult.FromError(""));
}
Log.Information("{user} started throttle in {channel} for {commandName} command", user.Username, context.Channel.Name, command.Name);
JobManager.AddJob(new ThrottleJob(command.Name, context.Channel.Id), s => s.ToRunNow());
return(PreconditionResult.FromSuccess());
}
}
public async Task RemoveTwitter(string twitterName)
{
using (var context = new DggContext())
{
var twitter =
await context.TwittersToCheck.FirstOrDefaultAsync(x =>
string.Compare(x.FriendlyUsername, twitterName, StringComparison.OrdinalIgnoreCase) == 0);
if (twitter is null)
{
await ReplyAsync("Twitter account not found in Database");
return;
}
var records = context.TweetRecords.Where(x => x.UserId == twitter.UserId);
context.TwittersToCheck.Remove(twitter);
context.TweetRecords.RemoveRange(records);
var changes = await context.SaveChangesAsync();
if (changes > 0)
{
Log.Information("{author} removed Twitter User:{user}", Context.Message.Author, twitterName);
Log.Information("Job Count is {count}", JobManager.AllSchedules.Count());
JobManager.RemoveJob(twitter.UserId.ToString());
Log.Information("Job Count is {count}", JobManager.AllSchedules.Count());
await ReplyAsync("Twitter account removed from the Database");
return;
}
await ReplyAsync("Unable to remove twitter from the database");
}
}
public void Execute()
{
using (var context = new DggContext())
{
var throttle = context.Throttles.FirstOrDefault(x =>
x.DiscordChannelId == _discordChannelId && x.CommandName == _commandName);
if (throttle is null)
{
context.Throttles.Add(new Throttle
{
DiscordChannelId = _discordChannelId,
CommandName = _commandName
});
context.SaveChanges();
JobManager.AddJob(new ThrottleJob(_commandName, _discordChannelId),
s => s.ToRunOnceIn(120).Seconds());
}
else
{
context.Throttles.Remove(throttle);
context.SaveChanges();
Log.Information("Throttle ended in {channel} for {commandName}", _discordChannelId, _commandName);
}
}
}
public async Task ChangePriority(string twitchName, int priority)
{
using (var context = new DggContext())
{
var stream = await context.StreamsToCheck.FirstOrDefaultAsync(x => x.FriendlyUsername.Equals(twitchName, StringComparison.OrdinalIgnoreCase));
if (stream is null)
{
await ReplyAsync("Twitch account not found in Database");
return;
}
stream.Priority = priority;
var changes = await context.SaveChangesAsync();
if (changes > 0)
{
await ReplyAsync($"{twitchName} priority changed to {priority}");
return;
}
await ReplyAsync($"Unable to change priority");
}
}
public async Task AddYoutube(string youtubeName, IGuildChannel guildChannel, string hexColor)
{
var channels = await _youtubeService.GetYouTubeVideoChannelInfoAsync(youtubeName);
if (channels.Items is null)
{
await ReplyAsync("Unable to get info from Youtube API");
return;
}
using (var context = new DggContext())
{
var channel = channels.Items.FirstOrDefault();
if (await context.YouTubesToCheck.FirstOrDefaultAsync(x => x.ChannelId == channel.Id) is null)
{
var youtubeToCheck = new YouTubeToCheck
{
DiscordChannelId = (long)guildChannel.Id,
DiscordServerId = (long)Context.Guild.Id,
ChannelId = channel.Id,
Frequency = 60,
FriendlyUsername = channel.Snippet.Title,
EmbedColor = (int)Helpers.GetColorFromHex(hexColor).RawValue
};
await context.YouTubesToCheck.AddAsync(youtubeToCheck);
var changes = await context.SaveChangesAsync();
if (changes > 0)
{
Log.Information("{author} added Youtube Channel:{channel}", Context.Message.Author,
youtubeName);
await ReplyAsync($"{channel.Snippet.Title} added to the database");
JobManager.AddJob(
new YoutubeJob(Context.SocketClient, _youtubeService, youtubeToCheck, new HttpClient(),
_config),
s => s.WithName(youtubeToCheck.ChannelId).ToRunEvery(youtubeToCheck.Frequency)
.Seconds());
return;
}
await ReplyAsync($"Unable to save youtube to database");
return;
}
await ReplyAsync("Youtube account already exists in the Database");
}
}
public async Task RemoveTwitch(string twitchName)
{
using (var context = new DggContext())
{
var stream = await context.StreamsToCheck.FirstOrDefaultAsync(x =>
string.Compare(x.FriendlyUsername, twitchName, StringComparison.OrdinalIgnoreCase) == 0);
if (stream is null)
{
await ReplyAsync("Twitch account not found in Database");
return;
}
var records = context.StreamRecords.Where(x => x.UserId == stream.UserId);
var record = records.FirstOrDefault();
var games = context.StreamGames.Where(x => x.StreamId == records.FirstOrDefault().StreamId);
var responses = context.StreamNullResponses.Where(x => x.UserId == stream.UserId);
context.StreamsToCheck.Remove(stream);
context.StreamRecords.RemoveRange(records);
context.StreamGames.RemoveRange(games);
context.StreamNullResponses.RemoveRange(responses);
var changes = await context.SaveChangesAsync();
if (changes > 0)
{
Log.Information("{author} removed Twitch channel:{channel}", Context.Message.Author,
twitchName);
Log.Information("Job Count is {count}", JobManager.AllSchedules.Count());
JobManager.RemoveJob(stream.UserId.ToString());
JobManager.RemoveJob(record?.StreamId.ToString());
Log.Information("Job Count is {count}", JobManager.AllSchedules.Count());
await ReplyAsync("Twitch account removed from the Database");
return;
}
await ReplyAsync("Unable to remove Twitch from the database");
}
}
public async Task GetLive(string unused = null)
{
StreamLastOnline lastOnline;
StreamRecord streamRecord;
StreamToCheck streamToCheck;
using (var db = new DggContext())
{
streamToCheck = (await db.StreamsToCheck.ToListAsync()).Aggregate((firstStream, secondStream) => firstStream.Priority > secondStream.Priority ? firstStream : secondStream);
lastOnline = await db.StreamLastOnlines.FirstOrDefaultAsync(x => x.UserId == streamToCheck.UserId);
streamRecord = await db.StreamRecords.FirstOrDefaultAsync(x => x.UserId == streamToCheck.UserId);
}
string msg;
if (lastOnline == null && streamRecord == null)
{
msg = $"{streamToCheck.FriendlyUsername} is offline. " +
"I'll have more info in the future, after the next time the stream goes live. " +
"Sorry!";
}
else if (lastOnline == null && streamRecord != null)
{
streamRecord.StartTime = DateTime.SpecifyKind(streamRecord.StartTime, DateTimeKind.Utc);
var duration = DateTime.UtcNow - streamRecord.StartTime;
msg = $"{streamToCheck.FriendlyUsername} is live! <{streamToCheck.StreamUrl}>\n" +
$"Currently playing {streamRecord.CurrentGame}\n" +
$"Live for {duration.ToFriendlyString()}";
}
else
{
lastOnline.LastOnlineAt = DateTime.SpecifyKind(lastOnline.LastOnlineAt, DateTimeKind.Utc);
var duration = DateTime.UtcNow - lastOnline.LastOnlineAt;
msg = $"{streamToCheck.FriendlyUsername} is offline.\n" +
$"Last online {duration.ToFriendlyString()} ago, was playing {lastOnline.LastGame}.";
}
await ReplyAsync(msg);
}
public async Task AddTwitter(string twitterName, IGuildChannel guildChannel, string hexColor)
{
var user = await _twitterService.GetUser(twitterName);
if (user is null)
{
await ReplyAsync("Unable to get info from Twitter API");
return;
}
using (var context = new DggContext())
{
if (await context.TwittersToCheck.FirstOrDefaultAsync(x => x.UserId == user.UserId) is null)
{
user.DiscordChannelId = (long)guildChannel.Id;
user.DiscordServerId = (long)Context.Guild.Id;
user.Frequency = 30;
user.EmbedColor = (int)Helpers.GetColorFromHex(hexColor).RawValue;
await context.TwittersToCheck.AddAsync(user);
var changes = await context.SaveChangesAsync();
if (changes > 0)
{
Log.Information("{author} added Twitter User:{user}", Context.Message.Author, twitterName);
await ReplyAsync($"{user.FriendlyUsername} added to the database");
JobManager.AddJob(new TwitterJob(Context.SocketClient, user, _twitterService),
s => s.WithName(user.UserId.ToString()).ToRunEvery(user.Frequency).Seconds());
return;
}
await ReplyAsync($"Unable to save twitter to database");
return;
}
await ReplyAsync("Twitter account already exists in the Database");
}
}
public async Task RemoveYoutube(string youtubeName)
{
using (var context = new DggContext())
{
var youtube =
await context.YouTubesToCheck.FirstOrDefaultAsync(x =>
string.Compare(x.FriendlyUsername, youtubeName, StringComparison.OrdinalIgnoreCase) == 0);
if (youtube is null)
{
await ReplyAsync("Youtube account not found in Database");
return;
}
var records = context.YouTubeRecords.Where(x => x.ChannelId == youtube.ChannelId);
context.YouTubesToCheck.Remove(youtube);
context.YouTubeRecords.RemoveRange(records);
var changes = await context.SaveChangesAsync();
if (changes > 0)
{
Log.Information("{author} removed Youtube channel:{channel}", Context.Message.Author,
youtubeName);
Log.Information("Job Count is {count}", JobManager.AllSchedules.Count());
JobManager.RemoveJob(youtube.ChannelId);
Log.Information("Job Count is {count}", JobManager.AllSchedules.Count());
await ReplyAsync("Youtube account removed from the Database");
return;
}
await ReplyAsync("Unable to remove Youtube from the database");
}
}
//TRUMPED
private static void CreateScheduledJobs(IServiceProvider serviceProvider)
{
try
{
var registry = new Registry();
using (var context = new DggContext())
{
context.Database.Migrate();
var throttles = context.Throttles;
context.Throttles.RemoveRange(throttles);
context.SaveChanges();
var twitters = context.TwittersToCheck;
foreach (var twitter in twitters)
{
registry.Schedule(new TwitterJob(
serviceProvider.GetRequiredService <DiscordSocketClient>(),
twitter,
serviceProvider.GetRequiredService <TwitterService>()))
.WithName(twitter.UserId.ToString())
.ToRunEvery(twitter.Frequency)
.Seconds();
Log.Information("{jobtype} started for {name} with ID: {id}", nameof(TwitterJob),
twitter.FriendlyUsername, twitter.UserId);
}
var youtubes = context.YouTubesToCheck;
foreach (var youTube in youtubes)
{
registry.Schedule(new YoutubeJob(
serviceProvider.GetRequiredService <DiscordSocketClient>(),
serviceProvider.GetRequiredService <YoutubeService>(),
youTube,
new HttpClient(),
serviceProvider.GetRequiredService <IConfiguration>())).WithName(youTube.ChannelId)
.WithName(youTube.ChannelId)
.ToRunEvery(youTube.Frequency)
.Seconds();
Log.Information("{jobtype} started for {name} with ID: {id}", nameof(YoutubeJob),
youTube.FriendlyUsername, youTube.ChannelId);
}
var streamsToCheck = context.StreamsToCheck.ToList();
foreach (var stream in streamsToCheck)
{
registry.Schedule(new TwitchJob(
serviceProvider.GetRequiredService <DiscordSocketClient>(),
serviceProvider.GetRequiredService <TwitchService>(),
stream))
.WithName(stream.UserId.ToString())
.ToRunEvery(30).Seconds();
Log.Information("{jobtype} started for {name} with ID: {id}", nameof(TwitchJob),
stream.FriendlyUsername, stream.UserId);
}
var streamRecords = context.StreamRecords;
foreach (var stream in streamRecords)
{
var thisStreamToCheck = streamsToCheck.Find(s => s.UserId == stream.UserId);
registry.Schedule(new TwitchUpdateJob(
serviceProvider.GetRequiredService <DiscordSocketClient>(),
serviceProvider.GetRequiredService <TwitchService>(),
thisStreamToCheck
)).WithName(stream.StreamId.ToString()).ToRunEvery(5).Minutes();
Log.Information("{jobtype} started for {name} with ID: {id}", nameof(TwitchUpdateJob),
thisStreamToCheck.FriendlyUsername, stream.StreamId);
}
JobManager.Initialize(registry);
}
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
}
public void Execute()
{
Log.Debug("Stream check started for {stream}", _stream.FriendlyUsername);
var streamToCheck = _stream;
var stream = _twitchService.GetTwitchStreamAsync(streamToCheck.UserId).GetAwaiter().GetResult();
StreamRecord existingRecord;
using (var db = new DggContext())
{
existingRecord = db.StreamRecords.FirstOrDefault(sr => sr.UserId == streamToCheck.UserId);
}
// live and was not previously live
if (stream != null && existingRecord == null)
{
var msgId = SendMessageAsync(streamToCheck, stream).GetAwaiter().GetResult();
using (var db = new DggContext())
{
db.StreamRecords.Add(new StreamRecord
{
UserId = stream.Channel.Id,
StreamId = stream.Id,
DiscordMessageId = msgId,
CurrentGame = stream.Game,
StartTime = DateTime.UtcNow
});
db.SaveChanges();
db.StreamGames.Add(new StreamGame
{
Game = stream.Game,
StreamId = stream.Id,
StartTime = DateTime.UtcNow
});
var lastOnlines = db.StreamLastOnlines.Where(s => s.UserId == streamToCheck.UserId);
db.StreamLastOnlines.RemoveRange(lastOnlines);
db.SaveChanges();
}
if (streamToCheck.EmbedColor != 0)
{
Console.WriteLine("add");
JobManager.AddJob(new TwitchUpdateJob(_client, _twitchService, streamToCheck),
s => s.WithName(stream.Id.ToString()).ToRunEvery(5).Minutes());
}
return;
}
// not live and was previously live
if (stream == null && existingRecord != null)
{
using (var context = new DggContext())
{
var responses = context.StreamNullResponses;
StreamNullResponse response;
if (responses.Any(r => r.UserId == existingRecord.UserId))
{
response = responses.First(r => r.UserId == existingRecord.UserId);
Console.WriteLine($"{response.NullResponseDate} + {DateTimeOffset.UtcNow.AddMinutes(-2)}");
if (response.NullResponseDate > DateTimeOffset.UtcNow.AddMinutes(-2))
{
return;
}
}
else
{
context.StreamNullResponses.Add(new StreamNullResponse
{
UserId = existingRecord.UserId,
NullResponseDate = DateTimeOffset.Now
});
context.SaveChanges();
return;
}
context.StreamNullResponses.Remove(response);
context.SaveChanges();
}
var channel = _client.GetChannel((ulong)streamToCheck.DiscordChannelId) as SocketTextChannel;
var msgId = existingRecord.DiscordMessageId;
if (streamToCheck.DeleteDiscordMessage && existingRecord.DiscordMessageId != 0)
{
Log.Debug("removing message");
var msg =
channel.GetMessageAsync((ulong)existingRecord.DiscordMessageId).GetAwaiter().GetResult() as
RestUserMessage;
msg.DeleteAsync().GetAwaiter().GetResult();
}
else if (!streamToCheck.DeleteDiscordMessage && streamToCheck.EmbedColor != 0 &&
existingRecord.DiscordMessageId != 0)
{
FinalMessageUpdateAsync(streamToCheck, existingRecord).GetAwaiter().GetResult();
}
if (streamToCheck.PinMessage && existingRecord.DiscordMessageId != 0)
{
Log.Debug("removing Pin");
var msg =
channel.GetMessageAsync((ulong)existingRecord.DiscordMessageId).GetAwaiter().GetResult() as
RestUserMessage;
if (!(msg is null))
{
msg.UnpinAsync().GetAwaiter().GetResult();
}
}
using (var db = new DggContext())
{
db.StreamLastOnlines.Add(new StreamLastOnline
{
UserId = streamToCheck.UserId,
FriendlyUsername = streamToCheck.FriendlyUsername,
LastOnlineAt = DateTime.UtcNow,
LastGame = existingRecord.CurrentGame
});
var games = db.StreamGames.Where(g => g.StreamId == existingRecord.StreamId);
db.StreamGames.RemoveRange(games);
Console.WriteLine($"Games: {db.SaveChanges()}");
var updateJob =
JobManager.AllSchedules.FirstOrDefault(u => u.Name == existingRecord.StreamId.ToString());
if (updateJob == null)
{
return;
}
Console.WriteLine("remove jhob");
JobManager.RemoveJob(updateJob.Name);
db.StreamRecords.Remove(existingRecord);
Console.WriteLine($"Records: {db.SaveChanges()}");
}
}
}
private async Task FinalMessageUpdateAsync(StreamToCheck streamToCheck, StreamRecord record)
{
List <StreamGame> games;
using (var db = new DggContext())
{
var latest = db.StreamGames
.FirstOrDefault(g => g.StreamId == record.StreamId && g.StopTime == null);
if (latest != null)
{
latest.StopTime = DateTime.UtcNow;
await db.SaveChangesAsync();
}
games = await db.StreamGames.Where(g => g.StreamId == record.StreamId).ToListAsync();
}
record.StartTime = DateTime.SpecifyKind(record.StartTime, DateTimeKind.Utc);
var streamDuration = DateTime.UtcNow - record.StartTime;
var startTime = TimeZoneInfo.ConvertTime(record.StartTime, Helpers.CentralTimeZone());
var stopTime = TimeZoneInfo.ConvertTime(DateTime.UtcNow, Helpers.CentralTimeZone());
var msg = new StringBuilder(streamToCheck.FriendlyUsername + " was live.\n\n");
msg.Append("**Started at:** ");
msg.Append(startTime.ToString("HH:mm"));
msg.Append(" Central\n");
msg.Append("**Ended at:** ");
msg.Append(stopTime.ToString("HH:mm"));
msg.Append(" Central\n");
msg.Append("_(total of ");
msg.Append(streamDuration.ToFriendlyString());
msg.Append(")_\n\n");
msg.Append("__Games Played__");
foreach (var g in games)
{
// i dunno why it's putting an empty game for 0 minutes first each time,
// but here's a quick fix lel
if (string.IsNullOrEmpty(g.Game))
{
continue;
}
g.StopTime = DateTime.SpecifyKind(g.StopTime.Value, DateTimeKind.Utc);
g.StartTime = DateTime.SpecifyKind(g.StartTime, DateTimeKind.Utc);
var duration = g.StopTime.Value - g.StartTime;
msg.Append("\n**");
msg.Append(g.Game);
msg.Append(":** ");
msg.Append(duration.ToFriendlyString());
}
try
{
var channel = _client.GetChannel((ulong)streamToCheck.DiscordChannelId) as SocketTextChannel;
var existingMsg = await channel.GetMessageAsync((ulong)record.DiscordMessageId) as RestUserMessage;
await existingMsg.ModifyAsync(m =>
{
m.Content = msg.ToString();
m.Embed = null;
});
}
catch (Exception ex)
{
Console.Error.WriteLine("[" + DateTime.UtcNow + "] TWITCH ERROR, FinalMessageUpdateAsync");
Console.Error.WriteLine(ex.ToString());
Console.Error.WriteLine(ex.InnerException?.ToString());
Console.Error.WriteLine("------------");
Console.Error.WriteLine();
}
}
public async Task AddTwitch(string twitchName, IGuildChannel guildChannel)
{
var response = await _twitchService.GetTwitchUserAsync(twitchName);
if (response.Users is null)
{
await ReplyAsync("Unable to get Streamer from Twitch API");
return;
}
await ReplyAsync("Please Enter in the Embed color in Hex format e.g. #ff851b\n" +
"You pick a color and get the code for here: <http://htmlcolorcodes.com>\n" +
"type in default to use the default color");
var hexMessage = await NextMessageAsync(timeout : TimeSpan.FromSeconds(30));
int hexColor;
if (hexMessage.Content.Equals("default", StringComparison.OrdinalIgnoreCase))
{
hexColor = (int)Helpers.GetColorFromHex("#010aad").RawValue;
}
else
{
hexColor = (int)Helpers.GetColorFromHex(hexMessage.Content).RawValue;
}
await ReplyAsync("Please Enter a message you would like to go along with the twitch embed. Type in default for no message");
var message = await NextMessageAsync(timeout : TimeSpan.FromSeconds(30));
await ReplyAsync("Please Enter the stream URL. type in default to use twitch url");
var urlMessage = await NextMessageAsync(timeout : TimeSpan.FromSeconds(30));
await ReplyAsync("Please Enter a number for the priority");
var priorityMessage = await NextMessageAsync(timeout : TimeSpan.FromSeconds(30));
using (var context = new DggContext())
{
var user = response.Users.FirstOrDefault();
if (await context.StreamsToCheck.FirstOrDefaultAsync(x => x.UserId == user.Id) is null)
{
var streamToCheck = new StreamToCheck
{
DiscordChannelId = (long)guildChannel.Id,
DiscordServerId = (long)Context.Guild.Id,
UserId = user.Id,
Frequency = 60,
FriendlyUsername = user.Name,
DeleteDiscordMessage = false,
PinMessage = true,
Priority = Convert.ToInt32(priorityMessage.Content),
StreamUrl = urlMessage.Content.Equals("default", StringComparison.OrdinalIgnoreCase) ? $"https://twitch.tv/{user.Name}" : urlMessage.Content,
DiscordMessage = message.Content.Equals("default", StringComparison.OrdinalIgnoreCase) ? String.Empty : message.Content,
EmbedColor = hexColor
};
await context.StreamsToCheck.AddAsync(streamToCheck);
var changes = await context.SaveChangesAsync();
if (changes > 0)
{
Log.Information("{author} added Twitch Channel:{channel}", Context.Message.Author,
twitchName);
await ReplyAsync($"{user.Name} added to the database");
JobManager.AddJob(new TwitchJob(Context.SocketClient, _twitchService, streamToCheck),
s => s.WithName(streamToCheck.UserId.ToString()).ToRunEvery(streamToCheck.Frequency)
.Seconds());
return;
}
await ReplyAsync($"Unable to save youtube to database");
return;
}
await ReplyAsync("Twitch account already exists in the Database");
}
}
public void Execute()
{
Log.Debug("Stream update check started for {stream}", _stream.FriendlyUsername);
StreamRecord record;
using (var db = new DggContext())
{
record = db.StreamRecords.FirstOrDefault(sr => sr.UserId == _stream.UserId);
if (record == null)
{
return;
}
}
var stream = _twitchService.GetTwitchStreamAsync(_stream.UserId).GetAwaiter().GetResult();
if (stream == null)
{
return;
}
if (string.IsNullOrEmpty(stream.Game))
{
stream.Game = "(no game)";
}
if (record.CurrentGame != stream.Game)
{
using (var db = new DggContext())
{
var streamGame = db.StreamGames
.FirstOrDefault(g => g.StreamId == stream.Id && g.StopTime == null);
streamGame.StopTime = DateTime.UtcNow;
record.CurrentGame = stream.Game;
db.StreamGames.Add(new StreamGame
{
StreamId = stream.Id,
Game = stream.Game,
StartTime = DateTime.UtcNow
});
db.StreamRecords.Update(record);
db.SaveChanges();
}
}
var embed = CreateEmbed(stream, (uint)_stream.EmbedColor);
try
{
var channel = _client.GetChannel((ulong)_stream.DiscordChannelId) as SocketTextChannel;
var msg =
channel.GetMessageAsync((ulong)record.DiscordMessageId).GetAwaiter()
.GetResult() as RestUserMessage;
msg.ModifyAsync(f => f.Embed = embed).GetAwaiter().GetResult();
using (var context = new DggContext())
{
var responses = context.StreamNullResponses;
if (responses.Any(f => f.UserId == _stream.UserId))
{
responses.Remove(responses.First(f => f.UserId == _stream.UserId));
}
context.SaveChanges();
}
}
catch (Exception ex)
{
Console.Error.WriteLine("[" + DateTime.UtcNow + "] TWITCH ERROR, UpdateEmbedAsync");
Console.Error.WriteLine(ex.ToString());
Console.Error.WriteLine(ex.InnerException?.ToString());
Console.Error.WriteLine("------------");
Console.Error.WriteLine();
}
}
public void Execute()
{
Log.Debug("Twitter check started for {twitter}", _twitter.FriendlyUsername);
using (var context = new DggContext())
{
var existing = context.TweetRecords.FirstOrDefault(t => t.UserId == _twitter.UserId);
var tweets = _twitterService.GetTweet(_twitter.UserId, existing?.TweetId).GetAwaiter().GetResult();
var channel = _client.GetChannel((ulong)_twitter.DiscordChannelId) as SocketTextChannel;
for (var i = 0; i < tweets.Count; i++)
{
var tweet = tweets[i];
if (tweet.FullText.StartsWith("@"))
{
tweets.RemoveAt(i);
i--;
continue;
}
var embed = CreateEmbed(tweet);
try
{
channel.SendMessageAsync("", embed: embed).GetAwaiter().GetResult();
}
catch (Exception ex)
{
Console.Error.WriteLine("[" + DateTime.UtcNow +
"] TWITTER ERROR, CheckTwitterAsync");
Console.Error.WriteLine(ex.ToString());
Console.Error.WriteLine(ex.InnerException?.ToString());
Console.Error.WriteLine("------------");
Console.Error.WriteLine();
}
if (existing == null)
{
tweets.Reverse();
break;
}
}
if (tweets.Count == 0)
{
return;
}
var latestTweet = tweets[tweets.Count - 1];
using (var db = new DggContext())
{
if (existing == null)
{
existing = new TweetRecord
{
UserId = latestTweet.User.Id,
TweetId = latestTweet.Id,
Text = WebUtility.HtmlDecode(latestTweet.FullText),
AuthorName = latestTweet.User.Name,
AuthorUsername = latestTweet.User.Username,
ProfileImageUrl = latestTweet.User.ProfileImageUrl,
CreatedAt = latestTweet.CreatedAt.UtcDateTime
};
db.TweetRecords.Add(existing);
}
else
{
existing.TweetId = latestTweet.Id;
existing.Text = WebUtility.HtmlDecode(latestTweet.FullText);
existing.AuthorName = latestTweet.User.Name;
existing.AuthorUsername = latestTweet.User.Username;
existing.ProfileImageUrl = latestTweet.User.ProfileImageUrl;
existing.CreatedAt = latestTweet.CreatedAt.UtcDateTime;
db.TweetRecords.Update(existing);
}
db.SaveChanges();
}
}
}
public void Execute()
{
Log.Debug("Checking youtube updates for {channel}", _youTubeToCheck.FriendlyUsername);
var videos = _youtubeService.GetYouTubeVideoListAsync(_youTubeToCheck.ChannelId).GetAwaiter()
.GetResult();
if (videos.Items is null)
{
return;
}
var latestVideo = videos.Items.FirstOrDefault();
var latestVideoId = latestVideo.Id.VideoId;
YouTubeRecord existingRecord;
using (var db = new DggContext())
{
existingRecord = db.YouTubeRecords.FirstOrDefault(r => r.ChannelId == _youTubeToCheck.ChannelId);
}
if (existingRecord != null &&
latestVideo.Snippet.PublishedAt.CompareTo(new DateTimeOffset(existingRecord.PublishedAt)) <= 0)
{
return;
}
var embed = SendMessageAsync(_youTubeToCheck, latestVideo).GetAwaiter().GetResult();
if (embed == null)
{
return;
}
using (var db = new DggContext())
{
if (existingRecord == null)
{
existingRecord = new YouTubeRecord
{
ChannelId = _youTubeToCheck.ChannelId,
VideoId = latestVideoId,
VideoTitle = latestVideo.Snippet.Title,
VideoDescription = embed.Description,
ImageUrl = embed.Image.Value.Url,
AuthorName = embed.Author.Value.Name,
AuthorUrl = embed.Author.Value.Url,
AuthorIconUrl = embed.Author.Value.IconUrl,
PublishedAt = latestVideo.Snippet.PublishedAt.UtcDateTime
};
db.YouTubeRecords.Add(existingRecord);
}
else
{
existingRecord.VideoId = latestVideoId;
existingRecord.VideoTitle = latestVideo.Snippet.Title;
existingRecord.VideoDescription = embed.Description;
existingRecord.ImageUrl = embed.Image.Value.Url;
existingRecord.AuthorName = embed.Author.Value.Name;
existingRecord.AuthorUrl = embed.Author.Value.Url;
existingRecord.AuthorIconUrl = embed.Author.Value.IconUrl;
existingRecord.PublishedAt = latestVideo.Snippet.PublishedAt.UtcDateTime;
db.YouTubeRecords.Update(existingRecord);
}
db.SaveChanges();
}
}