Ejemplo n.º 1
0
 private static List <string> GetGroups(NzbParserContext context, XContainer groupsElement)
 {
     return(groupsElement?
            .Elements(context.Namespace + NzbKeywords.Group)
            .Select(g => g.Value)
            .ToList());
 }
Ejemplo n.º 2
0
        public static XElement FindFirstElement(XContainer node, string localName)
        {
            var nodeElements = node?.Elements();

            if (nodeElements == null && nodeElements.Count() == 0)
            {
                return(null);
            }
            foreach (var element in nodeElements)
            {
                if (element.Name.LocalName == localName)
                {
                    return(element);
                }
            }
            foreach (var element in nodeElements)
            {
                var foundElement = FindFirstElement(element, localName);
                if (foundElement != null)
                {
                    return(foundElement);
                }
            }
            return(null);
        }
Ejemplo n.º 3
0
 private static List <NzbSegment> GetSegments(NzbParserContext context, XContainer segentsElement)
 {
     return(segentsElement?
            .Elements(context.Namespace + NzbKeywords.Segment)
            .Select(GetSegment)
            .ToList());
 }
Ejemplo n.º 4
0
        private static NntpGroups GetGroups(NzbParserContext context, XContainer groupsElement)
        {
            IEnumerable <string> groups = groupsElement?
                                          .Elements(context.Namespace + NzbKeywords.Group)
                                          .Select(g => g.Value);

            return(new NntpGroups(groups));
        }
Ejemplo n.º 5
0
        /// <summary>
        /// Returns whether a descendant of the specified <see cref="XElement" /> exists.
        /// </summary>
        /// <param name="element">The <see cref="XElement" />.</param>
        /// <param name="elementName">The name of the descendent node.</param>
        /// <param name="immediateOnly">Whether or not to search only the element's immediate descendants.</param>
        /// <returns><c>true</c> if the node exists or <c>false</c> otherwise.</returns>
        protected static bool Exists(XContainer element, string elementName, bool immediateOnly)
        {
            if (immediateOnly)
            {
                return(element?.Elements().Any(d => d.Name.LocalName.Equals(elementName, StringComparison.OrdinalIgnoreCase)) ?? false);
            }

            return(element?.Descendants().Any(d => d.Name.LocalName.Equals(elementName, StringComparison.OrdinalIgnoreCase)) ?? false);
        }
        /// <summary>
        /// Gets XML configuration parameter value as string.
        /// </summary>
        /// <param name="parametersElement">Root container element with 'parameter' nodes.</param>
        /// <param name="parameterName">Name of the parameter.</param>
        /// <param name="defaultValue">Default value returned if the parameter name is not found.</param>
        /// <returns>Parameter value as string.</returns>
        private static string GetParameterValue(XContainer parametersElement, string parameterName, string defaultValue)
        {
            var parameterElement = parametersElement.Elements("parameter").FirstOrDefault(x =>
            {
                var xAttribute = x.Attribute("name");
                return(xAttribute != null && xAttribute.Value.ToLower().Equals(parameterName.ToLower()));
            });

            return(parameterElement != null ? parameterElement.Value : defaultValue);
        }
Ejemplo n.º 7
0
        /// <summary>
        /// Loads a structure layout based upon an XML container's children.
        /// </summary>
        /// <param name="layoutTag">The collection of structure field tags to parse.</param>
        /// <returns>The structure layout that was loaded.</returns>
        public static StructureLayout LoadLayout(XContainer layoutTag)
        {
            StructureLayout layout = new StructureLayout();

            foreach (XElement element in layoutTag.Elements())
            {
                HandleElement(layout, element);
            }
            return(layout);
        }
        private static void DeleteItems(XContainer items)
        {
            foreach (var element in items.Elements())
            {
                var database = Factory.GetDatabase(element.GetAttributeValue("database"));

                var obj = database?.GetItem(element.GetAttributeValue("id"));
                obj?.Delete();
            }
        }
Ejemplo n.º 9
0
 /// <summary>
 /// Deserializes any script writers defined in the specified <see cref="XContainer"/>.
 /// </summary>
 /// <param name="parent">The <see cref="XContainer"/> object containing the XML definitions for the script writers.</param>
 private void DeserializeScriptWriters(XContainer parent)
 {
     foreach (var element in parent.Elements(_hyperDbXmlNamespace + "add"))
     {
         _scriptWriterTypes.TryAdd(
             GetRequiredAttribute(element, "name"),
             Type.GetType(GetRequiredAttribute(element, "type"), true) // Deliberately throw an exception if we can't load the type
             );
     }
 }
Ejemplo n.º 10
0
        private static string GetElementValue(XContainer parent, string name)
        {
            var elem = parent.Elements(name).FirstOrDefault();

            if (elem == null)
            {
                throw new Exception("Missing element " + name);
            }
            return(elem.Value);
        }
Ejemplo n.º 11
0
 /// <summary>
 /// Adds the event to the collection.
 /// </summary>
 /// <param name="element">The event being added.</param>
 private void AddEvent(XContainer element)
 {
     foreach (XElement child in element.Elements())
     {
         if (!this.Contains(child))
         {
             this.Add(child);
         }
     }
 }
 static void PrintDirectories(XContainer parent, string path)
 {
     foreach (XElement element in parent.Elements("dir"))
     {
         string dir      = element.Attribute("name").Value;
         string fullPath = path == null ? dir : $"{path}/{dir}";
         Console.WriteLine(fullPath);
         PrintDirectories(element, fullPath);
     }
 }
Ejemplo n.º 13
0
        private static Dictionary <string, string> GetJoins(XContainer ele)
        {
            if (ele == null)
            {
                return(new Dictionary <string, string>());
            }
            var ret = ele.Elements().ToDictionary(j => j.Attribute("name").Value, j => j.Value);

            return(ret);
        }
Ejemplo n.º 14
0
        private static Dictionary <string, string> LoadKeyValueRule(XContainer doc, string section, string container)
        {
            IEnumerable <XElement> step1Pre = doc.Elements(section).Elements(container);

            return(step1Pre.Select(element => new { Key = element.Value.Split('|')[0], Value = element.Value.Split('|')[1] })

                   .GroupBy(arg => arg.Key, arg => arg.Value, (key, values) => new { Key = key, Value = values.First() })

                   .ToDictionary(arg => arg.Key, arg => arg.Value));
        }
Ejemplo n.º 15
0
 /// <summary>
 /// This method returns a list of elements matching the specified name, using the specified string comparison method.
 /// </summary>
 /// <param name="container">The XML container instance.</param>
 /// <param name="name">The name of the element to locate.</param>
 /// <param name="comparisonType">One of the System.StringComparison values.</param>
 /// <returns>List of elements matching the specified name.</returns>
 public static IEnumerable <XElement> Elements(this XContainer container, XName name, StringComparison comparisonType)
 {
     foreach (XElement element in container.Elements())
     {
         if (String.Compare(element.Name.LocalName, name.LocalName, comparisonType) == 0)
         {
             yield return(element);
         }
     }
 }
Ejemplo n.º 16
0
        /// <summary>
        /// Gets the first (in document order) child element with the specified local name and one of the namespaces.
        /// </summary>
        /// <param name="container">The node containing the child elements.</param>
        /// <param name="namespaces">A collection of namespaces used when searching for the child element.</param>
        /// <param name="localName">The local (unqualified) name to match.</param>
        /// <returns>A <see cref="XElement" /> that matches the specified name and namespace, or null.</returns>
        public static XElement Element(this XContainer container, IEnumerable <XNamespace> namespaces, string localName)
        {
            Contract.Requires(container != null);
            Contract.Requires(namespaces != null);
            Contract.Requires(!string.IsNullOrWhiteSpace(localName));

            return(container.Elements()
                   .FirstOrDefault(
                       e => e.Name.LocalName == localName &&
                       namespaces.Contains(e.Name.Namespace)));
        }
Ejemplo n.º 17
0
 private static IDictionary <string, object> LoadCommandParameters(XContainer xe)
 {
     return
         (xe
          .Elements(XName.Get("parameter", _menuDescriptorSchemaUri))
          .ToDictionary(
              parameter => (string)parameter.Attribute(XName.Get("name")),
              parameter => (object)parameter.Value,
              StringComparer.OrdinalIgnoreCase)
          .AsReadOnly());
 }
Ejemplo n.º 18
0
 public static IEnumerable <XElement> ElementsIgnoreCase(this XContainer container, XName name)
 {
     foreach (var element in container.Elements())
     {
         if (element.Name.NamespaceName == name.NamespaceName &&
             string.Equals(element.Name.LocalName, name.LocalName, StringComparison.OrdinalIgnoreCase))
         {
             yield return(element);
         }
     }
 }
        private static IEnumerable <SimpleValueValidator> FindSimpleValueValidator(XContainer parent)
        {
            foreach (var simpleElement in parent.Elements("SimpleValue"))
            {
                var simple = new SimpleValueValidator();
                simple.Id         = simpleElement.Attribute("Id").Value;
                simple.Validation = simpleElement.Attribute("Validation").Value;

                yield return(simple);
            }
        }
Ejemplo n.º 20
0
 public static XElement Element(this XContainer node, XName name, bool ignoreNamespace)
 {
     if (ignoreNamespace)
     {
         return(node.Elements().FirstOrDefault(e => e.Name.LocalName == name.LocalName));
     }
     else
     {
         return(node.Element(name));
     }
 }
Ejemplo n.º 21
0
 // From https://stackoverflow.com/a/9335141/6651
 public static IEnumerable <XElement> ElementsCaseInsensitive(XContainer source, XName name)
 {
     foreach (XElement e in source.Elements())
     {
         if (e.Name.Namespace.NamespaceName.Equals(name.Namespace.NamespaceName, StringComparison.OrdinalIgnoreCase) &&
             e.Name.LocalName.Equals(name.LocalName, StringComparison.OrdinalIgnoreCase))
         {
             yield return(e);
         }
     }
 }
Ejemplo n.º 22
0
 protected ConditionSet([NotNull] XContainer el) : this()
 {
     if (el == null)
     {
         throw new ArgumentNullException(nameof(el));
     }
     foreach (XElement cel in el.Elements())
     {
         Add(Parse(cel));
     }
 }
Ejemplo n.º 23
0
        private static XElement GetElement(XContainer element, XName name)
        {
            if (element == null)
            {
                throw new ArgumentNullException("element");
            }
            var elems     = element.Elements().Where(xElement => xElement.Name.Equals(name));
            var xElements = elems as XElement[] ?? elems.ToArray();

            return(xElements.Any() ? xElements.ElementAt(0) : null);
        }
Ejemplo n.º 24
0
        /// <summary>
        /// Returns the element with the specified name, or creates and adds one if required.
        /// </summary>
        /// <param name="parent"></param>
        /// <param name="name"></param>
        /// <returns></returns>
        public static XElement ElementOrAdd(this XContainer parent, XName name, Func <XElement, bool> predicate)
        {
            var e = parent.Elements(name).FirstOrDefault(predicate);

            if (e == null)
            {
                parent.Add(e = new XElement(name));
            }

            return(e);
        }
Ejemplo n.º 25
0
 public static IEnumerable <XElement> FindElementSequences(this XContainer container, List <string> names)
 {
     foreach (XElement parent in container.Elements())
     {
         XText child = parent.GetSequenceChild(names);
         if (child != null)
         {
             yield return(parent);
         }
     }
 }
Ejemplo n.º 26
0
        // <summary>
        // Gets the first (in document order) child element with the specified local name and one of the namespaces.
        // </summary>
        // <param name="container">The node containing the child elements.</param>
        // <param name="namespaces">A collection of namespaces used when searching for the child element.</param>
        // <param name="localName">The local (unqualified) name to match.</param>
        // <returns>A <see cref="XElement" /> that matches the specified name and namespace, or null.</returns>
        public static XElement Element(this XContainer container, IEnumerable <XNamespace> namespaces, string localName)
        {
            DebugCheck.NotNull(container);
            DebugCheck.NotNull(namespaces);
            DebugCheck.NotEmpty(localName);

            return(container.Elements()
                   .FirstOrDefault(
                       e => e.Name.LocalName == localName &&
                       namespaces.Contains(e.Name.Namespace)));
        }
Ejemplo n.º 27
0
        public static IEnumerable <XElement> GetRequiredElements
        (
            [NotNull] this XContainer container,
            [NotNull] string elementName,
            bool ignoreNamespace = true
        )
        {
            var elements = ignoreNamespace
                ? container.Elements().Where(a => a.Name.LocalName == elementName)
                : container.Elements(elementName);

            var requiredElements = elements.ToList();

            if (!requiredElements.Any())
            {
                throw new InvalidDataException($"Required element \"{elements}\" not found.");
            }

            return(requiredElements);
        }
Ejemplo n.º 28
0
        //[Variation(Priority = 2, Desc = "XElement.AncestorsAndSelf(XName) I.", Param = true)]
        //[Variation(Priority = 2, Desc = "XElement.AncestorsAndSelf(XName) II.", Param = false)]

        #region Methods

        private void VerifyDeleteNodes <T>(IEnumerable <T> toRemove) where T : XNode
        {
            // copy of the data to delete
            IEnumerable <XNode> toRemoveCopy = toRemove.OfType <XNode>().ToList();

            // Create array of parents
            IEnumerable <XContainer> parents = toRemove.Select(x => (x == null) ? (XContainer)null : (x.Parent != null ? (XContainer)x.Parent : (XContainer)x.Document)).ToList();

            // calculate the expected results for the parents of the processed elements
            var expectedNodesForParent = new Dictionary <XContainer, List <ExpectedValue> >();

            foreach (XContainer p in parents)
            {
                if (p != null)
                {
                    expectedNodesForParent.TryAdd(p, p.Nodes().Except(toRemoveCopy.Where(x => x != null)).Select(a => new ExpectedValue(!(a is XText), a)).ProcessNodes().ToList());
                }
            }

            toRemove.Remove();

            IEnumerator <XNode>      copyToRemove = toRemoveCopy.GetEnumerator();
            IEnumerator <XContainer> parentsEnum  = parents.GetEnumerator();

            // verify on parents: deleted elements should not be found
            while (copyToRemove.MoveNext() && parentsEnum.MoveNext())
            {
                XNode node = copyToRemove.Current;
                if (node != null)
                {
                    XContainer parent = parentsEnum.Current;

                    TestLog.Compare(node.Parent, null, "Parent of deleted");
                    TestLog.Compare(node.Document, null, "Document of deleted");
                    TestLog.Compare(node.NextNode, null, "NextNode of deleted");
                    TestLog.Compare(node.PreviousNode, null, "PreviousNode of deleted");

                    if (parent != null)
                    {
                        TestLog.Compare(parent.Nodes().Where(x => x == node).IsEmpty(), "Nodes axis");
                        if (node is XElement)
                        {
                            var e = node as XElement;
                            e.Verify();
                            TestLog.Compare(parent.Element(e.Name) != node, "Element axis");
                            TestLog.Compare(parent.Elements(e.Name).Where(x => x == e).IsEmpty(), "Elements axis");
                        }

                        // Compare the rest of the elements
                        TestLog.Compare(expectedNodesForParent[parent].EqualAll(parent.Nodes(), XNode.EqualityComparer), "The rest of the nodes");
                    }
                }
            }
        }
Ejemplo n.º 29
0
        private static DataRow AddRecord(DataTable rs, XContainer rsXml)
        {
            var values = new List <object>();

            foreach (XElement fieldNode in rsXml.Elements())
            {
                AddColumn(rs, fieldNode.Name.LocalName);
                values.Add(fieldNode.Value);
            }
            return(rs.Rows.Add(values.ToArray()));
        }
Ejemplo n.º 30
0
        private string PrepareBookTitle(XContainer info)
        {
            XElement element = info.Elements(_ns + "book-title").FirstOrDefault();

            if (element == null)
            {
                return(string.Empty);
            }

            return(element.Value);
        }