/** 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;
}
}
}
