public void Index() { var g = new Service("local", "application");//, "ABQIAAAACPMbozlNv9AIzNvsWUm6vhSvnLMDprvOSMH9Qt_oH5Ww7FTw1hRHT7gTSie1yM34rowNwVfw424XPA"); Assert.Fail("Need to put password here"); g.setUserCredentials("*****@*****.**", "zzz"); var entry = new AtomEntry(); entry.Content.ExtensionFactories.Add(new MapsExtension()); entry.Title.Text = "test"; entry.Content.Type = "application/vnd.google-earth.kml+xml"; XmlDocument doc = new XmlDocument(); doc.LoadXml(@"<Placemark xmlns='http://www.opengis.net/kml/2.2'> <name>Faulkner's Birthplace</name> <description/> <Point> <coordinates>-89.520753,34.360902,0.0</coordinates> </Point> </Placemark>"); entry.Content.ExtensionElements.Add(new XmlExtension((XmlNode)doc.DocumentElement)); // doc.LoadXml(@"@"<m:Placemark> // <m:name>Faulkner's Birthplace</m:name> // <m:description/> // <m:Point> // <m:coordinates>-89.520753,34.360902,0.0</m:coordinates> // </m:Point> //</m:Placemark>"; //entry.Content.Content = ; //entry.AddExtension(new MapsExtension()); var m = new MemoryStream(); //var mapStuff = entry.Content.CreateExtension("PlaceMark", "http://www.opengis.net/kml/2.2"); // entry.Update(); try { entry.SaveToXml(m); } catch (Exception e) { var s = e.ToString(); throw; } m.Position = 0; var mm = new StreamReader(m).ReadToEnd(); var q = g.Insert(new Uri("http://maps.google.com/maps/feeds/features/208433541473729117510/0004779109f86bbabd62d/full"), entry); var p = g.Query(new Uri("http://maps.google.com/maps/feeds/maps/default/full")); var z = new StreamReader(p).ReadToEnd(); //// Arrange //HomeController controller = new HomeController(); //// Act //ViewResult result = controller.Index() as ViewResult; //// Assert //ViewDataDictionary viewData = result.ViewData; //Assert.AreEqual("Welcome to ASP.NET MVC!", viewData["Message"]); }
/** 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; }
/** Creates a new blog entry and sends it to the specified Uri */ static AtomEntry PostNewEntry(Service service, Uri blogPostUri) { Console.WriteLine("\nPublishing a blog post"); AtomEntry createdEntry = null; if (blogPostUri != null) { // construct the new entry AtomEntry newPost = new AtomEntry(); newPost.Title.Text = "Marriage!"; newPost.Content = new AtomContent(); newPost.Content.Content = "<div xmlns='http://www.w3.org/1999/xhtml'>" + "<p>Mr. Darcy has <em>proposed marriage</em> to me!</p>" + "<p>He is the last man on earth I would ever desire to marry.</p>" + "<p>Whatever shall I do?</p>" + "</div>"; newPost.Content.Type = "xhtml"; newPost.Authors.Add(new AtomPerson()); newPost.Authors[0].Name = "Elizabeth Bennet"; newPost.Authors[0].Email = "*****@*****.**"; createdEntry = service.Insert(blogPostUri, newPost); if (createdEntry != null) { Console.WriteLine(" New blog post created with title: " + createdEntry.Title.Text); } } return createdEntry; }
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); }
public Google2uManualWorkbook(WorksheetFeed in_feed, string in_url, string in_name, Service in_service) { _Service = in_service; WorkbookUrl = in_url; Workbook = in_feed; WorkbookName = in_name; Worksheets = new List<Google2uWorksheet>(); }
public void RequestFactoryTest() { Service target = new Service(); // TODO: Initialize to an appropriate value IGDataRequestFactory expected = new GDataGAuthRequestFactory("cl", "test"); IGDataRequestFactory actual; target.RequestFactory = expected; actual = target.RequestFactory; Assert.AreEqual(expected, actual); }
public void UriTest() { Uri uri = new Uri("http://www.test.com/"); IService service = new Service(); ServiceEventArgs target = new ServiceEventArgs(uri, service); // TODO: Initialize to an appropriate value Uri actual; actual = target.Uri; Assert.AreEqual(actual, uri); }
/// <summary> /// allows you to construct the dialog with a given service /// </summary> /// <param name="serviceToUse">the service object to use</param> public GoogleClientLogin(Service serviceToUse) { // // Required for Windows Form Designer support // InitializeComponent(); this.service = serviceToUse; }
////////////////////////////////////////////////////////////////////// /// <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"); } }
public Google2uAccountWorkbook(SpreadsheetEntry in_spreadsheet, Service in_service) { Workbook = in_spreadsheet; WorkbookName = in_spreadsheet.Title.Text; _Service = in_service; foreach (var link in in_spreadsheet.Links.Where(in_link => in_link.Rel.Equals("alternate", StringComparison.OrdinalIgnoreCase))) { WorkbookUrl = link.HRef.ToString(); break; } Worksheets = new List<Google2uWorksheet>(); }
/** 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; }
public void PublishNewEntry(BlogDescriptor blogDescriptor, String title, String content) { if (blogDescriptor == null) throw new ArgumentNullException("blogDescriptor"); if (String.IsNullOrEmpty(blogDescriptor.Username)) throw new ArgumentException("blogDescriptor.Username cannot be null or an empty string."); var entry = new gClient.AtomEntry(); entry.Content.Content = content; entry.Content.Type = "html"; entry.Title.Text = title; var service = new gClient.Service("blogger", GoogleSucks.GetApplicationName()); service.Credentials = new gClient.GDataCredentials(blogDescriptor.Username, blogDescriptor.Password); service.Insert(new Uri(GetFeedUri(blogDescriptor)), entry); }
////////////////////////////////////////////////////////////////////// /// <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(); } }
private void button1_Click(object sender, EventArgs e) { Service service = new Service("cl", "companyName-appName-1"); service.setUserCredentials("*****@*****.**", "jWH>45bY1"); EventEntry entry = new EventEntry(); DataSet ds = new DataSet(); When eventTimes = new When(); AtomEntry insertedEntry; SqlConnection cn = new SqlConnection(); try { cn = DBDevite.DBOpen(); SqlDataAdapter da = new SqlDataAdapter("SELECT u.Users as userw, c.Name as client, t.Date as date, t.TimeStart as start, t.TimeEnd as endw, t.About as about, t.TaskStatus " + "FROM tasks t " + "LEFT JOIN users u ON t.userID = u.ID " + "LEFT JOIN clients c ON t.clientID = c.ID " + "WHERE t.TaskStatus = 'true'", cn); SqlCommandBuilder cb = new SqlCommandBuilder(da); da.Fill(ds); } catch (SqlException ex) { MessageBox.Show(ex.Message); } finally { DBDevite.DBClose(cn); } Uri postUri = new Uri("http://www.google.com/calendar/feeds/[email protected]/private/full"); //запись в EventEntry foreach(DataTable thisTable in ds.Tables) { foreach(DataRow row in thisTable.Rows) { entry.Title.Text = row["client"].ToString() + " " + row["userw"].ToString(); entry.Content.Content = row["about"].ToString(); eventTimes.StartTime = Convert.ToDateTime(Convert.ToDateTime(row["date"].ToString()).ToString("dd-MM-yyyy") + " " + row["start"].ToString().Trim() + ":00"); eventTimes.EndTime = Convert.ToDateTime(Convert.ToDateTime(row["date"].ToString()).ToString("dd-MM-yyyy") + " " + row["endw"].ToString().Trim() + ":00"); entry.Times.Add(eventTimes); insertedEntry = service.Insert(postUri, entry); } } }
public BloggerWrapper(Settings settings, User user) { if (settings == null) throw new ArgumentNullException("settings"); if (user == null) throw new ArgumentNullException("user"); Settings = settings; User = user; BloggerService = new Service("blogger", "BlogMyFlickr") { Credentials = new GDataCredentials(settings.BloggerUserName, settings.BloggerPassword) }; GDataGAuthRequestFactory factory = (GDataGAuthRequestFactory)BloggerService.RequestFactory; factory.AccountType = "GOOGLE"; }
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 void PublishNewEntry(BlogDescriptor blogDescriptor, String title, String content) { if (blogDescriptor == null) { throw new ArgumentNullException("blogDescriptor"); } if (String.IsNullOrEmpty(blogDescriptor.Username)) { throw new ArgumentException("blogDescriptor.Username cannot be null or an empty string."); } var entry = new gClient.AtomEntry(); entry.Content.Content = content; entry.Content.Type = "html"; entry.Title.Text = title; var service = new gClient.Service("blogger", GoogleSucks.GetApplicationName()); service.Credentials = new gClient.GDataCredentials(blogDescriptor.Username, blogDescriptor.Password); service.Insert(new Uri(GetFeedUri(blogDescriptor)), entry); }
public void CredentialsTest() { Service target = new Service(); // TODO: Initialize to an appropriate value GDataCredentials expected = new GDataCredentials("test", "pwd"); GDataCredentials actual; target.Credentials = expected; actual = target.Credentials; Assert.AreEqual(expected, actual); }
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>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; } }
/** * 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> /// Generates a new Authentication Toklen for AppsService /// with the specified credentials for accessing provisioning feeds on the specified domain. /// </summary> /// <param name="domain">the domain to access</param> /// <param name="adminEmailAddress">the administrator's email address</param> /// <param name="adminPassword">the administrator's password</param> /// <returns>the newly generated authentication token</returns> public static String GetNewAuthenticationToken(string domain, string adminEmailAddress, string adminPassword) { Service service = new Service(AppsNameTable.GAppsService,"apps-"+domain); service.setUserCredentials(adminEmailAddress, adminPassword); return service.QueryClientLoginToken(); }
///////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////// /// <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"); }
///////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////// /// <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>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 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>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"); }