/// <summary>
/// Calls https://graph.facebook.com/vX.Y/{request.PageId/{request.Edge}.
/// </summary>
/// <typeparam name="T">A constructable subclass of Page to use. This allows deserializing data into custom subclasses that add extra metadata.</typeparam>
/// <param name="request">The details of the request (PageId, Since, Until, Limit) to send to the graph API.</param>
/// <returns>The list of posts under request.PageId in the given range request.Since and request.Until if the page exists, else null.</returns>
/// <exception cref="ArgumentNullException"><paramref name="request"/> is null</exception>
public async Task <PagedResponse <T> > GetPosts <T>(PostsRequest request) where T : Post
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
return(await GraphPagedResponse <T> .ExecuteRequest(ConstructRequest(request)));
}
public void Ctor_ValidPageIdAndEdge_ReturnsExpected(PostsRequestEdge edge, string expectedEdge)
{
var postsRequest = new PostsRequest("PageId", edge);
Assert.Equal("PageId", postsRequest.PageId);
Assert.Equal(edge, postsRequest.Edge);
Assert.Null(postsRequest.Fields);
Assert.Equal($"/PageId/{expectedEdge}?fields=id,message,link,caption,description,from,created_time,updated_time," +
"permalink_url,status_type,type,name,place,shares,comments.limit(0).summary(True)," +
"reactions.limit(0).summary(True)&", postsRequest.ToString());
}
public async Task <ListWithCount <Post> > GetPosts(Guid jobId, string[] allowedWords,
string[] forbiddenWords, DateTime?fromDate, DateTime?toDate, int page, int pageSize)
{
var body = new PostsRequest
{
JobId = jobId,
AllowedWords = allowedWords,
ForbiddenWords = forbiddenWords,
FromDate = fromDate,
ToDate = toDate,
Page = page,
PageSize = pageSize
};
return(await _httpService.Post <ListWithCount <Post> >($"analyzedPosts", body));
}
public async Task <IActionResult> Create([FromBody] PostsRequest request)
{
Post post = new Post();
post.message = request.message;
post.userName = request.userName;
IReliableDictionary <string, Post> votesDictionary = await this.stateManager.GetOrAddAsync <IReliableDictionary <string, Post> >("posts");
using (ITransaction tx = this.stateManager.CreateTransaction())
{
await votesDictionary.AddAsync(tx, post.id.ToString(), post);
await tx.CommitAsync();
}
return(new OkResult());
}
public async Task <IActionResult> Create([FromBody] PostsRequest request)
{
Uri serviceName = BlogRestApi.GetBlogDataServiceName(this.serviceContext);
Uri proxyAddress = this.GetProxyAddress(serviceName);
long partitionKey = this.GetPartitionKey(request.message);
string proxyUrl = $"{proxyAddress}/api/Posts?PartitionKey={partitionKey}&PartitionKind=Int64Range";
var postRequest = JsonConvert.SerializeObject(request);
var buffer = System.Text.Encoding.UTF8.GetBytes(postRequest);
var byteContent = new ByteArrayContent(buffer);
byteContent.Headers.ContentType = new MediaTypeHeaderValue("application/json");
using (HttpResponseMessage response = await this.httpClient.PostAsync(proxyUrl, byteContent))
{
if (response.StatusCode != System.Net.HttpStatusCode.OK)
{
return(this.StatusCode((int)response.StatusCode));
}
}
return(new OkResult());
}
public IEnumerable <ScrapedPost> Scrape(PageMetadata[] pages, DateTime since, DateTime until)
{
Debug.Assert(pages != null);
Console.WriteLine($"Started scraping {pages.Length} pages for their posts");
DateTime start = DateTime.Now;
int numberOfPosts = 0;
for (int i = 0; i < pages.Length; i++)
{
PageMetadata page = pages[i];
Console.WriteLine($"{i + 1}/{pages.Length}: {page.Name}");
// Query the Facebook Graph API to get all posts in the given range, published only by
// the page.
var graphRequest = new PostsRequest(page.FacebookId, PostsRequestEdge.Posts)
{
Since = since,
Until = until,
PaginationLimit = 100
};
PagedResponse <ScrapedPost> postsResponse = GraphClient.GetPosts <ScrapedPost>(graphRequest);
foreach (ScrapedPost post in postsResponse.AllData())
{
UpdateMetadata(post, page.Name);
Save(post, Refresh.False);
numberOfPosts++;
yield return(post);
}
Console.WriteLine(numberOfPosts);
}
Console.WriteLine($"Done scraping {pages.Length} pages for their posts");
}
//webresponse object -> Api Content, revelated a gzip encryption
public RootResponse <PostsItem> PostsServiceGetFromGzip(PostsRequest postsRequest)
{
string postsRootResponse = "";
var url = GetBaseUrlRequest(this.postsService, postsRequest);
try
{
var uri = new Uri(url, UriKind.Absolute);
var request = (HttpWebRequest)WebRequest.Create(uri);
//KEY to decompress /!\
request.AutomaticDecompression = DecompressionMethods.GZip | DecompressionMethods.Deflate;
using (HttpWebResponse response = (HttpWebResponse)request.GetResponse())
{
using (StreamReader reader = new StreamReader(response.GetResponseStream()))
{
postsRootResponse = reader.ReadToEnd();
}
var jsonPostsRoot = JsonConvert.DeserializeObject <RootResponse <PostsItem> >(postsRootResponse);
jsonPostsRoot.StatusCode = response.StatusCode.ToString();
return(jsonPostsRoot);
}
}
catch (WebException webEx)
{
var responseErr = (HttpWebResponse)webEx.Response;
return(new RootResponse <PostsItem> {
StatusCode = responseErr.StatusDescription
});
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
public void GivenTheUserGetsAListOfPostsWithTheFollowingProperties(Table table)
{
this.postsRequest = table.CreateInstance <PostsRequest>();
this.postsRootResponse = this.postsServiceRestApi.PostsServiceGetFromGzip(postsRequest);
}
public async Task <IDataResult <IEnumerable <PostModel> > > GetUserPosts(long userId, PostsRequest postsRequest)
{
var posts = await _postRepository.ListWhereIncludeAsync(post => post.User.Id == userId, p => p.User, p => p.User, p => p.Likes, p => p.Point);
var postsResult = posts.Select(p =>
{
var post = CreatePostModel(p);
//post.Views = p.Point.TotalViews;
return(post);
});
if (postsRequest.OrderByDateDesc.HasValue)
{
postsResult = postsRequest.OrderByDateDesc.Value
? postsResult.OrderByDescending(p => p.CreationDate)
: postsResult.OrderBy(p => p.CreationDate);
}
if (postsRequest.OrderByLikesDesc.HasValue)
{
postsResult = postsRequest.OrderByLikesDesc.Value
? postsResult.OrderByDescending(p => p.TimesLiked)
: postsResult.OrderBy(p => p.TimesLiked);
}
if (!string.IsNullOrWhiteSpace(postsRequest.Keyword))
{
postsResult = postsResult.Where(p => p.Message.Contains(postsRequest.Keyword) ||
p.Location.Contains(postsRequest.Keyword) ||
p.TimesLiked.ToString().Contains(postsRequest.Keyword));
}
return(DataResult <IEnumerable <PostModel> > .Success(postsResult));
}
/// <summary>
/// Calls https://graph.facebook.com/vX.Y/{request.PageId/{request.Edge}.
/// </summary>
/// <param name="request">The details of the request (PageId, Since, Until, Limit) to send to the graph API.</param>
/// <returns>The list of posts under request.PageId in the given range request.Since and request.Until if the page exists, else null.</returns>
/// <exception cref="ArgumentNullException"><paramref name="request"/> is null</exception>
public async Task <PagedResponse <Post> > GetPosts(PostsRequest request) => await GetPosts <Post>(request);
