public async void loadData(Post p) { var redditService = new RedditService(); post = await redditService.GetPostAsync(p.Id); var titleGOT = postPrefab.transform.GetChild(0); var titleGO = titleGOT.gameObject; titleGO.GetComponent <Text>().text = post.Title; var scoreGOT = postPrefab.transform.GetChild(1); var scoreGO = scoreGOT.gameObject; scoreGO.GetComponent <Text>().text = post.Score.ToString(); var authorGOT = postPrefab.transform.GetChild(2); var authorGO = authorGOT.gameObject; authorGO.GetComponent <Text>().text = post.Author; var commentsGOT = postPrefab.transform.GetChild(3); var commentsGO = commentsGOT.gameObject; commentsGO.GetComponent <Text>().text = post.NumberOfComments.ToString() + "comments"; }
public RedditController( AccountService accountService, RedditService redditService) { _redditService = redditService; _accountService = accountService; }
public async Task <Subreddit> GetSubRedditDetails() { var redditService = new RedditService(); var subReddit = await redditService.GetSubredditAsync("cringepics"); return(subReddit); }
public ReplyWithResponsesBot(string botUsername, string botPassword, string clientId, string clientSecretId, string[] subreddits, bool shouldRecreate, string databaseFilePath = "") { m_botUsername = botUsername; m_databaseFile = databaseFilePath; ConfigureDatabase(m_databaseFile, shouldRecreate); m_redditService = new RedditService(botUsername, botPassword, clientId, clientSecretId); //Configure subreddits to listen to foreach (string sub in subreddits) { m_redditService.ListenToSubreddit($"/r/{sub}"); Debug.Log($"Listening to subreddit /r/{sub}"); } m_botStartTime = DateTime.UtcNow; if (string.IsNullOrEmpty(m_databaseFile)) { m_saveDataTimer = new System.Timers.Timer(); m_saveDataTimer.Interval = Constants.DATABASE_SAVE_MILLISECONDS; m_saveDataTimer.Elapsed += OnSaveLatestDatabase; m_saveDataTimer.Start(); } }
async void testRedditCall() { var redditService = new RedditService(); var subRedditList = await redditService.GetSubredditsAsync(); var subReddit = await redditService.GetSubredditAsync("all"); var subRedditPosts = subReddit.Posts; var post = await redditService.GetPostAsync(subRedditPosts[0].Id); var title = post.Title; var score = post.Score; Debug.Log(title + "\n" + score); var titleGOT = this.gameObject.transform.GetChild(0); var titleGO = titleGOT.gameObject; titleGO.GetComponent <Text>().text = title; var scoreGOT = this.gameObject.transform.GetChild(1); var scoreGO = scoreGOT.gameObject; scoreGO.GetComponent <Text>().text = score.ToString(); }
public static async Task <bool> SendFeedUpdateAsync(TheGodfatherBot shard, RssSubscription sub, SyndicationItem latest) { DiscordChannel?chn; try { chn = await shard.Client.GetShard(sub.GuildId).GetChannelAsync(sub.ChannelId); } catch (NotFoundException) { return(false); } if (chn is null) { return(false); } var emb = new LocalizedEmbedBuilder(shard.Services.GetRequiredService <LocalizationService>(), sub.GuildId); emb.WithTitle(latest.Title.Text); emb.WithUrl(sub.Feed.LastPostUrl); emb.WithColor(DiscordColor.Gold); emb.WithLocalizedTimestamp(latest.LastUpdatedTime > latest.PublishDate ? latest.LastUpdatedTime : latest.PublishDate); if (latest.Content is TextSyndicationContent content) { string?imageUrl = RedditService.GetImageUrl(content); if (imageUrl is { })
public RedditCommands(RedditService redditService, SubscriptionsService subscriptionsService, RedditEmbedGenerator redditEmbedGenerator) { _redditService = redditService; _subscriptionsService = subscriptionsService; _redditEmbedGenerator = redditEmbedGenerator; _redditService.OnNewHotTopic += Reddit_OnNewHotTopicAsync; }
public SubscriptionsModule(DBContextFactory factory, EmbedService embedService, Config config, CNNService cnnService, RedditService redditService, MathService mathService) : base(mathService) { DBFactory = factory; EmbedService = embedService; Config = config; CNNService = cnnService; RedditService = redditService; }
public void GetEmbeddedResults() { Assert.IsNotNull(RedditService.GetEmbeddedResults("AskReddit", RedditCategory.Hot)); Assert.IsNotNull(RedditService.GetEmbeddedResults("AskReddit", RedditCategory.New)); Assert.IsNotNull(RedditService.GetEmbeddedResults("AskReddit", RedditCategory.Top)); Assert.IsTrue(RedditService.GetEmbeddedResults("AskDinosaurs", RedditCategory.Hot).Description.Contains(":warning:")); Assert.IsTrue(RedditService.GetEmbeddedResults("AskDinosaurs", RedditCategory.New).Description.Contains(":warning:")); Assert.IsTrue(RedditService.GetEmbeddedResults("AskDinosaurs", RedditCategory.Top).Description.Contains(":warning:")); }
private async Task RedditPost(CommandContext ctx, string query, RedditCategory category) { if (!BotServices.CheckUserInput(query)) { return; } var results = RedditService.GetEmbeddedResults(query, category); await ctx.RespondAsync("Search results for r/" + query, embed : results).ConfigureAwait(false); }
public async Task TestParseFrontPage() { string s = await File.ReadAllTextAsync("resources/frontpage.json"); JObject frontpagejson = JObject.Parse(s); RedditService RSS = new RedditService(logger); string bsturl = RSS.FindBSTThreadUrl(frontpagejson); Assert.Equal("https://old.reddit.com/r/ElectricSkateboarding/comments/93t8gd/buyselltrade_monthly_sticky_august/.json", bsturl); }
protected override async void OnNavigatedTo(NavigationEventArgs e) { _navigationHelper.OnNavigatedTo(e); string id = (string)e.Parameter; RedditService redditService = new RedditService(); PostComments postComments = await redditService.GetPostCommentsAsync(id); Post = postComments.Post; }
protected override async void OnNavigatedTo(NavigationEventArgs e) { _navigationHelper.OnNavigatedTo(e); RedditService redditService = new RedditService(); var subreddits = await redditService.GetSubredditsAsync(); Subreddits = new List <string>(subreddits); await redditService.GetPostCommentsAsync("2vvaj6"); }
public Startup(ServiceProvider provider) { _serviceProvider = provider; _secrets = provider.GetService <Secrets>(); _redditService = provider.GetService <RedditService>(); _channelRepo = provider.GetService <IChannelRepository>(); _messageRepo = provider.GetService <IMessageRepository>(); _prefixRepository = provider.GetService <IPrefixRepository>(); _guildRepository = provider.GetService <IGuildRepository>(); _client = new DiscordSocketClient(); _commands = new CommandService(); }
public HttpResponseMessage ListReddits(HttpRequestMessage request, string token = null) { HttpResponseMessage respose = new HttpResponseMessage(); if (string.IsNullOrEmpty(token)) { return(request.CreateErrorResponse(HttpStatusCode.Unauthorized, "No Token Supplied. Please register or login")); } var svc = new RedditService(); var reddits = svc.GetAllReddits(); return(request.CreateResponse(HttpStatusCode.OK, reddits)); }
public HttpResponseMessage Login(HttpRequestMessage request, [FromBody] User user) { var existing = new RedditService().GetUserByUserName(user.UserName); //not found, or wrong passsword if (existing == null || existing.Password != user.Password) { return(request.CreateErrorResponse(HttpStatusCode.NotFound, $"User {user.UserName} or password is wrong not found.")); } ; return(request.CreateResponse(HttpStatusCode.OK, existing.Token)); }
public async Task RedditAsync(CommandContext ctx, [Description("Subreddit.")] string sub) { string url = RedditService.GetFeedUrlForSubreddit(sub, RedditCategory.New, out string rsub); if (url is null) { throw new CommandFailedException("That subreddit doesn't exist."); } await this.Database.SubscribeAsync(ctx.Guild.Id, ctx.Channel.Id, url, rsub); await this.InformAsync(ctx, $"Subscribed to {Formatter.Bold(rsub)}", important : false); }
public HttpResponseMessage AddFavorite(HttpRequestMessage request, string token, [FromBody] Favorite favorite) { try { //var fav = new Favorite //{ // RedditId = "87y0ei", // Tags = new List<string> // { // {"sasa" }, {"when"} // } //}; //return request.CreateResponse(HttpStatusCode.OK, fav); var svc = new RedditService(); var existing = svc.GetUserByToken(token); if (existing == null) { return(request.CreateErrorResponse(HttpStatusCode.NotFound, "Invalid access token")); } var reddits = svc.GetAllReddits(); var reddit = reddits.FirstOrDefault(x => x.RedditId == favorite.RedditId); if (reddit == null) { return(request.CreateErrorResponse(HttpStatusCode.NotFound, $"Reddit Id {favorite.RedditId} not Found")); } if (existing.Favorites == null) { existing.Favorites = new List <Favorite>(); } existing.Favorites.Add(favorite); svc.SaveUser(existing); return(request.CreateResponse(HttpStatusCode.OK, $"Your tages for {favorite.RedditId} has been saved")); } catch (Exception ex) { return(request.CreateErrorResponse(HttpStatusCode.BadRequest, "Bad Request " + ex.Message)); } }
public HttpResponseMessage GetFavorites(HttpRequestMessage request, string token, string tag) { var svc = new RedditService(); var existing = svc.GetUserByToken(token); if (existing == null) { return(request.CreateErrorResponse(HttpStatusCode.NotFound, "Invalid access token")); } var redits = svc.GetRedditsForUser(existing, tag); return(request.CreateResponse(HttpStatusCode.OK, redits)); }
private static async Task RedditPost(CommandContext ctx, string query, RedditCategory category) { if (string.IsNullOrWhiteSpace(query)) { return; } await ctx.TriggerTypingAsync(); var results = RedditService.GetResults(query, category); if (results is null || results.Count == 0) { await BotServices.SendResponseAsync(ctx, Resources.NOT_FOUND_COMMON, ResponseType.Missing) .ConfigureAwait(false); return; } while (results.Count > 0) { var output = new DiscordEmbedBuilder() .WithFooter("Type 'next' within 10 seconds for the next five posts.") .WithColor(new DiscordColor("#FF4500")); foreach (var result in results.Take(5)) { output.AddField(result.Authors.FirstOrDefault()?.Name, $"[{(result.Title.Text.Length < 500 ? result.Title.Text : result.Title.Text.Take(500) + "...")}]({result.Links.First().Uri})"); results.Remove(result); } var message = await ctx.RespondAsync("Search results for r/" + query + " on Reddit", output) .ConfigureAwait(false); if (results.Count == 5) { continue; } var interactivity = await BotServices.GetUserInteractivity(ctx, "next", 10).ConfigureAwait(false); if (interactivity.Result is null) { break; } await BotServices.RemoveMessage(interactivity.Result).ConfigureAwait(false); await BotServices.RemoveMessage(message).ConfigureAwait(false); } }
public async Task RedditAsync(CommandContext ctx, [Description("Subreddit.")] string sub) { if (RedditService.GetFeedURLForSubreddit(sub, RedditCategory.New, out string rsub) is null) { throw new CommandFailedException("That subreddit doesn't exist."); } using (DatabaseContext db = this.Database.CreateContext()) { db.RssSubscriptions.RemoveRange(db.RssSubscriptions.Where(s => s.GuildId == ctx.Guild.Id && s.ChannelId == ctx.Channel.Id && s.Name == rsub)); await db.SaveChangesAsync(); } await this.InformAsync(ctx, $"Unsubscribed from {Formatter.Bold(rsub)}", important : false); }
public HttpResponseMessage Register(HttpRequestMessage request, [FromBody] User user) { var existing = new RedditService().GetUserByUserName(user.UserName); if (existing != null) { return(request.CreateErrorResponse(HttpStatusCode.Conflict, $"the username {user.UserName} is already taken")); } user.Token = Guid.NewGuid().ToString(); user.Favorites = new List <Favorite>(); var saved = new RedditService().SaveUser(user); return(request.CreateResponse(HttpStatusCode.OK, user.Token)); }
internal async Task LoadDataAsync() { RedditData = await RedditService.GetTopPost(); Posts.Clear(); RedditListItem value; foreach (var item in RedditData.data.children) { value = new RedditListItem { Value = item.data }; value.DismissItem += Dismiss; Posts.Add(value); } }
private Task SearchAndSendResultsAsync(CommandContext ctx, string sub, RedditCategory category) { if (string.IsNullOrWhiteSpace(sub)) { throw new InvalidCommandUsageException(ctx, "cmd-err-sub-none"); } string?url = RedditService.GetFeedURLForSubreddit(sub, category, out string?rsub); if (url is null || rsub is null) { if (rsub is null) { throw new CommandFailedException(ctx, "cmd-err-sub-format"); } else { throw new CommandFailedException(ctx, "cmd-err-sub-404", rsub); } } IReadOnlyList <SyndicationItem>?res = RssFeedsService.GetFeedResults(url); if (res is null) { throw new CommandFailedException(ctx, "cmd-err-sub-fail", rsub); } if (!res.Any()) { return(ctx.FailAsync("cmd-err-res-none")); } return(ctx.PaginateAsync(res, (emb, r) => { emb.WithTitle(r.Title.Text); emb.WithDescription(r.Summary, unknown: false); emb.WithUrl(r.Links.First().Uri); if (r.Content is TextSyndicationContent content) { string?url = RedditService.GetImageUrl(content); if (url is { }) { emb.WithImageUrl(url); } }
private async Task SearchAndSendResultsAsync(CommandContext ctx, string sub, RedditCategory category) { string url = RedditService.GetFeedUrlForSubreddit(sub, category, out string rsub); if (url is null) { throw new CommandFailedException("That subreddit doesn't exist."); } var res = RssService.GetFeedResults(url); if (res is null) { throw new CommandFailedException($"Failed to get the data from that subreddit ({Formatter.Bold(rsub)})."); } await RssService.SendFeedResultsAsync(ctx.Channel, res); }
async void loadSubredditPosts() { var redditService = new RedditService(); var subReddit = await redditService.GetSubredditAsync("all"); var position = new Vector3(0f, 0f, 0f); GameObject subRedditPostsGO = new GameObject(); subRedditPostsGO.name = "Subreddit Posts"; foreach (var p in subReddit.Posts) { GameObject postGO = new GameObject(); postGO.name = p.Id; postGO.transform.parent = subRedditPostsGO.transform; postGO.transform.position = position; PostManager po = postGO.AddComponent <PostManager>(); po.loadPrefab(postPreFab, position, Quaternion.identity); po.loadData(p); position.z += 0.9f; } }
public async Task UnsubscribeAsync(CommandContext ctx, [Description("desc-sub")] string sub) { if (string.IsNullOrWhiteSpace(sub)) { throw new InvalidCommandUsageException(ctx, "cmd-err-sub-none"); } string?url = RedditService.GetFeedURLForSubreddit(sub, RedditCategory.New, out string?rsub); if (url is null || rsub is null) { if (rsub is null) { throw new CommandFailedException(ctx, "cmd-err-sub-format"); } else { throw new CommandFailedException(ctx, "cmd-err-sub-404", rsub); } } RssFeed?feed = await this.Service.GetByUrlAsync(url); if (feed is null) { throw new CommandFailedException(ctx, "cmd-err-sub-not"); } RssSubscription?s = await this.Service.Subscriptions.GetAsync((ctx.Guild.Id, ctx.Channel.Id), feed.Id); if (s is null) { throw new CommandFailedException(ctx, "cmd-err-sub-not"); } await this.Service.Subscriptions.RemoveAsync((ctx.Guild.Id, ctx.Channel.Id), feed.Id); await ctx.InfoAsync(this.ModuleColor); }
public async Task TestMakeEmailsFromMatches() { MailgunService MSS = new MailgunService(logger); string bstthreadloc = await File.ReadAllTextAsync("resources/bstthread.json"); JArray BSTThreadJson = JArray.Parse(bstthreadloc); RedditService RSS = new RedditService(logger); // Get BST thread string rawCompanies = await File.ReadAllTextAsync("resources/common_companies.json"); string rawProducts = await File.ReadAllTextAsync("resources/common_boards.json"); JArray jarrCompany = JArray.Parse(rawCompanies); JArray jarrProduct = JArray.Parse(rawProducts); List <Company> companies = CompanyParser.ParseCompanies(jarrCompany); List <Product> products = ProductParser.ParseProducts(jarrProduct); List <Company> combined = CompanyParser.CombineCompanyLists(companies, products.Select(x => x.Company)); Esk8Service ESS = new Esk8Service(logger); List <RegexCategory <Company> > CompRs = ESS.GetCompanyRegexs(companies); List <RegexCategory <Product> > ProdRs = ESS.GetProductRegexs(products); List <BSTComment> comments = RSS.ParseComments(BSTThreadJson, CompRs, ProdRs); // Get mock subscribers string subloc = await File.ReadAllTextAsync("resources/Subscribers.json"); JArray subArray = JArray.Parse(subloc); List <PostedSubscribeObject> psubs = SubscriberParser.ParseSubscribers(subArray); List <Subscriber> subs = psubs.Select(x => Subscriber.FromPostedSubscriber(x)).ToList(); MatchService LSS = new MatchService(logger); Dictionary <Subscriber, List <LambdaMatch> > matches = LSS.MakeMatches(subs, comments); List <MailgunEmail> emails = matches.Select(x => MSS.MakeEmail(x.Key, x.Value)).ToList(); }
public async Task SubscribeAsync(CommandContext ctx, [Description("desc-chn")] DiscordChannel chn, [Description("desc-sub")] string sub) { chn ??= ctx.Channel; if (chn.Type != ChannelType.Text) { throw new InvalidCommandUsageException(ctx, "cmd-err-chn-type-text"); } if (string.IsNullOrWhiteSpace(sub)) { throw new InvalidCommandUsageException(ctx, "cmd-err-sub-none"); } string?url = RedditService.GetFeedURLForSubreddit(sub, RedditCategory.New, out string?rsub); if (url is null || rsub is null) { if (rsub is null) { throw new CommandFailedException(ctx, "cmd-err-sub-format"); } else { throw new CommandFailedException(ctx, "cmd-err-sub-404", rsub); } } if (await this.Service.SubscribeAsync(ctx.Guild.Id, ctx.Channel.Id, url, rsub)) { await ctx.InfoAsync(this.ModuleColor); } else { await ctx.FailAsync("cmd-err-sub", url); } }
public async Task TestParseBSTThreadWithUntilDate() { string s = await File.ReadAllTextAsync("resources/bstthread.json"); JArray BSTThreadJson = JArray.Parse(s); RedditService RSS = new RedditService(logger); // Get Companies, Products, Regexes, etc string rawCompanies = await File.ReadAllTextAsync("resources/common_companies.json"); string rawProducts = await File.ReadAllTextAsync("resources/common_boards.json"); JArray jarrCompany = JArray.Parse(rawCompanies); JArray jarrProduct = JArray.Parse(rawProducts); List <Company> companies = CompanyParser.ParseCompanies(jarrCompany); List <Product> products = ProductParser.ParseProducts(jarrProduct); List <Company> combined = CompanyParser.CombineCompanyLists(companies, products.Select(x => x.Company)); Esk8Service ESS = new Esk8Service(logger); List <RegexCategory <Company> > CompRs = ESS.GetCompanyRegexs(companies); List <RegexCategory <Product> > ProdRs = ESS.GetProductRegexs(products); DateTimeOffset Aug42018 = new DateTimeOffset(2018, 8, 4, 0, 0, 0, TimeSpan.FromSeconds(0)); List <BSTComment> comments = RSS.ParseComments(BSTThreadJson, CompRs, ProdRs, Aug42018); // Assert that there are 29 items in this json Assert.Equal(18, comments.Count); // Assert that there are X items for WTB Assert.Equal(1, comments.Count(x => x.BuySellTradeStatus == BST.BUY)); // Assert that there are Y items for WTS Assert.Equal(17, comments.Count(x => x.BuySellTradeStatus == BST.SELL)); // Assert that there are 0 items for Trade Assert.Equal(0, comments.Count(x => x.BuySellTradeStatus == BST.TRADE)); }