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");
}
