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 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();
}
}
}
//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 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("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()}");
}
}
}
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();
}
}