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));
}
