/// <summary>
        /// Converts a UfDataNode structure into a very basic form HTML.
        /// </summary>
        /// <param name="node">Node</param>
        /// <param name="formatDescriber">Microformat format describer object</param>
        /// <returns>HTML string</returns>
        public string Convert(UfDataNode node, UfFormatDescriber formatDescriber)
        {
            string output = string.Empty;

            StringWriter       stringWriter     = new StringWriter();
            UfElementDescriber elementDescriber = formatDescriber.BaseElement;

            using (XhtmlTextWriter writer = new XhtmlTextWriter(stringWriter))
            {
                writer.WriteBeginTag("div");
                writer.WriteAttribute("class", "microformats");
                writer.Write(HtmlTextWriter.TagRightChar);

                foreach (UfDataNode child in node.Nodes)
                {
                    writer.WriteLine();
                    AddNode(child, elementDescriber, writer);
                }

                writer.WriteEndTag("div");
                writer.WriteLine();
            }

            return(stringWriter.ToString());
        }
 public UfElementDescriber this[string name]
 {
     get
     {
         UfElementDescriber elementDescriber = null;
         for (int i = 0; i < this.InnerList.Count; i++)
         {
             UfElementDescriber testNode = (UfElementDescriber)this.InnerList[i];
             if (testNode.Name == name)
             {
                 return(testNode);
             }
         }
         return(elementDescriber);
     }
 }
Ejemplo n.º 3
0
        public static UfFormatDescriber Bookmark()
        {
            UfFormatDescriber uFormat = new UfFormatDescriber();
            uFormat.Name = "bookmark";
            uFormat.Description = "Bookmark";
            uFormat.Type = UfFormatDescriber.FormatTypes.Elemental;

            UfElementDescriber uFElement = new UfElementDescriber();
            uFElement.Name = "bookmark";
            uFElement.AllowedTags.Add("a");
            uFElement.AllowedTags.Add("link");
            uFElement.Attribute = "rel";
            uFElement.Type = UfElementDescriber.PropertyTypes.UrlText;
            uFormat.BaseElement = uFElement;
            uFElement.AttributeValues.Add(new UfAttributeValueDescriber("bookmark"));
            return uFormat;
        }
Ejemplo n.º 4
0
        private void AddChildNodes(UfDataNode xNode, UfDataNode node, UfElementDescriber ufElement)
        {
            //if (!string.IsNullOrEmpty(node.ElementId))
            //{
            //    xNode.Nodes.Add("id", node.ElementId);
            //}


            if (ufElement.AttributeValues.Count > 0)
            {
                // If its a rel or rev uf based on attribute values, just copy it
                // UfDataNode xNodeChild = xNode.Nodes.Append(node.Name, node.Value);
                foreach (UfDataNode childNode in node.Nodes)
                {
                    xNode.Nodes.Add(childNode.Name, childNode.Value, childNode.SourceUrl, childNode.RepresentativeNode);
                }
            }

            foreach (UfElementDescriber childElement in ufElement.Elements)
            {
                // Loop orginal data tree
                foreach (UfDataNode childNode in node.Nodes)
                {
                    // If node name = element describer name
                    if (childNode.Name == childElement.Name || childNode.Name == childElement.CompoundName)
                    {
                        // If element can have multiples call the AppendArrayList method
                        if (childElement.Multiples)
                        {
                            UfDataNode xChild = xNode.Nodes.Append(childNode.Name, childNode.Value, childNode.SourceUrl, childNode.RepresentativeNode);
                            AddChildNodes(xChild, childNode, childElement);
                        }
                        else
                        {
                            int        index  = xNode.Nodes.Add(childNode.Name, childNode.Value, childNode.SourceUrl, childNode.RepresentativeNode);
                            UfDataNode xChild = xNode.Nodes[index];
                            AddChildNodes(xChild, childNode, childElement);
                        }
                    }
                }
            }
        }
Ejemplo n.º 5
0
        public static UfFormatDescriber Tag()
        {
            UfFormatDescriber uFormat = new UfFormatDescriber();
            uFormat.Name = "tag";
            uFormat.Description = "Tag";
            uFormat.Type = UfFormatDescriber.FormatTypes.Elemental;

            UfElementDescriber uFElement = new UfElementDescriber();
            uFElement.Name = "tag";
            uFElement.Multiples = true;
            uFElement.AllowedTags.Add("a");
            uFElement.AllowedTags.Add("link");
            uFElement.Attribute = "rel";
            uFElement.Type = UfElementDescriber.PropertyTypes.UrlTextTag;
            uFormat.BaseElement = uFElement;
            uFElement.AttributeValues.Add(new UfAttributeValueDescriber("tag"));
            return uFormat;
        }
Ejemplo n.º 6
0
 public static UfFormatDescriber VoteLinks()
 {
     UfFormatDescriber uFormat = new UfFormatDescriber();
     uFormat.Name = "votelinks";
     uFormat.Description = "Vote Links";
     uFormat.Type = UfFormatDescriber.FormatTypes.Elemental;
     UfElementDescriber uFElement = new UfElementDescriber();
     uFElement.AllowedTags.Add("a");
     uFElement.AllowedTags.Add("link");
     uFElement.Attribute = "rel";
     uFElement.Type = UfElementDescriber.PropertyTypes.UrlTextAttribute;
     uFormat.BaseElement = uFElement;
     uFElement.AttributeValues.Add(new UfAttributeValueDescriber("vote-for", "vote-abstain vote-against"));
     uFElement.AttributeValues.Add(new UfAttributeValueDescriber("vote-against", "vote-abstain vote-for"));
     uFElement.AttributeValues.Add(new UfAttributeValueDescriber("vote-abstain", "vote-for vote-against"));
     return uFormat;
 }
 public void Remove(UfElementDescriber aElement)
 {
     InnerList.Remove(aElement);
 }
Ejemplo n.º 8
0
        public static UfFormatDescriber NoFollow()
        {
            UfFormatDescriber uFormat = new UfFormatDescriber();
            uFormat.Name = "nofollow";
            uFormat.Description = "Stops search engines following links";
            uFormat.Type = UfFormatDescriber.FormatTypes.Elemental;

            UfElementDescriber uFElement = new UfElementDescriber();
            uFElement.Name = "nofollow";
            uFElement.AllowedTags.Add("a");
            uFElement.AllowedTags.Add("link");
            uFElement.Attribute = "rel";
            uFElement.Type = UfElementDescriber.PropertyTypes.UrlText;
            uFormat.BaseElement = uFElement;
            uFElement.AttributeValues.Add(new UfAttributeValueDescriber("nofollow"));
            return uFormat;
        }
 public int IndexOf(UfElementDescriber aElement)
 {
     return(InnerList.IndexOf(aElement));
 }
Ejemplo n.º 10
0
        private void ParseUfElementValue(HtmlNode baseNode, UfElementDescriber ufElement, UfDataNode ufData)
        {
            // Create a single data node for whatever data insertion is needed.
            UfDataNode ufd = new UfDataNode();
            if(ufElement.CompoundName != string.Empty)
                ufd.ParentNodeNames = ufData.ParentNodeNames + ufElement.CompoundName + " ";
            else
                ufd.ParentNodeNames = ufData.ParentNodeNames + ufElement.Name + " ";

               ufd.ElementId = GetAttributeValue(baseNode, "id");

            // A parent node in the data schema
            if (ufElement.Elements.Count > 0)
            {
                if (ufElement.CompoundName == string.Empty)
                {
                    // Add a emtpy structural node
                    ufd.Name = ufElement.Name;
                }
                else
                {
                    // This is for compound structures, ie reviewer in hreview is a hcard
                    // Need to find a second attribute value to do this
                    HtmlAttribute att = baseNode.Attributes[ufElement.CompoundAttribute];
                    if (att != null)
                    {
                        if (UfHelpers.FindAttributeValue(att.Value.ToLower(), ufElement.CompoundName))
                        {
                            // Add a emtpy structural node using compound name
                            ufd.Name = ufElement.CompoundName;
                        }
                    }
                }

                // Recursion through the dom structure
                foreach (UfElementDescriber ufChildElement in ufElement.Elements)
                    ParseUfElement(baseNode, ufChildElement, ufd, false);

            }

            // A value needs to be found
            if (ufElement.Type != UfElementDescriber.PropertyTypes.None)
            {

                // Find child nodes with "value" or "value-title" classes
                HtmlNodeCollection valueNodes = null;
                HtmlNodeCollection valueTitleNodes = null;

                // The value pattern
                if (ufElement.Elements["value"] == null && ufElement.Name != "value")
                {
                    valueNodes = baseNode.SelectNodes(".//*[contains(concat(' ', @class, ' '),' value ')]");
                }

                // The value-title pattern is only allow for some property types ie dates
                // or name properties ie type, duration, geo, latitude and longitude
                if (ufElement.Type == UfElementDescriber.PropertyTypes.Date ||
                    ufElement.Name == "type" ||
                    ufElement.Name == "duration" ||
                    ufElement.Name == "geo" ||
                    ufElement.Name == "latitude" ||
                    ufElement.Name == "longitude")
                {
                    valueTitleNodes = baseNode.SelectNodes(".//*[contains(concat(' ', @class, ' '),' value-title ')]");
                }

                if (ufElement.Type == UfElementDescriber.PropertyTypes.UrlTextAttribute || ufElement.Type == UfElementDescriber.PropertyTypes.UrlTextTag || ufElement.Type == UfElementDescriber.PropertyTypes.UrlText)
                {

                    string text = UfHelpers.HtmlToText(baseNode, false);
                    string link = UfHelpers.GetAbsoluteUrl(GetAttributeValue(baseNode, "href"), this.baseUrl, url);
                    string att = GetAttributeValue(baseNode, ufElement.Attribute);
                    ufd.Name = ufElement.Name;

                    UfDataNode ufd1 = new UfDataNode();
                    UfDataNode ufd2 = new UfDataNode();
                    UfDataNode ufd3 = new UfDataNode();

                    ufd1.Name = "text";
                    ufd1.Value = text;
                    ufd.Nodes.Add(ufd1);

                    ufd2.Name = "link";
                    ufd2.Value = link;
                    ufd.Nodes.Add(ufd2);

                    // Add the attribute value used for XFN like structures
                    if (ufElement.Type == UfElementDescriber.PropertyTypes.UrlTextAttribute)
                    {
                        ufd3.Name = ufElement.Attribute;
                        ufd3.Value = att;
                        ufd.Nodes.Add(ufd3);
                    }

                    // Add the tag element of the url
                    if (ufElement.Type == UfElementDescriber.PropertyTypes.UrlTextTag)
                    {
                        ufd3.Name = "tag";
                        ufd3.Value = UfHelpers.GetTagFromUrl(link);
                        ufd.Nodes.Add(ufd3);
                    }

                    if (ufElement.CompoundName == string.Empty)
                    {
                        ufData.Nodes.Add(ufd);
                    }
                    else
                    {
                        HtmlAttribute att1 = baseNode.Attributes[ufElement.CompoundAttribute];
                        if (att1 != null)
                        {
                            if (UfHelpers.FindAttributeValue(att1.Value.ToLower(), ufElement.CompoundName))
                            {
                                ufd.Name = ufElement.CompoundName;
                                ufData.Nodes.Add(ufd);
                            }
                        }
                    }
                }

                // The value excerpting pattern
                else if (valueNodes != null)
                {
                    string text = string.Empty ;
                    foreach (HtmlNode node in valueNodes)
                    {
                        if (node.Name == "img" || node.Name == "area")
                        {
                            if (ufElement.Type == UfElementDescriber.PropertyTypes.Date)
                                text += GetAttributeValue(node, "title").Replace(" ", "") + " ";
                            else
                                text += GetAttributeValue(node, "title");
                        }
                        else if (node.Name == "abbr")
                        {
                            if (ufElement.Type == UfElementDescriber.PropertyTypes.Date)
                                text += GetAttributeValue(node, "title").Replace(" ", "") + " ";
                            else
                                text += GetAttributeValue(node, "title");
                        }
                        else
                        {
                            if (ufElement.Type == UfElementDescriber.PropertyTypes.Date)
                                text += UfHelpers.HtmlToText(node, false).Replace(" ", "") + " ";
                            else
                                text += UfHelpers.HtmlToText(node, false) + " ";
                        }
                    }

                    if(ufElement.Type == UfElementDescriber.PropertyTypes.Date)
                    {
                        // Take the fagmented bits and create a true ISODateTime string
                        ISODateTime isoDateTime = new ISODateTime();
                        text = isoDateTime.ParseUFFragmented(text);
                    }

                    ufd.Name = ufElement.Name;
                    ufd.Value = text.Trim();
                    AddNewDateNode(baseNode, ufData, ufd, ufElement);
                }

                // The value-title excerpting pattern
                else if (valueTitleNodes != null)
                {
                    string text = GetAttributeValue(valueTitleNodes[0], "title");
                    ufd.Name = ufElement.Name;
                    ufd.Value = text;
                    AddNewDateNode(baseNode, ufData, ufd, ufElement);
                }

                // Url from "a" or "link"
                else if ((baseNode.Name == "a" || baseNode.Name == "link") && GetAttributeValue(baseNode, "href") != string.Empty && ufElement.Type == UfElementDescriber.PropertyTypes.Url)
                {
                    string link = UfHelpers.GetAbsoluteUrl(GetAttributeValue(baseNode, "href"), this.baseUrl, url);
                    ufd.Name = ufElement.Name;
                    ufd.Value = link;
                    AddNewDateNode(baseNode, ufData, ufd, ufElement);
                }

                // Url from "img"
                else if ((baseNode.Name == "img" || baseNode.Name == "area") && GetAttributeValue(baseNode, "src") != string.Empty && ufElement.Type == UfElementDescriber.PropertyTypes.Url)
                {
                    string link = UfHelpers.GetAbsoluteUrl(GetAttributeValue(baseNode, "src"), this.baseUrl, url);
                    ufd.Name = ufElement.Name;
                    ufd.Value = link;
                    AddNewDateNode(baseNode, ufData, ufd, ufElement);
                }

                // Email from "a" or "link"
                else if (baseNode.Name == "a" && GetAttributeValue(baseNode, "href") != string.Empty && ufElement.Type == UfElementDescriber.PropertyTypes.Email)
                {
                    string address = UfHelpers.CleanEmailAddress(GetAttributeValue(baseNode, "href"));
                    ufd.Name = ufElement.Name;
                    ufd.Value = address;
                    AddNewDateNode(baseNode, ufData, ufd, ufElement);
                }

                // Tel from "object"
                else if (baseNode.Name == "object" && (GetAttributeValue(baseNode, "data") != "") && ufElement.Name == "tel")
                {
                    UfHelpers.TelOptimization(ufd, GetAttributeValue(baseNode, "data"));
                    AddNewDateNode(baseNode, ufData, ufd, ufElement);
                }

                // Date from "time"
                else if (baseNode.Name == "time" && GetAttributeValue(baseNode, "datetime") != "" && ufElement.Type == UfElementDescriber.PropertyTypes.Date)
                {
                    string text = GetAttributeValue(baseNode, "datetime");
                    ufd.Name = ufElement.Name;
                    ufd.Value = text;
                    AddNewDateNode(baseNode, ufData, ufd, ufElement);
                }

                // Date from "abbr"
                else if (baseNode.Name == "abbr" && GetAttributeValue(baseNode, "title") != string.Empty && ufElement.Type == UfElementDescriber.PropertyTypes.Date)
                {
                    string text = GetAttributeValue(baseNode, "title");
                    ufd.Name = ufElement.Name;
                    ufd.Value = text;
                    AddNewDateNode(baseNode, ufData, ufd, ufElement);
                }

                // Text from "abbr"
                else if (baseNode.Name == "abbr" || baseNode.Name == "acronym" && GetAttributeValue(baseNode, "title") != string.Empty)
                {
                    string text = GetAttributeValue(baseNode, "title");
                    ufd.Name = ufElement.Name;

                    // This is for geo been used as a location in hcalandar
                    if (ufElement.CompoundName != string.Empty)
                        ufd.Name = ufElement.CompoundName;

                    ufd.Value = text;
                    AddNewDateNode(baseNode, ufData, ufd, ufElement);
                }

                // Text from "input"
                else if (baseNode.Name == "input" && GetAttributeValue(baseNode, "value") != string.Empty)
                {
                    string text = GetAttributeValue(baseNode, "value");
                    ufd.Name = ufElement.Name;
                    ufd.Value = text;
                    AddNewDateNode(baseNode, ufData, ufd, ufElement);
                }

                // Tel from "area"
                else if (baseNode.Name == "area" && (GetAttributeValue(baseNode, "href") != "") && ufElement.Name == "tel")
                {
                    UfHelpers.TelOptimization(ufd, GetAttributeValue(baseNode, "href"));
                    AddNewDateNode(baseNode, ufData, ufd, ufElement);
                }

                // Text and url from "area"
                else if (baseNode.Name == "area" && (GetAttributeValue(baseNode, "href") != string.Empty || GetAttributeValue(baseNode, "alt") != string.Empty))
                {
                    if ((ufElement.Type == UfElementDescriber.PropertyTypes.Url || ufElement.Type == UfElementDescriber.PropertyTypes.Email) && GetAttributeValue(baseNode, "href") != string.Empty)
                    {
                        string text = GetAttributeValue(baseNode, "href");

                        if (ufElement.Type == UfElementDescriber.PropertyTypes.Email)
                            text = UfHelpers.CleanEmailAddress(text);

                        if (ufElement.Type == UfElementDescriber.PropertyTypes.Url)
                            text = UfHelpers.GetAbsoluteUrl(text, this.baseUrl, url);

                        ufd.Name = ufElement.Name;
                        ufd.Value = text;
                        AddNewDateNode(baseNode, ufData, ufd, ufElement);
                    }
                    else if (GetAttributeValue(baseNode, "alt") != string.Empty)
                    {
                        string text = GetAttributeValue(baseNode, "alt");
                        ufd.Name = ufElement.Name;
                        ufd.Value = text;
                        AddNewDateNode(baseNode, ufData, ufd, ufElement);
                    }

                }

                // Url/Image from "object"
                else if (baseNode.Name == "object" && GetAttributeValue(baseNode, "data") != string.Empty && (ufElement.Type == UfElementDescriber.PropertyTypes.Url || ufElement.Type == UfElementDescriber.PropertyTypes.Image))
                {
                    string text = UfHelpers.GetAbsoluteUrl(GetAttributeValue(baseNode, "data"), this.baseUrl, url);
                    ufd.Name = ufElement.Name;
                    ufd.Value = text;
                    AddNewDateNode(baseNode, ufData, ufd, ufElement);
                }

                // Image from "img" or "area"
                else if ((baseNode.Name == "img" || baseNode.Name == "area") && GetAttributeValue(baseNode, "src") != string.Empty && ufElement.Type == UfElementDescriber.PropertyTypes.Image)
                {
                    string text = UfHelpers.GetAbsoluteUrl(GetAttributeValue(baseNode, "src"), this.baseUrl, url);
                    ufd.Name = ufElement.Name;
                    ufd.Value = text;
                    AddNewDateNode(baseNode, ufData, ufd, ufElement);
                }

                // Text from "img" longdesc attribute
                else if (baseNode.Name == "img" && GetAttributeValue(baseNode, "longdesc") != string.Empty)
                {
                    string text = GetAttributeValue(baseNode, "longdesc");
                    ufd.Name = ufElement.Name;
                    ufd.Value = text;
                    AddNewDateNode(baseNode, ufData, ufd, ufElement); ;
                }

                // Text from "img" alt attribute
                else if (baseNode.Name == "img" && GetAttributeValue(baseNode, "alt") != string.Empty)
                {
                    string text = GetAttributeValue(baseNode, "alt");
                    ufd.Name = ufElement.Name;
                    ufd.Value = text;
                    AddNewDateNode(baseNode, ufData, ufd, ufElement);
                }

                // Text for type/value structures with no found children
                else if (ufElement.NodeType == UfElementDescriber.StructureTypes.TypeValuePair)
                {
                    // if no chidren nodes ie type/value are found use text
                    // the calls for a children node type and value are alway both thier parent
                    if (ufd.Nodes.Count == 0)
                    {
                        // Add text from node value
                        string text = UfHelpers.HtmlToText(baseNode, false);
                        ufd.Name = ufElement.Name;
                        ufd.Value = text;
                        AddNewDateNode(baseNode, ufData, ufd, ufElement);
                    }
                    else
                    {
                        // Add child type/value pair
                        ufd.Name = ufElement.Name;
                        AddNewDateNode(baseNode, ufData, ufd, ufElement);
                    }
                }

                // Text from Html node collect
                else if (ufElement.Type == UfElementDescriber.PropertyTypes.FormattedText)
                {
                    string text = UfHelpers.HtmlToText(baseNode, true);
                    ufd.Name = ufElement.Name;
                    ufd.Value = text;
                    AddNewDateNode(baseNode, ufData, ufd, ufElement);
                }

                else
                {
                    // Text from node value
                    //string text = FindValuePattern(baseNode, ufElement);
                    //if(text == string.Empty)
                    //    text = HtmlToText(baseNode, false);

                    string text = UfHelpers.HtmlToText(baseNode, false);
                    ufd.Name = ufElement.Name;
                    ufd.Value = text;
                    AddNewDateNode(baseNode, ufData, ufd, ufElement);
                }
            }
            else
            {
                AddNewDateNode(baseNode, ufData, ufd, ufElement);
            }
        }
Ejemplo n.º 11
0
        private void ParseUfElementValue(HtmlNode baseNode, UfElementDescriber ufElement, UfDataNode ufData)
        {
            // Create a single data node for whatever data insertion is needed.
            UfDataNode ufd = new UfDataNode();

            if (ufElement.CompoundName != string.Empty)
            {
                ufd.ParentNodeNames = ufData.ParentNodeNames + ufElement.CompoundName + " ";
            }
            else
            {
                ufd.ParentNodeNames = ufData.ParentNodeNames + ufElement.Name + " ";
            }


            ufd.ElementId = GetAttributeValue(baseNode, "id");


            // A parent node in the data schema
            if (ufElement.Elements.Count > 0)
            {
                if (ufElement.CompoundName == string.Empty)
                {
                    // Add a emtpy structural node
                    ufd.Name = ufElement.Name;
                }
                else
                {
                    // This is for compound structures, ie reviewer in hreview is a hcard
                    // Need to find a second attribute value to do this
                    HtmlAttribute att = baseNode.Attributes[ufElement.CompoundAttribute];
                    if (att != null)
                    {
                        if (UfHelpers.FindAttributeValue(att.Value.ToLower(), ufElement.CompoundName))
                        {
                            // Add a emtpy structural node using compound name
                            ufd.Name = ufElement.CompoundName;
                        }
                    }
                }

                // Recursion through the dom structure
                foreach (UfElementDescriber ufChildElement in ufElement.Elements)
                {
                    ParseUfElement(baseNode, ufChildElement, ufd, false);
                }
            }


            // A value needs to be found
            if (ufElement.Type != UfElementDescriber.PropertyTypes.None)
            {
                // Find child nodes with "value" or "value-title" classes
                HtmlNodeCollection valueNodes      = null;
                HtmlNodeCollection valueTitleNodes = null;

                // The value pattern
                if (ufElement.Elements["value"] == null && ufElement.Name != "value")
                {
                    valueNodes = baseNode.SelectNodes(".//*[contains(concat(' ', @class, ' '),' value ')]");
                }


                // The value-title pattern is only allow for some property types ie dates
                // or name properties ie type, duration, geo, latitude and longitude
                if (ufElement.Type == UfElementDescriber.PropertyTypes.Date ||
                    ufElement.Name == "type" ||
                    ufElement.Name == "duration" ||
                    ufElement.Name == "geo" ||
                    ufElement.Name == "latitude" ||
                    ufElement.Name == "longitude")
                {
                    valueTitleNodes = baseNode.SelectNodes(".//*[contains(concat(' ', @class, ' '),' value-title ')]");
                }



                if (ufElement.Type == UfElementDescriber.PropertyTypes.UrlTextAttribute || ufElement.Type == UfElementDescriber.PropertyTypes.UrlTextTag || ufElement.Type == UfElementDescriber.PropertyTypes.UrlText)
                {
                    string text = UfHelpers.HtmlToText(baseNode, false);
                    string link = UfHelpers.GetAbsoluteUrl(GetAttributeValue(baseNode, "href"), this.baseUrl, url);
                    string att  = GetAttributeValue(baseNode, ufElement.Attribute);
                    ufd.Name = ufElement.Name;

                    UfDataNode ufd1 = new UfDataNode();
                    UfDataNode ufd2 = new UfDataNode();
                    UfDataNode ufd3 = new UfDataNode();

                    ufd1.Name  = "text";
                    ufd1.Value = text;
                    ufd.Nodes.Add(ufd1);

                    ufd2.Name  = "link";
                    ufd2.Value = link;
                    ufd.Nodes.Add(ufd2);

                    // Add the attribute value used for XFN like structures
                    if (ufElement.Type == UfElementDescriber.PropertyTypes.UrlTextAttribute)
                    {
                        ufd3.Name  = ufElement.Attribute;
                        ufd3.Value = att;
                        ufd.Nodes.Add(ufd3);
                    }

                    // Add the tag element of the url
                    if (ufElement.Type == UfElementDescriber.PropertyTypes.UrlTextTag)
                    {
                        ufd3.Name  = "tag";
                        ufd3.Value = UfHelpers.GetTagFromUrl(link);
                        ufd.Nodes.Add(ufd3);
                    }

                    if (ufElement.CompoundName == string.Empty)
                    {
                        ufData.Nodes.Add(ufd);
                    }
                    else
                    {
                        HtmlAttribute att1 = baseNode.Attributes[ufElement.CompoundAttribute];
                        if (att1 != null)
                        {
                            if (UfHelpers.FindAttributeValue(att1.Value.ToLower(), ufElement.CompoundName))
                            {
                                ufd.Name = ufElement.CompoundName;
                                ufData.Nodes.Add(ufd);
                            }
                        }
                    }
                }

                // The value excerpting pattern
                else if (valueNodes != null)
                {
                    string text = string.Empty;
                    foreach (HtmlNode node in valueNodes)
                    {
                        if (node.Name == "img" || node.Name == "area")
                        {
                            if (ufElement.Type == UfElementDescriber.PropertyTypes.Date)
                            {
                                text += GetAttributeValue(node, "title").Replace(" ", "") + " ";
                            }
                            else
                            {
                                text += GetAttributeValue(node, "title");
                            }
                        }
                        else if (node.Name == "abbr")
                        {
                            if (ufElement.Type == UfElementDescriber.PropertyTypes.Date)
                            {
                                text += GetAttributeValue(node, "title").Replace(" ", "") + " ";
                            }
                            else
                            {
                                text += GetAttributeValue(node, "title");
                            }
                        }
                        else
                        {
                            if (ufElement.Type == UfElementDescriber.PropertyTypes.Date)
                            {
                                text += UfHelpers.HtmlToText(node, false).Replace(" ", "") + " ";
                            }
                            else
                            {
                                text += UfHelpers.HtmlToText(node, false) + " ";
                            }
                        }
                    }

                    if (ufElement.Type == UfElementDescriber.PropertyTypes.Date)
                    {
                        // Take the fagmented bits and create a true ISODateTime string
                        ISODateTime isoDateTime = new ISODateTime();
                        text = isoDateTime.ParseUFFragmented(text);
                    }

                    ufd.Name  = ufElement.Name;
                    ufd.Value = text.Trim();
                    AddNewDateNode(baseNode, ufData, ufd, ufElement);
                }

                // The value-title excerpting pattern
                else if (valueTitleNodes != null)
                {
                    string text = GetAttributeValue(valueTitleNodes[0], "title");
                    ufd.Name  = ufElement.Name;
                    ufd.Value = text;
                    AddNewDateNode(baseNode, ufData, ufd, ufElement);
                }

                // Url from "a" or "link"
                else if ((baseNode.Name == "a" || baseNode.Name == "link") && GetAttributeValue(baseNode, "href") != string.Empty && ufElement.Type == UfElementDescriber.PropertyTypes.Url)
                {
                    string link = UfHelpers.GetAbsoluteUrl(GetAttributeValue(baseNode, "href"), this.baseUrl, url);
                    ufd.Name  = ufElement.Name;
                    ufd.Value = link;
                    AddNewDateNode(baseNode, ufData, ufd, ufElement);
                }

                // Url from "img"
                else if ((baseNode.Name == "img" || baseNode.Name == "area") && GetAttributeValue(baseNode, "src") != string.Empty && ufElement.Type == UfElementDescriber.PropertyTypes.Url)
                {
                    string link = UfHelpers.GetAbsoluteUrl(GetAttributeValue(baseNode, "src"), this.baseUrl, url);
                    ufd.Name  = ufElement.Name;
                    ufd.Value = link;
                    AddNewDateNode(baseNode, ufData, ufd, ufElement);
                }

                // Email from "a" or "link"
                else if (baseNode.Name == "a" && GetAttributeValue(baseNode, "href") != string.Empty && ufElement.Type == UfElementDescriber.PropertyTypes.Email)
                {
                    string address = UfHelpers.CleanEmailAddress(GetAttributeValue(baseNode, "href"));
                    ufd.Name  = ufElement.Name;
                    ufd.Value = address;
                    AddNewDateNode(baseNode, ufData, ufd, ufElement);
                }

                // Tel from "object"
                else if (baseNode.Name == "object" && (GetAttributeValue(baseNode, "data") != "") && ufElement.Name == "tel")
                {
                    UfHelpers.TelOptimization(ufd, GetAttributeValue(baseNode, "data"));
                    AddNewDateNode(baseNode, ufData, ufd, ufElement);
                }

                // Date from "time"
                else if (baseNode.Name == "time" && GetAttributeValue(baseNode, "datetime") != "" && ufElement.Type == UfElementDescriber.PropertyTypes.Date)
                {
                    string text = GetAttributeValue(baseNode, "datetime");
                    ufd.Name  = ufElement.Name;
                    ufd.Value = text;
                    AddNewDateNode(baseNode, ufData, ufd, ufElement);
                }

                // Date from "abbr"
                else if (baseNode.Name == "abbr" && GetAttributeValue(baseNode, "title") != string.Empty && ufElement.Type == UfElementDescriber.PropertyTypes.Date)
                {
                    string text = GetAttributeValue(baseNode, "title");
                    ufd.Name  = ufElement.Name;
                    ufd.Value = text;
                    AddNewDateNode(baseNode, ufData, ufd, ufElement);
                }

                // Text from "abbr"
                else if (baseNode.Name == "abbr" || baseNode.Name == "acronym" && GetAttributeValue(baseNode, "title") != string.Empty)
                {
                    string text = GetAttributeValue(baseNode, "title");
                    ufd.Name = ufElement.Name;

                    // This is for geo been used as a location in hcalandar
                    if (ufElement.CompoundName != string.Empty)
                    {
                        ufd.Name = ufElement.CompoundName;
                    }

                    ufd.Value = text;
                    AddNewDateNode(baseNode, ufData, ufd, ufElement);
                }

                // Text from "input"
                else if (baseNode.Name == "input" && GetAttributeValue(baseNode, "value") != string.Empty)
                {
                    string text = GetAttributeValue(baseNode, "value");
                    ufd.Name  = ufElement.Name;
                    ufd.Value = text;
                    AddNewDateNode(baseNode, ufData, ufd, ufElement);
                }

                // Tel from "area"
                else if (baseNode.Name == "area" && (GetAttributeValue(baseNode, "href") != "") && ufElement.Name == "tel")
                {
                    UfHelpers.TelOptimization(ufd, GetAttributeValue(baseNode, "href"));
                    AddNewDateNode(baseNode, ufData, ufd, ufElement);
                }

                // Text and url from "area"
                else if (baseNode.Name == "area" && (GetAttributeValue(baseNode, "href") != string.Empty || GetAttributeValue(baseNode, "alt") != string.Empty))
                {
                    if ((ufElement.Type == UfElementDescriber.PropertyTypes.Url || ufElement.Type == UfElementDescriber.PropertyTypes.Email) && GetAttributeValue(baseNode, "href") != string.Empty)
                    {
                        string text = GetAttributeValue(baseNode, "href");

                        if (ufElement.Type == UfElementDescriber.PropertyTypes.Email)
                        {
                            text = UfHelpers.CleanEmailAddress(text);
                        }

                        if (ufElement.Type == UfElementDescriber.PropertyTypes.Url)
                        {
                            text = UfHelpers.GetAbsoluteUrl(text, this.baseUrl, url);
                        }

                        ufd.Name  = ufElement.Name;
                        ufd.Value = text;
                        AddNewDateNode(baseNode, ufData, ufd, ufElement);
                    }
                    else if (GetAttributeValue(baseNode, "alt") != string.Empty)
                    {
                        string text = GetAttributeValue(baseNode, "alt");
                        ufd.Name  = ufElement.Name;
                        ufd.Value = text;
                        AddNewDateNode(baseNode, ufData, ufd, ufElement);
                    }
                }

                // Url/Image from "object"
                else if (baseNode.Name == "object" && GetAttributeValue(baseNode, "data") != string.Empty && (ufElement.Type == UfElementDescriber.PropertyTypes.Url || ufElement.Type == UfElementDescriber.PropertyTypes.Image))
                {
                    string text = UfHelpers.GetAbsoluteUrl(GetAttributeValue(baseNode, "data"), this.baseUrl, url);
                    ufd.Name  = ufElement.Name;
                    ufd.Value = text;
                    AddNewDateNode(baseNode, ufData, ufd, ufElement);
                }

                // Image from "img" or "area"
                else if ((baseNode.Name == "img" || baseNode.Name == "area") && GetAttributeValue(baseNode, "src") != string.Empty && ufElement.Type == UfElementDescriber.PropertyTypes.Image)
                {
                    string text = UfHelpers.GetAbsoluteUrl(GetAttributeValue(baseNode, "src"), this.baseUrl, url);
                    ufd.Name  = ufElement.Name;
                    ufd.Value = text;
                    AddNewDateNode(baseNode, ufData, ufd, ufElement);
                }

                // Text from "img" longdesc attribute
                else if (baseNode.Name == "img" && GetAttributeValue(baseNode, "longdesc") != string.Empty)
                {
                    string text = GetAttributeValue(baseNode, "longdesc");
                    ufd.Name  = ufElement.Name;
                    ufd.Value = text;
                    AddNewDateNode(baseNode, ufData, ufd, ufElement);;
                }


                // Text from "img" alt attribute
                else if (baseNode.Name == "img" && GetAttributeValue(baseNode, "alt") != string.Empty)
                {
                    string text = GetAttributeValue(baseNode, "alt");
                    ufd.Name  = ufElement.Name;
                    ufd.Value = text;
                    AddNewDateNode(baseNode, ufData, ufd, ufElement);
                }


                // Text for type/value structures with no found children
                else if (ufElement.NodeType == UfElementDescriber.StructureTypes.TypeValuePair)
                {
                    // if no chidren nodes ie type/value are found use text
                    // the calls for a children node type and value are alway both thier parent
                    if (ufd.Nodes.Count == 0)
                    {
                        // Add text from node value
                        string text = UfHelpers.HtmlToText(baseNode, false);
                        ufd.Name  = ufElement.Name;
                        ufd.Value = text;
                        AddNewDateNode(baseNode, ufData, ufd, ufElement);
                    }
                    else
                    {
                        // Add child type/value pair
                        ufd.Name = ufElement.Name;
                        AddNewDateNode(baseNode, ufData, ufd, ufElement);
                    }
                }

                // Text from Html node collect
                else if (ufElement.Type == UfElementDescriber.PropertyTypes.FormattedText)
                {
                    string text = UfHelpers.HtmlToText(baseNode, true);
                    ufd.Name  = ufElement.Name;
                    ufd.Value = text;
                    AddNewDateNode(baseNode, ufData, ufd, ufElement);
                }

                else
                {
                    // Text from node value
                    //string text = FindValuePattern(baseNode, ufElement);
                    //if(text == string.Empty)
                    //    text = HtmlToText(baseNode, false);

                    string text = UfHelpers.HtmlToText(baseNode, false);
                    ufd.Name  = ufElement.Name;
                    ufd.Value = text;
                    AddNewDateNode(baseNode, ufData, ufd, ufElement);
                }
            }
            else
            {
                AddNewDateNode(baseNode, ufData, ufd, ufElement);
            }
        }
Ejemplo n.º 12
0
        private void AddChildNodes(UfDataNode xNode, UfDataNode node, UfElementDescriber ufElement)
        {
            //if (!string.IsNullOrEmpty(node.ElementId))
            //{
            //    xNode.Nodes.Add("id", node.ElementId);
            //}

            if (ufElement.AttributeValues.Count > 0)
            {
                // If its a rel or rev uf based on attribute values, just copy it
                // UfDataNode xNodeChild = xNode.Nodes.Append(node.Name, node.Value);
                foreach (UfDataNode childNode in node.Nodes)
                    xNode.Nodes.Add(childNode.Name, childNode.Value, childNode.SourceUrl, childNode.RepresentativeNode);

            }

            foreach (UfElementDescriber childElement in ufElement.Elements)
            {
                // Loop orginal data tree
                foreach (UfDataNode childNode in node.Nodes)
                {
                    // If node name = element describer name
                    if (childNode.Name == childElement.Name || childNode.Name == childElement.CompoundName)
                    {
                        // If element can have multiples call the AppendArrayList method
                        if (childElement.Multiples)
                        {
                            UfDataNode xChild = xNode.Nodes.Append(childNode.Name, childNode.Value, childNode.SourceUrl, childNode.RepresentativeNode);
                            AddChildNodes(xChild, childNode, childElement);
                        }
                        else
                        {
                            int index = xNode.Nodes.Add(childNode.Name, childNode.Value, childNode.SourceUrl, childNode.RepresentativeNode);
                            UfDataNode xChild = xNode.Nodes[index];
                            AddChildNodes(xChild, childNode, childElement);
                        }
                    }
                }
            }
        }
Ejemplo n.º 13
0
 public void Insert(int index, UfElementDescriber newElement)
 {
     InnerList.Insert(index, newElement);
 }
Ejemplo n.º 14
0
 public void Remove(UfElementDescriber aElement)
 {
     InnerList.Remove(aElement);
 }
Ejemplo n.º 15
0
 public int IndexOf(UfElementDescriber aElement)
 {
     return InnerList.IndexOf(aElement);
 }
Ejemplo n.º 16
0
 public bool Contains(UfElementDescriber aElement)
 {
     return InnerList.Contains(aElement);
 }
Ejemplo n.º 17
0
 public int Add(UfElementDescriber newElement)
 {
     return InnerList.Add(newElement);
 }
Ejemplo n.º 18
0
        //-----------------------------------------------------------------------
        public static UfFormatDescriber Xfn()
        {
            UfFormatDescriber uFormat = new UfFormatDescriber();
            uFormat.Name = "xfn";
            uFormat.Description = "XHTML Friends Network, describes realtionships";
            uFormat.Type = UfFormatDescriber.FormatTypes.Elemental;

            UfElementDescriber uFElement = new UfElementDescriber();
            uFElement.Name = "xfn";
            uFElement.AllowedTags.Add("a");
            uFElement.AllowedTags.Add("link");
            uFElement.Attribute = "rel";
            uFElement.Type = UfElementDescriber.PropertyTypes.UrlTextAttribute;
            uFormat.BaseElement = uFElement;

            uFElement.AttributeValues.Add(new UfAttributeValueDescriber("met", ""));
            uFElement.AttributeValues.Add(new UfAttributeValueDescriber("co-worker", ""));
            uFElement.AttributeValues.Add(new UfAttributeValueDescriber("colleague", ""));

            uFElement.AttributeValues.Add(new UfAttributeValueDescriber("muse", ""));
            uFElement.AttributeValues.Add(new UfAttributeValueDescriber("crush", ""));
            uFElement.AttributeValues.Add(new UfAttributeValueDescriber("date", ""));
            uFElement.AttributeValues.Add(new UfAttributeValueDescriber("sweetheart", ""));

            uFElement.AttributeValues.Add(new UfAttributeValueDescriber("co-resident", "neighbor"));
            uFElement.AttributeValues.Add(new UfAttributeValueDescriber("neighbor", "co-resident"));

            uFElement.AttributeValues.Add(new UfAttributeValueDescriber("child", "parent sibling spouse kin"));
            uFElement.AttributeValues.Add(new UfAttributeValueDescriber("parent", "child sibling spouse kin"));
            uFElement.AttributeValues.Add(new UfAttributeValueDescriber("sibling", "child parent spouse kin"));
            uFElement.AttributeValues.Add(new UfAttributeValueDescriber("spouse", "child parent sibling kin"));
            uFElement.AttributeValues.Add(new UfAttributeValueDescriber("kin", "child parent sibling spouse"));

            uFElement.AttributeValues.Add(new UfAttributeValueDescriber("contact", "acquaintance friend"));
            uFElement.AttributeValues.Add(new UfAttributeValueDescriber("acquaintance", "contact friend"));
            uFElement.AttributeValues.Add(new UfAttributeValueDescriber("friend", "contact friend"));

            uFElement.AttributeValues.Add(new UfAttributeValueDescriber("me", "contact acquaintance friend met co-worker colleague co-resident neighbor child parent sibling spouse kin muse crush date sweetheart"));

            return uFormat;
        }
 public bool Contains(UfElementDescriber aElement)
 {
     return(InnerList.Contains(aElement));
 }
Ejemplo n.º 20
0
        public static UfFormatDescriber XFolk()
        {
            UfFormatDescriber uFormat = new UfFormatDescriber();
            uFormat.Name = "xFolk";
            uFormat.Description = "xFolk";
            uFormat.Type = UfFormatDescriber.FormatTypes.Compound;

            uFormat.BaseElement = new UfElementDescriber("xfolkentry", false, true, UfElementDescriber.PropertyTypes.None);
            uFormat.BaseElement.Elements.Add(new UfElementDescriber("taggedlink", true, false, UfElementDescriber.PropertyTypes.UrlText));
            uFormat.BaseElement.Elements.Add(new UfElementDescriber("description", false, true, UfElementDescriber.PropertyTypes.Text));

            UfElementDescriber uFElement = new UfElementDescriber();
            uFElement.Name = "tag";
            uFElement.AllowedTags.Add("a");
            uFElement.AllowedTags.Add("link");
            uFElement.Attribute = "rel";
            uFElement.Type = UfElementDescriber.PropertyTypes.UrlTextTag;
            uFElement.AttributeValues.Add(new UfAttributeValueDescriber("tag"));
            uFormat.BaseElement.Elements.Add(uFElement);

            return uFormat;
        }
Ejemplo n.º 21
0
        /// <summary>
        /// Adds a new data node to the tree
        /// </summary>
        /// <param name="ufData">Parent node</param>
        /// <param name="ufNewDataNode">Node to be added</param>
        /// <param name="ufElement">The uF element describer</param>
        private void AddNewDateNode(HtmlNode baseNode, UfDataNode ufData, UfDataNode ufNewDataNode, UfElementDescriber ufElement)
        {
            if (IsDuplicateNode(ufData, ufNewDataNode) == false)
            {
                ufNewDataNode.OuterHtml = baseNode.OuterHtml;

                // This function deal both with the concatenation of multiple values
                // and the validation of multiple flag

                // If the structure is a value/type pair change the insert point
                if (ufElement.Elements["value"] != null && ufElement.Elements["type"] != null)
                {
                    // Add to child value node
                    UfDataNode ufdatanode = new UfDataNode("value", ufNewDataNode.Value);
                    ufNewDataNode.Nodes.Add(ufdatanode);
                    ufNewDataNode.Value = "";
                }

                // Concatenation of values
                if (ufElement.ConcatenateValues)
                {
                    // Create a new node or add to the existing one
                    if (ufData.Nodes[ufNewDataNode.Name] == null)
                        ufData.Nodes.Add(ufNewDataNode);
                    else
                        ufData.Nodes[ufNewDataNode.Name].Value += ufNewDataNode.Value;

                }
                else if (ufElement.Multiples == false)
                {
                    // Singluar - only take first instance
                    if (ufData.Nodes[ufNewDataNode.Name] == null)
                        ufData.Nodes.Add(ufNewDataNode);

                }
                else if (ufElement.Multiples == true)
                {
                    // Multiples
                    ufData.Nodes.Add(ufNewDataNode);
                }
            }
        }
Ejemplo n.º 22
0
        private void ParseUfElement(HtmlNode baseNode, UfElementDescriber ufElement, UfDataNode ufData, bool ufTopLevel)
        {
            // Select nodes with required attribute: class, rel or rev
            HtmlNodeCollection nodes = baseNode.SelectNodes(".//@" + ufElement.Attribute);

            if (nodes != null)
            {
                foreach (HtmlNode node in nodes)
                {
                    // Load the attribute class, rel or rev
                    HtmlAttribute att         = node.Attributes[ufElement.Attribute];
                    HtmlAttribute compoundAtt = node.Attributes[ufElement.CompoundAttribute];
                    if (att != null)
                    {
                        // We are dealing with elemental uf like XFN
                        if (ufElement.AttributeValues.Count > 0)
                        {
                            bool found = false;
                            // Search for a mulitple attribute values ie friend or contact in rel
                            foreach (UfAttributeValueDescriber avd in ufElement.AttributeValues)
                            {
                                if (UfHelpers.FindAttributeValue(att.Value.ToLower(), avd.Name))
                                {
                                    found = true;
                                }
                            }
                            if (found)
                            {
                                // Adds the Html from which uf is parsed
                                // ufData.OuterHtml = node.OuterHtml;
                                ParseUfElementValue(node, ufElement, ufData);
                            }
                        }
                        else
                        {
                            bool found = false;

                            // Search for a single attribute values ie hcard in class
                            if (UfHelpers.FindAttributeValue(att.Value.ToLower(), ufElement.Name) && ufElement.CompoundName == string.Empty)
                            {
                                found = true;
                            }

                            // Search for a dual attribute values
                            // This is for compound structures, ie reviewer in hreview which is a hcard
                            if (UfHelpers.FindAttributeValue(att.Value.ToLower(), ufElement.Name) && UfHelpers.FindAttributeValue(compoundAtt.Value.ToLower(), ufElement.CompoundName))
                            {
                                found = true;
                            }

                            if (found)
                            {
                                if (HasCompound(baseNode, node.ParentNode, false) == false || ufElement.RootElement == true)
                                {
                                    HtmlNodeCollection includeRefNodes = null;

                                    includeRefNodes = node.SelectNodes(".//a[@class[contains(.,'include')]]");
                                    if (includeRefNodes != null)
                                    {
                                        foreach (HtmlNode includeRefNode in includeRefNodes)
                                        {
                                            string link = GetAttributeValue(includeRefNode, "href");
                                            if (link.StartsWith("#"))
                                            {
                                                link = link.Replace("#", "");
                                                HtmlNodeCollection includeNodes = node.SelectNodes("//*[@id='" + link + "']");
                                                if (includeNodes != null && includeNodes.Count > 0)
                                                {
                                                    node.AppendChild(HtmlNode.CreateNode("<div>" + includeNodes[0].OuterHtml + "</div>"));
                                                }
                                            }
                                        }
                                    }

                                    includeRefNodes = node.SelectNodes(".//object[@class[contains(.,'include')]]");
                                    if (includeRefNodes != null)
                                    {
                                        foreach (HtmlNode includeRefNode in includeRefNodes)
                                        {
                                            string link = GetAttributeValue(includeRefNode, "data");
                                            if (link.StartsWith("#"))
                                            {
                                                link = link.Replace("#", "");
                                                HtmlNodeCollection includeNodes = node.SelectNodes("//*[@id='" + link + "']");
                                                if (includeNodes != null && includeNodes.Count > 0)
                                                {
                                                    node.AppendChild(HtmlNode.CreateNode("<div>" + includeNodes[0].OuterHtml + "</div>"));
                                                }
                                            }
                                        }
                                    }

                                    // For TD
                                    // Finds table head include pattern and appends node collection
                                    if (node.Name == "td" && GetAttributeValue(node, "headers") != string.Empty)
                                    {
                                        string   link      = GetAttributeValue(node, "headers");
                                        string[] itemArray = new string[1];
                                        itemArray[0] = link;
                                        if (link.IndexOf(' ') > -1)
                                        {
                                            itemArray = link.Split(' ');
                                        }

                                        for (int i = 0; i < itemArray.Length; i++)
                                        {
                                            HtmlNodeCollection includeNodes = null;
                                            includeNodes = this.startNode.SelectNodes("//node()[@id='" + itemArray[i].Trim() + "']");
                                            if (includeNodes != null && includeNodes.Count > 0)
                                            {
                                                // Appends fresh node to avoid overload issues
                                                foreach (HtmlNode childNode in includeNodes)
                                                {
                                                    node.AppendChild(HtmlNode.CreateNode("<div>" + childNode.OuterHtml + "</div>"));
                                                }
                                            }
                                        }
                                    }

                                    // For TR
                                    // Finds table head include pattern and appends node collection
                                    if (node.Name == "tr")
                                    {
                                        foreach (HtmlNode child in node.ChildNodes)
                                        {
                                            if (child.Name == "td" && GetAttributeValue(child, "headers") != string.Empty)
                                            {
                                                string   link      = GetAttributeValue(child, "headers");
                                                string[] itemArray = new string[1];
                                                itemArray[0] = link;
                                                if (link.IndexOf(' ') > -1)
                                                {
                                                    itemArray = link.Split(' ');
                                                }

                                                for (int i = 0; i < itemArray.Length; i++)
                                                {
                                                    HtmlNodeCollection includeNodes = null;
                                                    includeNodes = this.startNode.SelectNodes("//node()[@id='" + itemArray[i].Trim() + "']");
                                                    if (includeNodes != null && includeNodes.Count > 0)
                                                    {
                                                        // Appends fresh node to avoid overload issues
                                                        foreach (HtmlNode childNode in includeNodes)
                                                        {
                                                            child.AppendChild(HtmlNode.CreateNode("<div>" + childNode.OuterHtml + "</div>"));
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }


                                    // Adds the Html from which uf is parsed
                                    foreach (HtmlNode childNode in node.ChildNodes)
                                    {
                                        ufData.OuterHtml += childNode.OuterHtml;
                                    }


                                    // Recursion
                                    if (ufElement.Multiples || ufElement.ConcatenateValues)
                                    {
                                        ParseUfElementValue(node, ufElement, ufData);
                                    }
                                    else
                                    // Dont add a second data node for a format decription that does not support either
                                    // multiples or concatenation of values
                                    if (ufData.Nodes.Exists(ufElement.Name) == false)
                                    {
                                        ParseUfElementValue(node, ufElement, ufData);
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
 public int Add(UfElementDescriber newElement)
 {
     return(InnerList.Add(newElement));
 }
Ejemplo n.º 24
0
        /// <summary>
        /// Adds a new data node to the tree
        /// </summary>
        /// <param name="ufData">Parent node</param>
        /// <param name="ufNewDataNode">Node to be added</param>
        /// <param name="ufElement">The uF element describer</param>
        private void AddNewDateNode(HtmlNode baseNode, UfDataNode ufData, UfDataNode ufNewDataNode, UfElementDescriber ufElement)
        {
            if (IsDuplicateNode(ufData, ufNewDataNode) == false)
            {
                ufNewDataNode.OuterHtml = baseNode.OuterHtml;

                // This function deal both with the concatenation of multiple values
                // and the validation of multiple flag

                // If the structure is a value/type pair change the insert point
                if (ufElement.Elements["value"] != null && ufElement.Elements["type"] != null)
                {
                    // Add to child value node
                    UfDataNode ufdatanode = new UfDataNode("value", ufNewDataNode.Value);
                    ufNewDataNode.Nodes.Add(ufdatanode);
                    ufNewDataNode.Value = "";
                }

                // Concatenation of values
                if (ufElement.ConcatenateValues)
                {
                    // Create a new node or add to the existing one
                    if (ufData.Nodes[ufNewDataNode.Name] == null)
                    {
                        ufData.Nodes.Add(ufNewDataNode);
                    }
                    else
                    {
                        ufData.Nodes[ufNewDataNode.Name].Value += ufNewDataNode.Value;
                    }
                }
                else if (ufElement.Multiples == false)
                {
                    // Singluar - only take first instance
                    if (ufData.Nodes[ufNewDataNode.Name] == null)
                    {
                        ufData.Nodes.Add(ufNewDataNode);
                    }
                }
                else if (ufElement.Multiples == true)
                {
                    // Multiples
                    ufData.Nodes.Add(ufNewDataNode);
                }
            }
        }
Ejemplo n.º 25
0
        public static UfFormatDescriber ItemLicense()
        {
            UfFormatDescriber uFormat = new UfFormatDescriber();
            uFormat.Name = "item-license";
            uFormat.Description = "item-license used in hNews hEntry item";
            uFormat.Type = UfFormatDescriber.FormatTypes.Elemental;

            UfElementDescriber uFElement = new UfElementDescriber();
            uFElement.Name = "item-license";
            uFElement.AllowedTags.Add("a");
            uFElement.AllowedTags.Add("link");
            uFElement.Attribute = "rel";
            uFElement.Type = UfElementDescriber.PropertyTypes.UrlText;
            uFormat.BaseElement = uFElement;
            uFElement.AttributeValues.Add(new UfAttributeValueDescriber("item-license"));
            return uFormat;
        }
        private void AddNode(UfDataNode node, UfElementDescriber elementDescriber, XhtmlTextWriter writer)
        {
            if (node.Name != string.Empty)
            {
                indentNum++;
                writer.Indent = indentNum;

                UfElementDescriber currentDescriber = elementDescriber;
                foreach (UfElementDescriber childElementDescriber in elementDescriber.Elements)
                {
                    if (node.Name == childElementDescriber.Name || node.Name == childElementDescriber.CompoundName)
                    {
                        currentDescriber = childElementDescriber;
                    }
                }

                if (currentDescriber.Attribute == "class")
                {
                    writer.WriteBeginTag("div");
                    if (currentDescriber.CompoundName == "")
                    {
                        writer.WriteAttribute("class", node.Name);
                    }
                    else
                    {
                        writer.WriteAttribute("class", node.Name + " " + currentDescriber.Name);
                    }

                    if (!string.IsNullOrEmpty(node.ElementId))
                    {
                        writer.WriteAttribute("id", node.ElementId);
                    }

                    writer.Write(HtmlTextWriter.TagRightChar);
                    writer.WriteEncodedText(node.Value);


                    foreach (UfDataNode child in node.Nodes)
                    {
                        writer.WriteLine();
                        AddNode(child, currentDescriber, writer);
                    }


                    if (node.Name != string.Empty)
                    {
                        writer.WriteEndTag("div");
                        writer.WriteLine();
                    }
                }

                if (currentDescriber.Attribute == "rel")
                {
                    writer.WriteBeginTag("a");
                    writer.WriteAttribute("href", node.DescendantValue("link"));
                    writer.WriteAttribute("rel", node.Name);
                    writer.Write(HtmlTextWriter.TagRightChar);

                    writer.WriteEncodedText(node.DescendantValue("text"));
                    writer.WriteEndTag("a");
                    writer.WriteLine();
                }

                indentNum--;
                writer.Indent = indentNum;
            }
        }
Ejemplo n.º 27
0
        public static UfFormatDescriber Me()
        {
            UfFormatDescriber uFormat = new UfFormatDescriber();
            uFormat.Name = "me";
            uFormat.Description = "The finds rel=me without rest of xfn";
            uFormat.Type = UfFormatDescriber.FormatTypes.Elemental;

            UfElementDescriber uFElement = new UfElementDescriber();
            uFElement.Name = "me";
            uFElement.AllowedTags.Add("a");
            uFElement.AllowedTags.Add("link");
            uFElement.Attribute = "rel";
            uFElement.Type = UfElementDescriber.PropertyTypes.UrlText;
            uFormat.BaseElement = uFElement;

            uFElement.AttributeValues.Add(new UfAttributeValueDescriber("me", ""));

            return uFormat;
        }
Ejemplo n.º 28
0
        private void ParseUfElement(HtmlNode baseNode, UfElementDescriber ufElement, UfDataNode ufData, bool ufTopLevel)
        {
            // Select nodes with required attribute: class, rel or rev
            HtmlNodeCollection nodes = baseNode.SelectNodes(".//@" + ufElement.Attribute );

            if (nodes != null)
            {
                foreach (HtmlNode node in nodes)
                {

                    // Load the attribute class, rel or rev
                    HtmlAttribute att = node.Attributes[ufElement.Attribute];
                    HtmlAttribute compoundAtt = node.Attributes[ufElement.CompoundAttribute];
                    if (att != null)
                    {
                        // We are dealing with elemental uf like XFN
                        if (ufElement.AttributeValues.Count > 0)
                        {
                            bool found = false;
                            // Search for a mulitple attribute values ie friend or contact in rel
                            foreach (UfAttributeValueDescriber avd in ufElement.AttributeValues)
                            {
                                if (UfHelpers.FindAttributeValue(att.Value.ToLower(), avd.Name))
                                    found = true;

                            }
                            if (found)
                            {
                                // Adds the Html from which uf is parsed
                                // ufData.OuterHtml = node.OuterHtml;
                                ParseUfElementValue(node, ufElement, ufData);
                            }
                        }
                        else
                        {
                            bool found = false;

                            // Search for a single attribute values ie hcard in class
                            if (UfHelpers.FindAttributeValue(att.Value.ToLower(), ufElement.Name) && ufElement.CompoundName == string.Empty)
                                found = true;

                            // Search for a dual attribute values
                            // This is for compound structures, ie reviewer in hreview which is a hcard
                            if (UfHelpers.FindAttributeValue(att.Value.ToLower(), ufElement.Name) && UfHelpers.FindAttributeValue(compoundAtt.Value.ToLower(), ufElement.CompoundName))
                                found = true;

                            if (found)
                            {

                                if (HasCompound(baseNode, node.ParentNode, false) == false || ufElement.RootElement == true)
                                {
                                    HtmlNodeCollection includeRefNodes = null;

                                    includeRefNodes = node.SelectNodes(".//a[@class[contains(.,'include')]]");
                                    if (includeRefNodes != null)
                                    {
                                        foreach (HtmlNode includeRefNode in includeRefNodes)
                                        {
                                            string link = GetAttributeValue(includeRefNode, "href");
                                            if (link.StartsWith("#"))
                                            {
                                                link = link.Replace("#", "");
                                                HtmlNodeCollection includeNodes = node.SelectNodes("//*[@id='" + link + "']");
                                                if (includeNodes != null && includeNodes.Count > 0)
                                                    node.AppendChild(HtmlNode.CreateNode("<div>" + includeNodes[0].OuterHtml + "</div>"));
                                            }
                                        }

                                    }

                                    includeRefNodes = node.SelectNodes(".//object[@class[contains(.,'include')]]");
                                    if (includeRefNodes != null)
                                    {
                                        foreach (HtmlNode includeRefNode in includeRefNodes)
                                        {
                                            string link = GetAttributeValue(includeRefNode, "data");
                                            if (link.StartsWith("#"))
                                            {
                                                link = link.Replace("#", "");
                                                HtmlNodeCollection includeNodes = node.SelectNodes("//*[@id='" + link + "']");
                                                if (includeNodes != null && includeNodes.Count > 0)
                                                    node.AppendChild(HtmlNode.CreateNode("<div>" + includeNodes[0].OuterHtml + "</div>"));
                                            }
                                        }
                                    }

                                    // For TD
                                    // Finds table head include pattern and appends node collection
                                    if (node.Name == "td" && GetAttributeValue(node, "headers") != string.Empty)
                                    {
                                        string link = GetAttributeValue(node, "headers");
                                        string[] itemArray = new string[1];
                                        itemArray[0] = link;
                                        if (link.IndexOf(' ') > -1)
                                            itemArray = link.Split(' ');

                                        for (int i = 0; i < itemArray.Length; i++)
                                        {
                                            HtmlNodeCollection includeNodes = null;
                                            includeNodes = this.startNode.SelectNodes("//node()[@id='" + itemArray[i].Trim() + "']");
                                            if (includeNodes != null && includeNodes.Count > 0)
                                            {
                                                // Appends fresh node to avoid overload issues
                                                foreach (HtmlNode childNode in includeNodes)
                                                    node.AppendChild(HtmlNode.CreateNode("<div>" + childNode.OuterHtml + "</div>"));

                                            }
                                        }
                                    }

                                    // For TR
                                    // Finds table head include pattern and appends node collection
                                    if (node.Name == "tr")
                                    {
                                        foreach (HtmlNode child in node.ChildNodes)
                                        {
                                            if (child.Name == "td" && GetAttributeValue(child, "headers") != string.Empty)
                                            {
                                                string link = GetAttributeValue(child, "headers");
                                                string[] itemArray = new string[1];
                                                itemArray[0] = link;
                                                if (link.IndexOf(' ') > -1)
                                                    itemArray = link.Split(' ');

                                                for (int i = 0; i < itemArray.Length; i++)
                                                {
                                                    HtmlNodeCollection includeNodes = null;
                                                    includeNodes = this.startNode.SelectNodes("//node()[@id='" + itemArray[i].Trim() + "']");
                                                    if (includeNodes != null && includeNodes.Count > 0)
                                                    {
                                                        // Appends fresh node to avoid overload issues
                                                        foreach (HtmlNode childNode in includeNodes)
                                                            child.AppendChild(HtmlNode.CreateNode("<div>" + childNode.OuterHtml + "</div>"));

                                                    }
                                                }
                                            }
                                        }
                                    }

                                    // Adds the Html from which uf is parsed
                                    foreach (HtmlNode childNode in node.ChildNodes)
                                        ufData.OuterHtml += childNode.OuterHtml;

                                    // Recursion
                                    if (ufElement.Multiples || ufElement.ConcatenateValues)
                                        ParseUfElementValue(node, ufElement, ufData);
                                    else
                                        // Dont add a second data node for a format decription that does not support either
                                        // multiples or concatenation of values
                                        if (ufData.Nodes.Exists(ufElement.Name) == false)
                                            ParseUfElementValue(node, ufElement, ufData);

                                }
                            }
                        }
                    }
                }
            }
        }
Ejemplo n.º 29
0
        //-----------------------------------------------------------------------
        public static UfFormatDescriber NextPrevious()
        {
            UfFormatDescriber uFormat = new UfFormatDescriber();
            uFormat.Name = "nextprevious";
            uFormat.Description = "The rel next previous design pattern";
            uFormat.Type = UfFormatDescriber.FormatTypes.Compound;

            UfElementDescriber uFElement = new UfElementDescriber();
            uFElement.Name = "nextprevious";
            uFElement.AllowedTags.Add("a");
            uFElement.AllowedTags.Add("link");
            uFElement.Attribute = "rel";
            uFElement.Type = UfElementDescriber.PropertyTypes.UrlTextAttribute;
            uFormat.BaseElement = uFElement;

            uFElement.AttributeValues.Add(new UfAttributeValueDescriber("next", ""));
            uFElement.AttributeValues.Add(new UfAttributeValueDescriber("prev", ""));

            return uFormat;
        }
Ejemplo n.º 30
0
        private void AddNode(UfDataNode node, UfElementDescriber elementDescriber, XhtmlTextWriter writer)
        {
            if (node.Name != string.Empty)
            {
                indentNum++;
                writer.Indent = indentNum;

                UfElementDescriber currentDescriber = elementDescriber;
                foreach (UfElementDescriber childElementDescriber in elementDescriber.Elements)
                {
                    if (node.Name == childElementDescriber.Name || node.Name == childElementDescriber.CompoundName)
                    {
                        currentDescriber = childElementDescriber;
                    }
                }

                if (currentDescriber.Attribute == "class")
                {

                    writer.WriteBeginTag("div");
                    if (currentDescriber.CompoundName == "")
                        writer.WriteAttribute("class", node.Name);
                    else
                        writer.WriteAttribute("class", node.Name + " " + currentDescriber.Name);

                    if (!string.IsNullOrEmpty(node.ElementId))
                        writer.WriteAttribute("id", node.ElementId);

                    writer.Write(HtmlTextWriter.TagRightChar);
                    writer.WriteEncodedText(node.Value);

                    foreach (UfDataNode child in node.Nodes)
                    {
                        writer.WriteLine();
                        AddNode(child, currentDescriber, writer);
                    }

                    if (node.Name != string.Empty)
                    {
                        writer.WriteEndTag("div");
                        writer.WriteLine();
                    }
                }

                if (currentDescriber.Attribute == "rel")
                {
                    writer.WriteBeginTag("a");
                    writer.WriteAttribute("href", node.DescendantValue("link"));
                    writer.WriteAttribute("rel", node.Name);
                    writer.Write(HtmlTextWriter.TagRightChar);

                    writer.WriteEncodedText(node.DescendantValue("text"));
                    writer.WriteEndTag("a");
                    writer.WriteLine();
                }

                indentNum--;
                writer.Indent = indentNum;

            }
        }
 public void Insert(int index, UfElementDescriber newElement)
 {
     InnerList.Insert(index, newElement);
 }