public static SiteInfo GetSiteInfo(string filePath)
{
var siteInfo = new SiteInfo();
if (!FileUtils.IsFileExists(filePath))
{
return(siteInfo);
}
var feed = AtomFeed.Load(FileUtils.GetFileStreamReadOnly(filePath));
siteInfo.SiteName = AtomUtility.GetDcElementContent(feed.AdditionalElements, new List <string> {
SiteAttribute.SiteName, "PublishmentSystemName"
});
siteInfo.SiteDir = AtomUtility.GetDcElementContent(feed.AdditionalElements, new List <string> {
SiteAttribute.SiteDir, "PublishmentSystemDir"
});
if (siteInfo.SiteDir != null && siteInfo.SiteDir.IndexOf("\\", StringComparison.Ordinal) != -1)
{
siteInfo.SiteDir = siteInfo.SiteDir.Substring(siteInfo.SiteDir.LastIndexOf("\\", StringComparison.Ordinal) + 1);
}
siteInfo.SettingsXml = AtomUtility.GetDcElementContent(feed.AdditionalElements, SiteAttribute.SettingsXml);
siteInfo.Additional.IsCreateDoubleClick = false;
return(siteInfo);
}
/// <summary>
/// Provides example code for the Load(XmlReader) method
/// </summary>
public static void LoadXmlReaderExample()
{
#region Load(XmlReader reader)
AtomFeed feed = new AtomFeed();
using (Stream stream = new FileStream("AtomFeed.xml", FileMode.Open, FileAccess.Read))
{
XmlReaderSettings settings = new XmlReaderSettings();
settings.IgnoreComments = true;
settings.IgnoreWhitespace = true;
using (XmlReader reader = XmlReader.Create(stream, settings))
{
feed.Load(reader);
foreach (AtomEntry entry in feed.Entries)
{
if (entry.PublishedOn >= DateTime.Today)
{
// Perform some processing on the feed entry
}
}
}
}
#endregion
}
public void AtomFeedReader_MultiPageEnumerator()
{
var page1 = new AtomFeed();
var page2 = new AtomFeed();
using (var stream = new MemoryStream(Encoding.UTF8.GetBytes(Resources.TestFeed)))
{
page1.Load(stream);
stream.Seek(0, SeekOrigin.Begin);
page2.Load(stream);
}
page1.SetOpenSearchStartIndex(1);
page1.SetOpenSearchItemsPerPage(1);
((IList <AtomEntry>)page1.Entries).RemoveAt(1);
page2.SetOpenSearchStartIndex(2);
page2.SetOpenSearchItemsPerPage(1);
((IList <AtomEntry>)page2.Entries).RemoveAt(0);
var pages = new Stack <AtomFeed>(new[] { page2, page1 });
var request = new SDataResourceCollectionRequest(_service);
_mock.Setup(s => s.ReadFeed(request)).Returns(pages.Pop).AtMost(2);
var reader = request.ExecuteReader();
reader.ToList();
}
private static AtomFeed LoadFeedContent(Stream stream)
{
var feed = new AtomFeed();
feed.Load(stream);
return(feed);
}
public void TestNameIsNotEmail()
{
foreach (string file in files)
{
feed = AtomFeed.Load(file);
if (feed.Author != null)
{
Assert.IsFalse(AU.Utils.IsEmail(feed.Author.Name));
}
foreach (AtomPersonConstruct contributor in feed.Contributors)
{
Assert.IsFalse(AU.Utils.IsEmail(contributor.Name));
}
foreach (AtomEntry entry in feed.Entries)
{
if (entry.Author != null)
{
Assert.IsFalse(AU.Utils.IsEmail(entry.Author.Name));
}
foreach (AtomPersonConstruct contributor in entry.Contributors)
{
Assert.IsFalse(AU.Utils.IsEmail(contributor.Name));
}
}
}
}
/// <summary>
/// Given a package filename, loads the metadata from the MSI
/// </summary>
/// <param name="localPackagePath"> The local package path. </param>
/// <returns> </returns>
/// <remarks>
/// </remarks>
internal static Package GetCoAppPackageFileInformation(string localPackagePath)
{
if (!IsValidPackageFile(localPackagePath))
{
return(null);
}
var packageProperties = GetMsiProperties(localPackagePath);
// pull out the rules & feed, send the info to the pm.
var atomFeedText = packageProperties["CoAppPackageFeed"];
var canonicalName = packageProperties["CanonicalName"];
var feed = AtomFeed.Load(atomFeedText);
var result = feed.Packages.FirstOrDefault(each => each != null && each.CanonicalName == canonicalName);
if (result != null)
{
// set things that only we can do here...
result.LocalLocations.AddUnique(localPackagePath);
result.PackageHandler = Instance;
}
return(result);
}
public void DateExtensions()
{
var feed = AtomFeed.Load(XmlReader.Create(File.OpenRead("../in/offeringdateext.xml")));
OwsContextAtomFeed ows = new OwsContextAtomFeed(feed.Feed, true);
SerializationTest.SerializeToStream(ows, Console.OpenStandardOutput());
}
public void ImportRelatedField(bool overwrite)
{
if (!DirectoryUtils.IsDirectoryExists(_directoryPath))
{
return;
}
var filePaths = DirectoryUtils.GetFilePaths(_directoryPath);
foreach (var filePath in filePaths)
{
var feed = AtomFeed.Load(FileUtils.GetFileStreamReadOnly(filePath));
var title = AtomUtility.GetDcElementContent(feed.AdditionalElements, new List <string> {
nameof(RelatedFieldInfo.Title), "RelatedFieldName"
});
var totalLevel = TranslateUtils.ToInt(AtomUtility.GetDcElementContent(feed.AdditionalElements, nameof(RelatedFieldInfo.TotalLevel)));
var prefixes = AtomUtility.GetDcElementContent(feed.AdditionalElements, nameof(RelatedFieldInfo.Prefixes));
var suffixes = AtomUtility.GetDcElementContent(feed.AdditionalElements, nameof(RelatedFieldInfo.Suffixes));
var relatedFieldInfo = new RelatedFieldInfo(0, title, _siteId, totalLevel, prefixes, suffixes);
var srcRelatedFieldInfo = DataProvider.RelatedFieldDao.GetRelatedFieldInfo(_siteId, title);
if (srcRelatedFieldInfo != null)
{
if (overwrite)
{
DataProvider.RelatedFieldDao.Delete(srcRelatedFieldInfo.Id);
}
else
{
relatedFieldInfo.Title = DataProvider.RelatedFieldDao.GetImportTitle(_siteId, relatedFieldInfo.Title);
}
}
var relatedFieldId = DataProvider.RelatedFieldDao.Insert(relatedFieldInfo);
var lastInertedLevel = 1;
var lastInsertedParentId = 0;
var lastInsertedId = 0;
foreach (AtomEntry entry in feed.Entries)
{
var itemName = AtomUtility.GetDcElementContent(entry.AdditionalElements, nameof(RelatedFieldItemInfo.ItemName));
var itemValue = AtomUtility.GetDcElementContent(entry.AdditionalElements, nameof(RelatedFieldItemInfo.ItemValue));
var level = TranslateUtils.ToInt(AtomUtility.GetDcElementContent(entry.AdditionalElements, "Level"));
var parentId = 0;
if (level > 1)
{
parentId = level != lastInertedLevel ? lastInsertedId : lastInsertedParentId;
}
var relatedFieldItemInfo = new RelatedFieldItemInfo(0, relatedFieldId, itemName, itemValue, parentId, 0);
lastInsertedId = DataProvider.RelatedFieldItemDao.Insert(relatedFieldItemInfo);
lastInsertedParentId = parentId;
lastInertedLevel = level;
}
}
}
public void ImportContents(string filePath, bool isOverride, ChannelInfo nodeInfo, int taxis, bool isChecked, int checkedLevel, int adminId, int userId, int sourceId)
{
if (!FileUtils.IsFileExists(filePath))
{
return;
}
var feed = AtomFeed.Load(FileUtils.GetFileStreamReadOnly(filePath));
ImportContents(feed.Entries, nodeInfo, taxis, false, isChecked, checkedLevel, isOverride, adminId, userId, sourceId);
}
public void ImportContents(string filePath, bool isOverride, ChannelInfo nodeInfo, int taxis, int importStart, int importCount, bool isChecked, int checkedLevel, string adminName)
{
if (!FileUtils.IsFileExists(filePath))
{
return;
}
var feed = AtomFeed.Load(FileUtils.GetFileStreamReadOnly(filePath));
ImportContents(feed.Entries, nodeInfo, taxis, importStart, importCount, false, isChecked, checkedLevel, isOverride, adminName);
}
public async Task ImportContentsAsync(string filePath, bool isOverride, Channel channel, int taxis, int importStart, int importCount, bool isChecked, int checkedLevel, int adminId, string guid)
{
if (!FileUtils.IsFileExists(filePath))
{
return;
}
var feed = AtomFeed.Load(FileUtils.GetFileStreamReadOnly(filePath));
await ImportContentsAsync(feed.Entries, channel, taxis, importStart, importCount, false, isChecked, checkedLevel, isOverride, adminId, guid);
}
public List <int> ImportContents(string filePath, bool isOverride, ChannelInfo channelInfo, bool isChecked, int checkedLevel, int adminId, int userId, int sourceId)
{
if (!FileUtils.IsFileExists(filePath))
{
return(null);
}
var feed = AtomFeed.Load(FileUtils.GetFileStreamReadOnly(filePath));
return(ImportContents(feed.Entries, channelInfo, false, isChecked, checkedLevel, isOverride, adminId, userId, sourceId));
}
public void ImportTagStyle(bool overwrite)
{
if (!FileUtils.IsFileExists(_filePath))
{
return;
}
var feed = AtomFeed.Load(FileUtils.GetFileStreamReadOnly(_filePath));
foreach (AtomEntry entry in feed.Entries)
{
var styleName = AtomUtility.GetDcElementContent(entry.AdditionalElements, "StyleName");
if (!string.IsNullOrEmpty(styleName))
{
var tagStyleInfo = new TagStyleInfo
{
StyleName = styleName,
ElementName = AtomUtility.GetDcElementContent(entry.AdditionalElements, "ElementName"),
PublishmentSystemID = _publishmentSystemId,
IsTemplate =
TranslateUtils.ToBool(AtomUtility.GetDcElementContent(entry.AdditionalElements, "IsTemplate")),
StyleTemplate =
AtomUtility.Decrypt(AtomUtility.GetDcElementContent(entry.AdditionalElements,
"StyleTemplate")),
ScriptTemplate =
AtomUtility.Decrypt(AtomUtility.GetDcElementContent(entry.AdditionalElements,
"ScriptTemplate")),
ContentTemplate =
AtomUtility.Decrypt(AtomUtility.GetDcElementContent(entry.AdditionalElements,
"ContentTemplate")),
SettingsXML =
AtomUtility.Decrypt(AtomUtility.GetDcElementContent(entry.AdditionalElements, "SettingsXML"))
};
var srcTagStyleInfo = DataProvider.TagStyleDao.GetTagStyleInfo(_publishmentSystemId, tagStyleInfo.ElementName, tagStyleInfo.StyleName);
if (srcTagStyleInfo != null)
{
if (overwrite)
{
tagStyleInfo.StyleID = srcTagStyleInfo.StyleID;
DataProvider.TagStyleDao.Update(tagStyleInfo);
}
else
{
tagStyleInfo.StyleName = DataProvider.TagStyleDao.GetImportStyleName(_publishmentSystemId, tagStyleInfo.ElementName, tagStyleInfo.StyleName);
DataProvider.TagStyleDao.Insert(tagStyleInfo);
}
}
else
{
DataProvider.TagStyleDao.Insert(tagStyleInfo);
}
}
}
}
public void TestStream()
{
for (int i = 0; i < files.Length; i++)
{
FileStream stream = File.OpenRead(files[i]);
feed = AtomFeed.Load(stream);
Assert.IsNotNull(feed);
MemoryStream memStream = new MemoryStream();
feed.Save(memStream);
stream.Close();
}
}
public void TestXmlBaseContentUri()
{
AtomFeed feed = AtomFeed.Load(@"..\..\tests\feeds\pilgrim.xml", new Uri("http://purl.org/atom/ns#"));
foreach (AtomEntry entry in feed.Entries)
{
foreach (AtomContent content in entry.Contents)
{
Assert.IsNotNull(content.XmlBase);
Assert.IsTrue(content.XmlBase.ToString().StartsWith("http://diveintomark.org/"));
}
}
}
public void ImportContents(string filePath, bool isOverride, NodeInfo nodeInfo, int taxis, int importStart, int importCount, bool isChecked, int checkedLevel)
{
if (!FileUtils.IsFileExists(filePath))
{
return;
}
var feed = AtomFeed.Load(FileUtils.GetFileStreamReadOnly(filePath));
ImportContents(feed.Entries, nodeInfo, taxis, importStart, importCount, false, isChecked, checkedLevel, isOverride);
//this.FSO.CreateRedirectChannel(nodeID);
//this.FSO.AddChannelToWaitingCreate(nodeInfo.NodeID);
}
public void TestSaveToFile()
{
Init();
string filename = "test";
for (int i = 0; i < files.Length; i++)
{
feed = AtomFeed.Load(files[i], new Uri("http://purl.org/atom/ns#"));
Assert.IsNotNull(feed);
feed.Save(filename);
File.Delete(filename);
}
}
public void TestXmlBaseFeedUri()
{
foreach (string file in files)
{
FileInfo info = new FileInfo(file);
if (info.Name.ToLower() == "pilgrim.xml")
{
feed = AtomFeed.Load(file);
Assert.IsNotNull(feed.XmlBase);
Assert.AreEqual(feed.XmlBase.ToString(), "http://diveintomark.org/");
}
}
}
public void TestReaderWriter()
{
for (int i = 0; i < files.Length; i++)
{
StreamReader reader = new StreamReader(files[i]);
feed = AtomFeed.Load(reader);
Assert.IsNotNull(feed);
MemoryStream stream = new MemoryStream();
StreamWriter w = new StreamWriter(stream);
feed.Save(w);
stream.Close();
}
}
public void TestSaveToFile()
{
Init();
string filename = "test";
for (int i = 0; i < files.Length; i++)
{
feed = AtomFeed.Load(files[i]);
Assert.IsNotNull(feed);
feed.Save(filename);
File.Delete(filename);
}
}
public void TestUri()
{
for (int i = 0; i < files.Length; i++)
{
Console.WriteLine("{0}: {1}", i, files[i]);
feed = AtomFeed.Load(files[i]);
Assert.IsNotNull(feed.Uri);
foreach (AtomEntry entry in feed.Entries)
{
Assert.IsNotNull(entry.Uri);
}
}
}
public void Typical_Feed()
{
var xml = @"<feed xmlns=""http://www.w3.org/2005/Atom""
xmlns:sync=""http://schemas.sage.com/sdata/sync/2008/1"">
<sync:syncMode>catchUp</sync:syncMode>
<sync:digest>
<sync:origin>http://www.example.com/sdata/myApp1/myContract/-/accounts</sync:origin>
<sync:digestEntry>
<sync:endpoint>http://www.example.com/sdata/myApp1/myContract/-/accounts</sync:endpoint>
<sync:tick>6</sync:tick>
<sync:stamp>2008-10-30T17:23:08Z</sync:stamp>
<sync:conflictPriority>2</sync:conflictPriority>
</sync:digestEntry>
<sync:digestEntry>
<sync:endpoint>http://www.example.com/sdata/myApp2/myContract/-/accounts</sync:endpoint>
<sync:tick>10</sync:tick>
<sync:stamp>2008-10-30T12:16:51Z</sync:stamp>
<sync:conflictPriority>1</sync:conflictPriority>
</sync:digestEntry>
</sync:digest>
</feed>";
var feed = new AtomFeed();
using (var stream = new MemoryStream(Encoding.UTF8.GetBytes(xml)))
{
feed.Load(stream);
}
var syncMode = feed.GetSDataSyncMode();
Assert.That(syncMode, Is.EqualTo(SyncMode.CatchUp));
var digest = feed.GetSDataSyncDigest();
Assert.That(digest, Is.Not.Null);
Assert.That(digest.Origin, Is.EqualTo("http://www.example.com/sdata/myApp1/myContract/-/accounts"));
Assert.That(digest.Entries.Length, Is.EqualTo(2));
var entry = digest.Entries[0];
Assert.That(entry.EndPoint, Is.EqualTo("http://www.example.com/sdata/myApp1/myContract/-/accounts"));
Assert.That(entry.Tick, Is.EqualTo(6L));
Assert.That(entry.Stamp, Is.EqualTo(new DateTime(2008, 10, 30, 17, 23, 08)));
Assert.That(entry.ConflictPriority, Is.EqualTo(2));
entry = digest.Entries[1];
Assert.That(entry.EndPoint, Is.EqualTo("http://www.example.com/sdata/myApp2/myContract/-/accounts"));
Assert.That(entry.Tick, Is.EqualTo(10L));
Assert.That(entry.Stamp, Is.EqualTo(new DateTime(2008, 10, 30, 12, 16, 51)));
Assert.That(entry.ConflictPriority, Is.EqualTo(1));
}
public void ImportContentModelInfo(bool overwrite)
{
if (!FileUtils.IsFileExists(_filePath))
{
return;
}
var feed = AtomFeed.Load(FileUtils.GetFileStreamReadOnly(_filePath));
foreach (AtomEntry entry in feed.Entries)
{
var modelId = AtomUtility.GetDcElementContent(entry.AdditionalElements, "ModelID");
if (!string.IsNullOrEmpty(modelId))
{
var contentModelInfo = new ContentModelInfo
{
ModelId = modelId,
SiteId = _publishmentSystemId,
ModelName = AtomUtility.GetDcElementContent(entry.AdditionalElements, "ModelName"),
IsSystem =
TranslateUtils.ToBool(AtomUtility.GetDcElementContent(entry.AdditionalElements, "IsSystem")),
TableName = AtomUtility.GetDcElementContent(entry.AdditionalElements, "TableName"),
TableType =
EAuxiliaryTableTypeUtils.GetEnumType(
AtomUtility.GetDcElementContent(entry.AdditionalElements, "TableType")),
IconUrl = AtomUtility.GetDcElementContent(entry.AdditionalElements, "IconUrl"),
Description = AtomUtility.GetDcElementContent(entry.AdditionalElements, "Description")
};
var auxiliaryTableInfo = BaiRongDataProvider.TableCollectionDao.GetAuxiliaryTableInfo(modelId);
if (auxiliaryTableInfo != null && auxiliaryTableInfo.TableEnName == modelId)
{
if (overwrite)
{
BaiRongDataProvider.ContentModelDao.Update(contentModelInfo);
}
else
{
var importContentModelId = BaiRongDataProvider.ContentModelDao.GetImportContentModelId(_publishmentSystemId, contentModelInfo.ModelId);
contentModelInfo.ModelId = importContentModelId;
BaiRongDataProvider.ContentModelDao.Insert(contentModelInfo);
}
}
else
{
BaiRongDataProvider.ContentModelDao.Insert(contentModelInfo);
}
}
}
}
public void TestXmlReaderXmlWriter()
{
for (int i = 0; i < files.Length; i++)
{
XmlTextReader reader = new XmlTextReader(files[i]);
feed = AtomFeed.Load(reader);
Assert.IsNotNull(feed);
MemoryStream stream = new MemoryStream();
XmlTextWriter writer = new XmlTextWriter(stream,
System.Text.Encoding.Default);
feed.Save(writer);
stream.Close();
}
}
public void TestInvalidFeeds()
{
string filename = "test";
feedspath = @"..\..\tests\invalidfeeds\";
files = Directory.GetFiles(feedspath);
for (int i = 0; i < files.Length; i++)
{
feed = AtomFeed.Load(files[i]);
Assert.IsNotNull(feed);
feed.Save(filename);
File.Delete(filename);
}
}
public static void SingleImportTableStyle(ETableStyle tableStyle, string tableName, string styleDirectoryPath, int relatedIdentity)
{
if (!DirectoryUtils.IsDirectoryExists(styleDirectoryPath))
{
return;
}
var filePaths = DirectoryUtils.GetFilePaths(styleDirectoryPath);
foreach (var filePath in filePaths)
{
var feed = AtomFeed.Load(FileUtils.GetFileStreamReadOnly(filePath));
var attributeName = AtomUtility.GetDcElementContent(feed.AdditionalElements, "AttributeName");
var taxis = TranslateUtils.ToInt(AtomUtility.GetDcElementContent(feed.AdditionalElements, "Taxis"), 0);
var displayName = AtomUtility.GetDcElementContent(feed.AdditionalElements, "DisplayName");
var helpText = AtomUtility.GetDcElementContent(feed.AdditionalElements, "HelpText");
var isVisible = TranslateUtils.ToBool(AtomUtility.GetDcElementContent(feed.AdditionalElements, "IsVisible"));
var isVisibleInList = TranslateUtils.ToBool(AtomUtility.GetDcElementContent(feed.AdditionalElements, "IsVisibleInList"));
var isSingleLine = TranslateUtils.ToBool(AtomUtility.GetDcElementContent(feed.AdditionalElements, "IsSingleLine"));
var inputType = EInputTypeUtils.GetEnumType(AtomUtility.GetDcElementContent(feed.AdditionalElements, "InputType"));
var defaultValue = AtomUtility.GetDcElementContent(feed.AdditionalElements, "DefaultValue");
var isHorizontal = TranslateUtils.ToBool(AtomUtility.GetDcElementContent(feed.AdditionalElements, "IsHorizontal"));
//SettingsXML
var extendValues = AtomUtility.GetDcElementContent(feed.AdditionalElements, "ExtendValues");
var styleInfo = new TableStyleInfo(0, relatedIdentity, tableName, attributeName, taxis, displayName, helpText, isVisible, isVisibleInList, isSingleLine, EInputTypeUtils.GetValue(inputType), defaultValue, isHorizontal, extendValues);
var styleItems = new List <TableStyleItemInfo>();
foreach (AtomEntry entry in feed.Entries)
{
var itemTitle = AtomUtility.GetDcElementContent(entry.AdditionalElements, "ItemTitle");
var itemValue = AtomUtility.GetDcElementContent(entry.AdditionalElements, "ItemValue");
var isSelected = TranslateUtils.ToBool(AtomUtility.GetDcElementContent(entry.AdditionalElements, "IsSelected"));
styleItems.Add(new TableStyleItemInfo(0, 0, itemTitle, itemValue, isSelected));
}
if (styleItems.Count > 0)
{
styleInfo.StyleItems = styleItems;
}
if (TableStyleManager.IsExists(relatedIdentity, tableName, attributeName))
{
TableStyleManager.Delete(relatedIdentity, tableName, attributeName);
}
TableStyleManager.InsertWithTaxis(styleInfo, tableStyle);
}
}
/// <summary>
/// Provides example code for the Load(Uri, ICredentials, IWebProxy) method
/// </summary>
public static void LoadUriExample()
{
AtomFeed feed = new AtomFeed();
Uri source = new Uri("http://news.google.com/?output=atom");
feed.Load(source, CredentialCache.DefaultNetworkCredentials, null);
foreach (AtomEntry entry in feed.Entries)
{
if (entry.PublishedOn >= DateTime.Today)
{
// Perform some processing on the feed entry
}
}
}
public void ImportSeo(bool overwrite)
{
if (!FileUtils.IsFileExists(_filePath))
{
return;
}
var feed = AtomFeed.Load(FileUtils.GetFileStreamReadOnly(_filePath));
foreach (AtomEntry entry in feed.Entries)
{
var seoMetaId = ConvertHelper.GetInteger(AtomUtility.GetDcElementContent(entry.AdditionalElements, "SeoMetaID"));
if (!string.IsNullOrEmpty(seoMetaId.ToString()))
{
var seoInfo = new SeoMetaInfo();
seoInfo.SeoMetaId = seoMetaId;
seoInfo.PublishmentSystemId = _publishmentSystemId;
seoInfo.SeoMetaName = AtomUtility.GetDcElementContent(entry.AdditionalElements, "SeoMetaName");
seoInfo.IsDefault = TranslateUtils.ToBool(AtomUtility.GetDcElementContent(entry.AdditionalElements, "IsDefault"));
seoInfo.PageTitle = AtomUtility.GetDcElementContent(entry.AdditionalElements, "PageTitle");
seoInfo.Keywords = AtomUtility.GetDcElementContent(entry.AdditionalElements, "Keywords");
seoInfo.Description = AtomUtility.GetDcElementContent(entry.AdditionalElements, "Description");
seoInfo.Copyright = AtomUtility.GetDcElementContent(entry.AdditionalElements, "Copyright");
seoInfo.Author = AtomUtility.GetDcElementContent(entry.AdditionalElements, "Author");
seoInfo.Email = AtomUtility.GetDcElementContent(entry.AdditionalElements, "Email");
seoInfo.Language = AtomUtility.GetDcElementContent(entry.AdditionalElements, "Language");
seoInfo.Charset = AtomUtility.GetDcElementContent(entry.AdditionalElements, "Charset");
seoInfo.Distribution = AtomUtility.GetDcElementContent(entry.AdditionalElements, "Distribution");
seoInfo.Rating = AtomUtility.GetDcElementContent(entry.AdditionalElements, "Rating");
seoInfo.Robots = AtomUtility.GetDcElementContent(entry.AdditionalElements, "Robots");
seoInfo.RevisitAfter = AtomUtility.GetDcElementContent(entry.AdditionalElements, "RevisitAfter");
seoInfo.Expires = AtomUtility.GetDcElementContent(entry.AdditionalElements, "Expires");
var seoMetaInfo = DataProvider.SeoMetaDao.GetSeoMetaInfoBySeoMetaName(_publishmentSystemId, seoInfo.SeoMetaName);
if (seoMetaInfo != null)
{
if (overwrite)
{
DataProvider.SeoMetaDao.Update(seoInfo);
}
}
else
{
DataProvider.SeoMetaDao.Insert(seoInfo);
}
}
}
}
/// <summary>
/// Provides example code for the Load(IXPathNavigable) method
/// </summary>
public static void LoadIXPathNavigableExample()
{
XPathDocument source = new XPathDocument("http://news.google.com/?output=atom");
AtomFeed feed = new AtomFeed();
feed.Load(source);
foreach (AtomEntry entry in feed.Entries)
{
if (entry.PublishedOn >= DateTime.Today)
{
// Perform some processing on the feed entry
}
}
}
/// <summary>
/// Provides example code for the Load(Stream) method
/// </summary>
public static void LoadStreamExample()
{
AtomFeed feed = new AtomFeed();
using (Stream stream = new FileStream("AtomFeed.xml", FileMode.Open, FileAccess.Read))
{
feed.Load(stream);
foreach (AtomEntry entry in feed.Entries)
{
if (entry.PublishedOn >= DateTime.Today)
{
// Perform some processing on the feed entry
}
}
}
}
