public object Authorize(HttpRequest Request, string accountName)
{
try
{
var uri = Request.Url.ToString();
var code = Request["code"];
var error = Request["error"];
if (!string.IsNullOrEmpty(error))
if (error == "access_denied")
return new UserRejectException();
else
return new UnknownException(error);
BloggerService = null;
if (code != null)
{
string redirectUri = uri.Substring(0, uri.IndexOf("?"));
var token = CodeFlow.ExchangeCodeForTokenAsync(accountName, code, redirectUri, CancellationToken.None).Result;
string state = Request["state"];
var result = AuthWebUtility.ExtracRedirectFromState(CodeFlow.DataStore, accountName, state);
return result;
}
else
{
string redirectUri = uri;
string state = "ostate_";// Guid.NewGuid().ToString("N");
var result = new AuthorizationCodeWebApp(CodeFlow, redirectUri, state).AuthorizeAsync(accountName, CancellationToken.None).Result;
if (result.RedirectUri != null)
{
return result;
}
else
{
BloggerService = new BloggerService(new BaseClientService.Initializer()
{
HttpClientInitializer = result.Credential,
ApplicationName = APPLICATION_NAME
});
// alright
return "OK";
}
}
}
catch (Exception ex)
{
return ex;
}
}
static void Main(string[] args)
{
Google.Apis.Blogger.v3.BloggerService bs = new BloggerService(new BaseClientService.Initializer()
{
ApiKey = "AIzaSyCkyf5p4x_2tW-Bwmqt7Bbj-HhFIC_kXvw",
});
Google.Apis.Blogger.v3.BlogsResource br = new BlogsResource(bs);
var res = br.GetByUrl("http://blogzaserioznihora.blogspot.com/").Execute();
Google.Apis.Blogger.v3.PostsResource pr = new PostsResource(bs);
var list = pr.List("7485604791378022116");
list.FetchBodies = false;
var result = list.Execute();
}
/// <summary>
/// Retrieve pageview stats for a Blog.
/// Documentation https://developers.google.com/blogger/v3/reference/pageViews/get
/// Generation Note: This does not always build corectly. Google needs to standardise things I need to figuer out which ones are wrong.
/// </summary>
/// <param name="service">Authenticated Blogger service.</param>
/// <param name="blogId">The ID of the blog to get.</param>
/// <param name="optional">Optional paramaters.</param>
/// <returns>PageviewsResponse</returns>
public static Pageviews Get(BloggerService service, string blogId, PageViewsGetOptionalParms optional = null)
{
try
{
// Initial validation.
if (service == null)
{
throw new ArgumentNullException("service");
}
if (blogId == null)
{
throw new ArgumentNullException(blogId);
}
// Building the initial request.
var request = service.PageViews.Get(blogId);
// Applying optional parameters to the request.
request = (PageViewsResource.GetRequest)SampleHelpers.ApplyOptionalParms(request, optional);
// Requesting data.
return(request.Execute());
}
catch (Exception ex)
{
throw new Exception("Request PageViews.Get failed.", ex);
}
}
public static async Task <bool> LogIn()
{
using (var stream = new FileStream("client_secrets.json", FileMode.Open, FileAccess.Read))
{
credential = await GoogleWebAuthorizationBroker.AuthorizeAsync(
GoogleClientSecrets.Load(stream).Secrets, new[] { BloggerService.Scope.Blogger },
"*****@*****.**", CancellationToken.None);
}
using (var stream = new FileStream("client_secrets_links.json", FileMode.Open, FileAccess.Read))
{
linksCredential = await GoogleWebAuthorizationBroker.AuthorizeAsync(
GoogleClientSecrets.Load(stream).Secrets, new[] { BloggerService.Scope.Blogger },
"*****@*****.**", CancellationToken.None, new FileDataStore(@"Google.Apis.Auth\LinksBlog"));
}
if (credential == null || linksCredential == null)
{
return(false);
}
service = new BloggerService(new BaseClientService.Initializer
{
HttpClientInitializer = credential,
ApplicationName = "blogtestproject", // 這個名稱必須與申請憑證時所使用的專案名稱相同
});
linksService = new BloggerService(new BaseClientService.Initializer
{
HttpClientInitializer = linksCredential,
ApplicationName = "blogtestproject", // 這個名稱必須與申請憑證時所使用的專案名稱相同
});
return(service != null && linksCredential != null);
}
public static List<Post> getPostList(BloggerService bs, string blogId, PostsResource.ListRequest.StatusEnum status)
{
PostsResource.ListRequest req = bs.Posts.List(blogId);
req.View = PostsResource.ListRequest.ViewEnum.ADMIN;
req.FetchBodies = false;
req.FetchImages = false;
req.Status = status;
List<Post> listOfPost = new List<Post>();
string firstToken = "";
while (true)
{
PostList posts = req.Execute();
req.PageToken = posts.NextPageToken;
if (firstToken == "")
{
firstToken = posts.NextPageToken;
}
else if (firstToken != "" && posts.NextPageToken == firstToken)
{
break;
}
if (posts.Items != null)
{
posts.Items.ToList().ForEach(item => listOfPost.Add(item));
}
}
return listOfPost;
}
private async Task AuthenticateAsync()
{
if (_service != null)
{
return;
}
FileStream stream = new FileStream(SecretFileName, FileMode.Open, FileAccess.Read);
CancellationTokenSource cts = new CancellationTokenSource();
cts.CancelAfter(TimeSpan.FromSeconds(20));
CancellationToken ct = cts.Token;
_credential = await GoogleWebAuthorizationBroker.AuthorizeAsync(
GoogleClientSecrets.Load(stream).Secrets,
new[] { BloggerService.Scope.Blogger },
"user",
ct
);
BaseClientService.Initializer initializer = new BaseClientService.Initializer()
{
HttpClientInitializer = _credential,
ApplicationName = ApplicationName
};
_service = new BloggerService(initializer);
}
/// <summary>
/// Delete a post by ID.
/// Documentation https://developers.google.com/blogger/v3/reference/posts/delete
/// Generation Note: This does not always build corectly. Google needs to standardise things I need to figuer out which ones are wrong.
/// </summary>
/// <param name="service">Authenticated Blogger service.</param>
/// <param name="blogId">The ID of the Blog.</param>
/// <param name="postId">The ID of the Post.</param>
public static void Delete(BloggerService service, string blogId, string postId)
{
try
{
// Initial validation.
if (service == null)
{
throw new ArgumentNullException("service");
}
if (blogId == null)
{
throw new ArgumentNullException(blogId);
}
if (postId == null)
{
throw new ArgumentNullException(postId);
}
// Make the request.
service.Posts.Delete(blogId, postId).Execute();
}
catch (Exception ex)
{
throw new Exception("Request Posts.Delete failed.", ex);
}
}
/// <summary>
/// Authenticate to Google Using Oauth2
/// Documentation https://developers.google.com/accounts/docs/OAuth2
/// </summary>
/// <param name="clientId">From Google Developer console https://console.developers.google.com</param>
/// <param name="clientSecret">From Google Developer console https://console.developers.google.com</param>
/// <param name="userName">A string used to identify a user.</param>
/// <returns></returns>
public static BloggerService AuthenticateOauth(string clientId, string clientSecret, string userName)
{
string[] scopes = new string[] { BloggerService.Scope.Blogger, // view and manage your analytics data
BloggerService.Scope.BloggerReadonly }; // View your Blogs
try
{
// here is where we Request the user to give us access, or use the Refresh Token that was previously stored in %AppData%
UserCredential credential = GoogleWebAuthorizationBroker.AuthorizeAsync(new ClientSecrets {
ClientId = clientId, ClientSecret = clientSecret
}
, scopes
, userName
, CancellationToken.None
, new FileDataStore("Daimto.Blogger.Auth.Store")).Result;
BloggerService service = new BloggerService(new BloggerService.Initializer()
{
HttpClientInitializer = credential,
ApplicationName = "Blogger API Sample",
});
return(service);
}
catch (Exception ex)
{
Console.WriteLine(ex.InnerException);
return(null);
}
}
private void AddEntry_Click(object sender, System.EventArgs e)
{
addentry dlg = new addentry();
if (dlg.ShowDialog() == DialogResult.OK &&
dlg.Entry.Length > 0)
{
// now add this to the feed.
BloggerEntry entry = new BloggerEntry();
entry.Content.Content = dlg.Entry;
entry.Content.Type = "html";
entry.Title.Text = dlg.EntryTitle;
string userName = this.UserName.Text;
string passWord = this.Password.Text;
BloggerService service = new BloggerService("BloggerSampleApp.NET");
if (userName != null && userName.Length > 0)
{
service.Credentials = new GDataCredentials(userName, passWord);
}
service.Insert(new Uri(this.feedUri), entry);
RefreshFeed(this.feedUri);
}
}
/// <summary>
/// Search for a post.
/// Documentation https://developers.google.com/blogger/v3/reference/posts/search
/// Generation Note: This does not always build corectly. Google needs to standardise things I need to figuer out which ones are wrong.
/// </summary>
/// <param name="service">Authenticated Blogger service.</param>
/// <param name="blogId">ID of the blog to fetch the post from.</param>
/// <param name="q">Query terms to search this blog for matching posts.</param>
/// <param name="optional">Optional paramaters.</param>
/// <returns>PostListResponse</returns>
public static PostList Search(BloggerService service, string blogId, string q, PostsSearchOptionalParms optional = null)
{
try
{
// Initial validation.
if (service == null)
{
throw new ArgumentNullException("service");
}
if (blogId == null)
{
throw new ArgumentNullException(blogId);
}
if (q == null)
{
throw new ArgumentNullException(q);
}
// Building the initial request.
var request = service.Posts.Search(blogId, q);
// Applying optional parameters to the request.
request = (PostsResource.SearchRequest)SampleHelpers.ApplyOptionalParms(request, optional);
// Requesting data.
return(request.Execute());
}
catch (Exception ex)
{
throw new Exception("Request Posts.Search failed.", ex);
}
}
/// <summary>
/// Retrieves the comments for a blog, possibly filtered.
/// Documentation https://developers.google.com/blogger/v2/reference/comments/list
/// Generation Note: This does not always build corectly. Google needs to standardise things I need to figuer out which ones are wrong.
/// </summary>
/// <param name="service">Authenticated Blogger service.</param>
/// <param name="blogId">ID of the blog to fetch comments from.</param>
/// <param name="postId">ID of the post to fetch posts from.</param>
/// <param name="optional">Optional paramaters.</param>
/// <returns>CommentListResponse</returns>
public static CommentList List(BloggerService service, string blogId, string postId, CommentsListOptionalParms optional = null)
{
try
{
// Initial validation.
if (service == null)
{
throw new ArgumentNullException("service");
}
if (blogId == null)
{
throw new ArgumentNullException(blogId);
}
if (postId == null)
{
throw new ArgumentNullException(postId);
}
// Building the initial request.
var request = service.Comments.List(blogId, postId);
// Applying optional parameters to the request.
request = (CommentsResource.ListRequest)SampleHelpers.ApplyOptionalParms(request, optional);
// Requesting data.
return(request.Execute());
}
catch (Exception ex)
{
throw new Exception("Request Comments.List failed.", ex);
}
}
public void BloggerPublicFeedTest()
{
Tracing.TraceMsg("Entering BloggerPublicFeedTest");
FeedQuery query = new FeedQuery();
BloggerService service = new BloggerService(this.ApplicationName);
String publicURI = (String)this.externalHosts[0];
if (publicURI != null)
{
service.RequestFactory = this.factory;
query.Uri = new Uri(publicURI);
AtomFeed feed = service.Query(query);
if (feed != null)
{
// look for the one with dinner time...
foreach (AtomEntry entry in feed.Entries)
{
Assert.IsTrue(entry.ReadOnly, "The entry should be readonly");
}
}
}
}
//
// GET: /E3/
public ActionResult Index()
{
string apiKey = System.Configuration.ConfigurationManager.AppSettings["BloggerApiKey"];
string appName = System.Configuration.ConfigurationManager.AppSettings["GoogleAppName"];
BloggerService service = new BloggerService(new Google.Apis.Services.BaseClientService.Initializer()
{
ApiKey = apiKey,
ApplicationName = appName
});
ArticlesHelper helper = new ArticlesHelper(apiKey, appName, service);
List <Article> nintendoArticles = helper.GetArticlesFromBlog(NintendoBlogId, "Nintendo", 100, 1, "E3 2016", "/Artigos/Ler/");
List <Article> generalArticles = helper.GetArticlesFromBlog(MainBlogId, "Multi", 100, 1, "E3 2016", "/Artigos/Ler/");
List <Article> articles = new List <Article>();
articles.AddRange(nintendoArticles);
articles.AddRange(generalArticles);
ViewData["articles"] = articles.OrderByDescending(t => t.DatePublished).ToList();
return(View());
}
/// <summary>
/// Authenticate to Google Using Oauth2
/// Documentation https://developers.google.com/accounts/docs/OAuth2
/// </summary>
/// <param name="clientId">From Google Developer console https://console.developers.google.com</param>
/// <param name="clientSecret">From Google Developer console https://console.developers.google.com</param>
/// <param name="userName">A string used to identify a user.</param>
/// <returns></returns>
public static BloggerService AuthenticateOauth(string clientId, string clientSecret, string userName)
{
string[] scopes = new string[] { BloggerService.Scope.Blogger, // view and manage your analytics data
BloggerService.Scope.BloggerReadonly}; // View your Blogs
try
{
// here is where we Request the user to give us access, or use the Refresh Token that was previously stored in %AppData%
UserCredential credential = GoogleWebAuthorizationBroker.AuthorizeAsync(new ClientSecrets { ClientId = clientId, ClientSecret = clientSecret }
, scopes
, userName
, CancellationToken.None
, new FileDataStore("Daimto.Blogger.Auth.Store")).Result;
BloggerService service = new BloggerService(new BloggerService.Initializer()
{
HttpClientInitializer = credential,
ApplicationName = "Blogger API Sample",
});
return service;
}
catch (Exception ex)
{
Console.WriteLine(ex.InnerException);
return null;
}
}
/// <summary>
/// Gets one comment by id.
/// Documentation https://developers.google.com/blogger/v2/reference/comments/get
/// Generation Note: This does not always build corectly. Google needs to standardise things I need to figuer out which ones are wrong.
/// </summary>
/// <param name="service">Authenticated Blogger service.</param>
/// <param name="blogId">ID of the blog to containing the comment.</param>
/// <param name="postId">ID of the post to fetch posts from.</param>
/// <param name="commentId">The ID of the comment to get.</param>
/// <returns>CommentResponse</returns>
public static Comment Get(BloggerService service, string blogId, string postId, string commentId)
{
try
{
// Initial validation.
if (service == null)
{
throw new ArgumentNullException("service");
}
if (blogId == null)
{
throw new ArgumentNullException(blogId);
}
if (postId == null)
{
throw new ArgumentNullException(postId);
}
if (commentId == null)
{
throw new ArgumentNullException(commentId);
}
// Make the request.
return(service.Comments.Get(blogId, postId, commentId).Execute());
}
catch (Exception ex)
{
throw new Exception("Request Comments.Get failed.", ex);
}
}
/// <summary>
/// Retrieves a list of blogs, possibly filtered.
/// Documentation https://developers.google.com/blogger/v3/reference/blogs/listByUser
/// Generation Note: This does not always build corectly. Google needs to standardise things I need to figuer out which ones are wrong.
/// </summary>
/// <param name="service">Authenticated Blogger service.</param>
/// <param name="userId">ID of the user whose blogs are to be fetched. Either the word 'self' (sans quote marks) or the user's profile identifier.</param>
/// <param name="optional">Optional paramaters.</param>
/// <returns>BlogListResponse</returns>
public static BlogList ListByUser(BloggerService service, string userId, BlogsListByUserOptionalParms optional = null)
{
try
{
// Initial validation.
if (service == null)
{
throw new ArgumentNullException("service");
}
if (userId == null)
{
throw new ArgumentNullException(userId);
}
// Building the initial request.
var request = service.Blogs.ListByUser(userId);
// Applying optional parameters to the request.
request = (BlogsResource.ListByUserRequest)SampleHelpers.ApplyOptionalParms(request, optional);
// Requesting data.
return(request.Execute());
}
catch (Exception ex)
{
throw new Exception("Request Blogs.ListByUser failed.", ex);
}
}
/// <summary>
/// Revert a published or scheduled page to draft state.
/// Documentation https://developers.google.com/blogger/v3/reference/pages/revert
/// Generation Note: This does not always build corectly. Google needs to standardise things I need to figuer out which ones are wrong.
/// </summary>
/// <param name="service">Authenticated Blogger service.</param>
/// <param name="blogId">The ID of the blog.</param>
/// <param name="pageId">The ID of the page.</param>
/// <returns>PageResponse</returns>
public static Page Revert(BloggerService service, string blogId, string pageId)
{
try
{
// Initial validation.
if (service == null)
{
throw new ArgumentNullException("service");
}
if (blogId == null)
{
throw new ArgumentNullException(blogId);
}
if (pageId == null)
{
throw new ArgumentNullException(pageId);
}
// Make the request.
return(service.Pages.Revert(blogId, pageId).Execute());
}
catch (Exception ex)
{
throw new Exception("Request Pages.Revert failed.", ex);
}
}
public void BloggerVersion2Test()
{
Tracing.TraceMsg("Entering BloggerVersion2Test");
BloggerQuery query = new BloggerQuery();
BloggerService service = new BloggerService(this.ApplicationName);
string title = "V1" + Guid.NewGuid().ToString();
service.ProtocolMajor = 1;
service.RequestFactory = this.factory;
query.Uri = new Uri(this.bloggerURI);
// insert a new entry in version 1
AtomEntry entry = ObjectModelHelper.CreateAtomEntry(1);
entry.Categories.Clear();
entry.Title.Text = title;
entry.IsDraft = true;
entry.ProtocolMajor = 12;
AtomEntry returnedEntry = service.Insert(new Uri(this.bloggerURI), entry);
Assert.IsTrue(returnedEntry.ProtocolMajor == service.ProtocolMajor);
Assert.IsTrue(entry.IsDraft);
Assert.IsTrue(returnedEntry.IsDraft);
BloggerFeed feed = service.Query(query);
Assert.IsTrue(feed.ProtocolMajor == service.ProtocolMajor);
if (feed != null)
{
Assert.IsTrue(feed.TotalResults >= feed.Entries.Count, "totalresults should be >= number of entries");
Assert.IsTrue(feed.Entries.Count > 0, "We should have some entries");
}
service.ProtocolMajor = 2;
feed = service.Query(query);
Assert.IsTrue(feed.ProtocolMajor == service.ProtocolMajor);
if (feed != null)
{
Assert.IsTrue(feed.Entries.Count > 0, "We should have some entries");
Assert.IsTrue(feed.TotalResults >= feed.Entries.Count, "totalresults should be >= number of entries");
foreach (BloggerEntry e in feed.Entries)
{
if (e.Title.Text == title)
{
Assert.IsTrue(e.ProtocolMajor == 2);
Assert.IsTrue(e.IsDraft);
}
}
}
}
public void ServiceOpen()
{
service = new BloggerService(new BaseClientService.Initializer()
{
HttpClientInitializer = credential,
ApplicationName = "Buddhika Blogger",
});
}
public void ServiceOpen()
{
service = new BloggerService(new BaseClientService.Initializer()
{
HttpClientInitializer = credential,
ApplicationName = "Buddhika Blogger",
});
}
public static Post getPost(BloggerService bs, string blogId, string postId)
{
PostsResource.GetRequest req = bs.Posts.Get(blogId, postId);
req.View = PostsResource.GetRequest.ViewEnum.ADMIN;
Post p = req.Execute();
return p;
}
public static BlogList getBlogs(BloggerService service, String userId)
{
BlogsResource.ListByUserRequest blogListByUserAction = service.Blogs.ListByUser("self");
BlogList list = blogListByUserAction.Fetch();
return(list);
}
public static BloggerService createService(UserCredential uc, string appName)
{
BloggerService bs = new BloggerService(new BaseClientService.Initializer
{
HttpClientInitializer = uc,
ApplicationName = appName
});
return bs;
}
private static BloggerService BloggerService(UserCredential credential)
{
var service = new BloggerService(new BaseClientService.Initializer()
{
HttpClientInitializer = credential,
ApplicationName = "Blogger Console App"
});
return(service);
}
public static BlogPerUserInfo getBlogUserInfo(BloggerService bs, string blogId)
{
if (bs == null)
{
return null;
}
BlogUserInfosResource.GetRequest req = bs.BlogUserInfos.Get("self", blogId);
BlogUserInfo bui = req.Execute();
return bui.BlogUserInfoValue;
}
/// <summary>
/// Retrieves a list of blogs
///
/// Documentation: https://developers.google.com/blogger/docs/3.0/reference/blogs/listByUser
/// </summary>
/// <param name="service">a Valid authenticated BloggerService</param>
/// <param name="user">The ID of the user whose blogs are to be fetched. Either the word self or the user's profile ID.</param>
/// <returns></returns>
public static BlogList listByUser(BloggerService service, string user)
{
try
{
BlogsResource.ListByUserRequest list = service.Blogs.ListByUser(user);
return(list.Execute());
}
catch (Exception ex) {
// In the event there is an error with the request.
Console.WriteLine(ex.Message);
}
return(null);
}
public static List<Pageviews.CountsData> getPageViews(BloggerService bs, string blogId, PageViewsResource.GetRequest.RangeEnum range)
{
if (bs == null || getBlogUserInfo(bs, blogId).HasAdminAccess != true)
{
return null;
}
PageViewsResource.GetRequest req = bs.PageViews.Get(blogId);
req.Range = range;
Pageviews pv = req.Execute();
return pv.Counts.ToList();
}
/// <summary>
/// Retrieves a list of blogs
///
/// Documentation: https://developers.google.com/blogger/docs/3.0/reference/blogs/listByUser
/// </summary>
/// <param name="service">a Valid authenticated BloggerService</param>
/// <param name="user">The ID of the user whose blogs are to be fetched. Either the word self or the user's profile ID.</param>
/// <returns></returns>
public static BlogList listByUser(BloggerService service, string user)
{
try
{
BlogsResource.ListByUserRequest list = service.Blogs.ListByUser(user);
return list.Execute();
}
catch (Exception ex) {
// In the event there is an error with the request.
Console.WriteLine(ex.Message);
}
return null;
}
/// <summary>
/// Retrieves a blog by its ID.
///
/// Documentation: https://developers.google.com/blogger/docs/3.0/reference/blogs/get
/// </summary>
/// <param name="service">a Valid authenticated BloggerService</param>
/// <param name="id">The ID of the blog to get.</param>
/// <param name="maxPosts">Maximum number of posts to retrieve along with the blog. When this parameter is not specified, no posts will be returned as part of the blog resource.</param>
/// <returns></returns>
public static Blog GetFiles(BloggerService service, string id, long maxPosts)
{
try
{
BlogsResource.GetRequest list = service.Blogs.Get(id);
list.MaxPosts = maxPosts;
return list.Execute();
}
catch (Exception ex) {
// In the event there is an error with the request.
Console.WriteLine(ex.Message);
}
return null;
}
public static CommentList getComments(BloggerService service, BlogLink blogLink, String postId)
{
CommentsResource.ListRequest commentsListRequest = null;
try
{
commentsListRequest = new CommentsResource.ListRequest(service, blogLink.blogId, postId);
}
catch (Exception ex)
{
DAL.InsertAccessLog(blogLink.blogName, blogLink.userId, ex.ToString());
}
return(commentsListRequest.Fetch());
}
public static async Task AuthenticateAsync()
{
var credential = await GoogleWebAuthorizationBroker.AuthorizeAsync(
Application.GetResourceStream(new Uri("pack://application:,,,/client_id.json")).Stream,
new[] { BloggerService.Scope.BloggerReadonly },
"user",
CancellationToken.None);
Service = new BloggerService(new BaseClientService.Initializer
{
HttpClientInitializer = credential,
ApplicationName = "BloggerQuickViewer",
});
}
BloggerService GetService()
{
// Bloggerのインスタンスを取得
if (service == null)
{
var credential = GetCredential();
service = new BloggerService(new BaseClientService.Initializer()
{
HttpClientInitializer = credential,
ApplicationName = "Blogger Post"
});
}
return(service);
}
/// <summary>
/// Retrieves a blog by its ID.
///
/// Documentation: https://developers.google.com/blogger/docs/3.0/reference/blogs/get
/// </summary>
/// <param name="service">a Valid authenticated BloggerService</param>
/// <param name="id">The ID of the blog to get.</param>
/// <param name="maxPosts">Maximum number of posts to retrieve along with the blog. When this parameter is not specified, no posts will be returned as part of the blog resource.</param>
/// <returns></returns>
public static Blog GetFiles(BloggerService service, string id, long maxPosts)
{
try
{
BlogsResource.GetRequest list = service.Blogs.Get(id);
list.MaxPosts = maxPosts;
return(list.Execute());
}
catch (Exception ex) {
// In the event there is an error with the request.
Console.WriteLine(ex.Message);
}
return(null);
}
public void BloggerHTMLTest()
{
Tracing.TraceMsg("Entering BloggerHTMLTest");
FeedQuery query = new FeedQuery();
BloggerService service = new BloggerService(this.ApplicationName);
if (this.bloggerURI != null)
{
if (this.userName != null)
{
service.Credentials = new GDataCredentials(this.userName, this.passWord);
}
service.RequestFactory = this.factory;
query.Uri = new Uri(this.bloggerURI);
AtomFeed feed = service.Query(query);
String strTitle = "Dinner time" + Guid.NewGuid().ToString();
if (feed != null)
{
// get the first entry
String htmlContent = "<div><b>this is an html test text</b></div>";
AtomEntry entry = ObjectModelHelper.CreateAtomEntry(1);
entry.Categories.Clear();
entry.Title.Text = strTitle;
entry.Content.Type = "html";
entry.Content.Content = htmlContent;
AtomEntry newEntry = feed.Insert(entry);
Tracing.TraceMsg("Created blogger entry");
// try to get just that guy.....
FeedQuery singleQuery = new FeedQuery();
singleQuery.Uri = new Uri(newEntry.SelfUri.ToString());
AtomFeed newFeed = service.Query(singleQuery);
AtomEntry sameGuy = newFeed.Entries[0];
Assert.IsTrue(sameGuy.Title.Text.Equals(newEntry.Title.Text), "both titles should be identical");
Assert.IsTrue(sameGuy.Content.Type.Equals("html"));
String input = HttpUtility.HtmlDecode(htmlContent);
String output = HttpUtility.HtmlDecode(sameGuy.Content.Content);
Assert.IsTrue(input.Equals(output), "The input string should be equal the output string");
}
service.Credentials = null;
}
}
public static Post insertPost(BloggerService service, BlogLink blogLink, String content)
{
Post postContent = new Post();
postContent.Title = "#throughglass";
postContent.Content = content;
postContent.Labels = new List <String>()
{
"throughglass"
};
PostsResource prInsertAction = service.Posts;
return(prInsertAction.Insert(postContent, blogLink.blogId).Fetch());
}
private void InitializeClientService()
{
if (service == null)
{
ClientSecrets clientSecrets = Newtonsoft.Json.JsonConvert.DeserializeObject <ClientSecrets>(
File.ReadAllText("Assets/client_secrets.json"));
var initializer = new BaseClientService.Initializer()
{
ApplicationName = "TheFinePrint",
ApiKey = clientSecrets.ApiKey
};
service = new BloggerService(initializer);
}
}
public Article GetSingleArticleFromBlogByPath(string blogId, string blogDomain, string path)
{
Article article = null;
try
{
BloggerService service = new BloggerService(new Google.Apis.Services.BaseClientService.Initializer()
{
ApiKey = this.apiKey,
ApplicationName = this.applicationName
});
PostsResource.GetByPathRequest resource = service.Posts.GetByPath(blogId, path);
Post post = resource.Execute();
article = new Article();
article.Id = post.Id;
article.Title = post.Title;
if (post.Author != null)
{
article.AuthorData = GetAuthorFromJson(post.Author);
article.AuthorName = post.Author.DisplayName;
}
article.Content = post.Content;
article.CoverImage = post.Images != null && post.Images.Count > 0 ? post.Images[0].Url : null;
article.DatePublished = post.Published.HasValue ? post.Published.Value : DateTime.MinValue;
article.Domain = blogDomain;
article.GenerateNPartyArticleLink(blogDomain, "/Artigos/Ler/");
if (post.Labels != null && post.Labels.Count > 0)
{
article.Labels = new string[post.Labels.Count];
for (int i = 0; i < post.Labels.Count; i++)
{
article.Labels[i] = post.Labels[i];
}
}
}
catch (Exception e)
{
}
return(article);
}
public void Authenticate()
{
// here is where we Request the user to give us access, or use the Refresh Token that was previously stored in %AppData%
credential = GoogleWebAuthorizationBroker.AuthorizeAsync(new ClientSecrets
{
ClientId = clientId,
ClientSecret = clientSecret
}, scopes, userName, CancellationToken.None).Result;
var initializer = new BaseClientService.Initializer()
{
HttpClientInitializer = credential,
ApplicationName = "BloggerApp",
};
service = new BloggerService(initializer);
}
//
// GET: /ESports/EVO/
public ActionResult Index(int?page)
{
string apiKey = System.Configuration.ConfigurationManager.AppSettings["ESportsBloggerApiKey"];
string appName = System.Configuration.ConfigurationManager.AppSettings["ESportsGoogleAppName"];
BloggerService service = new BloggerService(new Google.Apis.Services.BaseClientService.Initializer()
{
ApiKey = apiKey,
ApplicationName = appName
});
ArticlesHelper helper = new ArticlesHelper(apiKey, appName, service);
List <Article> generalArticles = helper.GetArticlesFromBlog(ESportsBlogId, "ESports", 100, 1, "EVO 2016", "/Artigos/Ler/");
ViewData["articles"] = generalArticles;
return(View());
}
public static Post updatePostTitle(BloggerService service, BlogLink blogLink, PostManager postManager, String content)
{
Post patchContent = new Post();
patchContent.Title = content;
patchContent.Content = postManager.postContent;
patchContent.Id = postManager.postId;
patchContent.Labels = new List <String>()
{
"throughglass"
};
PostsResource.PatchRequest prPatchRequest = service.Posts.Patch(patchContent, blogLink.blogId, postManager.postId);
return(prPatchRequest.Fetch());
}
private async Task AuthenticateAsync()
{
if (service != null)
return;
credential = await GoogleWebAuthorizationBroker.AuthorizeAsync(
new Uri("ms-appx:///Assets/client_secrets.json"),
new[] { BloggerService.Scope.BloggerReadonly },
"user",
CancellationToken.None);
var initializer = new BaseClientService.Initializer()
{
HttpClientInitializer = credential,
ApplicationName = "BloggerApp",
};
service = new BloggerService(initializer);
}
private async Task AuthenticateAsync()
{
if (service != null)
{
return;
}
credential = await GoogleWebAuthorizationBroker.AuthorizeAsync(
new Uri("ms-appx:///Assets/client_secrets.json"),
new[] { BloggerService.Scope.BloggerReadonly },
"user",
CancellationToken.None);
var initializer = new BaseClientService.Initializer()
{
HttpClientInitializer = credential,
ApplicationName = "BloggerApp",
};
service = new BloggerService(initializer);
}
private static void InsertPost(BloggerService service, string title, string blogId, List <string> labels, string content)
{
//WebClient wc = new WebClient();
//byte[] bytes = wc.DownloadData(@"C:\Users\v-santt\Desktop\1.jpg");
//Post.ImagesData image = new Post.ImagesData();
//var url = System.Web.HttpUtility.UrlEncode("https://1.bp.blogspot.com/-kqFVZAmU6nE/XseAVmNjpZI/AAAAAAABUyA/wEnCVeLOfJ8hT_KUPPrghoDy3JV5u3swwCK4BGAsYHg/MV5BYjljZGFjNzktZjJlZC00ODkxLWExZGUtYjhmOWMxNGU1YTljXkEyXkFqcGdeQXVyNDc2NzU1MTA%2540._V1_QL50_SY1000_CR0%252C0%252C756%252C1000_AL_.jpg");
//image.Url = url;
//List<Post.ImagesData> images = new List<Post.ImagesData>();
//// images.Add(url);
////images.Add((Post.ImagesData)image.Url);
//images.Add(image);
var insertRequest = service.Posts.Insert(new Post()
{
Title = title,
Content = content,
Labels = labels,
}, blogId: blogId);;
insertRequest.Execute();
}
public void Login()
{
_ucUser = BloggerHelper.createCredential(_csAppSec, _fdsStore);
_bsBlogger = BloggerHelper.createService(_ucUser, _strAppName);
}
public async Task GetDataBlogZaSeriozniHora(string pageToken, Action<PageModel, Exception> callback)
{
string uri = "http://blogzaserioznihora.blogspot.com/";
Exception err = null;
var result = new PageModel();
try
{
BloggerService _service = new BloggerService(new BaseClientService.Initializer()
{
ApiKey = "AIzaSyCkyf5p4x_2tW-Bwmqt7Bbj-HhFIC_kXvw",
});
SiteModel site = Sites.FirstOrDefault(x => x.Title == "Блог за сериозни хора");
if (site == null)
{
var blog = await _service.Blogs.GetByUrl(uri).ExecuteAsync();
site = new SiteModel()
{
Title = "Блог за сериозни хора",
Id = blog.Id
};
//group.ImagePath = blog.
Sites.Add(site);
}
PageModel page = site.Pages.FirstOrDefault(x => x.CurrentPageToken == pageToken);
if (page != null)
{
result = page;
}
else
{
var getPosts = _service.Posts.List(site.Id);
getPosts.MaxResults = 8;
if (!string.IsNullOrEmpty(pageToken))
{
getPosts.PageToken = pageToken;
result.CurrentPageToken = pageToken;
}
var response = await getPosts.ExecuteAsync();
result.NextPageToken = response.NextPageToken;
result.PrevPageToken = response.PrevPageToken;
result.PageIndex = site.Pages.Count;
foreach (var item in response.Items)
{
var itemModel = new ItemModel()
{
Id = item.Id,
Title = item.Title,
OriginalItem = item,
//Parent = result,
OriginalUrl = item.Url,
CommentUrl = "http://www.blogger.com/comment.g?blogID=" + site.Id + "&postID="+ item.Id +"&isPopup=true"
};
var document = new HtmlDocument();
document.LoadHtml(WebContentHelper.WrapHtml(item.Content, 0, 0));
itemModel.Content = RefactorContent(document);
var img = document.DocumentNode.Descendants().FirstOrDefault(doc => doc.Name == "img" &&
(doc.Attributes["src"].Value.EndsWith(".jpg") || doc.Attributes["src"].Value.EndsWith(".gif") || doc.Attributes["src"].Value.EndsWith(".png")));
if (img != null)
{
itemModel.ImagePath = img.Attributes["src"].Value;
}
AddItemToTiles(itemModel);
result.Items.Add(itemModel);
if (string.IsNullOrEmpty(pageToken))
{
site.Items.Add(itemModel);
}
}
site.Pages.Add(result);
}
}
catch (Exception ex)
{
err = ex;
}
callback(result, err);
}
public void Login()
{
//Timeout
new Thread(delegate()
{
Thread.Sleep(30000);
if (_ucUser == null)
{
throw new Exception("Authorization timeout 30s");
}
}) { IsBackground = true }.Start();
_ucUser = GoogleWebAuthorizationBroker.AuthorizeAsync(
_csAppSec,
new[] { BloggerService.Scope.Blogger },
"user",
CancellationToken.None,
_fdsToken
).Result;
_bsBlog = new BloggerService(new BaseClientService.Initializer()
{
HttpClientInitializer = _ucUser,
ApplicationName = "Blogger Manager"
});
}
public static List<Blog> listAllBlogs(BloggerService bs)
{
if (bs == null)
{
return null;
}
BlogsResource.ListByUserRequest req = bs.Blogs.ListByUser("self");
BlogList bl = req.Execute();
return bl.Items.ToList();
}
public void Logout()
{
_ucUser = null;
_bsBlog = null;
_blBlogs = null;
_fdsToken.ClearAsync();
}
public void Logout()
{
_ucUser = null;
_bsBlogger = null;
_fdsStore.ClearAsync();
}