public static string GetNodeHistoryLastValue(XObject node)
        {
            if (node is XElement)
            {
                var text = ((node as XElement).FirstNode as XText).Value;
                return(text);

                var elements = ((XElement)node).Elements();
                foreach (var xElement in elements)
                {
                    if (!XmlMerger.IsHistoryNode(xElement.Name.LocalName))
                    {
                        return((xElement).Value);
                    }
                }

                return((node as XElement).Value);
            }
            else if (node is XText)
            {
                return((node as XText).Value);
            }
            else
            {
                return((node as XAttribute).Value);
            }

            // var hasHistory = node.ChildNodes.Cast<XmlNode>().Any(XmlMerger.IsHistoryNode);

            // return hasHistory ? node.FirstChild.InnerText : node.InnerText;
        }
Пример #2
0
        public void MergeWithOldChanges(IEnumerable <XElement> a, IEnumerable <XElement> b, XElement parentDocA, XElement parentDocB, string lastUpdate)
        {
            if (String.IsNullOrEmpty(lastUpdate))
            {
                foreach (var nodeB in b)
                {
                    if (nodeB.Name.LocalName == XmlLastupdateAttribbute_v1 || nodeB.Name.LocalName == XmlLastupdateAttribbute_v2)
                    {
                        lastUpdate = (nodeB.FirstNode as XText).Value;
                    }
                }
            }// pass

            foreach (var nodeB in b)
            {
                if (nodeB.Name.LocalName == "Header")
                {
                    continue;
                }

                bool isContains = false;

                if (nodeB.Name.LocalName == XmlLastupdateAttribbute_v1)
                {
                    continue;
                }

                foreach (var nodeA in a)
                {
                    bool canMerge = !IsHistoryNode(nodeB.Name.LocalName);


                    if (canMerge && nodeB.Name.LocalName == nodeA.Name.LocalName)
                    {
                        if (nodeA.HasAttributes && nodeB.HasAttributes)
                        {
                            var nodeName = nodeB.Name.LocalName;

                            if (nodeName == "Score")
                            {
                                canMerge = canMerge && IsIdenticalScores(nodeA, nodeB);
                            }
                            else if (nodeName == "Scorer")
                            {
                                canMerge = canMerge && IsIdenticalScorers(nodeA, nodeB);

                                isContains = isContains || XmlMerger.IsEqualsByAttributes(nodeA, nodeB);
                            }
                            else if (nodeName == "Card")
                            {
                                canMerge = canMerge && IsIdenticalCards(nodeA, nodeB);

                                isContains = isContains || XmlMerger.IsEqualsByAttributes(nodeA, nodeB);
                            }
                            else if (nodeName == "Participant")
                            {
                                canMerge = canMerge && IsIdenticalParticipants(nodeA, nodeB);
                            }
                            else if (nodeName == "Runner")
                            {
                                canMerge = canMerge && IsIdenticalRunners(nodeA, nodeB);
                            }
                            else if (nodeName == "Player")
                            {
                                canMerge = canMerge && IsIdenticalPlayers(nodeA, nodeB);
                            }
                            else if (nodeName == "Statistic")
                            {
                                canMerge = canMerge && IsIdenticalStatistics(nodeA, nodeB);
                            }
                            else if (nodeName == "Outcome" || nodeName == "Bookmaker" || nodeName == "Odds")
                            {
                                canMerge = canMerge && EqualsById(nodeA, nodeB);
                            }
                            else if (nodeName == "Odd")
                            {
                                canMerge = canMerge && EqualsBetLine(nodeA, nodeB);
                            } // else pass
                        }     // else pass
                    }
                    else
                    {
                        canMerge = false;
                    }

                    if (canMerge)
                    {
                        isContains = true;

                        if (nodeB.HasElements)
                        {
                            MergeWithOldChanges(nodeA.Elements(), nodeB.Elements(), nodeA, nodeB, lastUpdate);
                        }
                        else
                        {
                            if (nodeB.FirstNode is XText && nodeA.FirstNode is XText && (nodeB.FirstNode as XText).Value == (nodeA.FirstNode as XText).Value)
                            {
                                // pass, not changed
                            }
                            else if (nodeB.FirstNode is XText && nodeA.FirstNode is XText)
                            {
                                var historyInnerTextNodes = nodeA.XPathSelectElement(DvsHistoryValues);

                                XElement historyInnerTextNode;

                                if (historyInnerTextNodes == null)
                                {
                                    historyInnerTextNode = new XElement(DvsHistoryValues);
                                    nodeA.Add(historyInnerTextNode);
                                }
                                else
                                {
                                    historyInnerTextNode = historyInnerTextNodes;
                                }

                                var oldInnerTextNode = new XElement(DvsHistoryOldValue, (nodeA.FirstNode as XText).Value);

                                // copy
                                if (nodeA.HasAttributes)
                                {
                                    foreach (var attrA in nodeA.Attributes())
                                    {
                                        var newAttr = new XAttribute(attrA.Name.LocalName, attrA.Value);
                                        oldInnerTextNode.Add(newAttr);
                                    }
                                } // pass

                                // add timeframe attribute

                                if (string.IsNullOrEmpty(lastUpdate))
                                {
                                    lastUpdate = DateTime.UtcNow.ToString("yyyy-MM-ddTHH:mm:ss.fff");
                                }

                                var attrTime = new XAttribute(DvsLastupdateAttribbute, lastUpdate);
                                oldInnerTextNode.Add(attrTime);

                                historyInnerTextNode.Add(oldInnerTextNode);


                                (nodeA.FirstNode as XText).Value = (nodeB.FirstNode as XText).Value;
                                //nodeA.Add(new XText(nodeB.Value));
                            }
                        }

                        if (nodeA.HasAttributes && nodeB.HasAttributes)
                        {
                            MergeNodesAttributes(nodeA, nodeB, lastUpdate);
                        } // else pass
                    }
                    else
                    {
                        // pass
                    }
                }

                if (!isContains)
                {
                    // var newNode = parentDocA.OwnerDocument.ImportNode(nodeB, true);

                    // var result = ReflectiveEquals(nodeB, newNode);

                    parentDocA.Add(nodeB);
                }// else pass
            }
        }