public FeatureResult()
     : base()
 {
     links = new Collection<SyndicationLink>();
     elementExtensions = new SyndicationElementExtensionCollection();
     authors = new Collection<SyndicationPerson>();
     categories = new Collection<SyndicationCategory>();
     contributors = new Collection<SyndicationPerson>();
 }
        public void Clone_NoExtensions_ReturnsExpected()
        {
            var category = new SyndicationCategory();
            SyndicationElementExtensionCollection elementExtensions = category.ElementExtensions;

            SyndicationElementExtensionCollection clone = category.Clone().ElementExtensions;

            Assert.Empty(clone);
        }
        public static SyndicationElementExtensionCollection ToSyndicationElementExtensionCollection(this XmlElement[] elements)
        {
            SyndicationElementExtensionCollection extensions = new SyndicationElementExtensionCollection();

            foreach (var element in elements)
            {
                extensions.Add(element.ToSyndicationElementExtension());
            }

            return(extensions);
        }
Exemple #4
0
        public static string GetMediaVideoURL(SyndicationItem item)
        {
            string mediaVideoUrl = string.Empty;

            try
            {
                SyndicationElementExtensionCollection extensions = item.ElementExtensions;

                // Read extension items in order to find videos -> media:content.
                if (extensions != null && extensions.Count > 0)
                {
                    // media:group & media:content's
                    if (extensions.Count(p => p.OuterName == "group") == 1)
                    {
                        SyndicationElementExtension extensionGroup = extensions.First(p => p.OuterName == "group");
                        if (extensionGroup != null)
                        {
                            XNode      groupNode = XDocument.ReadFrom(extensionGroup.GetReader());
                            XDocument  doc       = XDocument.Parse(groupNode.ToString());
                            XNamespace media     = "http://search.yahoo.com/mrss/";
                            // Get content subitems inside group.
                            var query = (from contentElem in doc.Descendants(media + "content")
                                         select contentElem);
                            List <XElement> listContent = query.ToList();

                            if (listContent.Count > 0)
                            {
                                // Filter by type "video/mp4" | "video/x-ms-wmv"
                                var videoElems = new List <XElement>(listContent.Where(c => c.Attribute("type").Value == "video/mp4" && c.Attribute("url").Value.ToUpper().Contains("HIGH")));

                                if (!videoElems.Any())
                                {
                                    videoElems = new List <XElement>(listContent.Where(c => c.Attribute("type").Value == "video/mp4"));
                                    if (!videoElems.Any())
                                    {
                                        videoElems = new List <XElement>(listContent.Where(c => c.Attribute("type").Value == "video/x-ms-wmv"));
                                    }
                                }
                                if (videoElems.Any() && videoElems.First().Attribute("url") != null)
                                {
                                    mediaVideoUrl = videoElems.First().Attribute("url").Value;
                                }
                            }
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                Debug.WriteLine("There was an error getting media video from RSS. Error: {0}", ex);
            }

            return(mediaVideoUrl);
        }
Exemple #5
0
        private XElement GetMRSSValue(SyndicationElementExtensionCollection coll, string name)
        {
            var element = coll.SingleOrDefault(e => e.OuterNamespace == MEDIA_RSS_NAMESPACE);

            if (element != null)
            {
                return(element.GetObject <XElement>().Element(XName.Get(name, MEDIA_RSS_NAMESPACE)));
            }

            return(new XElement("new", ""));
        }
Exemple #6
0
        private object GetGPhotoValue(SyndicationElementExtensionCollection coll, string name)
        {
            var element = coll.SingleOrDefault(e => e.OuterNamespace == GPHOTO_NAMESPACE && e.OuterName == name);

            if (element != null)
            {
                return(element.GetObject <XElement>().Value);
            }

            return(null);
        }
Exemple #7
0
        private string GetItemContent(SyndicationElementExtensionCollection extensions)
        {
            var content = string.Empty;

            foreach (SyndicationElementExtension extension in extensions)
            {
                if (extension.GetObject <XElement>().Name.LocalName == "encoded")
                {
                    content = extension.GetObject <XElement>().Value;
                }
            }
            return(HtmlTagsRemover.Remove(content));
        }
        public static XmlElement[] ToXmlElementArray(this SyndicationElementExtensionCollection exts)
        {
            if (exts == null)
            {
                return(null);
            }
            XmlDocument doc = new XmlDocument();

            doc.Load(exts.GetReaderAtExtensionWrapper());
            XmlNodeList nodes = doc.DocumentElement.SelectNodes("//extensionWrapper/*");

            return(nodes.Cast <XmlElement>().ToArray());
        }
 public FeatureResult(Terradue.GeoJson.Feature.Feature feature)
     : base(feature.Geometry, feature.Properties)
 {
     base.Id = feature.Id;
     base.BoundingBoxes = feature.BoundingBoxes;
     base.CRS = feature.CRS;
     links = new Collection<SyndicationLink>();
     elementExtensions = new SyndicationElementExtensionCollection();
     Properties = feature.Properties;
     authors = new Collection<SyndicationPerson>();
     categories = new Collection<SyndicationCategory>();
     contributors = new Collection<SyndicationPerson>();
 }
 public FeatureCollectionResult(Terradue.GeoJson.Feature.FeatureCollection fc)
     : base()
 {
     base.BoundingBoxes = fc.BoundingBoxes;
     base.CRS = fc.CRS;
     base.Properties = fc.Properties;
     Links = new Collection<SyndicationLink>();
     fc.Features.FirstOrDefault(f => {
         FeatureResults.Add(new FeatureResult(f));
         return false;
     });
     elementExtensions = new SyndicationElementExtensionCollection();
     authors = new Collection<SyndicationPerson>();
     categories = new Collection<SyndicationCategory>();
     contributors = new Collection<SyndicationPerson>();
 }
        public void Clone_WithExtensions_ReturnsExpected()
        {
            var category = new SyndicationCategory();

            SyndicationElementExtensionCollection elementExtensions = category.ElementExtensions;

            elementExtensions.Add(new ExtensionObject {
                Value = 10
            });

            SyndicationElementExtensionCollection clone = category.Clone().ElementExtensions;

            Assert.Equal(1, clone.Count);

            elementExtensions.Clear();
            Assert.Equal(1, clone.Count);
        }
 public string GetExtendedValue(string key, SyndicationElementExtensionCollection elementExtensions, string attributeName = "")
 {
     try
     {
         foreach (SyndicationElementExtension extension in elementExtensions)
         {
             XElement ele = extension.GetObject<XElement>();
             if (ele.Name.LocalName == key)
             {
                 if (attributeName == string.Empty)
                 {
                     return WebUtility.HtmlDecode(ele.Value);
                 }
                 else
                 {
                     return ele.Attribute(attributeName).Value;
                 }
             }
         }
     }
     catch (Exception) { }
     return string.Empty;
 }
 ExtensibleSyndicationObject(ExtensibleSyndicationObject source)
 {
     if (source.attributeExtensions != null)
     {
         this.attributeExtensions = new Dictionary<XmlQualifiedName, string>();
         foreach (XmlQualifiedName key in source.attributeExtensions.Keys)
         {
             this.attributeExtensions.Add(key, source.attributeExtensions[key]);
         }
     }
     else
     {
         this.attributeExtensions = null;
     }
     if (source.elementExtensions != null)
     {
         this.elementExtensions = new SyndicationElementExtensionCollection(source.elementExtensions);
     }
     else
     {
         this.elementExtensions = null;
     }
 }
Exemple #14
0
 private bool FindImageSRC_InExtension(SyndicationElementExtensionCollection extensions)
 {
     if (extensions.Count != 0)
     {
         try
         {
             var e   = extensions.First(l => l.OuterName == "image");
             var el  = e.GetObject <XElement>();
             var uri = GetUrl(el.Value);
             if (uri != null)
             {
                 GetImageFromURI(uri);
             }
             //  string matchString = Regex.Match(el.Value, "<img.+?src=[\"'](.+?)[\"'].+?>", RegexOptions.IgnoreCase).Groups[1].Value;
             //var src1 = srcMaybe.Value;
             return(true);
         }
         catch (Exception)
         {
             return(false);
         }
     }
     return(false);
 }
Exemple #15
0
        private void wc_OpenReadCompleted(object sender, OpenReadCompletedEventArgs e)
        {
            if (e.Error != null)
            {
                FeedLocationTextBox.Text = "Error in Reading Feed. Try Again later!!";
                return;
            }

            // Optional, use LINQ to query GeoRSS feed.
            //UseLinq(e.Result); return;

            using (Stream s = e.Result)
            {
                SyndicationFeed        feed;
                List <SyndicationItem> feedItems = new List <SyndicationItem>();

                GraphicsLayer graphicsLayer = MyMap.Layers["MyGraphicsLayer"] as GraphicsLayer;
                graphicsLayer.ClearGraphics();

                using (XmlReader reader = XmlReader.Create(s))
                {
                    feed = SyndicationFeed.Load(reader);
                    foreach (SyndicationItem feedItem in feed.Items)
                    {
                        SyndicationElementExtensionCollection ec = feedItem.ElementExtensions;

                        string x         = "";
                        string y         = "";
                        string magnitude = feedItem.Title.Text;

                        foreach (SyndicationElementExtension ee in ec)
                        {
                            XmlReader xr = ee.GetReader();
                            switch (ee.OuterName)
                            {
                            case ("lat"):
                            {
                                y = xr.ReadElementContentAsString();
                                break;
                            }

                            case ("long"):
                            {
                                x = xr.ReadElementContentAsString();
                                break;
                            }
                            }
                        }

                        if (!string.IsNullOrEmpty(x))
                        {
                            Graphic graphic = new Graphic()
                            {
                                Geometry = new MapPoint(Convert.ToDouble(x, System.Globalization.CultureInfo.InvariantCulture),
                                                        Convert.ToDouble(y, System.Globalization.CultureInfo.InvariantCulture),
                                                        new SpatialReference(4326)),
                                Symbol = LayoutRoot.Resources["QuakePictureSymbol"] as ESRI.ArcGIS.Client.Symbols.Symbol
                            };

                            graphic.Attributes.Add("MAGNITUDE", magnitude);

                            graphicsLayer.Graphics.Add(graphic);
                        }
                    }
                }
            }
        }
        public static SyndicationElementExtensionCollection XElementsToElementExtensions(IEnumerable<XElement> elements) {

            SyndicationElementExtensionCollection exts = new SyndicationElementExtensionCollection();

            foreach (var element in elements) {
                if (element.Name.Namespace == "http://www.genesi-dr.eu/spec/opensearch/extensions/eop/1.0/"
                    || element.Name.Namespace == "http://xmlns.com/2008/dclite4g#"
                    || element.Name.Namespace == "http://earth.esa.int/sar"
                    || element.Name.Namespace == "http://dclite4g.xmlns.com/ws.rdf#"
                    || element.Name.Namespace == "http://a9.com/-/opensearch/extensions/sru/2.0/")
                    continue;
                exts.Add(new SyndicationElementExtension(element.CreateReader()));
            }

            return exts;
        }
Exemple #17
0
        private void wc_OpenReadCompleted(object sender, OpenReadCompletedEventArgs e)
        {
            if (e.Error != null)
            {
                if (LoadFailed != null)
                {
                    LoadFailed(this, new RssLoadFailedEventArgs()
                    {
                        ex        = new Exception(Properties.Resources.GeoRss_ReadingFeedFailed, e.Error),
                        UserState = e.UserState
                    });
                }
                return;
            }

            ESRI.ArcGIS.Client.GraphicCollection graphics = new ESRI.ArcGIS.Client.GraphicCollection();

            //Add symbols from each entry read from the feed to the graphics object of the layer
            using (Stream s = e.Result)
            {
                SyndicationFeed        feed;
                List <SyndicationItem> feedItems = new List <SyndicationItem>();

                using (XmlReader reader = XmlReader.Create(s))
                {
                    feed = SyndicationFeed.Load(reader);
                    foreach (SyndicationItem feedItem in feed.Items)
                    {
                        SyndicationElementExtensionCollection ec = feedItem.ElementExtensions;

                        string                       slong      = "";
                        string                       slat       = "";
                        Geometry.Geometry            g          = null;
                        IDictionary <string, object> attributes = new Dictionary <string, object>();
                        foreach (SyndicationElementExtension ee in ec)
                        {
                            if (ee.OuterNamespace.Equals(_W3CGEONAMESPACE_, StringComparison.OrdinalIgnoreCase))
                            {
                                //This is not part of the georss-simple spec, but this makes it support a common
                                //use-case with geo:lat/geo:long coordinate pairs, as described at
                                //http://www.w3.org/2003/01/geo/
                                XmlReader xr = ee.GetReader();
                                switch (ee.OuterName)
                                {
                                case ("lat"):
                                {
                                    slat = xr.ReadElementContentAsString();
                                    break;
                                }

                                case ("long"):
                                {
                                    slong = xr.ReadElementContentAsString();
                                    break;
                                }

                                case ("Point"):
                                {
                                    XmlReader xmlPoint = xr.ReadSubtree();
                                    while (xmlPoint.Read())
                                    {
                                        if (xmlPoint.LocalName == "lat" && xmlPoint.NamespaceURI == _W3CGEONAMESPACE_)
                                        {
                                            slat = xmlPoint.ReadElementContentAsString();
                                        }
                                        else if (xmlPoint.LocalName == "long" && xmlPoint.NamespaceURI == _W3CGEONAMESPACE_)
                                        {
                                            slong = xmlPoint.ReadElementContentAsString();
                                        }
                                    }
                                    break;
                                }
                                }
                            }
                            else if (ee.OuterNamespace.Equals(_GEORSSNAMESPACE_, StringComparison.OrdinalIgnoreCase))
                            {
                                XmlReader xr = ee.GetReader();
                                switch (ee.OuterName)
                                {
                                case ("point"):
                                {
                                    string   sp   = xr.ReadElementContentAsString();
                                    string[] sxsy = sp.Split(new char[] { ' ' });
                                    slong = sxsy[1];
                                    slat  = sxsy[0];
                                    break;
                                }

                                case ("line"):
                                {
                                    string          sp   = xr.ReadElementContentAsString();
                                    PointCollection pnts = StringToPoints(sp);
                                    if (pnts != null)
                                    {
                                        Polyline line = new Polyline()
                                        {
                                            SpatialReference = new SpatialReference(4326)
                                        };
                                        line.Paths.Add(pnts);
                                        g = line;
                                    }
                                    break;
                                }

                                case ("polygon"):
                                {
                                    string          sp   = xr.ReadElementContentAsString();
                                    PointCollection pnts = StringToPoints(sp);
                                    if (pnts != null)
                                    {
                                        Polygon line = new Polygon()
                                        {
                                            SpatialReference = new SpatialReference(4326)
                                        };
                                        line.Rings.Add(pnts);
                                        g = line;
                                    }
                                    break;
                                }

                                case ("box"):
                                {
                                    string          sp   = xr.ReadElementContentAsString();
                                    PointCollection pnts = StringToPoints(sp);
                                    if (pnts != null && pnts.Count == 2)
                                    {
                                        g = new Envelope(pnts[0], pnts[1])
                                        {
                                            SpatialReference = new SpatialReference(4326)
                                        };
                                    }
                                    break;
                                }

                                case ("circle"):
                                {
                                    string   sp   = xr.ReadElementContentAsString();
                                    string[] sxsy = sp.Split(new char[] { ' ' });
                                    if (sxsy.Length == 3)
                                    {
                                        double x = double.NaN, y = double.NaN, r = double.NaN;
                                        string stX = sxsy[1];
                                        string stY = sxsy[0];
                                        string stR = sxsy[2];
                                        if (double.TryParse(stY, NumberStyles.Any, CultureInfo.InvariantCulture, out y) &&
                                            double.TryParse(stX, NumberStyles.Any, CultureInfo.InvariantCulture, out x) &&
                                            double.TryParse(stR, NumberStyles.Any, CultureInfo.InvariantCulture, out r))
                                        {
                                            g = GetRadiusAsPolygonGeodesic(new MapPoint(x, y), r, 360);
                                        }
                                    }
                                    break;
                                }

                                case ("where"):                                         //GeoRSS-GML
                                {
                                    //GML geometry parsing goes here. However this is not
                                    //part of GeoRSS-simple and not supported for this datasource
                                    //We'll just ignore these entries
                                    break;
                                }

                                    #region Attributes
                                case ("elev"):
                                {
                                    string sp        = xr.ReadElementContentAsString();
                                    double elevation = 0;
                                    if (double.TryParse(sp, NumberStyles.Any, CultureInfo.InvariantCulture, out elevation))
                                    {
                                        attributes.Add("elev", elevation);
                                    }
                                    break;
                                }

                                case ("floor"):
                                {
                                    string sp    = xr.ReadElementContentAsString();
                                    int    floor = 0;
                                    if (int.TryParse(sp, NumberStyles.Any, CultureInfo.InvariantCulture, out floor))
                                    {
                                        attributes.Add("floor", floor);
                                    }
                                    break;
                                }

                                case ("radius"):
                                {
                                    string sp     = xr.ReadElementContentAsString();
                                    double radius = 0;
                                    if (double.TryParse(sp, NumberStyles.Any, CultureInfo.InvariantCulture, out radius))
                                    {
                                        attributes.Add("radius", radius);
                                    }
                                    break;
                                }

                                //case ("featuretypetag"):
                                //case ("relationshiptag"):
                                //case ("featurename"):
                                default:
                                {
                                    string sp = xr.ReadElementContentAsString();
                                    attributes.Add(ee.OuterName, sp);
                                    break;
                                }
                                    #endregion
                                }
                            }
                        }

                        if (!string.IsNullOrEmpty(slong) && !string.IsNullOrEmpty(slat))
                        {
                            double x = double.NaN;
                            double y = double.NaN;
                            if (double.TryParse(slat, NumberStyles.Any, CultureInfo.InvariantCulture, out y) &&
                                double.TryParse(slong, NumberStyles.Any, CultureInfo.InvariantCulture, out x))
                            {
                                g = new MapPoint(x, y, new SpatialReference(4326));
                            }
                        }
                        if (g != null)
                        {
                            Graphic graphic = new Graphic()
                            {
                                Geometry = g
                            };

                            if (feedItem.Title != null)
                            {
                                graphic.Attributes.Add("Title", feedItem.Title.Text);
                            }
                            if (feedItem.Summary != null)
                            {
                                graphic.Attributes.Add("Summary", feedItem.Summary.Text);
                            }
                            if (feedItem.PublishDate != null)
                            {
                                graphic.Attributes.Add("PublishDate", feedItem.PublishDate);
                                graphic.TimeExtent = new TimeExtent(feedItem.PublishDate.DateTime);
                            }
                            if (feedItem.Links.Count > 0)
                            {
                                graphic.Attributes.Add("Link", feedItem.Links[0].Uri);
                            }
                            graphic.Attributes.Add("FeedItem", feedItem);
                            graphic.Attributes.Add("Id", feedItem.Id);
                            foreach (var val in attributes)
                            {
                                if (!graphic.Attributes.ContainsKey(val.Key))
                                {
                                    graphic.Attributes.Add(val.Key, val.Value);
                                }
                            }

                            // Add attribute GeometryType used by renderer
                            string gt = null;
                            if (g is MapPoint)
                            {
                                gt = "point";
                            }
                            else if (g is Polyline)
                            {
                                gt = "line";
                            }
                            else if (g is Polygon || g is Envelope)
                            {
                                gt = "polygon";
                            }
                            if (gt != null)
                            {
                                graphic.Attributes.Add(GeometryTypeAttribute, gt);
                            }
                            graphics.Add(graphic);
                        }
                    }
                }
            }

            //Invoking the initialize method of the base class to finish the initialization of the graphics layer:
            if (LoadCompleted != null)
            {
                LoadCompleted(this, new RssLoadedEventArgs()
                {
                    Graphics  = graphics,
                    UserState = e.UserState
                }
                              );
            }
        }
Exemple #18
0
        public static string GetExtraImage(SyndicationItem rssItem)
        {
            string feedMediaImage = null;

            try
            {
                SyndicationElementExtensionCollection extensions = rssItem.ElementExtensions;

                // Read extension items in order to find images: png, jpg preference to the bigger.
                if (extensions != null && extensions.Count > 0)
                {
                    var listImages = new List <XElement>();
                    // media:thumbnail and itunes
                    if (extensions.Any(p => p.OuterName == "thumbnail" || p.OuterName == "image"))
                    {
                        var extensionImages = new List <SyndicationElementExtension>(extensions.Where(p => p.OuterName == "thumbnail" || p.OuterName == "image"));
                        listImages.AddRange(extensionImages.Select(aux => new XElement(aux.GetObject <XElement>())));
                    }

                    if (listImages != null)
                    {
                        // Apply filter to get higher images.
                        var filteredImages = new List <XElement>();

                        foreach (XElement elem in listImages)
                        {
                            // 1.- Ask for .png - checking that the URL is an absolute URL.
                            if (elem.Attribute("url") != null && elem.Attribute("url").Value.ToLower().Contains("http") &&
                                elem.Attribute("url").Value.ToLower().Contains("png"))
                            {
                                filteredImages.Add(elem);
                            }
                            else if (elem.Value.ToLower().Contains("http") && elem.Value.ToLower().Contains("png")) // in itunes the image url is not an attribute.
                            {
                                filteredImages.Add(elem);
                            }
                        }
                        if (filteredImages.Count == 0)
                        {
                            // 2.- Ask for .jpg - checking that the URL is an absolute URL.
                            foreach (XElement elem in listImages)
                            {
                                if (elem.Attribute("url") != null && elem.Attribute("url").Value.ToLower().Contains("http") &&
                                    elem.Attribute("url").Value.ToLower().Contains("jpg"))
                                {
                                    filteredImages.Add(elem);
                                }
                                else if (elem.Value.ToLower().Contains("http") && elem.Value.ToLower().Contains("jpg")) // in itunes the image url is not an attribute.
                                {
                                    filteredImages.Add(elem);
                                }
                            }
                        }
                        // 3.- Get the bigger.
                        if (filteredImages != null)
                        {
                            var compareImagesBySize = new Comparison <XElement>(CompareImagesBySize);
                            filteredImages.Sort(compareImagesBySize);
                            XElement resultImage = filteredImages.FirstOrDefault();
                            if (resultImage != null)
                            {
                                feedMediaImage = (resultImage.Attribute("url") != null) ? resultImage.Attribute("url").Value : resultImage.Value;
                            }
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                Debug.WriteLine("There was an error getting extra image from RSS. Error: {0}", ex);
            }

            return(feedMediaImage);
        }
 public GenericJsonCollection()
 {
     links             = new Collection <Terradue.ServiceModel.Syndication.SyndicationLink>();
     elementExtensions = new SyndicationElementExtensionCollection();
     authors           = new Collection <SyndicationPerson>();
 }
 internal void LoadElementExtensions(XmlBuffer buffer)
 {
     this.elementExtensions = new SyndicationElementExtensionCollection(buffer);
 }
 static Collection <T> ReadNuGetExtension <T>(this SyndicationElementExtensionCollection extensions, string name)
 {
     return(extensions.ReadElementExtensions <T>(name, Namespaces.NuGet));
 }
 public static T Extension <T>(this SyndicationElementExtensionCollection extensions, string name)
 {
     return(extensions.ReadNuGetExtension <T>(name).First());
 }
Exemple #23
0
 private void AddAuthorElement(SyndicationElementExtensionCollection elementExtensions, SyndicationVisitorContext context)
 {
     elementExtensions.Add("author", Constants.ItunesNS.NamespaceName, context.Config.Authors.GetAuthorsString());
 }
Exemple #24
0
 private void AddItunesImage(SyndicationElementExtensionCollection extensions)
 {
     extensions.Add(new XElement(Constants.ItunesNS +"image", new XAttribute("href", ImageUrl.AbsoluteUri)));
 }
    protected void SaveElements(EntitySet<Element> elements,
      SyndicationElementExtensionCollection collection, int parentKey)
    {
      var els = collection.Select(e => new Element()
      {
        OuterNamespace = e.OuterNamespace,
        OuterName = e.OuterName,
        Xml = e.GetReader().ReadOuterXml(),
        ParentKey = parentKey
      });
      foreach (Element e in els)
      {

        elements.Add(e);
        dc.Elements.InsertOnSubmit(e);
      }
      dc.SubmitChanges();
    }
        public Dictionary<string, object> SyndicationElementExtensions(SyndicationElementExtensionCollection elements, ref NameValueCollection namespaces)
        {
            string prefix = "";
            Dictionary<string, object> properties = new Dictionary<string, object>();

            XPathDocument x = new XPathDocument(elements.GetReaderAtElementExtensions());
            XPathNavigator nav = x.CreateNavigator();

            if (options.KeepNamespaces) {
                var allNodes = nav.SelectDescendants(XPathNodeType.All, true);
                while (allNodes.MoveNext()) {
                    var names = allNodes.Current.GetNamespacesInScope(XmlNamespaceScope.Local);
                    foreach (var n in names.Keys) {
                        namespaces.Set(n, names[n]);
                    }
                }
            }

            nav.MoveToRoot();
            var childnodes = nav.SelectChildren(XPathNodeType.Element);
            XPathNavigator prev = null;
            while (childnodes.MoveNext()) {
                var childnode = childnodes.Current;
                XmlNamespaceManager xnsm = new XmlNamespaceManager(childnode.NameTable);
                if (options.KeepNamespaces) {
                    prefix = childnode.Prefix + ":";
                }
                try {
                    properties.Add(prefix + childnode.LocalName, ImportNode(childnode.Clone()));
                } catch (ArgumentException) {
                    if (properties.ContainsKey(prefix + childnode.LocalName) && properties[prefix + childnode.LocalName] is object[]) {
                        object[] array = (object[])properties[prefix + childnode.LocalName];
                        List<object> list = array.ToList();
                        list.Add(ImportNode(childnode.Clone()));
                        properties[prefix + childnode.LocalName] = list.ToArray();
                    } else {
                        List<object> list = new List<object>();
                        list.Add(ImportNode(childnode.Clone()));
                        properties[prefix + childnode.LocalName] = list.ToArray();
                    }
                }
                prev = childnode.Clone();
            }

            return properties;
        }
 internal void LoadElementExtensions(XmlReader readerOverUnparsedExtensions, int maxExtensionSize)
 {
     if (readerOverUnparsedExtensions == null)
     {
         throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("readerOverUnparsedExtensions");
     }
     if (maxExtensionSize < 0)
     {
         throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("maxExtensionSize"));
     }
     XmlDictionaryReader r = XmlDictionaryReader.CreateDictionaryReader(readerOverUnparsedExtensions);
     this.elementExtensions = new SyndicationElementExtensionCollection(CreateXmlBuffer(r, maxExtensionSize));
 }
Exemple #28
0
        private object GetGPhotoValue(SyndicationElementExtensionCollection coll, string name)
        {
            var element = coll.SingleOrDefault(e => e.OuterNamespace == GPHOTO_NAMESPACE && e.OuterName == name);
            if (element != null)
            {
                return element.GetObject<XElement>().Value;
            }

            return null;
        }
 protected void LoadElements(SyndicationElementExtensionCollection collection, EntitySet<Element> entitySet)
 {
   foreach (Element element in entitySet)
   {
     collection.Add(new SyndicationElementExtension(new XmlTextReader(new StringReader(element.Xml))));
   }
 }
Exemple #30
0
        private XElement GetMRSSValue(SyndicationElementExtensionCollection coll, string name)
        {
            var element = coll.SingleOrDefault(e => e.OuterNamespace == MEDIA_RSS_NAMESPACE);
            if (element != null)
            {
                return element.GetObject<XElement>().Element(XName.Get(name, MEDIA_RSS_NAMESPACE));
            }

            return new XElement("new", "");
        }
 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;
 }
Exemple #32
0
        //Adding symbols from each entry read from the feed to the graphics object of the layer
        private void wc_OpenReadCompleted(object sender, OpenReadCompletedEventArgs e)
        {
            if (e.Error != null)
            {
                if (LoadFailed != null)
                {
                    LoadFailed(this, new RssLoadFailedEventArgs()
                    {
                        ex        = new Exception("Error in Reading the RSS feed. Try Again later!", e.Error),
                        UserState = e.UserState
                    });
                }
                return;
            }

            ESRI.ArcGIS.Client.GraphicCollection graphics = new ESRI.ArcGIS.Client.GraphicCollection();

            using (Stream s = e.Result)
            {
                SyndicationFeed        feed;
                List <SyndicationItem> feedItems = new List <SyndicationItem>();

                using (XmlReader reader = XmlReader.Create(s))
                {
                    feed = SyndicationFeed.Load(reader);
                    foreach (SyndicationItem feedItem in feed.Items)
                    {
                        SyndicationElementExtensionCollection ec = feedItem.ElementExtensions;

                        string x = "";
                        string y = "";

                        foreach (SyndicationElementExtension ee in ec)
                        {
                            XmlReader xr = ee.GetReader();
                            switch (ee.OuterName)
                            {
                            case ("lat"):
                            {
                                y = xr.ReadElementContentAsString();
                                break;
                            }

                            case ("long"):
                            {
                                x = xr.ReadElementContentAsString();
                                break;
                            }

                            case ("point"):
                            {
                                string   sp   = xr.ReadElementContentAsString();
                                string[] sxsy = sp.Split(new char[] { ' ' });
                                x = sxsy[1];
                                y = sxsy[0];
                                break;
                            }
                            }
                        }

                        if (!string.IsNullOrEmpty(x))
                        {
                            Graphic graphic = new Graphic()
                            {
                                Geometry = new MapPoint(Convert.ToDouble(x), Convert.ToDouble(y))
                            };

                            graphic.Attributes.Add("Title", feedItem.Title.Text);
                            graphic.Attributes.Add("Summary", feedItem.Summary.Text);
                            graphic.Attributes.Add("PublishDate", feedItem.PublishDate);
                            graphic.Attributes.Add("Id", feedItem.Id);

                            graphics.Add(graphic);
                        }
                    }
                }
            }

            //Invoking the initialize method of the base class to finish the initialization of the graphics layer:
            if (LoadCompleted != null)
            {
                LoadCompleted(this, new RssLoadedEventArgs()
                {
                    Graphics  = graphics,
                    UserState = e.UserState
                }
                              );
            }
        }
 public static SyndicationElementExtension FirstExtensionOfType <T>(this SyndicationElementExtensionCollection elementExtensions)
 {
     return(elementExtensions.FirstOrDefault(x => x.GetObject <T>().GetType() == typeof(T)));
 }
        public static Dictionary<string, object> ExportSyndicationElementExtensions(SyndicationElementExtensionCollection exts)
        {
            Dictionary<string, object> dic = new Dictionary<string, object>();

            List<object> entries = new List<object>();

            foreach (var ext in exts) {

                if (ext.OuterName == "Query" && ext.OuterNamespace == "http://a9.com/-/spec/opensearch/1.1/") {
                    var query = SyndicationElementExtensionsToDictionary(ext);
                    dic.Remove ("Query");
                    dic.Add("Query", query.First().Value);
                    continue;
                }

                var xml = XElement.Load(ext.GetReader());

                xml = RemoveAllNamespaces(xml);

                string json = JsonConvert.SerializeXNode(xml, Newtonsoft.Json.Formatting.None, true);

                object obj = Deserialize(json);

                string key = string.IsNullOrEmpty(ext.OuterName) ? xml.Name.LocalName : ext.OuterName;

                if (dic.ContainsKey(key) && dic[key] is List<object> ) {
                    ((List<object>)dic[key]).Add(obj);
                }
                if (dic.ContainsKey(key) && !(dic[key] is List<object>) ) {
                    List<object> list = new List<object>();
                    list.Add(dic[key]);
                    list.Add(obj);
                    dic.Remove(key);
                    dic.Add(key, list);
                }
                if (!dic.ContainsKey(key)) {
                    dic.Add(key, obj);
                }
            }

            return dic;
        }