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();
}
internal CellFeed fetch(string uri)
{
try {
// フィードアドレス設定
FeedQuery singleQuery = new FeedQuery();
singleQuery.Uri = new Uri(uri);
AtomFeed feed;
SpreadsheetEntry spreadsheet;
// フィード取得
feed = service.Query(singleQuery); // 認証エラーはここから
if (feed.Entries.Count == 0) {
return null;
}
spreadsheet = (SpreadsheetEntry)feed.Entries[0];
WorksheetFeed wsFeed = spreadsheet.Worksheets;
WorksheetEntry worksheet = (WorksheetEntry)wsFeed.Entries[0];
// Fetch the cell feed of the worksheet.
CellQuery cellQuery = new CellQuery(worksheet.CellFeedLink);
cellQuery.MinimumRow = 3;
cellQuery.MinimumColumn = 2;
cellQuery.MaximumColumn = 4;
return service.Query(cellQuery);
} catch (InvalidCredentialsException) {
// 認証エラー
throw;
} catch (GDataRequestException) {
// Execution of request failed: {address}
throw;
}
}
/** 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;
}
/// <summary>
/// overwritten Query method
/// </summary>
/// <param name="feedQuery">The CodeSearchQuery touse</param>
/// <returns>the retrieved CodeSearchFeed</returns>
public new CodeSearchFeed Query(FeedQuery feedQuery)
{
Stream feedStream = Query(feedQuery.Uri);
CodeSearchFeed feed = new CodeSearchFeed(feedQuery.Uri, this);
feed.Parse(feedStream, AlternativeFormat.Atom);
feedStream.Close();
return feed;
}
public IList<BlogEntry> GetAllEntries()
{
FeedQuery query = new FeedQuery();
query.Uri = new Uri("http://www.blogger.com/feeds/" + BlogId + "/posts/default");
query.NumberToRetrieve = 500;
return MapEntries(Service.Query(query).Entries);
}
public AtomFeed GetGoogleCalendar()
{
Service service = new Service();
FeedQuery query = new FeedQuery();
query.Uri = new Uri(publicCalendarUrl);
return service.Query(query);
}
public void UseSSLTest()
{
FeedQuery target = new FeedQuery(); // TODO: Initialize to an appropriate value
bool expected = true;
bool actual;
target.UseSSL = expected;
actual = target.UseSSL;
Assert.AreEqual(expected, actual);
}
//////////////////////////////////////////////////////////////////////
/// <summary>empty a feed</summary>
//////////////////////////////////////////////////////////////////////
protected void FeedCleanup(String uriToClean, String userName, String pwd)
{
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();
if (uriToClean != null)
{
if (userName != null)
{
service.Credentials = new GDataCredentials(userName, pwd);
}
GDataLoggingRequestFactory factory = (GDataLoggingRequestFactory)this.factory;
factory.MethodOverride = true;
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;
factory.MethodOverride = false;
}
}
}
/////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
/// <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");
}
}
/** 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 ActionResult IndexOLD(string id)
{
string uri;
bool permalink = false;
if (string.IsNullOrEmpty(id))
uri = _baseUri;
else
{
uri = postUri(id);
permalink = true;
}
FeedQuery query = new FeedQuery();
query.Uri = new Uri(uri);
if (!permalink)
{
query.StartIndex = 0;
query.NumberToRetrieve = 2;
}
AtomFeed feed = null;
feed = _service.Query(query);
var bpl = new List<BlogPost>();
foreach (var e in feed.Entries)
{
var bp = new BlogPost()
{
Title = e.Title.Text,
Content = e.Content.Content,
Date = e.Published,
ID = e.EditUri.Content.Substring(e.EditUri.Content.LastIndexOf('/') + 1)
};
bpl.Add(bp);
}
return View(new BlogListData()
{
//SideBarData = new Models.Shared.MainSideBarData(),
Posts = bpl
//Posts = feed.Entries.Select(e => new BlogPost()
//{
// Title = e.Title.Text,
// Content = e.Content.Content,
// Date = e.Published,
// ID = Regex.Replace(e.Links.Single(l => l.Rel == "edit").HRef.ToString(), uri + "/", "")
//}).ToList()
});
}
private IList<Webinar> LoadWebinars()
{
var service = new YouTubeService("HibernatingRhinosExercise");
var query = new FeedQuery(_uri);
var webinars = new List<Webinar>();
AtomFeed result = service.Query(query);
if (result != null)
{
webinars = ParseAtomFeed(result);
}
return webinars;
}
public IList<Webinar> FindWebinars(string keyword)
{
var service = new YouTubeService("HibernatingRhinosExercise");
var query = new FeedQuery("https://gdata.youtube.com/feeds/api/videos?q={0}" + keyword);
var webinars = new List<Webinar>();
AtomFeed result = service.Query(query);
if (result != null)
{
webinars = ParseAtomFeed(result);
}
return webinars;
}
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;
}
public void getActivityFeed(String feedUri)
{
FeedQuery query = new FeedQuery();
query.Uri = new Uri(feedUri);
AtomFeed feed = service.Query(query);
foreach (AtomEntry entry in feed.Entries)
{
Console.WriteLine(String.Format("Page: {0}", entry.Title.Text));
String actionType = getCategoryLabel(entry.Categories);
Console.WriteLine(String.Format(" {0} on {1}, by {2}", actionType,
entry.Updated.ToShortDateString(), entry.Authors[0].Email));
}
}
//////////////////////////////////////////////////////////////////////
/// <summary>[Test] public QueryObjectTest()</summary>
//////////////////////////////////////////////////////////////////////
[Test] public void QueryObjectTest()
{
Tracing.TraceInfo("Entering QueryObject Test");
FeedQuery query = new FeedQuery();
query.Uri = new Uri(this.defaultHost);
AtomCategory aCat = new AtomCategory("Test", new AtomUri("urn:test.com"));
QueryCategory qCat = new QueryCategory(aCat);
query.Categories.Add(qCat);
aCat = new AtomCategory("TestNotAndOr", new AtomUri("urn:test.com"));
qCat = new QueryCategory(aCat);
qCat.Operator = QueryCategoryOperator.OR;
qCat.Excluded = true;
query.Categories.Add(qCat);
aCat = new AtomCategory("ANDTHISONE", new AtomUri(""));
qCat = new QueryCategory(aCat);
query.Categories.Add(qCat);
aCat = new AtomCategory("AnotherOrWithoutCategory");
qCat = new QueryCategory(aCat);
qCat.Operator = QueryCategoryOperator.OR;
qCat.Excluded = true;
query.Categories.Add(qCat);
query.Query = "Hospital";
query.NumberToRetrieve = 20;
Tracing.TraceInfo("query: " + query.Uri);
Uri uri = query.Uri;
Tracing.TraceInfo("Uri: query= " + uri.Query);
query.Uri = uri;
Tracing.TraceInfo("Parsed Query URI: " + query.Uri);
Assert.IsTrue(uri.AbsolutePath.Equals(query.Uri.AbsolutePath), "both query URIs should be identical, uri: " + uri.AbsolutePath + " compared to query: " + query.Uri.AbsolutePath);
query.CategoryQueriesAsParameter = true;
uri = query.Uri;
Tracing.TraceInfo("Uri: query= " + uri.Query);
query.Uri = uri;
Tracing.TraceInfo("Parsed Query URI: " + query.Uri.AbsoluteUri);
Assert.IsTrue(uri.AbsolutePath.Equals(query.Uri.AbsolutePath), "both query URIs should be identical, uri: " + uri.AbsolutePath + " compared to query: " + query.Uri.AbsolutePath);
}
//////////////////////////////////////////////////////////////////////
/// <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();
}
}
/// <summary>
/// Prints a list of the user's calendars.
/// </summary>
/// <param name="service">The authenticated CalendarService object.</param>
static void PrintUserCalendars(CalendarService service)
{
FeedQuery query = new FeedQuery();
query.Uri = new Uri("http://www.google.com/calendar/feeds/default");
// Tell the service to query:
AtomFeed calFeed = service.Query(query);
Console.WriteLine("Your calendars:");
Console.WriteLine();
for (int i = 0; i < calFeed.Entries.Count; i++)
{
Console.WriteLine(calFeed.Entries[i].Title.Text);
}
Console.WriteLine();
}
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);
}
public GoogleFinanceLib()
{
Service sFinance = new Service("finance", "StockTicker");//"CCSC-StockTicker-1a");
/*
* Setup credentials.
*/
sFinance.Credentials = new GDataCredentials(sUsername, sPassword);
GDataGAuthRequestFactory rfFactory = (GDataGAuthRequestFactory)sFinance.RequestFactory;
rfFactory.AccountType = "GOOGLE";
FeedQuery fqQuery = new FeedQuery();
/*
* Need "query" uri.
*/
fqQuery.Uri = new Uri("http://www.google.com/finance");
fqQuery.Query = "GOOG";
/* AtomFeed afFeed = sFinance.Query(fqQuery);
*/
// string s = "";
}
public List<Calendar> GetUserCalendars()
{
FeedQuery query = new FeedQuery();
query.Uri = new Uri(GoogleFeedsUriDefault);
// Tell the service to query:
AtomFeed calFeed = calendarService.Query(query);
List<Calendar> result = new List<Calendar>();
foreach (var item in calFeed.Entries)
{
var calID = item.SelfUri.ToString().Split(new char[] {'/'});
var calendar = new Calendar
{
Title = item.Title.Text,
CalendarID = calID.Last()
};
result.Add(calendar);
}
return result;
}
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;
}
// end of accessor public bool CategoryQueriesAsParameter
#if WindowsCE || PocketPC
#else
//////////////////////////////////////////////////////////////////////
/// <summary>Passing in a complete URI, we strip all the
/// GData query-related things and then treat the rest
/// as the base URI. For this we create a service.</summary>
/// <param name="uri">a complete URI</param>
/// <param name="service">the new GData service for this URI</param>
/// <param name="query">the parsed query object for this URI</param>
//////////////////////////////////////////////////////////////////////
public static void Parse(Uri uri, out Service service, out FeedQuery query)
{
query = new FeedQuery();
query.ParseUri(uri);
service = new Service();
}
/// <summary>
/// helper method to setup a query object with some parameters
/// based on a requestsettings
/// </summary>
/// <param name="q"></param>
/// <param name="settings"></param>
internal static void PrepareQuery(FeedQuery q, RequestSettings settings)
{
if (settings.PageSize != -1)
{
q.NumberToRetrieve = settings.PageSize;
}
if (settings.OAuthUser != null)
{
q.OAuthRequestorId = settings.OAuthUser;
if (settings.OAuthDomain != null)
{
q.OAuthRequestorId += "@" + settings.OAuthDomain;
}
}
}
/// <summary>
/// Retrieves and prints the access control lists of all
/// of the authenticated user's calendars.
/// </summary>
/// <param name="service">The authenticated CalendarService object.</param>
static void RetrieveAcls(CalendarService service)
{
FeedQuery query = new FeedQuery();
query.Uri = new Uri("http://www.google.com/calendar/feeds/default");
AtomFeed calFeed = service.Query(query);
Console.WriteLine();
Console.WriteLine("Sharing permissions for your calendars:");
// Retrieve the meta-feed of all calendars.
foreach (AtomEntry calendarEntry in calFeed.Entries)
{
Console.WriteLine("Calendar: {0}", calendarEntry.Title.Text);
AtomLink link = calendarEntry.Links.FindService(
AclNameTable.LINK_REL_ACCESS_CONTROL_LIST, null);
// For each calendar, retrieve its ACL feed.
if (link != null)
{
AclFeed feed = service.Query(new AclQuery(link.HRef.ToString()));
foreach (AclEntry aclEntry in feed.Entries)
{
Console.WriteLine("\tScope: Type={0} ({1})", aclEntry.Scope.Type,
aclEntry.Scope.Value);
Console.WriteLine("\tRole: {0}", aclEntry.Role.Value);
}
}
}
}
public void UriTest()
{
FeedQuery target = new FeedQuery(); // TODO: Initialize to an appropriate value
Uri expected = new Uri("http://www.test.com/");
Uri actual;
target.Uri = expected;
actual = target.Uri;
Assert.AreEqual(expected, actual);
}
public void FeedQueryCopyUriTest() {
string baseUri = "http://www.test.com/";
FeedQuery source = new FeedQuery(baseUri);
source.Author = "Firstname Lastname";
FeedQuery target = new FeedQuery();
target.Uri = source.Uri;
Assert.AreEqual(source.Author, target.Author);
}
public void FeedQueryConstructorTest()
{
string baseUri = "http://www.test.com/"; // TODO: Initialize to an appropriate value
FeedQuery target = new FeedQuery(baseUri);
Assert.AreEqual(target.Uri, new Uri(baseUri));
}
public void FeedQueryConstructorTest1()
{
FeedQuery target = new FeedQuery();
Assert.IsNotNull(target);
}
public void AuthorTest()
{
FeedQuery target = new FeedQuery(); // TODO: Initialize to an appropriate value
string expected = "TestValue";
string actual;
target.Author = expected;
actual = target.Author;
Assert.AreEqual(expected, actual);
}
public void CategoriesTest()
{
FeedQuery target = new FeedQuery(); // TODO: Initialize to an appropriate value
Assert.IsNotNull(target.Categories);
}
