/// <summary>eventhandler - called for event extension element
/// </summary>
/// <param name="sender">the object which send the event</param>
/// <param name="e">FeedParserEventArguments, holds the feedEntry</param>
/// <returns> </returns>
protected void OnNewExtensionsElement(object sender, ExtensionElementEventArgs e)
{
if (e == null)
{
throw new ArgumentNullException("e");
}
AtomFeedParser parser = sender as AtomFeedParser;
if (e.Base.XmlName == AtomParserNameTable.XmlAtomEntryElement)
{
// the base is the Entry of the feed, let's call our parsing on the Entry
AtomEntry entry = e.Base as AtomEntry;
if (entry != null)
{
entry.Parse(e, parser);
}
}
else
{
HandleExtensionElements(e, parser);
}
}
//////////////////////////////////////////////////////////////////////
/// <summary>helper method to create a new, decoupled entry based on a feedEntry</summary>
/// <param name="entryToImport">the entry from a feed that you want to put somewhere else</param>
/// <returns> the new entry ready to be inserted</returns>
//////////////////////////////////////////////////////////////////////
public static AtomEntry ImportFromFeed(AtomEntry entryToImport)
{
//Tracing.Assert(entryToImport != null, "entryToImport should not be null");
if (entryToImport == null)
{
throw new ArgumentNullException("entryToImport");
}
AtomEntry entry = null;
entry = (AtomEntry)Activator.CreateInstance(entryToImport.GetType());
entry.CopyEntry(entryToImport);
entry.Id = null;
// if the source is empty, set the source to the old feed
if (entry.Source == null)
{
entry.Source = entryToImport.Feed;
}
//Tracing.TraceInfo("Imported entry: " + entryToImport.Title.Text + " to: " + entry.Title.Text);
return(entry);
}
/////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
/// <summary>reads one of the feed entries at a time</summary>
/// <param name="reader"> XmlReader positioned at the entry element</param>
/// <returns> notifies user using event mechanism</returns>
//////////////////////////////////////////////////////////////////////
public void ParseEntry(XmlReader reader)
{
//Tracing.Assert(reader != null, "reader should not be null");
if (reader == null)
{
throw new ArgumentNullException("reader");
}
object localname = reader.LocalName;
//Tracing.TraceCall("Parsing atom entry");
if (localname.Equals(this.nameTable.Entry) == false)
{
throw new ClientFeedException("trying to parse an atom entry, but reader is not at the right spot");
}
AtomEntry entry = OnCreateNewEntry();
ParseBasicAttributes(reader, entry);
// remember the depth of entry
int depth = -1;
while (NextChildElement(reader, ref depth))
{
localname = reader.LocalName;
if (IsCurrentNameSpace(reader, BaseNameTable.NSAtom))
{
if (localname.Equals(this.nameTable.Id))
{
entry.Id = entry.CreateAtomSubElement(reader, this) as AtomId;
ParseBaseLink(reader, entry.Id);
}
else if (localname.Equals(this.nameTable.Link))
{
entry.Links.Add(ParseLink(reader, entry));
}
else if (localname.Equals(this.nameTable.Updated))
{
entry.Updated = DateTime.Parse(Utilities.DecodedValue(reader.ReadString()), CultureInfo.InvariantCulture);
}
else if (localname.Equals(this.nameTable.Published))
{
entry.Published = DateTime.Parse(Utilities.DecodedValue(reader.ReadString()), CultureInfo.InvariantCulture);
}
else if (localname.Equals(this.nameTable.Author))
{
entry.Authors.Add(ParsePerson(reader, entry));
}
else if (localname.Equals(this.nameTable.Contributor))
{
entry.Contributors.Add(ParsePerson(reader, entry));
}
else if (localname.Equals(this.nameTable.Rights))
{
entry.Rights = ParseTextConstruct(reader, entry);
}
else if (localname.Equals(this.nameTable.Category))
{
AtomCategory category = ParseCategory(reader, entry);
entry.Categories.Add(category);
}
else if (localname.Equals(this.nameTable.Summary))
{
entry.Summary = ParseTextConstruct(reader, entry);
}
else if (localname.Equals(this.nameTable.Content))
{
entry.Content = ParseContent(reader, entry);
}
else if (localname.Equals(this.nameTable.Source))
{
entry.Source = entry.CreateAtomSubElement(reader, this) as AtomSource;
ParseSource(reader, entry.Source);
}
else if (localname.Equals(this.nameTable.Title))
{
entry.Title = ParseTextConstruct(reader, entry);
}
// all parse methods should leave the reader at the end of their element
reader.Read();
}
else if (IsCurrentNameSpace(reader, BaseNameTable.gBatchNamespace))
{
// parse the google batch extensions if they are there
ParseBatch(reader, entry);
}
else
{
// default extension parsing
ParseExtensionElements(reader, entry);
}
}
OnNewAtomEntry(entry);
return;
}
/////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
/// <summary>overloaded to make it easier to fire the event</summary>
/// <param name="newEntry">the new AtomEntry to fire </param>
//////////////////////////////////////////////////////////////////////
protected void OnNewAtomEntry(AtomEntry newEntry)
{
FeedParserEventArgs args = new FeedParserEventArgs(null, newEntry);
this.OnNewAtomEntry(args);
}
public AsyncSendData(AsyncDataHandler handler, AtomEntry entry, SendOrPostCallback callback, object userData)
: this(handler, null, entry, null, callback, userData, false)
{
}
public void DeleteAsync(AtomEntry entry, bool permanentDelete, Object userData)
{
AsyncDeleteData data = new AsyncDeleteData(entry, permanentDelete, userData, ProgressReportDelegate);
AsyncStarter(data, AsyncDeleteWorker, userData);
}
public AsyncDeleteData(AtomEntry entry, bool permanentDelete, object userData, SendOrPostCallback callback)
: base(null, userData, callback)
{
_entry = entry;
_permanentDelete = permanentDelete;
}
