Ejemplo n.º 1
0
        public static XElement ElementThrow(this XContainer container, string name)
        {
            var node = container.Element(name);

            if (node == null)
            {
                throw new Exception("Can not find " + name);
            }
            return(node);
        }
Ejemplo n.º 2
0
        private static IEnumerable <Uri> GetEndpoints(XContainer storageServicePropertiesElement, XNamespace azureNamespace, string endpointElement)
        {
            var endpointsElement = storageServicePropertiesElement.Element(azureNamespace + endpointElement);

            return(endpointsElement != null
                ? endpointsElement.Elements()
                   .Select(e => new Uri(e.Value))
                   .ToList()
                : Enumerable.Empty <Uri>());
        }
Ejemplo n.º 3
0
        public static string GetElementValue(this XContainer parentElement, string elementName)
        {
            XElement element = parentElement.Element(elementName);

            if (element == null)
            {
                return(null);
            }
            return(element.Value);
        }
Ejemplo n.º 4
0
        private ContractFeedEvent ExtractContractFeedEvent(XContainer element)
        {
            try
            {
                var id = element.Element(_nsAtom + "id")?.Value.Split(':').ElementAt(1);

                _logger.Info($"Bookmark Id: {id}");

                var contract = element
                               .Element(_nsAtom + "content")?
                               .Descendants(_nsUrn + "contract")?.First()
                               .Element(_nsUrn + "contracts")?.Descendants(_nsUrn + "contract").First();

                if (contract == null)
                {
                    return(null);
                }

                var hierarchyType   = contract.Element(_nsUrn + "hierarchyType")?.Value;
                var fundingTypeCode = contract.Element(_nsUrn + "fundingType")?.Element(_nsUrn + "fundingTypeCode")?.Value;
                var status          = contract.Element(_nsUrn + "contractStatus")?.Element(_nsUrn + "status")?.Value;
                var parentStatus    = contract.Element(_nsUrn + "contractStatus")?.Element(_nsUrn + "parentStatus")?.Value;
                var updatedString   = element.Element(_nsAtom + "updated")?.Value;
                var updated         = DateTime.Parse(updatedString);
                var ukprn           = contract.Element(_nsUrn + "contractor")?.Element(_nsUrn + "ukprn")?.Value;

                return(new ContractFeedEvent
                {
                    Id = new Guid(id),
                    ProviderId = long.Parse(ukprn),
                    HierarchyType = hierarchyType,
                    FundingTypeCode = fundingTypeCode,
                    Status = status,
                    ParentStatus = parentStatus,
                    Updated = updated
                });
            }
            catch (Exception ex)
            {
                _logger.Warn(ex, "Problem extracting contract feed event");
                return(null);
            }
        }
Ejemplo n.º 5
0
        public static string ElementValue(this XContainer container, XName name)
        {
            if (container == null)
            {
                return(null);
            }
            var element = container.Element(name);

            return(element != null ? element.Value : null);
        }
            public MigrationData(XContainer migrationXMLData)
            {
                if (migrationXMLData == null)
                {
                    return;
                }

                UncensorGUID = migrationXMLData.Element("guidUncensor")?.Value;
                BodyGUID     = migrationXMLData.Element("guidBody")?.Value;
                PenisGUID    = migrationXMLData.Element("guidPenis")?.Value;
                BallsGUID    = migrationXMLData.Element("guidBalls")?.Value;

                //These things can be null if the XML doesn't exist or empty strings if it does exist but is left blank
                //Set everything to null for easier checks
                UncensorGUID = UncensorGUID.IsNullOrWhiteSpace() ? null : UncensorGUID;
                BodyGUID     = BodyGUID.IsNullOrWhiteSpace() ? null : BodyGUID;
                PenisGUID    = PenisGUID.IsNullOrWhiteSpace() ? null : PenisGUID;
                BallsGUID    = BallsGUID.IsNullOrWhiteSpace() ? null : BallsGUID;
            }
Ejemplo n.º 7
0
        public static string ElementValueOrDefault(this XContainer container, string name, string @default)
        {
            var node = container.Element(name);

            if (node == null)
            {
                return(@default);
            }
            return(node.Value);
        }
Ejemplo n.º 8
0
        private static ICollection <DefaultCategory> LoadCategories(XContainer container)
        {
            var result     = new List <DefaultCategory>();
            var categories = container.Element("categories");

            TraverseCategories(result, categories, "expenses", CategoryType.Expense);
            TraverseCategories(result, categories, "incomes", CategoryType.Income);

            return(result);
        }
        private static XElement ElementVerified(this XContainer x, XName name)
        {
            var xElement = x.Element(name);

            if (xElement == null)
            {
                throw new XmlException(String.Format("Could not find element \"{0}\"", name));
            }
            return(xElement);
        }
Ejemplo n.º 10
0
        private void ReadLineStudies(XContainer xRoot)
        {
            XElement xmlLineStudies = xRoot.Element("LineStudies");

            if (xmlLineStudies == null)
            {
                return;
            }
            int useablePanelsCount = UseablePanelsCount;

            foreach (XElement node in xmlLineStudies.Elements())
            {
                if (node.Name != "LineStudy")
                {
                    return;
                }

                int panelIndex = ConvertFromXmlEx("PanelIndex", node, -1);
                if (panelIndex == -1)
                {
                    continue;
                }
                if (panelIndex >= useablePanelsCount)
                {
                    panelIndex = 0;
                }

                string key        = ConvertFromXmlEx("Key", node, String.Empty);
                string studyTypeS = ConvertFromXmlEx("StudyType", node, String.Empty);
                LineStudy.StudyTypeEnum studyType =
                    (LineStudy.StudyTypeEnum)System.Enum.Parse(typeof(LineStudy.StudyTypeEnum), studyTypeS, true);
                Brush    stroke   = (Brush)ConvertFromXml("StrokeColor", node);
                object[] extrArgs = (object[])ConvertFromBinary(ConvertFromXmlEx("ExtraArgs", node, string.Empty), typeof(object[]));

                LineStudy lineStudy = CreateLineStudy(studyType, key, stroke, panelIndex);
                lineStudy.SetArgs(extrArgs);

                double x1Value = ConvertFromXmlEx("X1Value", node, 0.0);
                double x2Value = ConvertFromXmlEx("X2Value", node, 0.0);
                double y1Value = ConvertFromXmlEx("Y1Value", node, 0.0);
                double y2Value = ConvertFromXmlEx("Y2Value", node, 0.0);
                lineStudy.SetXYValues(x1Value, y1Value, x2Value, y2Value);
                lineStudy._selectable     = ConvertFromXmlEx("Selectable", node, false);
                lineStudy.StrokeThickness = ConvertFromXmlEx("StrokeThickness", node, 1.0);
                lineStudy.StrokeType      =
                    (LinePattern)System.Enum.Parse(typeof(LinePattern), ConvertFromXmlEx("StrokeType", node, LinePattern.Solid.ToString()), true);
                lineStudy.Opacity = ConvertFromXmlEx("Opacity", node, 1.0);

                if (lineStudy is IShapeAble)
                {
                    IShapeAble shapeAble = (IShapeAble)lineStudy;
                    shapeAble.Fill = (Brush)ConvertFromXml("Fill", node);
                }
            }
        }
Ejemplo n.º 11
0
        private void ReadWorkSpace(XContainer xRoot)
        {
            XElement xmlWorkspace = xRoot.Element("WorkSpace");

            if (xmlWorkspace == null)
            {
                return;
            }

            try
            {
                ShowAnimations            = ConvertFromXmlEx("ShowAnimations", xmlWorkspace, false);
                ScaleAlignment            = (ScaleAlignmentTypeEnum)System.Enum.Parse(typeof(ScaleAlignmentTypeEnum), ConvertFromXmlEx("YAxes", xmlWorkspace, String.Empty), true);
                ScalingType               = (ScalingTypeEnum)System.Enum.Parse(typeof(ScalingTypeEnum), ConvertFromXmlEx("ScalingType", xmlWorkspace, String.Empty), true);
                YGrid                     = ConvertFromXmlEx("ShowYGrid", xmlWorkspace, true);
                XGrid                     = ConvertFromXmlEx("ShowXGrid", xmlWorkspace, true);
                GridStroke                = (Brush)ConvertFromXml("GridStroke", xmlWorkspace);
                ThreeDStyle               = ConvertFromXmlEx("ThreeDStyle", xmlWorkspace, true);
                UpColor                   = Utils.StringToColor(ConvertFromXmlEx("UpColor", xmlWorkspace, String.Empty));
                DownColor                 = Utils.StringToColor(ConvertFromXmlEx("DownColor", xmlWorkspace, String.Empty));
                CrossHairs                = ConvertFromXmlEx("CrossHairs", xmlWorkspace, false);
                LeftChartSpace            = ConvertFromXmlEx("LeftChartSpace", xmlWorkspace, 5);
                RightChartSpace           = ConvertFromXmlEx("RightChartSpace", xmlWorkspace, 10);
                RealTimeXLabels           = ConvertFromXmlEx("RealTimeData", xmlWorkspace, true);
                FontFace                  = ConvertFromXmlEx("FontFace", xmlWorkspace, String.Empty);
                FontForeground            = (Brush)ConvertFromXml("FontForeground", xmlWorkspace);
                PriceStyle                = (PriceStyleEnum)System.Enum.Parse(typeof(PriceStyleEnum), ConvertFromXmlEx("PriceStyle", xmlWorkspace, String.Empty), true);
                DisplayTitles             = ConvertFromXmlEx("DisplayTitles", xmlWorkspace, true);
                DarvasBoxes               = ConvertFromXmlEx("DarvasBoxes", xmlWorkspace, false);
                ChartType                 = (ChartTypeEnum)System.Enum.Parse(typeof(ChartTypeEnum), ConvertFromXmlEx("ChartType", xmlWorkspace, String.Empty), true);
                TickPeriodicity           = ConvertFromXmlEx("TickPeriodicity", xmlWorkspace, 5);
                TickCompressionType       = (TickCompressionEnum)System.Enum.Parse(typeof(TickCompressionEnum), ConvertFromXmlEx("TickCompressionType", xmlWorkspace, String.Empty), true);
                InfoPanelFontSize         = ConvertFromXmlEx("InfoPanelFontSize", xmlWorkspace, 10);
                InfoPanelFontFamily       = new FontFamily(ConvertFromXmlEx("InfoPanelFontFamily", xmlWorkspace, "Arial"));
                InfoPanelLabelsForeground = (Brush)ConvertFromXml("InfoPanelLabelsForeground", xmlWorkspace);
                InfoPanelLabelsBackground = (Brush)ConvertFromXml("InfoPanelLabelsBackground", xmlWorkspace);
                InfoPanelValuesForeground = (Brush)ConvertFromXml("InfoPanelValuesForeground", xmlWorkspace);
                InfoPanelValuesBackground = (Brush)ConvertFromXml("InfoPanelValuesBackground", xmlWorkspace);
                InfoPanelPosition         = (InfoPanelPositionEnum)System.Enum.Parse(typeof(InfoPanelPositionEnum), ConvertFromXmlEx("InfoPanelPosition", xmlWorkspace, String.Empty), true);
                IndicatorDialogBackground = (Brush)ConvertFromXml("IndicatorDialogBackground", xmlWorkspace);
                if (_panelsContainer._infoPanel != null)
                {
                    _panelsContainer._infoPanel.Position = PointEx.Parse(ConvertFromXmlEx("InfoPanelPositionCoords", xmlWorkspace, "0,0"));
                }

                for (int i = 0; i < _priceStyleParams.Length; i++)
                {
                    _priceStyleParams[i] = ConvertFromXmlEx("PriceStyleParam_" + i, xmlWorkspace, 0.0);
                }
            }
            catch (Exception ex)
            {
                Debug.WriteLine(ex);
            }
        }
Ejemplo n.º 12
0
        public static XElement GetOrAddElement(this XContainer parent, XName name)
        {
            var element = parent.Element(name);

            if (element == null)
            {
                element = new XElement(name);
                parent.Add(element);
            }
            return(element);
        }
Ejemplo n.º 13
0
        private static Decimal GetDecimalFromXml(XContainer container, String name, Decimal defaultValue = 0)
        {
            var item = container.Element(name);

            if (item != null)
            {
                Decimal.TryParse(item.Value, NumberStyles.Any, CultureInfo.InvariantCulture, out defaultValue);
            }

            return(defaultValue);
        }
Ejemplo n.º 14
0
        /// <remarks>
        /// Source: http://stackoverflow.com/a/14892813/1636276
        /// </remarks>
        public static XElement GetOrCreateElement(this XContainer container, string name)
        {
            var element = container.Element(name);

            if (element == null)
            {
                element = new XElement(name);
                container.Add(element);
            }
            return(element);
        }
Ejemplo n.º 15
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.º 16
0
        /// <summary>
        /// Finds the element text.
        /// </summary>
        /// <param name="parent">The parent.</param>
        /// <param name="element">The element.</param>
        /// <returns>The element value or null if not found.</returns>
        protected static string FindElementText(XContainer parent, XName element)
        {
            if (parent == null)
            {
                throw new ArgumentNullException("parent");
            }

            var child = parent.Element(element);

            return(child == null ? null : child.Value);
        }
Ejemplo n.º 17
0
        private static XElement EnsureElement(XContainer container, string elementName)
        {
            var element = container.Element(elementName);

            if (element == null)
            {
                throw new InvalidOperationException($"Invalid manifest format. Missing '{elementName}' element name");
            }

            return(element);
        }
        public static XElement ShouldHaveElement(this XContainer parent, string name)
        {
            var elem = parent.Element(xmlNamespace + name);

            if (elem == null)
            {
                throw new AssertionException(string.Format("Could not find an element named {0}", name));
            }

            return(elem);
        }
Ejemplo n.º 19
0
        private void LoadThreeStateItemContainerOrdered <T>(XContainer xParent, string elementName, string entryName,
                                                            ThreeStateItemContainerOrdered <T> container) where T : Def
        {
            var xFoundElement = xParent.Element(elementName);

            if (xFoundElement == null)
            {
                return;
            }

            container.FilterBooleanState = LoadEnum <FilterBoolean>(xFoundElement, "FilterBooleanState");
            LoadBoolean(xFoundElement, "OffPartialNoSelect", b => container.OffPartialNoSelect = b);
            LoadBoolean(xFoundElement, "OrderedFiltering", b => container.OrderedFiltering     = b);

            var orderedList = new List <T>();

            foreach (var xElement in xFoundElement.Elements(entryName))
            {
                var xDefName = xElement.Element(DefNameNode);
                if (xDefName == null)
                {
                    goto EnsureAllEntriesPresent;
                }

                var def = LoadDef <T>(xElement, DefNameNode) as T;
                if (def == null)
                {
                    goto EnsureAllEntriesPresent;
                }

                orderedList.Add(def);

                if (!container.TryGetValue(def, out var threeStateItem))
                {
                    goto EnsureAllEntriesPresent;
                }

                var state = LoadEnum <MultiCheckboxState>(xElement, StateNode);
                threeStateItem.State = state;
            }

EnsureAllEntriesPresent:
            foreach (var entry in container)
            {
                if (orderedList.Contains(entry.Key))
                {
                    continue;
                }

                orderedList.Add(entry.Key);
            }

            container.SetNewOrder(orderedList);
        }
Ejemplo n.º 20
0
        private static string GetWordIpa(XContainer ipaDocument, string word)
        {
            var wordIpa = ipaDocument.Element("IPADict")
                          ?.Element("WordList")
                          ?.Elements("IpaEntry")
                          .Where(d => d.Element("Item")?.Value.ToString() == word)
                          .Select(d => d.Element("Ipa")?.Value.ToString())
                          .DefaultIfEmpty(String.Empty).FirstOrDefault();

            return(wordIpa);
        }
Ejemplo n.º 21
0
        private static TrackManiaCallback?TryParseCallback(XContainer messageElement)
        {
            XElement methodNameElement = messageElement.Element("methodName");

            if (methodNameElement == null)
            {
                return(null);
            }

            return(TryParseCallback(methodNameElement.Value.Trim()));
        }
        private static void loadCategories(Post post, XContainer doc)
        {
            var categories = doc.Element("categories");

            if (categories == null)
            {
                return;
            }

            post.Categories = categories.Elements("category").Select(node => node.Value).ToArray();
        }
Ejemplo n.º 23
0
        private static T GetElementValue <T>(this XContainer xElement, string childElementName, T defaultvalue)
        {
            var childElement = xElement.Element(childElementName);

            if (childElement == null)
            {
                return(defaultvalue);
            }

            return(DeserializeValue(childElement.Value, defaultvalue));
        }
Ejemplo n.º 24
0
        /// <summary>
        /// Ruft ein notwendiges Element ab.
        /// </summary>
        /// <param name="xContainer">Container in dem das Element enthalten ist.</param>
        /// <param name="xname">Name des Elements</param>
        /// <returns>Das erste Element mit dem gewünschten Namen.</returns>
        /// <exception cref="XObjectException">Falls keine Element mit dem Namen exisitert.</exception>
        public static XElement RequiredElement(this XContainer xContainer, XName xname)
        {
            var element = xContainer.Element(xname);

            if (element == null)
            {
                throw new XObjectException($"Notwendiges Element {xname} fehlt.", xContainer);
            }

            return(element);
        }
Ejemplo n.º 25
0
 private static void InsertItemPrice(XContainer item, IEnumerable <XElement> toList, IReadOnlyDictionary <string, IChain> chainList, IReadOnlyDictionary <string, double> userItems)
 {
     toList.ToList().ForEach(itemCode =>
     {
         var newItem = new Item(item.Element("ItemName")?.Value, userItems[item?.Element("ItemName")?.Value]);
         AddItemToChain(itemCode.Attribute("name").Value,
                        itemCode.Attribute("code").Value,
                        newItem,
                        chainList);
     });
 }
Ejemplo n.º 26
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.º 27
0
        public static XElement GetOrAddElement(this XContainer container, XName name)
        {
            XElement xelement = container.Element(name);

            if (xelement == null)
            {
                xelement = new XElement(name);
                container.Add((object)xelement);
            }
            return(xelement);
        }
Ejemplo n.º 28
0
        private static XContainer GrabContainer(this XContainer parent, XName name)
        {
            var element = parent.Element(name);

            if (element == null)
            {
                element = new XElement(name);
                parent.Add(element);
            }
            return(element);
        }
 protected static string ReadValueStr(XContainer securityInfoNode, string propertyName)
 {
     if (securityInfoNode.Element(propertyName) != null)
     {
         var rtn = securityInfoNode.Element(propertyName).Value;
         if (!string.IsNullOrEmpty(rtn))
         {
             return(rtn.Trim());
         }
         else
         {
             return(null);
         }
     }
     else
     {
         return(null);
         // throw new System.Xml.XmlException(string.Format("未找到节点{0}", propertyName));
     }
 }
Ejemplo n.º 30
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)
        {
            var e = parent.Element(name);

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

            return(e);
        }