public async void C_postsUpdated(object sender, PostsUpdateEventArgs e)
{
credentials credentials;
using (StreamReader stream = new StreamReader("credentials.json"))
{
string json = stream.ReadToEnd();
credentials = JsonConvert.DeserializeObject <credentials>(json);
}
TelegramBotClient botClient = new TelegramBotClient(credentials.BOT_TOKEN);
foreach (var post in e.Added)
{
if (!post.Listing.IsVideo && post.Listing.IsRedditMediaDomain && !InCache(post.Permalink))
{
Console.WriteLine(post.Listing.URL);
botClient.SendPhotoAsync(chatId: credentials.chatId, photo: post.Listing.URL, caption: post.Title);
}
else if (post.Listing.IsVideo && post.Listing.IsRedditMediaDomain && !InCache(post.Permalink))
{
VideoDownload(post.Listing.Permalink);
var file = System.IO.File.OpenRead("./video.mp4");
Message msg = await botClient.SendVideoAsync(chatId : credentials.chatId, video : file, caption : post.Title, supportsStreaming : true);
file.Close();
Console.WriteLine("Video Sent!");
Console.WriteLine("Deleting local file...");
System.IO.File.Delete("./video.mp4");
}
}
}
private void Posts_NewUpdated_OrEdited(object sender, PostsUpdateEventArgs e)
{
try
{
foreach (var post in e.Added)
{
Parallel.ForEach(PostHandlers, p =>
{
//_logger.Information($"Processing comment: {post.Id} Subreddit: {_subredditName} Handler: {p.GetType().Name}");
p.Process(post);
});
}
}
catch (RedditGatewayTimeoutException exception)
{
_logger.Error(exception, $"Exception caught in {nameof(Posts_NewUpdated_OrEdited)}. Redoing event and continuing...");
Subreddit.Posts.NewUpdated -= Posts_NewUpdated_OrEdited;
SubscribeToPostFeed();
}
catch (RedditServiceUnavailableException exception)
{
_logger.Error(exception, $"Exception caught in {nameof(Posts_NewUpdated_OrEdited)}. Redoing event and continuing...");
Subreddit.Posts.NewUpdated -= Posts_NewUpdated_OrEdited;
SubscribeToPostFeed();
}
catch (Exception exception)
{
_logger.Error(exception, $"Unexpected exception caught in {nameof(Posts_NewUpdated_OrEdited)}");
}
}
/// <summary>
/// Custom event handler for handling monitored new posts as they come in.
/// See Reddit.NETTests for more complex examples.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
public static void C_NewPostsUpdated(object sender, PostsUpdateEventArgs e)
{
foreach (Post post in e.Added)
{
Console.WriteLine("[" + post.Subreddit + "] New Post by " + post.Author + ": " + post.Title);
}
}
// When new post is detected push the notification and log it.
public static void C_NewPostsUpdated(object sender, PostsUpdateEventArgs e)
{
foreach (var post in e.Added)
{
Log.WriteLog("New Free Game found " + post.Author + ": " + post.Title, LogType.Log);
PushNotification(post, gamesChannel);
}
}
private void Posts_NewUpdated(object sender, PostsUpdateEventArgs e)
{
try {
PostsUpdated.Invoke(e);
} catch (Exception ex) {
Console.WriteLine(ex.Message);
}
}
// Fires asynchronously whenever a new post is detected in one of the monitored subreddits. --Kris
public void C_NewPostsUpdated(object sender, PostsUpdateEventArgs e)
{
// Comment on each new post as it comes in. --Kris
foreach (Post post in e.Added)
{
Comment comment = post.Comment(ParseVars(Scripts[Random.Next(0, Scripts.Count)], post)).Submit();
Log("Added comment " + comment.Fullname + " to post " + post.Fullname);
}
}
private void C_AddNewPostToQueue(object sender, PostsUpdateEventArgs eventArgs)
{
foreach (var post in eventArgs.Added)
{
var payload = BuildRedditQueueMessageFromRedditMessage(new PostWrapper(post));
_rabbitPublisher.Publish <QueueMessage>(payload, _routingKey);
}
var dept = _serviceConfigurations.QueueHost;
}
private void C_NewPostsUpdated(object sender, PostsUpdateEventArgs e)
{
foreach (Post post in e.Added)
{
_logger.LogInformation($"New post from /u/{post.Author} in /r/{post.Subreddit} leaving comment");
post.Reply(string.Format(_botSetting.DefaultReplyMessage, post.Author) + _botSetting.MessageFooter);
}
}
private void C_NewPostsUpdated(object sender, PostsUpdateEventArgs e)
{
foreach (LinkPost post in e.Added)
{
if (!NewPosts.ContainsKey(post.Fullname))
{
NewPosts.Add(post.Fullname, post);
}
}
}
private void c_NewPostAdded(object sender, PostsUpdateEventArgs args)
{
foreach (var post in args.Added)
{
if (post is Reddit.Controllers.LinkPost)
{
_redditHelper.ProcessPost(post as Reddit.Controllers.LinkPost);
}
else
{
_logger.LogInformation($"New post '{post.Fullname}' ({post.Title}) is not a link!");
}
}
}
private void TriggerUpdate(PostsUpdateEventArgs args, string type)
{
switch (type)
{
case "best":
OnBestUpdated(args);
break;
case "hot":
OnHotUpdated(args);
break;
case "new":
OnNewUpdated(args);
break;
case "rising":
OnRisingUpdated(args);
break;
case "top":
OnTopUpdated(args);
break;
case "controversial":
OnControversialUpdated(args);
break;
case "modqueue":
OnModQueueUpdated(args);
break;
case "modqueuereports":
OnModQueueReportsUpdated(args);
break;
case "modqueuespam":
OnModQueueSpamUpdated(args);
break;
case "modqueueunmoderated":
OnModQueueUnmoderatedUpdated(args);
break;
case "modqueueedited":
OnModQueueEditedUpdated(args);
break;
}
}
//To-DO
private PostsUpdateEventArgs _redditService_PostsUpdated(PostsUpdateEventArgs eve)
{
IEnumerable <Channel> channels = _channelRepo.GetChannelByType(Models.Domain.ChannelType.approval);
foreach (Channel chan in channels)
{
SocketGuild guild = _client.Guilds.FirstOrDefault(g => g.Id == chan.Guild.GuildID);
if (guild != null)
{
foreach (Post pos in eve.Added)
{
var pos2 = pos.Listing;
Embed emb;
if (postmediaTypes.Contains(pos2.PostHint))
{
emb = EmbedService.BuildMediaRedditPost(pos, guild).Build();
}
else
{
emb = EmbedService.BuildRedditPost(pos, guild).Build();
}
ISocketMessageChannel chanel = (ISocketMessageChannel)guild.GetChannel(chan.ChanelID);
RestUserMessage msg = chanel.SendMessageAsync(embed: emb).Result;
msg.AddReactionAsync(check);
msg.AddReactionAsync(cross);
Message mesg = new Message()
{
Channel = chan,
ChannelID = chan.ChanelID,
MessageID = msg.Id
};
_messageRepo.AddMessage(mesg);
_messages.Add(mesg);
}
}
}
return(eve);
}
public static void NewPostUpdate(object sender, PostsUpdateEventArgs e)
{
foreach (Post p in e.NewPosts)
{
var val = Program.parameters.FirstOrDefault(param => p.Title.Trim().ToLower().Contains(param.Trim().ToLower()));;
if (!String.IsNullOrEmpty(val) && !Program.NewPosts.Contains(p))
{
try
{
EmbedBuilder eb = DiscordHelper.Instance.CreateMessage(p, Program.users, val);
var chnl = Program.client.GetChannel(Program.channelId) as IMessageChannel; // 4
Program.lastMessage.Channel.SendMessageAsync(text: eb.Description, embed: eb.Build());
Program.NewPosts.Add(p);
}
catch (Exception execpt)
{
throw new Exception("An error has occured.");
}
}
}
}
private async void PostsOnNewUpdated(object?sender, PostsUpdateEventArgs e)
{
foreach (var post in e.Added)
{
Discord.DebugLogger.LogMessage(LogLevel.Debug, $"{nameof(Startup.Reebot)}", $"Detected: {post.Title}", DateTime.Now);
DiscordEmoji nsfw;
if (post.NSFW)
{
nsfw = DiscordEmoji.FromName(Discord, ":warning:");
}
else
{
nsfw = DiscordEmoji.FromName(Discord, ":white_check_mark:");
}
var embed = new DiscordEmbedBuilder
{
Author = new DiscordEmbedBuilder.EmbedAuthor
{
Name = Reddit.Account.Me.Name,
IconUrl = Reddit.Account.Me.IconImg
},
Description = $"{post.Author} has posted in r/{post.Subreddit.ToLower()}\n" +
$"{Formatter.BlockCode(post.Title)}",
Color = new Optional <DiscordColor>(DiscordColor.Blue),
Footer = new DiscordEmbedBuilder.EmbedFooter
{
Text = "Powered by glosharp"
}
};
embed.AddField("Wanna read more?", Formatter.MaskedUrl("See more...", new Uri($"https://reddit.com{post.Permalink}")));
embed.AddField("Is it safe to view at work?", nsfw);
var channel = await Discord.GetChannelAsync(747611805257302076);
await Discord.SendMessageAsync(channel : channel, embed : embed);
}
}
internal virtual void OnControversialUpdated(PostsUpdateEventArgs e)
{
ControversialUpdated?.Invoke(this, e);
}
private async void NewRedditPost(object sender, PostsUpdateEventArgs e)
{
foreach (var post in e.Added)
{
// Old post... somehow
if (post.Created.AddHours(1) < DateTime.Now)
{
continue;
}
foreach (var guildData in SaveDataManager.saveData.guildDataList)
{
try
{
if (ConfigManager.config.guildWhitelist.Contains(guildData.guildId.ToString()))
{
LinkPost linkPost = post as LinkPost;
EmbedBuilder builder = new EmbedBuilder()
{
Title = $"[r/{post.Subreddit}] {post.Title}",
Url = $"https://www.reddit.com{post.Permalink}"
};
if (linkPost != null)
{
if (linkPost.URL.Contains("i.redd.it"))
{
builder.ImageUrl = linkPost.URL;
}
else if (linkPost.URL.Contains("v.redd.it"))
{
builder.ImageUrl = linkPost.URL;
builder.Title += "[Video]";
}
else
{
builder.ImageUrl = linkPost.Thumbnail;
builder.Url = linkPost.URL;
builder.Description = $"[Permalink to post]({$"https://www.reddit.com{linkPost.Permalink}"}){Environment.NewLine}";
}
}
else
{
if (post.Listing.SelfText.Length >= 301)
{
builder.Description = WebUtility.HtmlDecode(post.Listing.SelfText.Substring(0, 300)) + "...";
}
else
{
builder.Description = WebUtility.HtmlDecode(post.Listing.SelfText);
}
}
builder.Footer = new EmbedFooterBuilder()
{
Text = $"by u/{post.Author}"
};
string mention = guildData.useMention ? $"<@&{guildData.mentionRoleId}>" : "";
await socketClient.GetGuild(guildData.guildId).GetTextChannel(guildData.channelId).SendMessageAsync(text: mention, embed: builder.Build());
}
else
{
await socketClient.GetGuild(guildData.guildId).LeaveAsync();
}
}
catch (Exception ex)
{
Console.WriteLine("[!!.] Had an error while trying to handle new post." + Environment.NewLine + ex.Message + Environment.NewLine + ex.StackTrace);
}
}
}
}
internal virtual void OnRisingUpdated(PostsUpdateEventArgs e)
{
RisingUpdated?.Invoke(this, e);
}
internal virtual void OnTopUpdated(PostsUpdateEventArgs e)
{
TopUpdated?.Invoke(this, e);
}
private void MonitorPostsThread(MonitoringSnapshot monitoring, string key, string type, string subKey, int startDelayMs = 0)
{
if (startDelayMs > 0)
{
Thread.Sleep(startDelayMs);
}
while (!Terminate &&
Monitoring.Get(key).Contains(subKey))
{
List <Post> oldList;
List <Post> newList;
switch (type)
{
default:
throw new RedditControllerException("Unrecognized type '" + type + "'.");
case "best":
oldList = best;
newList = GetBest();
break;
case "hot":
oldList = hot;
newList = GetHot();
break;
case "new":
oldList = newPosts;
newList = GetNew();
break;
case "rising":
oldList = rising;
newList = GetRising();
break;
case "top":
oldList = top;
newList = GetTop();
break;
case "controversial":
oldList = controversial;
newList = GetControversial();
break;
case "modqueue":
oldList = modQueue;
newList = GetModQueue();
break;
case "modqueuereports":
oldList = modQueueReports;
newList = GetModQueueReports();
break;
case "modqueuespam":
oldList = modQueueSpam;
newList = GetModQueueSpam();
break;
case "modqueueunmoderated":
oldList = modQueueUnmoderated;
newList = GetModQueueUnmoderated();
break;
case "modqueueedited":
oldList = modQueueEdited;
newList = GetModQueueEdited();
break;
}
if (Lists.ListDiff(oldList, newList, out List <Post> added, out List <Post> removed))
{
// Event handler to alert the calling app that the list has changed. --Kris
PostsUpdateEventArgs args = new PostsUpdateEventArgs
{
NewPosts = newList,
OldPosts = oldList,
Added = added,
Removed = removed
};
TriggerUpdate(args, type);
}
Thread.Sleep(Monitoring.Count() * MonitoringWaitDelayMS);
}
}
private async void NewUpdatedAsync(object sender, PostsUpdateEventArgs posts)
{
await this.NewUpdatedAsync(posts.Added);
}
internal virtual void OnModQueueEditedUpdated(PostsUpdateEventArgs e)
{
ModQueueEditedUpdated?.Invoke(this, e);
}
