public FeatureResult(FeatureResult result)
: this((Terradue.GeoJson.Feature.Feature)result)
{
links = new Collection<SyndicationLink>(result.Links);
elementExtensions = new SyndicationElementExtensionCollection(result.elementExtensions);
this.Title = result.Title;
this.LastUpdatedTime = result.LastUpdatedTime;
base.Id = result.Id;
this.authors = result.Authors;
this.categories = result.Categories;
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
FeatureResult f = new FeatureResult();
JToken jsont = serializer.Deserialize<JToken>(reader);
if (jsont.SelectToken("id") != null)
f.Id = jsont.SelectToken("id").ToString();
if (jsont.SelectToken("properties") != null)
GenericFunctions.ImportProperties(jsont.SelectToken("properties"), f);
if (jsont.SelectToken("geometry") != null) {
GeometryConverter geomConverter = new GeometryConverter();
f.Geometry = (GeometryObject)geomConverter.ReadJson(jsont.SelectToken("geometry").CreateReader(), typeof(GeometryObject), jsont, serializer);
}
return f;
}
public FeatureResult ImportItem(IOpenSearchResultItem result)
{
if (result == null)
throw new ArgumentNullException("result");
FeatureResult feature;
XmlDocument doc = new XmlDocument();
List<XmlElement> elements = new List<XmlElement>();
foreach (var ext in result.ElementExtensions) {
XmlElement element = ext.GetObject<XmlElement>();
elements.Add(element);
}
XmlElement geometry = ImportUtils.FindGmlGeometry(elements.ToArray());
if (geometry != null)
feature = new FeatureResult(Terradue.GeoJson.Geometry.GeometryFactory.GmlToFeature(geometry));
else {
geometry = util.FindDctSpatialGeometry(elements.ToArray());
if (geometry != null)
feature = new FeatureResult(Terradue.GeoJson.Geometry.GeometryFactory.WktToFeature(geometry.InnerXml));
else
feature = new FeatureResult(Terradue.GeoJson.Geometry.GeometryFactory.WktToFeature(null));
}
NameValueCollection namespaces = null;
XmlNamespaceManager xnsm = null;
string prefix = "";
feature.Id = result.Id;
feature.Identifier = result.identifier;
if (result.Date != null)
feature.Properties.Add(prefix + "published", result.Date.ToString("yyyy'-'MM'-'dd'T'HH':'mm':'ss'Z'"));
if (result.Links != null && result.Links.Count > 0) {
feature.Links = result.Links;
}
if (result.Title != null)
feature.Title = result.Title;
return feature;
}
public static FeatureResult FromOpenSearchResultItem(IOpenSearchResultItem result)
{
if (result == null)
throw new ArgumentNullException("result");
FeatureResult feature;
var geom = ImportUtils.FindGeometry(result);
if (geom != null)
feature = new FeatureResult(new Feature(geom, null));
else
feature = new FeatureResult();
feature.ElementExtensions = new SyndicationElementExtensionCollection(result.ElementExtensions);
feature.Id = result.Id;
feature.LastUpdatedTime = result.LastUpdatedTime;
feature.PublishDate = result.PublishDate;
feature.Summary = result.Summary;
feature.Content = result.Content;
feature.contributors = result.Contributors;
feature.authors = result.Authors;
feature.Title = result.Title;
feature.categories = result.Categories;
feature.Copyright = result.Copyright;
feature.Identifier = result.Identifier;
feature.Links = new Collection<SyndicationLink>(result.Links);
feature.sortKey = result.SortKey;
return feature;
}
public FeatureResult ImportItem(SyndicationItem item)
{
if (item != null) {
List<XmlElement> elements = new List<XmlElement>();
foreach (var element in item.ElementExtensions) {
elements.Add(element.GetObject<XmlElement>());
}
XmlElement geometry = ImportUtils.FindGmlGeometry(elements.ToArray());
FeatureResult feature = new FeatureResult(Terradue.GeoJson.Geometry.GeometryFactory.GmlToFeature(geometry));
NameValueCollection namespaces = null;
XmlNamespaceManager xnsm = null;
string prefix = "";
if (options.KeepNamespaces) {
// Initialize namespaces
namespaces = new NameValueCollection();
namespaces.Set("", "http://geojson.org/ns#");
namespaces.Set("atom", "http://www.w3.org/2005/Atom");
XmlReader reader = item.ElementExtensions.GetReaderAtElementExtensions();
xnsm = new XmlNamespaceManager(reader.NameTable);
foreach (var names in xnsm.GetNamespacesInScope(XmlNamespaceScope.All)) {
namespaces.Set(names.Key, names.Value);
}
feature.Properties.Add("@namespaces", namespaces);
prefix = "atom:";
}
// Import Item
if ((item.Authors != null) && (item.Authors.Count > 0)) {
object[] authors = new object[item.Authors.Count];
feature.Properties.Add(prefix + "authors", authors);
for (int i = 0; i < item.Authors.Count; i++) {
Dictionary<string,object> author = new Dictionary<string, object>();
author.Add(prefix + "name", item.Authors[i].Name);
author.Add(prefix + "email", item.Authors[i].Email);
author.Add(prefix + "uri", item.Authors[i].Uri);
author = author.Union(util.ImportAttributeExtensions(item.Authors[i].AttributeExtensions, namespaces, xnsm)).ToDictionary(x => x.Key, x => x.Value);
author = author.Union(util.ImportElementExtensions(item.Authors[i].ElementExtensions, namespaces)).ToDictionary(x => x.Key, x => x.Value);
authors[i] = author;
}
}
if (item.BaseUri != null) {
feature.Properties.Add(prefix + "uri", item.BaseUri.ToString());
}
if ((item.Categories != null) && (item.Categories.Count > 0)) {
object[] categories = new object[item.Categories.Count];
feature.Properties.Add(prefix + "categories", categories);
for (int i = 0; i < item.Categories.Count; i++) {
Dictionary<string,object> category = new Dictionary<string, object>();
category.Add(prefix + "name", item.Categories[i].Name);
category.Add(prefix + "label", item.Categories[i].Label);
category.Add(prefix + "scheme", item.Categories[i].Scheme);
category = category.Union(util.ImportAttributeExtensions(item.Categories[i].AttributeExtensions, namespaces, xnsm)).ToDictionary(x => x.Key, x => x.Value);
category = category.Union(util.ImportElementExtensions(item.Categories[i].ElementExtensions, namespaces)).ToDictionary(x => x.Key, x => x.Value);
categories[i] = category;
}
}
if ((item.Contributors != null) && (item.Contributors.Count > 0)) {
object[] contributors = new object[item.Contributors.Count];
feature.Properties.Add(prefix + "categories", contributors);
for (int i = 0; i < item.Contributors.Count; i++) {
Dictionary<string,object> contributor = new Dictionary<string, object>();
contributor.Add(prefix + "name", item.Contributors[i].Name);
contributor.Add(prefix + "email", item.Contributors[i].Email);
contributor.Add(prefix + "uri", item.Contributors[i].Uri);
contributor = contributor.Union(util.ImportAttributeExtensions(item.Contributors[i].AttributeExtensions, namespaces, xnsm)).ToDictionary(x => x.Key, x => x.Value);
contributor = contributor.Union(util.ImportElementExtensions(item.Contributors[i].ElementExtensions, namespaces)).ToDictionary(x => x.Key, x => x.Value);
contributors[i] = contributor;
}
}
if (item.Copyright != null) {
feature.Properties.Add(prefix + "rights", item.Copyright.Text);
}
if (item.Summary != null) {
feature.Properties.Add(prefix + "summary", item.Summary.Text);
}
if (item.Content != null) {
feature.Properties.Add(prefix + "content", item.Summary.Text);
}
feature.Id = item.Id;
if (item.LastUpdatedTime != null)
feature.Properties.Add(prefix + "published", item.LastUpdatedTime);
if ((item.Links != null) && (item.Links.Count > 0)) {
feature.Links = item.Links;
}
if (item.Title != null)
feature.Properties.Add(prefix + "title", item.Title);
return feature;
}
return null;
}
public static Dictionary<string, object> ExportProperties(FeatureResult feature)
{
// Start with an empty NameValueCollection
Dictionary <string,object> properties = new Dictionary<string, object>();
if (feature.Links != null && feature.Links.Count > 0) {
properties["links"] = GenericFunctions.LinksToProperties(feature.Links);
}
if (feature.LastUpdatedTime.Ticks != 0)
properties["updated"] = feature.LastUpdatedTime.ToUniversalTime().ToString("yyyy-MM-ddTHH:mm:ssZ");
if (feature.PublishDate.Ticks != 0)
properties["published"] = feature.PublishDate.ToUniversalTime().ToString("yyyy-MM-ddTHH:mm:ssZ");
if (feature.Title != null)
properties["title"] = feature.Title.Text;
if (feature.Summary != null)
properties["summary"] = feature.Summary.Text;
if (feature.Content != null) {
var dic = new Dictionary<string, string>();
if (!string.IsNullOrEmpty(feature.Content.Type))
dic.Add("type", feature.Content.Type);
if (feature.Content is XmlSyndicationContent)
{
MemoryStream ms = new MemoryStream();
var xw = XmlWriter.Create(ms);
(feature.Content as XmlSyndicationContent).WriteTo(xw, "content", "");
xw.Flush();
ms.Seek(0, SeekOrigin.Begin);
dic.Add("value", XElement.Load(XmlReader.Create(ms)).Value);
}
if (feature.Content is TextSyndicationContent)
{
dic.Add("value", (feature.Content as TextSyndicationContent).Text);
}
if (feature.Content is UrlSyndicationContent)
{
dic.Add("src", (feature.Content as UrlSyndicationContent).Url.ToString());
}
properties["content"] = dic;
}
if (feature.Authors != null && feature.Authors.Count > 0) {
List<object> authors = new List<object>();
foreach (var author in feature.Authors) {
Dictionary<string,object> authord = GenericFunctions.ExportSyndicationElementExtensions(author.ElementExtensions);
if (authord == null)
authord = new Dictionary<string, object>();
authord.Add("email", author.Email);
authord.Add("name", author.Name);
if (author.Uri != null)
authord.Add("uri", author.Uri.ToString());
authors.Add(authord);
}
properties["authors"] = authors;
}
if (feature.Categories != null && feature.Categories.Count > 0) {
List<object> categories = new List<object>();
foreach (var category in feature.Categories) {
Dictionary<string,object> cat = GenericFunctions.ExportSyndicationElementExtensions(category.ElementExtensions);
if (cat == null)
cat = new Dictionary<string, object>();
cat.Add("@term", category.Name);
cat.Add("@label", category.Label);
cat.Add("@scheme", category.Scheme);
categories.Add(cat);
}
properties["categories"] = categories;
}
if (feature.Copyright != null) {
properties["copyright"] = feature.Copyright.Text;
}
var exts = GenericFunctions.ExportSyndicationElementExtensions(feature.ElementExtensions);
properties = properties.Concat(exts).ToDictionary(x => x.Key, x => x.Value);
return properties;
}
public static void ImportProperties(JToken propObject, FeatureResult feature)
{
foreach (var child in propObject.Children<JProperty>()) {
if (child.Path == "properties.authors") {
foreach (var linkObject in child.Values())
feature.Authors.Add(SyndicationPersonFromJTokenList(linkObject));
continue;
}
if (child.Path == "properties.contirbutors") {
foreach (var linkObject in child.Values())
feature.Contributors.Add(SyndicationPersonFromJTokenList(linkObject));
continue;
}
if (child.Path == "properties.title") {
feature.Title = GenericFunctions.TryTextSyndicationContent(child);
continue;
}
if (child.Path == "properties.links") {
foreach (var linkObject in child.Values())
feature.Links.Add(SyndicationLinkFromJTokenList(linkObject));
continue;
}
if (child.Path == "properties.published") {
feature.PublishDate = child.Values().First().Value<DateTime>();
continue;
}
if (child.Path == "properties.updated") {
feature.LastUpdatedTime = child.Values().First().Value<DateTime>();
continue;
}
if (child.Path == "properties.summary") {
feature.Summary = GenericFunctions.TryTextSyndicationContent(child);
continue;
}
if (child.Path == "properties.content") {
feature.Content = GenericFunctions.TrySyndicationContent(child);
continue;
}
if (child.Path == "properties.copyright") {
feature.Copyright = GenericFunctions.TryTextSyndicationContent(child);
continue;
}
try {
if (child.Value.Type == JTokenType.Array) {
foreach (var child1 in child.Value) {
var xmlReader = JsonConvert.DeserializeXNode("{" + child.Name + ":" + child1.ToString() + "}").CreateReader();
feature.ElementExtensions.Add(new SyndicationElementExtension(xmlReader));
}
} else {
var xmlReader = JsonConvert.DeserializeXNode("{" + child.ToString() + "}").CreateReader();
feature.ElementExtensions.Add(new SyndicationElementExtension(xmlReader));
}
} catch (Exception) {
}
}
}
