/// <summary>constructor for the feedParser events</summary>
/// <param name="feed">the feed to use </param>
/// <param name="entry">the feedentry to use </param>
public FeedParserEventArgs(AtomFeed feed, AtomEntry entry) {
this.feedEntry = entry;
this.feed = feed;
if (feed == null && entry == null) {
this.done = true;
}
}
private AsyncSendData(AsyncDataHandler handler, Uri uriToUse, AtomEntry entry, AtomFeed feed,
SendOrPostCallback callback, object userData, bool parseFeed)
: base(uriToUse, null, userData, callback, parseFeed) {
this.DataHandler = handler;
this.entry = entry;
this.Feed = feed;
}
/// <summary>
/// constructor. takes the async data blob
/// </summary>
/// <param name="data">async data to constructor</param>
internal AsyncOperationCompletedEventArgs(AsyncData data)
: base(data.Exception, false, data.UserData) {
feedObject = data.Feed;
stream = data.DataStream;
IAsyncEntryData entryData = data as IAsyncEntryData;
if (entryData != null) {
entryObject = entryData.Entry;
}
}
/// <summary>starts the parsing process</summary>
/// <param name="streamInput">input stream to parse </param>
/// <param name="feed">the basefeed object that should be set</param>
public override void Parse(Stream streamInput, AtomFeed feed) {
Tracing.TraceCall("feedparser starts parsing");
try {
XmlReader reader = new XmlTextReader(streamInput, this.nameTable.Nametable);
MoveToStartElement(reader);
ParseFeed(reader, feed);
} catch (Exception e) {
throw new ClientFeedException("Parsing failed", e);
}
}
public void TestGZipQuery()
{
IGDataRequest request = this.calendarService.RequestFactory.CreateRequest(GDataRequestType.Query, new Uri(calendarUri));
Assert.IsTrue(request.UseGZip, "IGDataRequest.UseGZip property should be true.");
request.Credentials = new GDataCredentials(this.userName, this.passWord);
request.Execute();
Assert.IsTrue(request.UseGZip, "IGDataRequest.UseGZip is not true, the response was NOT in GZip format.");
Stream responseStream = request.GetResponseStream();
Assert.IsTrue(responseStream != null, "Response stream should not be null.");
AtomFeed feed = new AtomFeed(new Uri(calendarUri), this.calendarService);
feed.Parse(request.GetResponseStream(), AlternativeFormat.Atom);
Assert.IsTrue(feed.Self != null, "AtomFeed object is not right.");
}
/// <summary>
/// constructor. takes the async data blog
/// </summary>
/// <param name="data">async data to constructor</param>
internal AsyncOperationCompletedEventArgs(AsyncData data) : base(data.Exception, false, data.UserData)
{
AsyncQueryData qData = data as AsyncQueryData;
AsyncSendData sData = data as AsyncSendData;
this.uri = data.UriToUse;
if (qData != null)
{
this.feedObject = qData.Feed;
this.stream = qData.DataStream;
}
if (sData != null)
{
this.entryObject = sData.Entry;
}
}
private static List<Webinar> ParseAtomFeed(AtomFeed atomFeed)
{
IEnumerable<AtomEntry> atomEntryCollection = atomFeed.Entries;
var webinars = new List<Webinar>();
foreach (var item in atomEntryCollection)
{
var entry = (YouTubeEntry) item;
var webinar = new Webinar
{
Id = entry.VideoId,
Title = entry.Title.Text,
Summary = entry.Summary.Text,
Published = entry.Published
};
webinars.Add(webinar);
}
return webinars;
}
/// <summary>public AtomSource(AtomFeed feed)</summary>
public AtomSource(AtomFeed feed)
: this()
{
Tracing.Assert(feed != null, "feed should not be null");
if (feed == null)
{
throw new ArgumentNullException("feed");
}
// now copy them
this.authors = feed.Authors;
this.contributors = feed.Contributors;
this.categories = feed.Categories;
this.Generator = feed.Generator;
this.Icon = feed.Icon;
this.Logo = feed.Logo;
this.Id = feed.Id;
this.links = feed.Links;
this.Rights = feed.Rights;
this.Subtitle = feed.Subtitle;
this.Title = feed.Title;
this.Updated = feed.Updated;
}
/// <summary>creates a new feed instance to be returned by
/// Batch(), Query() and other operations
///
/// Subclasses can supply their own feed implementation by
/// overriding this method.
/// </summary>
protected virtual AtomFeed CreateFeed(Uri uriToUse)
{
ServiceEventArgs args = null;
AtomFeed feed = null;
if (this.NewFeed != null)
{
args = new ServiceEventArgs(uriToUse, this);
this.NewFeed(this, args);
}
if (args != null)
{
feed = args.Feed;
}
if (feed == null)
{
feed = new AtomFeed(uriToUse, this);
}
return(feed);
}
/// <summary>public WebResponse Insert(Uri insertUri, Stream entryStream, ICredentials credentials)</summary>
/// <param name="feed">the feed this entry should be inserted into</param>
/// <param name="entry">the entry to be inserted</param>
/// <returns> the inserted entry</returns>
AtomEntry IService.Insert(AtomFeed feed, AtomEntry entry)
{
Tracing.Assert(feed != null, "feed should not be null");
if (feed == null)
{
throw new ArgumentNullException("feed");
}
Tracing.Assert(entry != null, "entry should not be null");
if (entry == null)
{
throw new ArgumentNullException("entry");
}
if (feed.ReadOnly)
{
throw new GDataRequestException("Can not update a read-only feed");
}
Tracing.TraceMsg("Post URI is: " + feed.Post);
Uri target = new Uri(feed.Post);
return(Insert(target, entry));
}
/////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
/// <summary>overloaded to make eventfiring easier</summary>
/// <param name="feed"> the new feed to fire</param>
//////////////////////////////////////////////////////////////////////
protected void OnNewAtomEntry(AtomFeed feed)
{
FeedParserEventArgs args = new FeedParserEventArgs(feed, null);
this.OnNewAtomEntry(args);
}
/////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
/// <summary>starts the parsing process</summary>
/// <param name="streamInput">input stream to parse </param>
/// <param name="feed">the feed object to construct</param>
//////////////////////////////////////////////////////////////////////
public override void Parse(Stream streamInput, AtomFeed feed)
{
}
public static void ProcessSubmissions(AtomFeed feed)
{
int i = 0;
Submission submission = new Submission();
foreach(ListEntry entry in feed.Entries)
{
if (i>0)
{
Submissions.Add(submission);
i = 0;
submission = new Submission();
}
foreach(ListEntry.Custom listrow in entry.Elements)
{
switch (i)
{
case 0: submission.CSF = listrow.Value;
break;
case 1: submission.PlannedDate = listrow.Value;
break;
case 2: submission.SubmittedDate = listrow.Value;
break;
case 3: submission.SubmissionType = listrow.Value;
break;
case 4: submission.Milestone = listrow.Value;
break;
case 5: submission.Title = listrow.Value;
break;
case 6: submission.Number = listrow.Value;
break;
case 7: submission.Revision = listrow.Value;
break;
case 9: submission.UpdatedDate = listrow.Value;
break;
}
i++;
}
}
}
/////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
/// <summary>default constructor so that FxCop does not complain</summary>
//////////////////////////////////////////////////////////////////////
public GDataBatchRequestException(AtomFeed batchResult)
{
this.batchResult = batchResult;
}
public void XmlNameTest()
{
AtomFeed target = new AtomFeed(new Uri("http://www.test.com/"), null);
Assert.AreEqual(AtomParserNameTable.XmlFeedElement, target.XmlName);
}
public AsyncSendData(AsyncDataHandler handler, Uri uriToUse, AtomFeed feed, SendOrPostCallback callback, object userData)
: this(handler, uriToUse, null, feed, callback, userData, false) {
}
/// <summary>
/// takes a given feed, and does a batch post of that feed
/// against the batchUri parameter. If that one is NULL
/// it will try to use the batch link URI in the feed
/// </summary>
/// <param name="feed">the feed to post</param>
/// <param name="batchUri">the URI to user</param>
/// <param name="userData">the userdata identifying this request</param>
/// <returns></returns>
public void BatchAsync(AtomFeed feed, Uri batchUri, Object userData) {
AsyncSendData data = new AsyncSendData(this, batchUri, feed, this.ProgressReportDelegate, userData);
WorkerSendEventHandler workerDelegate = new WorkerSendEventHandler(AsyncBatchWorker);
this.AsyncStarter(data, workerDelegate, userData);
}
/// <summary>reads in the feed properties, updates the feed object, then starts
/// working on the entries...</summary>
/// <param name="reader"> xmlReader positioned at the Feed element</param>
/// <param name="feed">the basefeed object that should be set</param>
/// <returns> notifies user using event mechanism</returns>
protected void ParseFeed(XmlReader reader, AtomFeed feed) {
Tracing.Assert(reader != null, "reader should not be null");
if (reader == null) {
throw new ArgumentNullException("reader");
}
Tracing.Assert(feed != null, "feed should not be null");
if (feed == null) {
throw new ArgumentNullException("feed");
}
Tracing.TraceCall("entering AtomFeed Parser");
object localname = reader.LocalName;
Tracing.TraceInfo("localname is: " + reader.LocalName);
if (localname.Equals(this.nameTable.Feed)) {
Tracing.TraceInfo("Found standard feed document");
// found the feed......
// now parse the source base of this element
ParseSource(reader, feed);
// feed parsing complete, send notfication
this.OnNewAtomEntry(feed);
} else if (localname.Equals(this.nameTable.Entry)) {
Tracing.TraceInfo("Found entry document");
ParseEntry(reader);
} else {
Tracing.TraceInfo("ParseFeed called and nothing was parsed" + localname.ToString());
// throw new ClientFeedException("An invalid Atom Document was passed to the parser. Neither Feed nor Entry started the document");
}
OnParsingDone();
feed.MarkElementDirty(false);
}
/////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
/// <summary>runs a batch upload test</summary>
//////////////////////////////////////////////////////////////////////
[Test] public void GoogleBaseBatchUpdates()
{
Tracing.TraceMsg("Entering GoogleBaseBatchUpdates");
FeedQuery query = new FeedQuery();
Service service = new GBaseService(this.ApplicationName, this.gBaseKey);
if (this.gBaseURI != null)
{
if (this.userName != null)
{
service.Credentials = new GDataCredentials(this.userName, this.passWord);
}
service.RequestFactory = this.factory;
query.Uri = new Uri(this.gBaseURI);
AtomFeed baseFeed = service.Query(query);
// this should have a batch URI
Assert.IsTrue(baseFeed.Batch != null, "This is a base Feed, it should have batch URI");
AtomFeed batchFeed = new AtomFeed(baseFeed);
// set the default operation.
batchFeed.BatchData = new GDataBatchFeedData();
batchFeed.BatchData.Type = GDataBatchOperationType.delete;
int i = 1;
foreach (AtomEntry entry in baseFeed.Entries)
{
AtomEntry batchEntry = batchFeed.Entries.CopyOrMove(entry);
batchEntry.BatchData = new GDataBatchEntryData();
batchEntry.BatchData.Id = i.ToString();
batchEntry.BatchData.Type = GDataBatchOperationType.update;
batchEntry.Title.Text = "Updated";
}
AtomFeed resultFeed = service.Batch(batchFeed, new Uri(baseFeed.Batch));
foreach (AtomEntry resultEntry in resultFeed.Entries )
{
GDataBatchEntryData data = resultEntry.BatchData;
Assert.IsTrue(data.Status.Code == 200, "Status code should be 200, is:" + data.Status.Code);
}
}
}
/// <summary>
/// takes a given feed, and does a batch post of that feed
/// against the batchUri parameter. If that one is NULL
/// it will try to use the batch link URI in the feed
/// </summary>
/// <param name="feed">the feed to post</param>
/// <param name="batchUri">the URI to user</param>
/// <returns>the returned AtomFeed</returns>
public AtomFeed Batch(AtomFeed feed, Uri batchUri)
{
return(Batch(feed, batchUri, null));
}
/// <summary>
/// templated type safe version of Insert
/// </summary>
/// <typeparam name="TEntry"></typeparam>
/// <param name="feed"></param>
/// <param name="entry"></param>
/// <returns> the new Entry, as returned from the server</returns>
public TEntry Insert <TEntry>(AtomFeed feed, TEntry entry) where TEntry : AtomEntry
{
IService s = this as IService;
return(s.Insert(feed, entry) as TEntry);
}
/////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
/// <summary>runs a test of batch support on the events feed</summary>
//////////////////////////////////////////////////////////////////////
[Test] public void CalendarBatchTest()
{
Tracing.TraceMsg("Entering CalendarBatchTest");
CalendarService service = new CalendarService(this.ApplicationName);
if (this.defaultCalendarUri != null)
{
if (this.userName != null)
{
service.Credentials = new GDataCredentials(this.userName, this.passWord);
}
service.RequestFactory = this.factory;
EventQuery query = new EventQuery(this.defaultCalendarUri);
EventFeed feed = service.Query(query);
AtomFeed batchFeed = new AtomFeed(feed);
string newEntry1Title = "new event" + Guid.NewGuid().ToString();
EventEntry newEntry1 = new EventEntry(newEntry1Title);
newEntry1.BatchData = new GDataBatchEntryData("1", GDataBatchOperationType.insert);
batchFeed.Entries.Add(newEntry1);
string newEntry2Title = "new event" + Guid.NewGuid().ToString();
EventEntry newEntry2 = new EventEntry(newEntry2Title);
newEntry2.BatchData = new GDataBatchEntryData("2", GDataBatchOperationType.insert);
batchFeed.Entries.Add(newEntry2);
string newEntry3Title = "new event" + Guid.NewGuid().ToString();
EventEntry newEntry3 = new EventEntry(newEntry3Title);
newEntry3.BatchData = new GDataBatchEntryData("3", GDataBatchOperationType.insert);
batchFeed.Entries.Add(newEntry3);
Tracing.TraceMsg("Creating batch items");
EventFeed batchResultFeed = (EventFeed)service.Batch(batchFeed, new Uri(feed.Batch));
foreach (EventEntry evt in batchResultFeed.Entries)
{
Assert.IsNotNull(evt.BatchData, "Result should contain batch information.");
Assert.IsNotNull(evt.BatchData.Id, "Result should have a Batch ID.");
Assert.AreEqual(201, evt.BatchData.Status.Code, "Created entries should return 201");
switch (evt.BatchData.Id)
{
case "1":
Assert.AreEqual(newEntry1Title, evt.Title.Text, "titles should be equal.");
break;
case "2":
Assert.AreEqual(newEntry2Title, evt.Title.Text, "titles should be equal.");
break;
case "3":
Assert.AreEqual(newEntry3Title, evt.Title.Text, "titles should be equal.");
break;
default:
Assert.Fail("Unrecognized entry in result of batch insert feed");
break;
}
}
Tracing.TraceMsg("Updating created entries.");
batchFeed = new AtomFeed(feed);
foreach (EventEntry evt in batchResultFeed.Entries)
{
evt.BatchData = new GDataBatchEntryData(evt.BatchData.Id, GDataBatchOperationType.update);
evt.Title.Text = evt.Title.Text + "update";
batchFeed.Entries.Add(evt);
}
batchResultFeed = (EventFeed) service.Batch(batchFeed, new Uri(feed.Batch));
foreach (EventEntry evt in batchResultFeed.Entries)
{
Assert.IsNotNull(evt.BatchData, "Result should contain batch information.");
Assert.IsNotNull(evt.BatchData.Id, "Result should have a Batch ID.");
Assert.AreEqual(200, evt.BatchData.Status.Code, "Updated entries should return 200");
switch (evt.BatchData.Id)
{
case "1":
Assert.AreEqual(newEntry1Title + "update", evt.Title.Text, "titles should be equal.");
break;
case "2":
Assert.AreEqual(newEntry2Title + "update", evt.Title.Text, "titles should be equal.");
break;
case "3":
Assert.AreEqual(newEntry3Title + "update", evt.Title.Text, "titles should be equal.");
break;
default:
Assert.Fail("Unrecognized entry in result of batch update feed");
break;
}
}
Tracing.TraceMsg("Deleting created entries.");
batchFeed = new AtomFeed(feed);
foreach (EventEntry evt in batchResultFeed.Entries)
{
evt.BatchData = new GDataBatchEntryData(GDataBatchOperationType.delete);
evt.Id = new AtomId(evt.EditUri.ToString());
batchFeed.Entries.Add(evt);
}
batchResultFeed = (EventFeed)service.Batch(batchFeed, new Uri(feed.Batch));
foreach (EventEntry evt in batchResultFeed.Entries)
{
Assert.AreEqual(200, evt.BatchData.Status.Code, "Deleted entries should return 200");
}
service.Credentials = null;
}
}
public void BatchDataTest()
{
AtomFeed target = new AtomFeed(new Uri("http://www.test.com/"), null);
GDataBatchFeedData expected = new GDataBatchFeedData();
GDataBatchFeedData actual;
target.BatchData = expected;
actual = target.BatchData;
Assert.AreEqual(expected, actual);
}
public AsyncSendData(AsyncDataHandler handler, Uri uriToUse, AtomFeed feed, SendOrPostCallback callback, object userData)
: this(handler, uriToUse, null, feed, callback, userData, false)
{
}
public void EntriesTest()
{
AtomFeed target = new AtomFeed(new Uri("http://www.test.com/"), null);
Assert.IsNotNull(target.Entries);
}
private AsyncSendData(AsyncDataHandler handler, Uri uriToUse, AtomEntry entry, AtomFeed feed, SendOrPostCallback callback, object userData, bool parseFeed)
: base(uriToUse, null, userData, callback, parseFeed)
{
this.DataHandler = handler;
this.entry = entry;
this.Feed = feed;
}
/////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
/// <summary>virtual, starts the parsing process</summary>
/// <param name="streamInput">input stream to parse </param>
/// <param name="feed">the basefeed object that should be set</param>
//////////////////////////////////////////////////////////////////////
public abstract void Parse(Stream streamInput, AtomFeed feed);
public void GoogleBaseBatchInsert()
{
Tracing.TraceMsg("Entering GoogleBaseBatchUpload");
FeedQuery query = new FeedQuery();
Service service = new GBaseService(this.ApplicationName, this.gBaseKey);
if (this.gBaseURI != null)
{
if (this.userName != null)
{
service.Credentials = new GDataCredentials(this.userName, this.passWord);
}
service.RequestFactory = this.factory;
query.Uri = new Uri(this.gBaseURI);
AtomFeed baseFeed = service.Query(query);
// this should have a batch URI
Assert.IsTrue(baseFeed.Batch != null, "This is a base Feed, it should have batch URI");
AtomFeed batchFeed = new AtomFeed(new Uri(this.gBaseURI), service);
// set the default operation. Unneeded, as the default is insert,
// but want to make sure the code is complete
batchFeed.BatchData = new GDataBatchFeedData();
batchFeed.BatchData.Type = GDataBatchOperationType.delete;
for (int i=0; i<20; i++)
{
AtomEntry entry = ObjectModelHelper.CreateGoogleBaseEntry(i);
entry.BatchData = new GDataBatchEntryData();
entry.BatchData.Type = GDataBatchOperationType.insert;
entry.BatchData.Id = i.ToString();
batchFeed.Entries.Add(entry);
}
AtomFeed resultFeed = service.Batch(batchFeed, new Uri(baseFeed.Batch));
foreach (AtomEntry resultEntry in resultFeed.Entries )
{
GDataBatchEntryData data = resultEntry.BatchData;
Assert.IsTrue(data.Status.Code == 201, "Status code should be 201, is:" + data.Status.Code);
}
}
}
public void TotalResultsTest()
{
AtomFeed target = new AtomFeed(new Uri("http://www.test.com/"), null);
int expected = 5; // TODO: Initialize to an appropriate value
int actual;
target.TotalResults = expected;
actual = target.TotalResults;
Assert.AreEqual(expected, actual);
}
/////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
/// <summary>runs a batch upload test</summary>
//////////////////////////////////////////////////////////////////////
[Test] public void GoogleBaseBatchMix()
{
Tracing.TraceMsg("Entering GoogleBaseBatchMix");
FeedQuery query = new FeedQuery();
Service service = new GBaseService(this.ApplicationName, this.gBaseKey);
if (this.gBaseURI != null)
{
if (this.userName != null)
{
service.Credentials = new GDataCredentials(this.userName, this.passWord);
}
service.RequestFactory = this.factory;
query.Uri = new Uri(this.gBaseURI);
AtomFeed baseFeed = service.Query(query);
// this should have a batch URI
Assert.IsTrue(baseFeed.Batch != null, "This is a base Feed, it should have batch URI");
AtomFeed batchFeed = new AtomFeed(baseFeed);
// set the default operation.
batchFeed.BatchData = new GDataBatchFeedData();
batchFeed.BatchData.Type = GDataBatchOperationType.insert;
int id = 1;
bool fUpdate = true;
foreach (AtomEntry entry in baseFeed.Entries)
{
AtomEntry batchEntry = batchFeed.Entries.CopyOrMove(entry);
if (fUpdate==true)
{
batchEntry.BatchData = new GDataBatchEntryData();
batchEntry.BatchData.Id = id.ToString();
batchEntry.BatchData.Type = GDataBatchOperationType.update;
batchEntry.Title.Text = "Updated";
fUpdate = false;
}
else
{
batchEntry.BatchData = new GDataBatchEntryData();
batchEntry.BatchData.Id = id.ToString();
batchEntry.BatchData.Type = GDataBatchOperationType.delete;
fUpdate = true;
}
// insert one
id++;
batchEntry = ObjectModelHelper.CreateGoogleBaseEntry(1);
batchEntry.BatchData = new GDataBatchEntryData();
batchEntry.BatchData.Type = GDataBatchOperationType.insert;
batchEntry.BatchData.Id = id.ToString();
batchFeed.Entries.Add(batchEntry);
id++;
}
AtomFeed resultFeed = service.Batch(batchFeed, new Uri(baseFeed.Batch));
foreach (AtomEntry resultEntry in resultFeed.Entries )
{
GDataBatchEntryData data = resultEntry.BatchData;
int testcode = 200;
if (data.Type == GDataBatchOperationType.insert)
{
testcode = 201;
}
Assert.IsTrue(data.Status.Code == testcode, "Status code should be: " + testcode + ", is:" + data.Status.Code);
}
}
}
/// <summary>constructor</summary>
public AtomEntryCollection(AtomFeed feed) : base()
{
this.feed = feed;
}
/// <summary>
/// parses the current position in the xml reader and fills
/// the provided GDataFeedBatch property on the feed object
/// </summary>
/// <param name="reader">the xmlreader positioned at a batch element</param>
/// <param name="feed">the atomfeed object to fill in</param>
protected void ParseBatch(XmlReader reader, AtomFeed feed) {
if (reader == null) {
throw new ArgumentNullException("reader");
}
if (feed == null) {
throw new ArgumentNullException("feed");
}
if (IsCurrentNameSpace(reader, BaseNameTable.gBatchNamespace)) {
object elementName = reader.LocalName;
if (feed.BatchData == null) {
feed.BatchData = new GDataBatchFeedData();
}
GDataBatchFeedData batch = feed.BatchData;
if (elementName.Equals(this.nameTable.BatchOperation)) {
batch.Type = (GDataBatchOperationType)Enum.Parse(typeof(GDataBatchOperationType),
reader.GetAttribute(BaseNameTable.XmlAttributeType), true);
} else {
Tracing.TraceInfo("got an unknown batch element: " + elementName.ToString());
reader.Skip();
}
}
}
/////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
/// <summary>starts the parsing process</summary>
/// <param name="streamInput">input stream to parse </param>
/// <param name="feed">the feed object to construct</param>
//////////////////////////////////////////////////////////////////////
public override void Parse(Stream streamInput, AtomFeed feed)
{
}
/// <summary>internal method to set the feed</summary>
internal void setFeed(AtomFeed feed) {
if (feed != null) {
this.Dirty = true;
this.Service = feed.Service;
}
this.feed = feed;
}
/// <summary>parses xml to fill a precreated AtomSource object (might be a feed)</summary>
/// <param name="reader">correctly positioned reader</param>
/// <param name="source">created source object to be filled</param>
/// <returns> </returns>
protected void ParseSource(XmlReader reader, AtomSource source)
{
Tracing.Assert(reader != null, "reader should not be null");
if (reader == null)
{
throw new ArgumentNullException("reader");
}
Tracing.Assert(source != null, "source should not be null");
if (source == null)
{
throw new ArgumentNullException("source");
}
Tracing.TraceCall();
int depth = -1;
ParseBasicAttributes(reader, source);
while (NextChildElement(reader, ref depth))
{
object localname = reader.LocalName;
AtomFeed feed = source as AtomFeed;
if (IsCurrentNameSpace(reader, BaseNameTable.NSAtom))
{
if (localname.Equals(this.nameTable.Title))
{
source.Title = ParseTextConstruct(reader, source);
}
else if (localname.Equals(this.nameTable.Updated))
{
source.Updated = DateTime.Parse(Utilities.DecodedValue(reader.ReadString()), CultureInfo.InvariantCulture);
}
else if (localname.Equals(this.nameTable.Link))
{
source.Links.Add(ParseLink(reader, source));
}
else if (localname.Equals(this.nameTable.Id))
{
source.Id = source.CreateAtomSubElement(reader, this) as AtomId;
ParseBaseLink(reader, source.Id);
}
else if (localname.Equals(this.nameTable.Icon))
{
source.Icon = source.CreateAtomSubElement(reader, this) as AtomIcon;
ParseBaseLink(reader, source.Icon);
}
else if (localname.Equals(this.nameTable.Logo))
{
source.Logo = source.CreateAtomSubElement(reader, this) as AtomLogo;
ParseBaseLink(reader, source.Logo);
}
else if (localname.Equals(this.nameTable.Author))
{
source.Authors.Add(ParsePerson(reader, source));
}
else if (localname.Equals(this.nameTable.Contributor))
{
source.Contributors.Add(ParsePerson(reader, source));
}
else if (localname.Equals(this.nameTable.Subtitle))
{
source.Subtitle = ParseTextConstruct(reader, source);
}
else if (localname.Equals(this.nameTable.Rights))
{
source.Rights = ParseTextConstruct(reader, source);
}
else if (localname.Equals(this.nameTable.Generator))
{
source.Generator = ParseGenerator(reader, source);
}
else if (localname.Equals(this.nameTable.Category))
{
// need to make this another colleciton
source.Categories.Add(ParseCategory(reader, source));
}
else if (feed != null && localname.Equals(this.nameTable.Entry))
{
ParseEntry(reader);
}
// this will either move the reader to the end of an element
// if at the end, to the start of a new one.
reader.Read();
}
else if (feed != null && IsCurrentNameSpace(reader, BaseNameTable.gBatchNamespace))
{
// parse the google batch extensions if they are there
ParseBatch(reader, feed);
}
else if (feed != null && IsCurrentNameSpace(reader, BaseNameTable.OpenSearchNamespace(this.versionInfo)))
{
if (localname.Equals(this.nameTable.TotalResults))
{
feed.TotalResults = int.Parse(Utilities.DecodedValue(reader.ReadString()), CultureInfo.InvariantCulture);
}
else if (localname.Equals(this.nameTable.StartIndex))
{
feed.StartIndex = int.Parse(Utilities.DecodedValue(reader.ReadString()), CultureInfo.InvariantCulture);
}
else if (localname.Equals(this.nameTable.ItemsPerPage))
{
feed.ItemsPerPage = int.Parse(Utilities.DecodedValue(reader.ReadString()), CultureInfo.InvariantCulture);
}
}
else
{
// default extension parsing.
ParseExtensionElements(reader, source);
}
}
return;
}
/////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
/// <summary>default constructor so that FxCop does not complain</summary>
//////////////////////////////////////////////////////////////////////
public GDataBatchRequestException(AtomFeed batchResult)
{
this.batchResult = batchResult;
}
private BlogEntry MapEntry(AtomEntry entry, AtomFeed comments)
{
BlogEntry blogEntry = MapEntry(entry);
blogEntry.Comments = new List<Comment>();
foreach (AtomEntry atomComment in comments.Entries)
{
Comment comment = new Comment();
comment.Content = atomComment.Content.Content;
comment.PubDate = atomComment.Published;
comment.Author = atomComment.Authors[0].Name;
comment.id = CommentIdRegex.Match(atomComment.SelfUri.Content).Groups["commentid"].Value;
blogEntry.Comments.Add(comment);
}
return blogEntry;
}
/////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
/// <summary>overloaded to make eventfiring easier</summary>
/// <param name="feed"> the new feed to fire</param>
//////////////////////////////////////////////////////////////////////
protected void OnNewAtomEntry(AtomFeed feed)
{
FeedParserEventArgs args = new FeedParserEventArgs(feed, null);
this.OnNewAtomEntry(args);
}
/// <summary>constructor</summary>
public AtomEntryCollection(AtomFeed feed)
: base()
{
this.feed = feed;
}
private static void DisplayFeed(AtomFeed myFeed)
{
foreach (AtomEntry entry in myFeed.Entries)
{
System.Diagnostics.Debug.WriteLine(entry.Id.AbsoluteUri + ", ");
}
}
public void FeedTest()
{
Uri uri = new Uri("http://www.test.com/");
IService service = new Service();
ServiceEventArgs target = new ServiceEventArgs(uri, service); // TODO: Initialize to an appropriate value
AtomFeed expected = new AtomFeed(uri, service);
AtomFeed actual;
target.Feed = expected;
actual = target.Feed;
Assert.AreEqual(expected, actual);
}
/// <summary>public AtomSource(AtomFeed feed)</summary>
public AtomSource(AtomFeed feed)
: this() {
Tracing.Assert(feed != null, "feed should not be null");
if (feed == null) {
throw new ArgumentNullException("feed");
}
// now copy them
this.authors = feed.Authors;
this.contributors = feed.Contributors;
this.categories = feed.Categories;
this.Generator = feed.Generator;
this.Icon = feed.Icon;
this.Logo = feed.Logo;
this.Id = feed.Id;
this.links = feed.Links;
this.Rights = feed.Rights;
this.Subtitle = feed.Subtitle;
this.Title = feed.Title;
this.Updated = feed.Updated;
}
/////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
/// <summary>virtual, starts the parsing process</summary>
/// <param name="streamInput">input stream to parse </param>
/// <param name="feed">the basefeed object that should be set</param>
//////////////////////////////////////////////////////////////////////
public abstract void Parse(Stream streamInput, AtomFeed feed);