/** Lists the user's blogs and returns the URI for posting new entries * to the blog which the user selected. */ static Uri SelectUserBlog(Service service) { Console.WriteLine("\nPlease select a blog on which to post."); FeedQuery query = new FeedQuery(); // Retrieving a list of blogs query.Uri = new Uri("http://www.blogger.com/feeds/default/blogs"); AtomFeed feed = service.Query(query); // Publishing a blog post Uri blogPostUri = null; if (feed != null) { foreach (AtomEntry entry in feed.Entries) { // Print out the title of the Blog Console.WriteLine(" Blog name: " + entry.Title.Text); Console.Write(" Post to this blog? (y/n): "); if (Console.ReadLine().Equals("y")) { // find the href in the link with a rel pointing to the blog's feed for (int i = 0; i < entry.Links.Count; i++) { if (entry.Links[i].Rel.Equals("http://schemas.google.com/g/2005#post")) { blogPostUri = new Uri(entry.Links[i].HRef.ToString()); Console.WriteLine(" Your new posts will be sent to " + blogPostUri.AbsoluteUri.ToString()); } } return blogPostUri; } } } return blogPostUri; }
static void Main(string[] args) { Console.WriteLine("Suchwort:"); string searchTerm = Console.ReadLine(); string uriSearchTerm = HttpUtility.UrlEncode(searchTerm); string url = "http://gdata.youtube.com/feeds/videos?q=" + uriSearchTerm; Console.WriteLine("Connection to YouTube - Searching: " + searchTerm); FeedQuery query = new FeedQuery(""); Service service = new Service("youtube", "sample"); query.Uri = new Uri(url); query.StartIndex = 0; query.NumberToRetrieve = 20; AtomFeed resultFeed = service.Query(query); foreach (AtomEntry entry in resultFeed.Entries) { Console.WriteLine("Title: " + entry.Title.Text); Console.WriteLine("Link: " + entry.AlternateUri.Content); Console.WriteLine("Tags:"); foreach (AtomCategory cat in entry.Categories) { Console.Write(cat.Term + ", "); } Console.WriteLine(); } Console.ReadLine(); }
public AtomFeed GetGoogleCalendar() { Service service = new Service(); FeedQuery query = new FeedQuery(); query.Uri = new Uri(publicCalendarUrl); return service.Query(query); }
private static String GetFeedUriFromQuery(BlogDescriptor blogDescriptor) { var query = new gClient.FeedQuery(blogDescriptor.Address); var service = new gClient.Service("blogger", GoogleSucks.GetApplicationName()) { Credentials = new gClient.GDataCredentials(blogDescriptor.Username, blogDescriptor.Password) }; var bloggerFeed = service.Query(query); var feeds = new List <gClient.AtomEntry>(); while (bloggerFeed != null && bloggerFeed.Entries.Count > 0) { foreach (gClient.AtomEntry entry in bloggerFeed.Entries) { feeds.Add(entry); } if (bloggerFeed.NextChunk != null) { query.Uri = new Uri(bloggerFeed.NextChunk); bloggerFeed = service.Query(query); } else { bloggerFeed = null; } } foreach (gClient.AtomEntry entry in feeds) { if (entry != null) { foreach (gClient.AtomLink link in entry.Links) { if (link.Rel == gClient.BaseNameTable.ServiceFeed) { return(link.HRef.ToString()); } } } } return(null); }
private static IList <BlogEntryDescriptor> GetBlogEntries(BlogDescriptor blogDescriptor, String feedUri) { IList <BlogEntryDescriptor> result = new List <BlogEntryDescriptor>(); if (feedUri != null) { var query = new gClient.FeedQuery(feedUri); var service = new gClient.Service("blogger", GoogleSucks.GetApplicationName()) { Credentials = new gClient.GDataCredentials(blogDescriptor.Username, blogDescriptor.Password) }; var bloggerFeed = service.Query(query); while (bloggerFeed != null && bloggerFeed.Entries.Count > 0) { foreach (gClient.AtomEntry entry in bloggerFeed.Entries) { result.Add( new BlogEntryDescriptor() { Content = entry.Content.Content, Subject = entry.Title.Text, Sender = entry.Authors[0].Name, Date = entry.Published }); } if (bloggerFeed.NextChunk != null) { query.Uri = new Uri(bloggerFeed.NextChunk); bloggerFeed = service.Query(query); } else { bloggerFeed = null; } } } return(result); }
/** Lists the user's blogs. */ static void ListUserBlogs(Service service) { Console.WriteLine("\nRetrieving a list of blogs"); FeedQuery query = new FeedQuery(); // Retrieving a list of blogs query.Uri = new Uri("http://www.blogger.com/feeds/default/blogs"); AtomFeed feed = null; feed = service.Query(query); foreach (AtomEntry entry in feed.Entries) { Console.WriteLine(" Blog title: " + entry.Title.Text); } }
public static AtomFeed GetFeed(string url = "", int start = 0, int num_results = 0) { FeedQuery query = new FeedQuery(""); Google.GData.Client.Service service = new Google.GData.Client.Service(); query.Uri = new Uri(url); if (start > 0) { query.StartIndex = start; } if (num_results > 0) { query.NumberToRetrieve = num_results; } AtomFeed feed = service.Query(query); return feed; }
////////////////////////////////////////////////////////////////////// /// <summary>deletes all entries in defhost feed</summary> ////////////////////////////////////////////////////////////////////// [Test] public void DefaultHostDeleteAll() { Tracing.TraceMsg("Entering DefaultHostDeleteAll"); FeedQuery query = new FeedQuery(); Service service = new Service(); service.RequestFactory = this.factory; query.Uri = new Uri(this.defaultHost); AtomFeed returnFeed = service.Query(query); foreach (AtomEntry entry in returnFeed.Entries ) { entry.Delete(); } }
[Test] public void CalendarXHTMLTest() { Tracing.TraceMsg("Entering CalendarXHTMLTest"); FeedQuery query = new FeedQuery(); Service service = new Service(); if (this.defaultCalendarUri != null) { if (this.userName != null) { service.Credentials = new GDataCredentials(this.userName, this.passWord); } service.RequestFactory = this.factory; query.Uri = new Uri(this.defaultCalendarUri); AtomFeed calFeed = service.Query(query); String strTitle = "Dinner time" + Guid.NewGuid().ToString(); if (calFeed != null) { // get the first entry Tracing.TraceMsg("Created calendar entry"); String xhtmlContent = "<div><b>this is an xhtml test text</b></div>"; AtomEntry entry = ObjectModelHelper.CreateAtomEntry(1); Tracing.TraceMsg("Created calendar entry"); entry.Title.Text = strTitle; entry.Content.Type = "xhtml"; Tracing.TraceMsg("Created calendar entry"); entry.Content.Content = xhtmlContent; AtomEntry newEntry = calFeed.Insert(entry); Tracing.TraceMsg("Created calendar 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("xhtml")); Assert.IsTrue(sameGuy.Content.Content.Equals(xhtmlContent)); } service.Credentials = null; } }
///////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////// /// <summary>runs an authentication test</summary> ////////////////////////////////////////////////////////////////////// [Test] public void GoogleAuthenticationTest() { Tracing.TraceMsg("Entering GoogleAuthenticationTest"); FeedQuery query = new FeedQuery(); Service service = new Service(); int iCount; if (this.defaultCalendarUri != null) { if (this.userName != null) { service.Credentials = new GDataCredentials(this.userName, this.passWord); } service.RequestFactory = this.factory; query.Uri = new Uri(this.defaultCalendarUri); AtomFeed calFeed = service.Query(query); ObjectModelHelper.DumpAtomObject(calFeed,CreateDumpFileName("AuthenticationTest")); iCount = calFeed.Entries.Count; String strTitle = "Dinner time" + Guid.NewGuid().ToString(); if (calFeed != null && calFeed.Entries.Count > 0) { // get the first entry AtomEntry entry = calFeed.Entries[0]; entry = ObjectModelHelper.CreateAtomEntry(1); entry.Title.Text = strTitle; AtomEntry newEntry = calFeed.Insert(entry); iCount++; Tracing.TraceMsg("Created calendar 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"); } calFeed = service.Query(query); Assert.AreEqual(iCount, calFeed.Entries.Count, "Feed should have one more entry, it has: " + calFeed.Entries.Count); if (calFeed != null && calFeed.Entries.Count > 0) { // look for the one with dinner time... foreach (AtomEntry entry in calFeed.Entries) { Tracing.TraceMsg("Entrie title: " + entry.Title.Text); if (String.Compare(entry.Title.Text, strTitle)==0) { entry.Content.Content = "Maybe stay until breakfast"; entry.Update(); Tracing.TraceMsg("Updated entry"); } } } calFeed = service.Query(query); Assert.AreEqual(iCount, calFeed.Entries.Count, "Feed should have one more entry, it has: " + calFeed.Entries.Count); if (calFeed != null && calFeed.Entries.Count > 0) { // look for the one with dinner time... foreach (AtomEntry entry in calFeed.Entries) { Tracing.TraceMsg("Entrie title: " + entry.Title.Text); if (String.Compare(entry.Title.Text, strTitle)==0) { entry.Delete(); iCount--; Tracing.TraceMsg("deleted entry"); } } } calFeed = service.Query(query); Assert.AreEqual(iCount, calFeed.Entries.Count, "Feed should have the same count again, it has: " + calFeed.Entries.Count); service.Credentials = null; } }
[Test] public void CalendarStressTest() { Tracing.TraceMsg("Entering CalendarStressTest"); FeedQuery query = new FeedQuery(); Service service = new Service(); if (this.defaultCalendarUri != null) { if (this.userName != null) { service.Credentials = new GDataCredentials(this.userName, this.passWord); } service.RequestFactory = this.factory; query.Uri = new Uri(this.defaultCalendarUri); AtomFeed calFeed = service.Query(query); if (calFeed != null) { for (int i = 0; i<127; i++) { AtomEntry entry = ObjectModelHelper.CreateAtomEntry(1); entry.Title.Text = "Entry number: " + i; calFeed.Insert(entry); } } calFeed = service.Query(query); int iCount = 0; while (calFeed != null && calFeed.Entries.Count > 0) { iCount += calFeed.Entries.Count; // just query the same query again. if (calFeed.NextChunk != null) { query.Uri = new Uri(calFeed.NextChunk); calFeed = service.Query(query); } else { calFeed = null; } } Assert.AreEqual(127, iCount, "Feed should have 127 entries, it has: " + iCount); service.Credentials = null; } }
/** Get the comments feed URI for the desired blog entry. */ static Uri SelectBlogEntry(Service service, Uri blogPostUri) { Console.WriteLine("\nPlease select a blog entry on which to comment."); FeedQuery query = new FeedQuery(); query.Uri = blogPostUri; AtomFeed feed = service.Query(query); Uri commentPostUri = null; if (feed != null) { foreach (AtomEntry entry in feed.Entries) { // Print out the title of the Blog Console.WriteLine(" Blog entry title: " + entry.Title.Text); Console.Write(" Post a comment on this entry? (y/n): "); if (Console.ReadLine().Equals("y")) { // Create the Post URL for adding a comment by finding this entry's id number. // Find the href in the link with a rel pointing to the blog's feed. for (int i = 0; i < entry.Links.Count; i++) { if (entry.Links[i].Rel == "edit") { string commentUriStart = Regex.Replace(blogPostUri.ToString(), "/posts/default", ""); string selfLink = entry.Links[i].HRef.ToString(); string entryId = Regex.Replace(selfLink, blogPostUri.ToString() + "/", ""); // Build the comment URI from the blog id in and the entry id. commentPostUri = new Uri(commentUriStart + "/" + entryId + "/comments/default"); Console.WriteLine(" Your new comments will be sent to " + commentPostUri.ToString()); return commentPostUri; } } } } } return commentPostUri; }
///////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////// /// <summary>creates X rows and updates it</summary> ////////////////////////////////////////////////////////////////////// [Test] public void DefaultHostMassiveInsertAndUpdate() { Tracing.TraceMsg("Entering DefaultHostMassiveInsertAndUpdate"); int iCount=0; FeedQuery query = new FeedQuery(); Service service = new Service(); service.RequestFactory = this.factory; query.Uri = new Uri(this.defaultHost); AtomFeed returnFeed = service.Query(query); AtomEntry entry; iCount = returnFeed.Entries.Count; // now we have all we need. int z = 0; for (int i = 0; i < this.iIterations; i++) { z++; if (z > 500) { z = 0; // do a requery every hundreth to see mem usage Tracing.TraceMsg("Query at point: " + i); returnFeed = service.Query(query); } Tracing.TraceMsg("Inserting entry: " + i); entry = ObjectModelHelper.CreateAtomEntry(i); entry = returnFeed.Insert(entry); entry.Content.Content = "Updated entry: " + Guid.NewGuid().ToString(); entry.Update(); } // now query the guy again. returnFeed = service.Query(query); Assert.AreEqual(iCount+this.iIterations, returnFeed.Entries.Count, "feed should have " + this.iIterations + " more entries now"); Tracing.TraceMsg("Exiting DefaultHostMassiveInsertAndUpdate"); }
///////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////// /// <summary>creates a number or rows </summary> ////////////////////////////////////////////////////////////////////// [Test] public void DefaultHostInsertAndStay() { Tracing.TraceMsg("Entering DefaultHostInsertAndStay"); int iCount=0; FeedQuery query = new FeedQuery(); Service service = new Service(); service.RequestFactory = this.factory; query.Uri = new Uri(this.defaultHost); AtomFeed returnFeed = service.Query(query); AtomEntry entry; iCount = returnFeed.Entries.Count; // now we have all we need. for (int i = 0; i < this.iIterations; i++) { Tracing.TraceMsg("DefaultHostInsertAndStay: inserting entry #: " + i); entry = ObjectModelHelper.CreateAtomEntry(i); entry = returnFeed.Insert(entry); } Tracing.TraceMsg("DefaultHostInsertAndStay: inserted lot's of entries"); // done doing the inserts... // now query the guy again. returnFeed = service.Query(query); Assert.AreEqual(iCount+this.iIterations, returnFeed.Entries.Count, "feed should have " + this.iIterations + " more entries now"); }
static void Main(string[] args) { if (args.Length < 5) { Console.WriteLine("Not enough parameters. Usage is ExecRequest <service> <cmd> <uri> <username> <password>, where cmd is QUERY, UPDATE, INSERT, DELETE"); Console.WriteLine("or"); Console.WriteLine("ExecRequest <service> <cmd> <uri> /a <authsubtoken> - to use a session token"); Console.WriteLine("or"); Console.WriteLine("ExecRequest <service> <cmd> <uri> /e <authsubtoken> - to exchance a one time token for a session token"); return; } string s = args[0]; string cmd = args[1]; string targetUri = args[2]; string userName = args[3]; string passWord = args[4]; Service service = new Service(s, ApplicationName); if (userName.Equals("/a")) { Console.WriteLine("Using AuthSubToken: " + passWord); // password should contain the authsubtoken GAuthSubRequestFactory factory = new GAuthSubRequestFactory(s, ApplicationName); factory.Token = passWord; service.RequestFactory = factory; } else if (userName.Equals("/e")) { Console.WriteLine("Using Onetime token: " + passWord); passWord = AuthSubUtil.exchangeForSessionToken(passWord, null); Console.WriteLine("Exchanged for Session Token: " + passWord); // password should contain the authsubtoken GAuthSubRequestFactory factory = new GAuthSubRequestFactory(s, ApplicationName); factory.Token = passWord; service.RequestFactory = factory; } else { Console.WriteLine("Setting user credentials for: " + userName); service.setUserCredentials(userName, passWord); } try { if (cmd.Equals("QUERY")) { Console.WriteLine("Querying: " + targetUri); Stream result = service.Query(new Uri(targetUri)); DumpStream(result); } if (cmd.Equals("DELETE")) { service.Delete(new Uri(targetUri)); Console.WriteLine("successfully deleted: " + targetUri); } if (cmd.Equals("POST")) { String input = Console.In.ReadToEnd(); Console.Write(input); Stream result = service.StringSend(new Uri(targetUri), input, GDataRequestType.Insert); DumpStream(result); } if (cmd.Equals("UPDATE")) { String input = Console.In.ReadToEnd(); Console.Write(input); Stream result = service.StringSend(new Uri(targetUri), input, GDataRequestType.Update); DumpStream(result); } } catch (GDataRequestException e) { HttpWebResponse response = e.Response as HttpWebResponse; Console.WriteLine("Error executing request for Verb: " + cmd + ", Errorcode: " + response.StatusCode); Console.WriteLine(response.StatusDescription); Console.WriteLine(e.ResponseString); } }
///////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////// /// <summary>runs an authentication test</summary> ////////////////////////////////////////////////////////////////////// [Test] public void BloggerStressTest() { Tracing.TraceMsg("Entering Blogger GoogleStressTest"); FeedQuery query = new FeedQuery(); Service service = new Service(this.ServiceName, 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 blogFeed = service.Query(query); ObjectModelHelper.DumpAtomObject(blogFeed,CreateDumpFileName("AuthenticationTest")); if (blogFeed != null) { for (int i=0; i< 100; i++) { AtomEntry entry = ObjectModelHelper.CreateAtomEntry(i); entry.Categories.Clear(); entry.Title.Text = "Title " + i; entry.Content.Content = "Some text..."; entry.Content.Type = "html"; blogFeed.Insert(entry); } } } }
///////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////// /// <summary>tests if we can access a public feed</summary> ////////////////////////////////////////////////////////////////////// [Test] public void BloggerPublicFeedTest() { Tracing.TraceMsg("Entering BloggerPublicFeedTest"); FeedQuery query = new FeedQuery(); Service service = new Service(this.ServiceName, 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"); } } } }
///////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////// /// <summary>checks for xhtml persistence</summary> ////////////////////////////////////////////////////////////////////// [Test] public void BloggerHTMLTest() { Tracing.TraceMsg("Entering BloggerHTMLTest"); FeedQuery query = new FeedQuery(); Service service = new Service(this.ServiceName, this.ApplicationName); if (this.bloggerURI != null) { if (this.userName != null) { service.Credentials = new GDataCredentials(this.userName, this.passWord); } GDataLoggingRequestFactory factory = (GDataLoggingRequestFactory) this.factory; factory.MethodOverride = true; service.RequestFactory = this.factory; query.Uri = new Uri(this.bloggerURI); AtomFeed calFeed = service.Query(query); String strTitle = "Dinner time" + Guid.NewGuid().ToString(); if (calFeed != 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 = calFeed.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; factory.MethodOverride = false; } }
////////////////////////////////////////////////////////////////////// /// <summary>runs an authentication test</summary> ////////////////////////////////////////////////////////////////////// [Test] public void GoogleAuthenticationTest() { Tracing.TraceMsg("Entering Blogger AuthenticationTest"); FeedQuery query = new FeedQuery(); Service service = new Service(this.ServiceName, this.ApplicationName); int iCount; 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 blogFeed = service.Query(query); ObjectModelHelper.DumpAtomObject(blogFeed,CreateDumpFileName("AuthenticationTest")); iCount = blogFeed.Entries.Count; String strTitle = "Dinner time" + Guid.NewGuid().ToString(); if (blogFeed != null && blogFeed.Entries.Count > 0) { // get the first entry AtomEntry entry = blogFeed.Entries[0]; entry = ObjectModelHelper.CreateAtomEntry(1); // blogger does not like labels yet. entry.Categories.Clear(); entry.Title.Text = strTitle; entry.Categories.Clear(); entry.IsDraft = true; entry.Updated = Utilities.EmptyDate; entry.Published = Utilities.EmptyDate; AtomEntry newEntry = blogFeed.Insert(entry); iCount++; 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]; Tracing.TraceMsg("retrieved blogger entry"); Assert.IsTrue(sameGuy.Title.Text.Equals(newEntry.Title.Text), "both titles should be identical"); Assert.IsTrue(sameGuy.IsDraft == true); } blogFeed = service.Query(query); Assert.AreEqual(iCount, blogFeed.Entries.Count, "Feed should have one more entry, it has: " + blogFeed.Entries.Count); if (blogFeed != null && blogFeed.Entries.Count > 0) { // look for the one with dinner time... foreach (AtomEntry entry in blogFeed.Entries) { Tracing.TraceMsg("Entrie title: " + entry.Title.Text); if (String.Compare(entry.Title.Text, strTitle)==0) { entry.Content.Content = "Maybe stay until breakfast"; entry.Content.Type = "text"; entry.Update(); Tracing.TraceMsg("Updated entry"); } } } blogFeed = service.Query(query); Assert.AreEqual(iCount, blogFeed.Entries.Count, "Feed should have one more entry, it has: " + blogFeed.Entries.Count); if (blogFeed != null && blogFeed.Entries.Count > 0) { // look for the one with dinner time... foreach (AtomEntry entry in blogFeed.Entries) { Tracing.TraceMsg("Entrie title: " + entry.Title.Text); if (String.Compare(entry.Title.Text, strTitle)==0) { entry.Delete(); iCount--; Tracing.TraceMsg("deleted entry"); } } } blogFeed = service.Query(query); Assert.AreEqual(iCount, blogFeed.Entries.Count, "Feed should have the same count again, it has: " + blogFeed.Entries.Count); service.Credentials = null; } }
private static IList<BlogEntryDescriptor> GetBlogEntries(BlogDescriptor blogDescriptor, String feedUri) { IList<BlogEntryDescriptor> result = new List<BlogEntryDescriptor>(); if (feedUri != null) { var query = new gClient.FeedQuery(feedUri); var service = new gClient.Service("blogger", GoogleSucks.GetApplicationName()) { Credentials = new gClient.GDataCredentials(blogDescriptor.Username, blogDescriptor.Password) }; var bloggerFeed = service.Query(query); while (bloggerFeed != null && bloggerFeed.Entries.Count > 0) { foreach (gClient.AtomEntry entry in bloggerFeed.Entries) { result.Add( new BlogEntryDescriptor() { Content = entry.Content.Content, Subject = entry.Title.Text, Sender = entry.Authors[0].Name, Date = entry.Published }); } if (bloggerFeed.NextChunk != null) { query.Uri = new Uri(bloggerFeed.NextChunk); bloggerFeed = service.Query(query); } else { bloggerFeed = null; } } } return result; }
private static String GetFeedUriFromQuery(BlogDescriptor blogDescriptor) { var query = new gClient.FeedQuery(blogDescriptor.Address); var service = new gClient.Service("blogger", GoogleSucks.GetApplicationName()) { Credentials = new gClient.GDataCredentials(blogDescriptor.Username, blogDescriptor.Password) }; var bloggerFeed = service.Query(query); var feeds = new List<gClient.AtomEntry>(); while (bloggerFeed != null && bloggerFeed.Entries.Count > 0) { foreach (gClient.AtomEntry entry in bloggerFeed.Entries) feeds.Add(entry); if (bloggerFeed.NextChunk != null) { query.Uri = new Uri(bloggerFeed.NextChunk); bloggerFeed = service.Query(query); } else { bloggerFeed = null; } } foreach (gClient.AtomEntry entry in feeds) if (entry != null) foreach (gClient.AtomLink link in entry.Links) if (link.Rel == gClient.BaseNameTable.ServiceFeed) return link.HRef.ToString(); return null; }
/** * Forms an HTTP request and parses the response for a translation. * * @param text The string to translate. * @param from The language code to translate from. * @param to The language code to translate to. * @return The translated string. * @throws Exception */ private static string retrieveTranslation(string text, string from, string to) { if (!Language.isValidLanguage(from) || !Language.isValidLanguage(to) || Language.AUTO_DETECT == to) { throw new ArgumentException("You must use a valid language code to translate to and from."); } try { Uri RequestURL = new Uri(URL_STRING + from + "|" + to + TEXT_VAR + text); //URLEncoder.encode( text, ENCODING ) ); Service TranslationRequest = new Service("GoogleTranslateUnofficialAPI"); Stream result = TranslationRequest.Query(RequestURL); String page = ""; const int size = 4096; byte[] bytes = new byte[size]; int numBytes; while ((numBytes = result.Read(bytes, 0, size)) > 0) { page += System.Text.Encoding.UTF8.GetString(bytes, 0, numBytes); } //{\"responseData\": {\"translatedText\":\"tout va bien dans ma douleur, elle n\\u0026#39;est pas un salon de beaut??, salle de gravure, de cendre et de l\\u0026#39;ombre, voil?? le h??ros\"}, \"responseDetails\": null, \"responseStatus\": 200} int resultBox = page.IndexOf("\"translatedText\":\""); if (resultBox < 0) throw new Exception("No translation result returned."); String start = page.Substring(resultBox + 18); int nStart = start.IndexOf('\"'); return start.Substring(0, nStart); } catch (Exception ex) { throw new Exception("[Google.Unoffical.Translate] Error retrieving translation.", ex); } }
/// <summary> /// Lists the user's blogs and returns the URI for posting new entries to the blog which the user selected. /// </summary> /// <param name="service"></param> /// <returns></returns> private Uri SelectUserBlog(Service service) { FeedQuery query = new FeedQuery(); // Retrieving a list of blogs query.Uri = new Uri("http://www.blogger.com/feeds/default/blogs"); AtomFeed feed = service.Query(query); // Publishing a blog post Uri blogPostUri = null; if (feed != null) { foreach (AtomEntry entry in feed.Entries) { // find the href in the link with a rel pointing to the blog's feed for (int i = 0; i < entry.Links.Count; i++) { if (entry.Links[i].Rel.Equals("http://schemas.google.com/g/2005#post")) { blogPostUri = new Uri(entry.Links[i].HRef.ToString()); } } return blogPostUri; } } return blogPostUri; }
private static AtomFeed GetFeed(string url, int start, int number) { System.Diagnostics.Trace.Write("Conectando youtube at " + url); FeedQuery query = new FeedQuery(""); Service service = new Service("youtube", "exampleCo"); query.Uri = new Uri(url); query.StartIndex = start; query.NumberToRetrieve = number; AtomFeed myFeed = service.Query(query); return myFeed; }
///////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////// /// <summary>creates a number or rows and delets them again</summary> ////////////////////////////////////////////////////////////////////// [Test] public void DefaultHostMassiveInsertAndDelete() { Tracing.TraceMsg("Entering DefaultHostMassiveInsertAndDelete"); int iCount=0; FeedQuery query = new FeedQuery(); Service service = new Service(); service.RequestFactory = this.factory; query.Uri = new Uri(this.defaultHost); AtomFeed returnFeed = service.Query(query); AtomEntry entry; iCount = returnFeed.Entries.Count; AtomEntryCollection newEntries = new AtomEntryCollection(null); // now we have all we need. for (int i = 0; i < this.iIterations; i++) { entry = ObjectModelHelper.CreateAtomEntry(i); entry = returnFeed.Insert(entry); newEntries.Add(entry); } Tracing.TraceMsg("DefaultHostMassiveInsert: inserted lot's of entries"); // done doing the inserts... // now query the guy again. returnFeed = service.Query(query); Assert.AreEqual(iCount+this.iIterations, returnFeed.Entries.Count, "feed should have " + this.iIterations + " more entries now"); // now udpate the 100 entries we have added for (int i = 0; i < this.iIterations; i++) { entry = newEntries[i]; entry.Title.Text = Guid.NewGuid().ToString(); entry.Update(); } Tracing.TraceMsg("DefaultHostMassiveInsert: updated lot's of entries"); returnFeed = service.Query(query); Assert.AreEqual(iCount+this.iIterations, returnFeed.Entries.Count, "feed should have " + this.iIterations + " more entries now"); // let's find them and delete them... for (int i = 0; i < this.iIterations; i++) { entry = newEntries[i]; foreach (AtomEntry feedEntry in returnFeed.Entries ) { if (String.Compare(feedEntry.Title.Text, entry.Title.Text) == 0) { // got him Tracing.TraceMsg("trying to delete entry: " + feedEntry.Title.Text +" = " + entry.Title.Text); feedEntry.Delete(); break; } } } // and a last time returnFeed = service.Query(query); Assert.AreEqual(iCount, returnFeed.Entries.Count, "feed should have the same number again"); Tracing.TraceMsg("DefaultHostMassiveInsertAndDelete: deleted lot's of entries"); }
/** Display title for entries in the blog in the hard coded date range. */ static void ListBlogEntriesInDateRange(Service service, Uri blogUri) { Console.WriteLine("\nRetrieving posts using query parameters"); // Retrieve all posts in a blog between Jan 1, 2006 and Apr 12, 2007 FeedQuery query = new FeedQuery(); query.Uri = blogUri; query.MinPublication = new DateTime(2006, 1, 1); query.MaxPublication = new DateTime(2007, 4, 12); AtomFeed feed = service.Query(query); foreach (AtomEntry entry in feed.Entries) { Console.WriteLine(" Entry Title: " + entry.Title.Text); } }
///////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////// /// <summary>reads one external feed and inserts it locally</summary> ////////////////////////////////////////////////////////////////////// [Test] public void DefaultHostInsertExternalFeed() { Tracing.TraceMsg("Entering DefaultHostInsertExternalFeed"); if (this.strRemoteHost != null) { // remove old data DefaultHostDeleteAll(); FeedQuery query = new FeedQuery(); Service service = new Service(); service.RequestFactory = (IGDataRequestFactory) new GDataLoggingRequestFactory(this.ServiceName, this.ApplicationName); query.Uri = new Uri(this.strRemoteHost); AtomFeed remoteFeed = service.Query(query); query.Uri = new Uri(this.defaultHost); AtomFeed localFeed = service.Query(query); foreach (AtomEntry remoteEntry in remoteFeed.Entries) { localFeed.Entries.Add(remoteEntry); Tracing.TraceInfo("added: " + remoteEntry.Title.Text); } bool f; foreach (AtomEntry localEntry in localFeed.Entries) { f = localEntry.IsDirty(); Assert.AreEqual(true, f, "This entry better be dirty now"); } f = localFeed.IsDirty(); Assert.AreEqual(true, f, "This feed better be dirty now"); localFeed.Publish(); foreach (AtomEntry localEntry in localFeed.Entries) { f = localEntry.IsDirty(); Assert.AreEqual(false, f, "This entry better NOT be dirty now"); } f = localFeed.IsDirty(); Assert.AreEqual(false, f, "This feed better NOT be dirty now"); // requery localFeed = service.Query(query); foreach (AtomEntry localEntry in localFeed.Entries) { AtomSource source = localEntry.Source; Assert.AreEqual(source.Id.Uri.ToString(), remoteFeed.Id.Uri.ToString(), "This entry better has the same source ID than the remote feed"); } } }
[Test] public void CalendarCommentTest() { Tracing.TraceMsg("Entering CalendarCommentTest"); EventQuery query = new EventQuery(); CalendarService service = new CalendarService(this.ApplicationName); int iCount; if (this.defaultCalendarUri != null) { if (this.userName != null) { service.Credentials = new GDataCredentials(this.userName, this.passWord); } service.RequestFactory = this.factory; query.Uri = new Uri(this.defaultCalendarUri); EventFeed calFeed = service.Query(query) as EventFeed; iCount = calFeed.Entries.Count; String strTitle = "Comment Test" + Guid.NewGuid().ToString(); if (calFeed != null) { // insert a new entry EventEntry entry = ObjectModelHelper.CreateEventEntry(1); entry.Title.Text = strTitle; entry.Times[0].AllDay = true; calFeed.Insert(entry); iCount++; Tracing.TraceMsg("Created calendar entry"); } calFeed = service.Query(query) as EventFeed; Assert.AreEqual(iCount, calFeed.Entries.Count, "Feed should have one more entry, it has: " + calFeed.Entries.Count); if (calFeed != null && calFeed.Entries.Count > 0) { // look for the one with dinner time... foreach (EventEntry entry in calFeed.Entries) { Tracing.TraceMsg("Entrie title: " + entry.Title.Text); if (String.Compare(entry.Title.Text, strTitle)==0) { // get the comment feed Uri commentFeedUri = new Uri(entry.Comments.FeedLink.Href); // now we use an AtomFeed to post there Service feedService = new Service("cl", "UnitTests"); feedService.Credentials = new GDataCredentials(this.userName, this.passWord); query.Uri = commentFeedUri; AtomFeed commentFeed = feedService.Query(query); AtomEntry newEntry = ObjectModelHelper.CreateAtomEntry(1); Tracing.TraceMsg("trying to insert a comment"); try { commentFeed.Insert(newEntry); } catch (GDataRequestException e ) { Console.WriteLine(e.ResponseString); Tracing.TraceMsg(e.ResponseString); } } } } service.Credentials = null; } }
///////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////// /// <summary>[Test] creates a new entry, saves and loads it back</summary> ////////////////////////////////////////////////////////////////////// [Test] public void DefaultHostInsertOneAndDelete() { Tracing.TraceMsg("Entering DefaultHostInsertOneAndDelete"); AtomEntry entry = ObjectModelHelper.CreateAtomEntry(1); Service service = new Service(); FeedQuery query = new FeedQuery(); service.RequestFactory = this.factory; int iCount=0; string strTitle = "DefaultHostInsertOneAndDelete" + Guid.NewGuid().ToString(); entry.Title.Text = strTitle; query.Uri = new Uri(this.defaultHost); AtomFeed returnFeed = service.Query(query); iCount = returnFeed.Entries.Count; for (int i = 0; i < this.iIterations; i++) { Tracing.TraceMsg("DefaultHostInsertOneAndDelete, iteration : " + i); Stream s = service.EntrySend(new Uri(this.defaultHost), entry, GDataRequestType.Insert); s.Close(); returnFeed = service.Query(query); Assert.AreEqual(iCount+1, returnFeed.Entries.Count, "feed should have one more entry now"); AtomEntry returnEntry = null; foreach (AtomEntry feedEntry in returnFeed.Entries ) { if (String.Compare(feedEntry.Title.Text, strTitle) == 0) { // got him returnEntry = feedEntry; break; } } Assert.IsTrue(returnEntry != null, "did not find the just inserted entry"); returnEntry.Delete(); // query again and check count returnFeed = service.Query(query); Assert.AreEqual(iCount, returnFeed.Entries.Count, "feed has different number of entries as expected"); } }
static void ListEntryComments(Service service, Uri commentUri) { if (commentUri != null) { Console.WriteLine("\nRetrieving all blog post comments"); // Retrieve all comments on a blog entry FeedQuery query = new FeedQuery(); Console.WriteLine(" Query URI: " + commentUri.ToString()); query.Uri = commentUri; AtomFeed feed = service.Query(query); foreach (AtomEntry entry in feed.Entries) { Console.WriteLine(" Comment Title: " + entry.Title.Text); } } }
public void enumerateImages () { //FIXME make this configurable, it should at least flip between all albuns of the user String feed = "http://picasaweb.google.com/data/feed/api/user/kumpera/album/RandomPhotos?kind=photo"; FeedQuery query = new FeedQuery(); Service service = new Service("picasa", "MoonLight Desklets"); query.Uri = new Uri(feed); AtomFeed picasaFeed = service.Query(query); urls = new String [picasaFeed.Entries.Count]; int i=0; foreach (AtomEntry entry in picasaFeed.Entries) { urls[i++] = entry.Content.Src.Content; Console.WriteLine ("content: "+entry.Content.Src.Content); } Moonlight.Gtk.Desklet.Invoke(delegate { DownloadImage (0); }); }
////////////////////////////////////////////////////////////////////// /// <summary>empty a feed</summary> ////////////////////////////////////////////////////////////////////// protected void FeedCleanup(String uriToClean, String userName, String pwd, int protocolMajor) { Tracing.TraceCall(); Tracing.TraceCall("Cleaning URI: " + uriToClean); if (!this.wipeFeeds) { Tracing.TraceInfo("Skipped cleaning URI due to configuration."); return; } FeedQuery query = new FeedQuery(); Service service = new Service(); service.ProtocolMajor = protocolMajor; if (uriToClean != null) { if (userName != null) { service.Credentials = new GDataCredentials(userName, pwd); } service.RequestFactory = this.factory; query.Uri = new Uri(uriToClean); Tracing.TraceCall("Querying " + uriToClean); AtomFeed feed = service.Query(query); Tracing.TraceCall("Queryed " + uriToClean); if (feed != null) Tracing.TraceCall("Entries: " + feed.Entries.Count.ToString()); int iCount = 0; if (feed.Entries.Count > 0) { while (feed.Entries.Count > 0) { Tracing.TraceCall("Feed has still " + feed.Entries.Count.ToString() + " entries left."); foreach (AtomEntry entry in feed.Entries) { Tracing.TraceCall("Deleting entry " + iCount); entry.Delete(); iCount++; Tracing.TraceCall("Deleted entry " + iCount); } feed = service.Query(query); } Assert.AreEqual(0, feed.Entries.Count, "Feed should have no more entries, it has: " + feed.Entries.Count); service.Credentials = null; } } }