/// <summary>
        /// Serializes service result to a X-Road message response.
        /// </summary>
        protected virtual void SerializeXRoadResponse(XRoadContext context)
        {
            OnBeforeSerialization(context);

            context.Request.ContentStream.Position = 0;
            using (var reader = XmlReader.Create(context.Request.ContentStream, new XmlReaderSettings {
                CloseInput = false
            }))
            {
                var writer = new XmlTextWriter(context.Response.ContentStream, context.Response.ContentEncoding);

                writer.WriteStartDocument();

                var protocolDefinition = context.Response.ServiceManager?.ProtocolDefinition;

                if (context.MessageFormatter.TryMoveToEnvelope(reader))
                {
                    context.MessageFormatter.WriteStartEnvelope(writer, reader.Prefix);
                    writer.WriteAttributes(reader, true);
                    writer.WriteMissingAttributes(protocolDefinition);
                }
                else
                {
                    writer.WriteSoapEnvelope(context.MessageFormatter, protocolDefinition);
                }

                if (context.MessageFormatter.TryMoveToHeader(reader))
                {
                    writer.WriteNode(reader, true);
                }

                context.MessageFormatter.WriteStartBody(writer);
                if (context.MessageFormatter.TryMoveToBody(reader))
                {
                    writer.WriteAttributes(reader, true);
                }

                context.ServiceMap.SerializeResponse(writer, context.Result, context.Response, reader, CustomSerialization);

                writer.WriteEndDocument();
                writer.Flush();
            }

            context.Response.SaveTo(context.HttpContext, context.MessageFormatter);

            OnAfterSerialization(context);
        }
Exemplo n.º 2
0
        // Writes the content (inner XML) of the current node into the provided XmlTextWriter.
        private async Task WriteNodeAsync(XmlTextWriter xtw, bool defattr)
        {
            int d = NodeType == XmlNodeType.None ? -1 : Depth;

            while (await ReadAsync().ConfigureAwait(false) && d < Depth)
            {
                switch (NodeType)
                {
                case XmlNodeType.Element:
                    xtw.WriteStartElement(Prefix, LocalName, NamespaceURI);
                    xtw.QuoteChar = QuoteChar;
                    xtw.WriteAttributes(this, defattr);
                    if (IsEmptyElement)
                    {
                        xtw.WriteEndElement();
                    }
                    break;

                case XmlNodeType.Text:
                    xtw.WriteString(await GetValueAsync().ConfigureAwait(false));
                    break;

                case XmlNodeType.Whitespace:
                case XmlNodeType.SignificantWhitespace:
                    xtw.WriteWhitespace(await GetValueAsync().ConfigureAwait(false));
                    break;

                case XmlNodeType.CDATA:
                    xtw.WriteCData(Value);
                    break;

                case XmlNodeType.EntityReference:
                    xtw.WriteEntityRef(Name);
                    break;

                case XmlNodeType.XmlDeclaration:
                case XmlNodeType.ProcessingInstruction:
                    xtw.WriteProcessingInstruction(Name, Value);
                    break;

                case XmlNodeType.DocumentType:
                    xtw.WriteDocType(Name, GetAttribute("PUBLIC"), GetAttribute("SYSTEM"), Value);
                    break;

                case XmlNodeType.Comment:
                    xtw.WriteComment(Value);
                    break;

                case XmlNodeType.EndElement:
                    xtw.WriteFullEndElement();
                    break;
                }
            }
            if (d == Depth && NodeType == XmlNodeType.EndElement)
            {
                await ReadAsync().ConfigureAwait(false);
            }
        }
Exemplo n.º 3
0
        private void WriteNode(XmlTextWriter xtw, bool defattr)
        {
            int d = this.NodeType == XmlNodeType.None ? -1 : this.Depth;

            while (this.Read() && (d < this.Depth))
            {
                switch (this.NodeType)
                {
                case XmlNodeType.Element:
                    xtw.WriteStartElement(this.Prefix, this.LocalName, this.NamespaceURI);
                    xtw.QuoteChar = this.QuoteChar;
                    xtw.WriteAttributes(this, defattr);
                    if (this.IsEmptyElement)
                    {
                        xtw.WriteEndElement();
                    }
                    break;

                case XmlNodeType.Text:
                    xtw.WriteString(this.Value);
                    break;

                case XmlNodeType.Whitespace:
                case XmlNodeType.SignificantWhitespace:
                    xtw.WriteWhitespace(this.Value);
                    break;

                case XmlNodeType.CDATA:
                    xtw.WriteCData(this.Value);
                    break;

                case XmlNodeType.EntityReference:
                    xtw.WriteEntityRef(this.Name);
                    break;

                case XmlNodeType.XmlDeclaration:
                case XmlNodeType.ProcessingInstruction:
                    xtw.WriteProcessingInstruction(this.Name, this.Value);
                    break;

                case XmlNodeType.DocumentType:
                    xtw.WriteDocType(this.Name, this.GetAttribute("PUBLIC"), this.GetAttribute("SYSTEM"), this.Value);
                    break;

                case XmlNodeType.Comment:
                    xtw.WriteComment(this.Value);
                    break;

                case XmlNodeType.EndElement:
                    xtw.WriteFullEndElement();
                    break;
                }
            }
            if (d == this.Depth && this.NodeType == XmlNodeType.EndElement)
            {
                Read();
            }
        }
Exemplo n.º 4
0
        /// <summary>
        /// Serializes service result to a X-Road message response.
        /// </summary>
        protected virtual void SerializeXRoadResponse(XRoadContextClassic context)
        {
            OnBeforeSerialization(context);

            context.Request.ContentStream.Position = 0;
            using (var reader = XmlReader.Create(context.Request.ContentStream, new XmlReaderSettings {
                CloseInput = false
            }))
            {
                var writer = new XmlTextWriter(context.Response.ContentStream, context.Response.ContentEncoding);

                writer.WriteStartDocument();

                if (reader.MoveToElement(0) && reader.IsCurrentElement(0, "Envelope", NamespaceConstants.SOAP_ENV))
                {
                    writer.WriteStartElement(reader.Prefix, "Envelope", NamespaceConstants.SOAP_ENV);
                    writer.WriteAttributes(reader, true);
                }
                else
                {
                    writer.WriteStartElement(PrefixConstants.SOAP_ENV, "Envelope", NamespaceConstants.SOAP_ENV);
                    writer.WriteAttributeString("xmlns", PrefixConstants.SOAP_ENV, NamespaceConstants.XMLNS, NamespaceConstants.SOAP_ENV);
                }

                if (reader.MoveToElement(1) && reader.IsCurrentElement(1, "Header", NamespaceConstants.SOAP_ENV))
                {
                    writer.WriteNode(reader, true);
                }

                writer.WriteStartElement("Body", NamespaceConstants.SOAP_ENV);
                if (reader.IsCurrentElement(1, "Body", NamespaceConstants.SOAP_ENV) || reader.MoveToElement(1, "Body", NamespaceConstants.SOAP_ENV))
                {
                    writer.WriteAttributes(reader, true);
                }

                context.ServiceMap.SerializeResponse(writer, context.Result, context.Response, reader, CustomSerialization);

                writer.WriteEndDocument();
                writer.Flush();
            }

            context.Response.SaveTo(context.HttpContext);

            OnAfterSerialization(context);
        }
Exemplo n.º 5
0
        static void Main(string[] args)
        {
            XmlTextReader Reader = new XmlTextReader(@"..\..\..\Data\Users.xml");
            XmlTextWriter Writer = new XmlTextWriter(@"..\..\..\Data\Users2.xml", null);

            Writer.Formatting = Formatting.Indented;

            while (Reader.Read())
            {
                if ((Reader.NodeType == XmlNodeType.Element) && (Reader.Name == "User"))
                {
                    Writer.WriteStartElement(Reader.Name);
                    Reader.MoveToNextAttribute();
                    Writer.WriteAttributeString("ID", "User" + Reader.Value);
                    Reader.MoveToNextAttribute();
                    Writer.WriteAttributeString("UserName", Reader.Value);
                }
                else
                {
                    switch (Reader.NodeType)
                    {
                    case XmlNodeType.Element:
                        Writer.WriteStartElement(Reader.Name);
                        Writer.WriteAttributes(Reader, false);
                        break;

                    case XmlNodeType.CDATA:
                        Writer.WriteCData(Reader.Value);
                        break;

                    case XmlNodeType.EndElement:
                        Writer.WriteEndElement();
                        break;

                    case XmlNodeType.EntityReference:
                        Writer.WriteEntityRef(Reader.Name);
                        break;

                    case XmlNodeType.ProcessingInstruction:
                        Writer.WriteProcessingInstruction(Reader.Name, Reader.Value);
                        break;

                    case XmlNodeType.Text:
                    case XmlNodeType.SignificantWhitespace:
                        Writer.WriteString(Reader.Value);
                        break;

                    default:
                        break;
                    }
                }
            }
            Reader.Close();
            Writer.Close();
        }
Exemplo n.º 6
0
        /// <summary>
        /// Copy a node from the current XmlTextReader object to the given XmlTextWriter object.
        /// </summary>
        /// <param name="xw">the XmlTextWriter object to write to</param>
        public void CopyNode(XmlTextWriter xw)
        {
            switch (NodeType)
            {
            case XmlNodeType.Element:
                xw.WriteStartElement(Name);
                xw.WriteAttributes(this, true);
                if (IsEmptyElement)
                {
                    xw.WriteEndElement();
                }
                break;

            case XmlNodeType.EndElement:
                xw.WriteEndElement();
                break;

            case XmlNodeType.Text:
                xw.WriteString(Value);
                break;

            case XmlNodeType.SignificantWhitespace:
                xw.WriteWhitespace(Value);
                break;

            case XmlNodeType.Whitespace:
                // You could insert xw.WriteWhitespace(Value); to preserve
                // insignificant white space, but it either adds bloat or
                // messes up formatting.
                break;

            case XmlNodeType.Attribute:
                xw.WriteAttributeString(Name, Value);
                break;

            case XmlNodeType.ProcessingInstruction:
                xw.WriteProcessingInstruction(Name, Value);
                break;

            case XmlNodeType.XmlDeclaration:
                xw.WriteStartDocument(true);
                break;

            default:
                Logit.WriteLine("Doing NOTHING with type=" + NodeType.ToString() + " Name=" + Name + " Value=" + Value);     // DEBUG
                break;
            }
        }
Exemplo n.º 7
0
        public void WriteAttributes()
        {
            string        xml = "<root><test a='b' c='d' /><b /></root>";
            XmlTextReader xtr = new XmlTextReader(xml,
                                                  XmlNodeType.Document, null);

            xtw.QuoteChar = '\'';
            xtr.Read();
            xtw.WriteStartElement("root");      // <root
            xtr.Read();
            xtw.WriteStartElement("test");      // ><test
            xtw.WriteAttributes(xtr, false);    // a='b' c='d'
            Assert.AreEqual(XmlNodeType.Element, xtr.NodeType);
            xtw.WriteEndElement();              // />
            xtw.WriteStartElement("b");         // <b
            xtw.WriteEndElement();              // />
            xtw.WriteEndElement();              // </root>
            xtw.Close();
            Assert.AreEqual(xml, writer.ToString());
        }
        public void WriteAttributes()
        {
            XmlDocument      doc = new XmlDocument();
            StringWriter     sw  = new StringWriter();
            XmlWriter        wr  = new XmlTextWriter(sw);
            StringBuilder    sb  = sw.GetStringBuilder();
            XmlParserContext ctx = new XmlParserContext(doc.NameTable, new XmlNamespaceManager(doc.NameTable), "", XmlSpace.Default);
            XmlTextReader    xtr = new XmlTextReader("<?xml version='1.0' encoding='utf-8' standalone='no'?><root a1='A' b2='B' c3='C'><foo><bar /></foo></root>", XmlNodeType.Document, ctx);

            xtr.Read(); // read XMLDecl
            wr.WriteAttributes(xtr, false);
            // This method don't always have to take this double-quoted style...
            Assert.AreEqual("version=\"1.0\" encoding=\"utf-8\" standalone=\"no\"", sw.ToString().Trim(), "#WriteAttributes.XmlDecl.1");

            sb.Remove(0, sb.Length);    // init
            ctx = new XmlParserContext(doc.NameTable, new XmlNamespaceManager(doc.NameTable), "", XmlSpace.Default);
            xtr = new XmlTextReader("<?xml version='1.0'		 standalone='no'?><root a1='A' b2='B' c3='C'><foo><bar /></foo></root>", XmlNodeType.Document, ctx);
            xtr.Read(); // read XMLDecl
            Assert.AreEqual(XmlNodeType.XmlDeclaration, xtr.NodeType);
            sw = new StringWriter();
            wr = new XmlTextWriter(sw);

            // This block raises an error on MS.NET 1.0.
            wr.WriteAttributes(xtr, false);
            // This method don't always have to take this double-quoted style...
            Assert.AreEqual("version=\"1.0\" standalone=\"no\"", sw.ToString().Trim(), "#WriteAttributes.XmlDecl.2");

            sw = new StringWriter();
            wr = new XmlTextWriter(sw);
            sb.Remove(0, sb.Length); // init

            xtr.Read();              // read root
            Assert.AreEqual(XmlNodeType.Element, xtr.NodeType);
            wr.WriteStartElement(xtr.LocalName, xtr.NamespaceURI);
            wr.WriteAttributes(xtr, false);
            wr.WriteEndElement();
            wr.Close();
            // This method don't always have to take this double-quoted style...
            Assert.AreEqual("<root a1=\"A\" b2=\"B\" c3=\"C\" />", sw.ToString().Trim(), "#WriteAttributes.Element");
            xtr.Close();
        }
Exemplo n.º 9
0
        private void RewriteFullElements(ref XmlTextWriter wrt, string aDOXmlString)
        {
            XmlTextReader rdr = new XmlTextReader(aDOXmlString, XmlNodeType.Document, null);

            rdr.MoveToContent();

            while (rdr.ReadState != ReadState.EndOfFile)
            {
                if (rdr.Name == "s:Schema")
                {
                    wrt.WriteNode(rdr, false);
                    wrt.Flush();
                }
                else if (rdr.Name == "z:row" && rdr.NodeType == XmlNodeType.Element)
                {
                    wrt.WriteStartElement("z", "row", "#RowsetSchema");
                    rdr.MoveToFirstAttribute();
                    wrt.WriteAttributes(rdr, true);
                    wrt.Flush();
                }
                else if (rdr.Name == "z:row" && rdr.NodeType == XmlNodeType.EndElement)
                {
                    wrt.WriteEndElement();
                    wrt.Flush();
                }
                else if (rdr.Name == "rs:data" && rdr.NodeType == XmlNodeType.Element)
                {
                    wrt.WriteStartElement("rs", "data", "urn:schemas-microsoft-com:rowset");
                }
                else if (rdr.Name == "rs:data" && rdr.NodeType == XmlNodeType.EndElement)
                {
                    wrt.WriteEndElement();
                    wrt.Flush();
                }

                rdr.Read();
            }
            wrt.WriteEndElement();
            wrt.Flush();
        }
Exemplo n.º 10
0
        private XmlDocument XmlFromSgml(TextReader textReader)
        {
            Stack <string> stack     = new Stack <string>();
            TextWriter     logWriter = new StringWriter();

            try
            {
                Sgml.SgmlReader reader = new Sgml.SgmlReader();
                reader.DocType            = "HTML";
                reader.WhitespaceHandling = WhitespaceHandling.All;
                reader.CaseFolding        = Sgml.CaseFolding.ToLower;
                reader.InputStream        = textReader;
                reader.ErrorLog           = logWriter;

                StringWriter writer    = new StringWriter();
                XmlWriter    xmlWriter = null;

                try
                {
                    xmlWriter = new XmlTextWriter(writer);

                    bool   rootElement     = true;
                    string lastElementName = "";
                    while ((reader.Read()) && !reader.EOF)
                    {
                        switch (reader.NodeType)
                        {
                        case XmlNodeType.Element:
                            try
                            {
                                xmlWriter.WriteStartElement(reader.LocalName);
                                xmlWriter.WriteAttributes(reader, true);
                                if (reader.IsEmptyElement)
                                {
                                    xmlWriter.WriteEndElement();
                                    lastElementName = "";
                                }
                                else
                                {
                                    lastElementName = reader.LocalName;
                                }
                            }
                            catch (Exception exc)
                            {
                                logger.LogError(exc, lastElementName);
                            }


                            break;

                        case XmlNodeType.Text:
                            if (string.IsNullOrEmpty(lastElementName))
                            {
                                string text = reader.Value;
                                xmlWriter.WriteString(text);
                            }
                            else
                            {
                                if (rootElement)
                                {
                                    rootElement = false;
                                    stack.Push(".");
                                }
                                else
                                {
                                    xmlWriter.WriteElementString("value", reader.Value);
                                    xmlWriter.WriteEndElement();
                                    stack.Push(lastElementName);
                                }
                                lastElementName = "";
                            }
                            break;

                        case XmlNodeType.EndElement:
                            if (stack.Peek() == reader.LocalName)
                            {
                                stack.Pop();
                                break;
                            }

                            logger.LogTrace(reader.LocalName);
                            try
                            {
                                xmlWriter.WriteEndElement();
                                lastElementName = "";
                            }
                            catch (Exception exc)
                            {
                                logger.LogError(exc, lastElementName);
                            }
                            break;
                        }
                    }
                }
                finally
                {
                    if (xmlWriter != null)
                    {
                        xmlWriter.Close();
                    }
                }


                string xml = writer.ToString();

                XmlDocument doc = new XmlDocument();

                doc.PreserveWhitespace = true;

                doc.LoadXml(xml);
                return(doc);
            }
            finally
            {
                string str = logWriter.ToString();
                if (string.IsNullOrEmpty(str))
                {
                    logger.LogError(str);
                }
                logWriter.Dispose();
            }
        }
Exemplo n.º 11
0
        /// <summary>
        /// Copies everything from the reader object to the writer instance
        /// </summary>
        /// <param name="writer">The XmlTextWriter to copy to.</param>
        /// <param name="reader">The XmlReader to read from.</param>
        /// <param name="defattr">true to copy the default attributes from the XmlReader; otherwise, false.</param>
        /// <param name="skipHtmlNode">是否跳过html节点</param>
        /// <param name="clearTag">是否清除html tag,只输出纯文本</param>
        /// <param name="maxCount">copy的文本的字符数,如果maxCount&lt;=0,copy全部文本</param>
        /// <param name="endStr">如果只copy了部分文本,部分文本后的附加字符,如...</param>
        public static void WriteXml(XmlTextWriter writer, XmlReader reader, bool defattr, bool skipHtmlNode, bool clearTag, int maxCount, string endStr)
        {
            if (writer == null)
            {
                throw new ArgumentNullException("writer");
            }
            if (reader == null)
            {
                throw new ArgumentNullException("reader");
            }
            int  count    = 0;
            bool finished = false;

            reader.Read();
            while (!finished && !reader.EOF)
            {
                char[] writeNodeBuffer   = null;
                bool   canReadValueChunk = reader.CanReadValueChunk;
                int    num = (reader.NodeType == XmlNodeType.None) ? -1 : reader.Depth;
                do
                {
                    if (clearTag && reader.NodeType != XmlNodeType.Text)
                    {
                        writer.WriteString(" ");
                        continue;
                    }
                    switch (reader.NodeType)
                    {
                    case XmlNodeType.Element:
                        if (skipHtmlNode && reader.Name != null && reader.Name.ToLower() == "html")
                        {
                            break;
                        }
                        writer.WriteStartElement(reader.Prefix, reader.LocalName, reader.NamespaceURI);
                        writer.WriteAttributes(reader, defattr);
                        if (reader.IsEmptyElement)
                        {
                            writer.WriteEndElement();
                        }
                        break;

                    case XmlNodeType.Text:
                        int num2;
                        if (!canReadValueChunk)
                        {
                            if (maxCount > 0)
                            {
                                string value = reader.Value;
                                if ((count + value.Length) >= maxCount)
                                {
                                    value = value.Substring(0, (maxCount - count));
                                    if (!String.IsNullOrEmpty(endStr))
                                    {
                                        value += endStr;
                                    }
                                    finished = true;
                                }
                                writer.WriteString(value);
                                count += value.Length;
                            }
                            else
                            {
                                writer.WriteString(reader.Value);
                            }
                            break;
                        }
                        if (writeNodeBuffer == null)
                        {
                            writeNodeBuffer = new char[0x400];
                        }
                        while ((num2 = reader.ReadValueChunk(writeNodeBuffer, 0, 0x400)) > 0)
                        {
                            if (maxCount > 0)
                            {
                                if ((count + num2) >= maxCount)
                                {
                                    num2 = maxCount - count;
                                    writer.WriteChars(writeNodeBuffer, 0, num2);
                                    if (!String.IsNullOrEmpty(endStr))
                                    {
                                        writer.WriteString(endStr);
                                    }
                                    finished = true;
                                }
                                else
                                {
                                    writer.WriteChars(writeNodeBuffer, 0, num2);
                                }
                                count += num2;
                            }
                            else
                            {
                                writer.WriteChars(writeNodeBuffer, 0, num2);
                            }
                        }
                        break;

                    case XmlNodeType.CDATA:
                        writer.WriteCData(reader.Value);
                        break;

                    case XmlNodeType.EntityReference:
                        writer.WriteEntityRef(reader.Name);
                        break;

                    case XmlNodeType.ProcessingInstruction:
                    case XmlNodeType.XmlDeclaration:
                        writer.WriteProcessingInstruction(reader.Name, reader.Value);
                        break;

                    case XmlNodeType.Comment:
                        writer.WriteComment(reader.Value);
                        break;

                    case XmlNodeType.DocumentType:
                        writer.WriteDocType(reader.Name, reader.GetAttribute("PUBLIC"), reader.GetAttribute("SYSTEM"), reader.Value);
                        break;

                    case XmlNodeType.Whitespace:
                    case XmlNodeType.SignificantWhitespace:
                        writer.WriteWhitespace(reader.Value);
                        break;

                    case XmlNodeType.EndElement:
                        if (skipHtmlNode && reader.Name != null && reader.Name.ToLower() == "html")
                        {
                            break;
                        }
                        writer.WriteFullEndElement();
                        break;
                    }
                }while(!finished && reader.Read() && ((num < reader.Depth) || ((num == reader.Depth) && (reader.NodeType == XmlNodeType.EndElement))));
            }
        }
Exemplo n.º 12
0
        public static string InjectInXml(string XML, int InjectionPosition, string Payload)
        {
            bool IsOldVersion = true;
            //StringBuilder OutXml = new StringBuilder();
            StringReader XMLStringReader = new StringReader(XML.Trim());
            XmlReader    Reader          = XmlReader.Create(XMLStringReader);
            //XmlWriter Writer = XmlWriter.Create(OutXml);
            StringWriter  OutXml = new StringWriter();
            XmlTextWriter Writer = new XmlTextWriter(OutXml);

            Writer.Formatting = Formatting.Indented;
            int  ParameterCount = 0;
            bool Read           = true;
            //bool NextRead = false;
            bool FirstElement = true;

            while (Read)
            {
                //if (!NextRead) Read = Reader.Read();
                //NextRead = false;
                Read = Reader.Read();
                if (!Read)
                {
                    continue;
                }
                //while (Reader.NodeType == XmlNodeType.Whitespace || Reader.NodeType == XmlNodeType.SignificantWhitespace)
                //{
                //    Reader.Read();
                //}
                if (Reader.IsStartElement())
                {
                    Writer.WriteStartElement(Reader.Name);
                    if (Reader.HasAttributes)
                    {
                        Writer.WriteAttributes(Reader, false);
                        if (FirstElement)
                        {
                            string FPV = Reader.GetAttribute("fpv");
                            if (FPV != null)
                            {
                                if (FPV == "4")
                                {
                                    IsOldVersion = false;
                                }
                            }
                        }
                    }
                    FirstElement = false;
                    if (Reader.IsEmptyElement)
                    {
                        if (ParameterCount == InjectionPosition)
                        {
                            if (IsOldVersion)
                            {
                                Writer.WriteString(Tools.XmlSafe(Payload));
                            }
                            else
                            {
                                Writer.WriteString(Tools.Base64Encode(Payload));
                            }
                        }
                        else
                        {
                            Writer.WriteString(Reader.Value);
                        }
                        ParameterCount++;
                        Writer.WriteEndElement();
                    }

                    //Read = Reader.Read();
                    //while (Reader.NodeType == XmlNodeType.Whitespace || Reader.NodeType == XmlNodeType.SignificantWhitespace)
                    //{
                    //    Reader.Read();
                    //}
                    //if (Reader.NodeType == XmlNodeType.Text || Reader.NodeType == XmlNodeType.EndElement)
                    //{
                    //    if (ParameterCount == InjectionPosition)
                    //        Writer.WriteString(Payload);
                    //    else
                    //        Writer.WriteString(Reader.Value);
                    //    ParameterCount++;
                    //}
                    //else
                    //{
                    //    NextRead = true;
                    //}
                    //if (Reader.NodeType == XmlNodeType.EndElement)
                    //{
                    //    //if (ParameterCount == InjectionPosition)
                    //    //    Writer.WriteString(Payload);
                    //    //else
                    //    //    Writer.WriteString("");
                    //    //ParameterCount++;
                    //    Writer.WriteEndElement();
                    //}
                }
                else if (Reader.NodeType == XmlNodeType.Text)
                {
                    if (ParameterCount == InjectionPosition)
                    {
                        if (IsOldVersion)
                        {
                            Writer.WriteString(Tools.XmlSafe(Payload));
                        }
                        else
                        {
                            Writer.WriteString(Tools.Base64Encode(Payload));
                        }
                    }
                    else
                    {
                        Writer.WriteString(Reader.Value);
                    }
                    ParameterCount++;
                }
                else if (Reader.NodeType == XmlNodeType.Whitespace || Reader.NodeType == XmlNodeType.SignificantWhitespace)
                {
                }
                else if (Reader.NodeType == XmlNodeType.EndElement)
                {
                    Writer.WriteEndElement();
                }
                //else
                //{
                //    if (Reader.NodeType == XmlNodeType.EndElement)
                //    {
                //        Writer.WriteEndElement();
                //    }
                //    //else
                //    //{
                //    //    if (ParameterCount == InjectionPosition)
                //    //        Writer.WriteString(Payload);
                //    //    else
                //    //        Writer.WriteString(Reader.Value);
                //    //    ParameterCount++;
                //    //}
                //}
            }
            Reader.Close();
            Writer.Close();
            OutXml.Close();
            //string OutXmlString = OutXml.ToString().Split(new string[] { "?>" }, 2, StringSplitOptions.None)[1];
            return(OutXml.ToString());
        }
Exemplo n.º 13
0
        /// <summary>
        /// Using the dictionary, if transaction id is in the dictionary, rewrite the host and path
        /// </summary>
        /// <param name="dictionary"></param>
        /// <returns></returns>
        internal static bool RewriteRootPathAsReferer(Dictionary <string, string> dictionary, int refererCount, int transactionCount)
        {
            bool   matchTransactionAndRefererCount = false;
            string xmlFile           = "identifier.xml";
            int    rCount            = 0;
            int    tCount            = 0;
            string tempId            = "0000";
            string originalHost      = "";
            bool   foundInDictionary = false;

            #region Xml Reader and Writer initialization
            Encoding      utf8withoutbom = new UTF8Encoding(false);
            XmlTextReader reader         = new XmlTextReader(xmlFile);
            reader.WhitespaceHandling = WhitespaceHandling.All;
            XmlValidatingReader vr = new XmlValidatingReader(reader);
            //XmlReaderSettings xmlReaderSettings = new XmlReaderSettings();
            vr.ValidationType = ValidationType.None;
            vr.EntityHandling = EntityHandling.ExpandEntities;
            StreamWriter sw     = new StreamWriter("reformated.xml", false, utf8withoutbom);
            XmlWriter    writer = new XmlTextWriter(sw);
            #endregion

            writer.WriteRaw("<?xml version=\"1.0\" encoding=\"iso-8859-1\"?>");
            reader.MoveToContent();
            do
            {
                #region Encounter start elements
                if (reader.NodeType == XmlNodeType.Element)
                {
                    writer.WriteStartElement(reader.Prefix, reader.LocalName, reader.NamespaceURI);
                    if (reader.Name.Equals("transaction"))
                    {
                        //cycle through all attributes of the transaction
                        tCount++;
                        //method was turned to ID from GenerateTransactionIdentifiers()
                        tempId = reader.GetAttribute("method");
                        for (int i = 0; i < reader.AttributeCount; i++)
                        {
                            //look for the method attribute
                            if (reader.Name.Equals("host"))
                            {
                                //will be used for appending path
                                originalHost = reader.Value;

                                if (dictionary.ContainsKey(tempId))
                                {
                                    //rewrite host into referer
                                    if (reader.GetAttribute("protocol").Equals("https"))
                                    {
                                        writer.WriteAttributeString(reader.Name, "    Referer: " + dictionary[tempId] + " ");
                                    }
                                    else
                                    {
                                        writer.WriteAttributeString(reader.Name, "     Referer: " + dictionary[tempId] + " ");
                                    }
                                    rCount++;
                                }
                                else
                                {
                                    if (reader.GetAttribute("protocol").Equals("https"))
                                    {
                                        writer.WriteAttributeString(reader.Name, "    " + "No Referer ");
                                    }
                                    else
                                    {
                                        writer.WriteAttributeString(reader.Name, "      " + "No Referer ");
                                    }
                                }
                            }
                            else if (reader.Name.Equals("path"))
                            {
                                //rewrite path into originalHost with referer
                                writer.WriteAttributeString(reader.Name, originalHost + reader.GetAttribute(reader.Name));
                            }
                            else if (reader.Name.Equals("transaction"))
                            {
                                //skip
                            }
                            else
                            {
                                //write the rest of the attributes
                                writer.WriteAttributeString(reader.Name, reader.GetAttribute(reader.Name));
                            }
                            reader.MoveToNextAttribute();
                        }
                    }
                    writer.WriteAttributes(reader, true);

                    ////The below ensures that ssl tags have a short end tag
                    //if (reader.Name.Equals("ssl")
                    //    || reader.Name.Equals("alpn"))
                    //{
                    //    writer.WriteEndElement();
                    //}
                    //else if (reader.Name.Equals("first-line"))
                    //{
                    //    //if the first-line has a short end tag, maintain it as a short end tag
                    //    if (reader.IsEmptyElement)
                    //    {
                    //        writer.WriteEndElement();
                    //    }
                    //}
                    if (reader.IsEmptyElement)
                    {
                        writer.WriteEndElement();
                    }
                }
                #endregion
                #region Encounter end elements
                //else if ((reader.NodeType == XmlNodeType.EndElement) || reader.IsEmptyElement)
                else if (reader.NodeType == XmlNodeType.EndElement)
                {
                    //Console.Write("\n3");
                    writer.WriteEndElement();
                    //WriteAttributes(reader, writer);//is this line neccessary? No it isn't.
                }
                #endregion
                #region Encounter attributes outside of elements
                //takes care of all other elements' attributes, but this shouldn't be reached.
                else if (reader.NodeType == XmlNodeType.Attribute)
                {
                    Console.WriteLine("Attribute: " + reader.Name.ToString() + " found outside of element.");
                    writer.WriteAttributes(reader, true);
                }
                #endregion
                #region Encounter inner text
                else if (reader.NodeType == XmlNodeType.Text)
                {
                    //Console.Write("2");
                    writer.WriteString(reader.Value);
                }
                #endregion
                #region Encounter CDATA
                else if (reader.NodeType.Equals(XmlNodeType.CDATA))
                {
                    writer.WriteRaw("<![CDATA[" + reader.Value + "]]>");
                }
                #endregion
            } while (reader.Read());

            writer.Close();
            reader.Close();

            if (rCount == refererCount)
            {
                if (tCount == transactionCount)
                {
                    matchTransactionAndRefererCount = true;
                }
            }

            return(matchTransactionAndRefererCount);
        }
Exemplo n.º 14
0
        /// <summary>
        /// Converts the specified html into XHTML compliant text.
        /// </summary>
        /// <param name="html">html to convert.</param>
        /// <param name="converter">The converter.</param>
        /// <returns></returns>
        private string ConvertHtmlToXHtml(string html, Converter <string, string> converter)
        {
            _reader.DocType            = "html";
            _reader.WhitespaceHandling = WhitespaceHandling.All;
            // Hack to fix SF bug #1678030
            html = RemoveNewLineBeforeCdata(html);
            _reader.InputStream = new StringReader(string.Format("<html>{0}</html>", html));
            _reader.CaseFolding = CaseFolding.ToLower;
            var       writer    = new StringWriter();
            XmlWriter xmlWriter = null;

            try
            {
                xmlWriter = new XmlTextWriter(writer);

                bool insideAnchor = false;
                bool skipRead     = false;
                while ((skipRead || _reader.Read()) && !_reader.EOF)
                {
                    skipRead = false;
                    switch (_reader.NodeType)
                    {
                    case XmlNodeType.Element:
                        //Special case for anchor tags for the time being.
                        //We need some way to communicate which elements the current node is nested within
                        if (_reader.IsEmptyElement)
                        {
                            xmlWriter.WriteStartElement(_reader.LocalName);
                            xmlWriter.WriteAttributes(_reader, true);
                            if (_reader.LocalName == "a" || _reader.LocalName == "script" ||
                                _reader.LocalName == "iframe" || _reader.LocalName == "object")
                            {
                                xmlWriter.WriteFullEndElement();
                            }
                            else
                            {
                                xmlWriter.WriteEndElement();
                            }
                        }
                        else
                        {
                            if (_reader.LocalName == "a")
                            {
                                insideAnchor = true;
                            }
                            xmlWriter.WriteStartElement(_reader.LocalName);
                            xmlWriter.WriteAttributes(_reader, true);
                        }
                        break;

                    case XmlNodeType.Text:
                        string text = _reader.Value;

                        if (converter != null && !insideAnchor)
                        {
                            xmlWriter.WriteRaw(converter(HttpUtility.HtmlEncode(text)));
                        }
                        else
                        {
                            xmlWriter.WriteString(text);
                        }
                        break;

                    case XmlNodeType.EndElement:
                        if (_reader.LocalName == "a")
                        {
                            insideAnchor = false;
                        }

                        if (_reader.LocalName == "a" ||
                            _reader.LocalName == "script" ||
                            _reader.LocalName == "iframe" ||
                            _reader.LocalName == "object")
                        {
                            xmlWriter.WriteFullEndElement();
                        }
                        else
                        {
                            xmlWriter.WriteEndElement();
                        }
                        break;

                    default:
                        xmlWriter.WriteNode(_reader, true);
                        skipRead = true;
                        break;
                    }
                }
            }
            finally
            {
                if (xmlWriter != null)
                {
                    xmlWriter.Close();
                }
            }

            string xml = writer.ToString();

            return(xml.Substring("<html>".Length, xml.Length - "<html></html>".Length));
        }
Exemplo n.º 15
0
        /// <summary>
        /// Goes through a charlesLog.xml file and changes the Method attribute to IDs
        /// <param name="xmlFile">Charles Log XML file name</param>
        /// </summary>
        /// <returns>Count of Transactions</returns>
        internal static int GenerateTransactionIdentifiers(string xmlFile)
        {
            int transactionCount = 0;

            #region Xml Reader and Writer initialization
            XmlTextReader reader         = new XmlTextReader(xmlFile);
            Encoding      utf8withoutbom = new UTF8Encoding(false);
            reader.WhitespaceHandling = WhitespaceHandling.All;
            XmlValidatingReader vr = new XmlValidatingReader(reader);
            //XmlReaderSettings xmlReaderSettings = new XmlReaderSettings();
            vr.ValidationType = ValidationType.None;
            vr.EntityHandling = EntityHandling.ExpandEntities;
            StreamWriter sw     = new StreamWriter("identifier.xml", false, utf8withoutbom);
            XmlWriter    writer = new XmlTextWriter(sw);

            #endregion
            #region Read log step by step and write to identifiers.xml
            writer.WriteRaw("<?xml version=\"1.0\" encoding=\"iso-8859-1\"?>");
            reader.MoveToContent();
            do
            {
                #region Encounter start elements
                if (reader.NodeType == XmlNodeType.Element)
                {
                    writer.WriteStartElement(reader.Prefix, reader.LocalName, reader.NamespaceURI);
                    if (reader.Name.Equals("transaction"))
                    {
                        //cycle through all attributes of the transaction
                        for (int i = 0; i < reader.AttributeCount; i++)
                        {
                            //look for the method attribute
                            if (reader.Name.Equals("method"))
                            {
                                //change it to transaction Count
                                writer.WriteAttributeString(reader.Name, transactionCount.ToString("00000"));
                                transactionCount++;
                            }
                            else if (reader.Name.Equals("transaction"))
                            {
                                //skip
                            }
                            else
                            {
                                //write the rest of the attributes
                                writer.WriteAttributeString(reader.Name, reader.GetAttribute(reader.Name));
                            }
                            reader.MoveToNextAttribute();
                        }
                    }
                    writer.WriteAttributes(reader, true);
                    if (reader.IsEmptyElement)
                    {
                        writer.WriteEndElement();
                    }
                    ////The below checks short end tags
                    //if (reader.Name.Equals("ssl")
                    //    || reader.Name.Equals("alpn"))
                    //{
                    //    writer.WriteEndElement();
                    //}
                    //else if (reader.Name.Equals("first-line"))
                    //{
                    //    //if the first-line has a short end tag, maintain it as a short end tag
                    //    if (reader.IsEmptyElement)
                    //    {
                    //        writer.WriteEndElement();
                    //    }
                    //}
                }
                #endregion
                #region Encounter end elements
                else if (reader.NodeType == XmlNodeType.EndElement)
                {
                    //Console.Write("\n3");
                    writer.WriteEndElement();
                    //WriteAttributes(reader, writer);//is this line neccessary? No it isn't.
                }
                //else if (reader.IsEmptyElement) {
                //    writer.WriteEndElement();
                //}
                #endregion
                #region Encounter attributes outside of elements
                //takes care of all other elements' attributes, but this shouldn't be reached.
                else if (reader.NodeType == XmlNodeType.Attribute)
                {
                    Console.WriteLine("Attribute: " + reader.Name.ToString() + " found outside of element.");
                    writer.WriteAttributes(reader, true);
                }
                #endregion
                #region Encounter inner text
                else if (reader.NodeType == XmlNodeType.Text)
                {
                    //Console.Write("2");
                    writer.WriteString(reader.Value);
                }
                #endregion
                #region Encounter CDATA
                else if (reader.NodeType.Equals(XmlNodeType.CDATA))
                {
                    writer.WriteRaw("<![CDATA[" + reader.Value + "]]>");
                }
                #endregion
            } while (reader.Read());
            #endregion

            writer.Close();
            reader.Close();

            return(transactionCount);
        }
Exemplo n.º 16
0
        // duplicate all writes to the log writer

        public override void WriteAttributes(XmlReader reader, Boolean defattr)
        {
            base.WriteAttributes(reader, defattr);
            _logWriter.WriteAttributes(reader, defattr);
        }
Exemplo n.º 17
0
        public TableXml(TableXsd tableXsd, FileInfo path, FileIndex fileIndex, int tableNo)
            : base(path, fileIndex, tableXsd.Schema, TableNamespace(tableXsd), TableNamespaceLocation(TableNamespace(tableXsd), tableNo))
        {
            path.Refresh();
            if (path.Exists == false)
            {
                // We will now use Document from the base class.
                return;
            }

            // We will now void to load large XML documents (> 32MB) into
            // the memory because this can make an OutOfMemoryException
            // Therefore we will set the Document to NULL and use
            // a XmlTextWriter instead.
            long maxSizeForUsingXmlDocument = 1024 * 1024 * 32;

            if (path.Length < maxSizeForUsingXmlDocument)
            {
                try
                {
                    using (var fileStream = new FileStream(path.FullName, FileMode.Open, FileAccess.ReadWrite, FileShare.Read))
                    {
                        using (var xmlReader = XmlReader.Create(fileStream, CreateXmlReaderSettings(base.Schema, ValidationType.None)))
                        {
                            Document.Load(xmlReader);
                            xmlReader.Close();
                        }
                    }
                    return;
                }
                catch (OutOfMemoryException)
                {
                    Document = null;
                    GC.Collect();
                    GC.WaitForPendingFinalizers();
                }
            }

            Document = null;

            _shadowFile = new FileInfo($"{path.FullName}.shadow");
            try
            {
                DeleteFile(_shadowFile);

                _shadowFileStream = new FileStream(_shadowFile.FullName, FileMode.CreateNew, FileAccess.ReadWrite, FileShare.Read);
                _xmlTextWriter    = new XmlTextWriter(_shadowFileStream, Encoding.UTF8)
                {
                    Formatting = Formatting.Indented
                };

                using (var sourceFileStream = new FileStream(path.FullName, FileMode.Open, FileAccess.Read, FileShare.Read))
                {
                    using (var xmlReader = XmlReader.Create(sourceFileStream, CreateXmlReaderSettings(base.Schema, ValidationType.None)))
                    {
                        while (xmlReader.Read())
                        {
                            switch (xmlReader.NodeType)
                            {
                            case XmlNodeType.Element:
                                _xmlTextWriter.WriteStartElement(xmlReader.Prefix, xmlReader.LocalName, xmlReader.NamespaceURI);
                                _xmlTextWriter.WriteAttributes(xmlReader, true);
                                if (xmlReader.IsEmptyElement)
                                {
                                    _xmlTextWriter.WriteEndElement();
                                }
                                break;

                            case XmlNodeType.Text:
                                _xmlTextWriter.WriteString(xmlReader.Value);
                                break;

                            case XmlNodeType.Whitespace:
                            case XmlNodeType.SignificantWhitespace:
                                _xmlTextWriter.WriteWhitespace(xmlReader.Value);
                                break;

                            case XmlNodeType.CDATA:
                                _xmlTextWriter.WriteCData(xmlReader.Value);
                                break;

                            case XmlNodeType.EntityReference:
                                _xmlTextWriter.WriteEntityRef(xmlReader.Name);
                                break;

                            case XmlNodeType.XmlDeclaration:
                            case XmlNodeType.ProcessingInstruction:
                                _xmlTextWriter.WriteProcessingInstruction(xmlReader.Name, xmlReader.Value);
                                break;

                            case XmlNodeType.DocumentType:
                                _xmlTextWriter.WriteDocType(xmlReader.Name, xmlReader.GetAttribute("PUBLIC"), xmlReader.GetAttribute("SYSTEM"), xmlReader.Value);
                                break;

                            case XmlNodeType.Comment:
                                _xmlTextWriter.WriteComment(xmlReader.Value);
                                break;

                            case XmlNodeType.EndElement:
                                if (string.Compare(xmlReader.LocalName, "table", StringComparison.Ordinal) == 0)
                                {
                                    break;
                                }
                                _xmlTextWriter.WriteFullEndElement();
                                break;
                            }
                        }
                    }
                }
            }
            catch
            {
                _xmlTextWriter?.Close();
                _shadowFileStream?.Close();
                _shadowFileStream?.Dispose();

                DeleteFile(_shadowFile);

                throw;
            }
        }
Exemplo n.º 18
0
        internal bool ParseReaderNode()
        {
            if (reader.Depth > markupDepth)
            {
                if (writer != null)   // ProcessMarkup
                {
                    switch (reader.NodeType)
                    {
                    case XmlNodeType.Element:
                        writer.WriteStartElement(reader.Prefix, reader.LocalName, reader.NamespaceURI);
                        writer.WriteAttributes(reader, false);
                        if (reader.IsEmptyElement)
                        {
                            writer.WriteEndElement();
                        }
                        break;

                    case XmlNodeType.Text:
                        writer.WriteString(reader.Value);
                        break;

                    case XmlNodeType.SignificantWhitespace:
                        writer.WriteWhitespace(reader.Value);
                        break;

                    case XmlNodeType.CDATA:
                        writer.WriteCData(reader.Value);
                        break;

                    case XmlNodeType.EntityReference:
                        writer.WriteEntityRef(reader.Name);
                        break;

                    case XmlNodeType.Comment:
                        writer.WriteComment(reader.Value);
                        break;

                    case XmlNodeType.EndElement:
                        writer.WriteFullEndElement();
                        break;
                    }
                }
                return(true);
            }
            if (reader.NodeType == XmlNodeType.Element)
            {
                if (builder.ProcessElement(reader.Prefix, reader.LocalName, reader.NamespaceURI))
                {
                    namespaceManager.PushScope();
                    if (reader.MoveToFirstAttribute())
                    {
                        do
                        {
                            builder.ProcessAttribute(reader.Prefix, reader.LocalName, reader.NamespaceURI, reader.Value);
                            if (Ref.Equal(reader.NamespaceURI, schemaNames.NsXmlNs) && isProcessNamespaces)
                            {
                                namespaceManager.AddNamespace(reader.Prefix == string.Empty ? string.Empty : reader.LocalName, reader.Value);
                            }
                        }while (reader.MoveToNextAttribute());
                        reader.MoveToElement(); // get back to the element
                    }
                    builder.StartChildren();
                    if (reader.IsEmptyElement)
                    {
                        namespaceManager.PopScope();
                        builder.EndChildren();
                    }
                    else if (!builder.IsContentParsed())
                    {
                        markupDepth  = reader.Depth;
                        stringWriter = new StringWriter();
                        writer       = new XmlTextWriter(stringWriter);
                        writer.WriteStartElement(reader.LocalName);
                    }
                }
                else if (!reader.IsEmptyElement)
                {
                    markupDepth = reader.Depth;
                    writer      = null;
                }
            }
            else if (reader.NodeType == XmlNodeType.Text ||
                     reader.NodeType == XmlNodeType.EntityReference ||
                     reader.NodeType == XmlNodeType.SignificantWhitespace ||
                     reader.NodeType == XmlNodeType.CDATA)
            {
                builder.ProcessCData(reader.Value);
            }
            else if (reader.NodeType == XmlNodeType.EndElement)
            {
                if (reader.Depth == markupDepth)
                {
                    if (writer != null)   // processUnparsedContent
                    {
                        writer.WriteEndElement();
                        writer.Close();
                        writer = null;
                        XmlDocument doc = new XmlDocument();
                        doc.Load(new XmlTextReader(new StringReader(stringWriter.ToString())));
                        XmlNodeList list   = doc.DocumentElement.ChildNodes;
                        XmlNode[]   markup = new XmlNode[list.Count];
                        for (int i = 0; i < list.Count; i++)
                        {
                            markup[i] = list[i];
                        }
                        builder.ProcessMarkup(markup);
                        namespaceManager.PopScope();
                        builder.EndChildren();
                    }
                    markupDepth = int.MaxValue;
                }
                else
                {
                    namespaceManager.PopScope();
                    builder.EndChildren();
                }
                if (reader.Depth == schemaXmlDepth)
                {
                    return(false); // done
                }
            }
            return(true);
        }
Exemplo n.º 19
0
        public static string InjectInXml(string XML, int InjectionPosition, string Payload)
        {
            //StringBuilder OutXml = new StringBuilder();
            StringReader XMLStringReader = new StringReader(XML.Trim());
            XmlReader    Reader          = XmlReader.Create(XMLStringReader);
            //XmlWriter Writer = XmlWriter.Create(OutXml);
            StringWriter  OutXml         = new StringWriter();
            XmlTextWriter Writer         = new XmlTextWriter(OutXml);
            int           ParameterCount = 0;
            bool          Read           = true;
            bool          NextRead       = false;

            while (Read)
            {
                if (!NextRead)
                {
                    Read = Reader.Read();
                }
                NextRead = false;
                if (!Read)
                {
                    continue;
                }
                if (Reader.IsStartElement())
                {
                    Writer.WriteStartElement(Reader.Name);
                    if (Reader.HasAttributes)
                    {
                        Writer.WriteAttributes(Reader, false);
                    }
                    Read = Reader.Read();
                    if (Reader.NodeType == XmlNodeType.EndElement)
                    {
                        if (ParameterCount == InjectionPosition)
                        {
                            Writer.WriteString(Payload);
                        }
                        else
                        {
                            Writer.WriteString("");
                        }
                        ParameterCount++;
                        Writer.WriteEndElement();
                    }
                    else
                    {
                        NextRead = true;
                    }
                }
                else
                {
                    if (Reader.NodeType == XmlNodeType.EndElement)
                    {
                        Writer.WriteEndElement();
                    }
                    else
                    {
                        if (ParameterCount == InjectionPosition)
                        {
                            Writer.WriteString(Payload);
                        }
                        else
                        {
                            Writer.WriteString(Reader.Value);
                        }
                        ParameterCount++;
                    }
                }
            }
            Reader.Close();
            Writer.Close();
            OutXml.Close();
            //string OutXmlString = OutXml.ToString().Split(new string[] { "?>" }, 2, StringSplitOptions.None)[1];
            return(OutXml.ToString());
        }
Exemplo n.º 20
0
        private XmlTextReader ProcessPublishedContext(XmlTextReader xReader, PipelineContext context)
        {
            TextWriter    sWriter = new StringWriter();
            XmlTextWriter xWriter = new XmlTextWriter(sWriter);

            xReader.MoveToContent();

            while (!xReader.EOF)
            {
                switch (xReader.NodeType)
                {
                case XmlNodeType.Element:
                    xWriter.WriteStartElement(xReader.Prefix, xReader.LocalName, xReader.NamespaceURI);
                    xWriter.WriteAttributes(xReader, false);
                    try
                    {
                        if (IsValidItem(xReader))
                        {
                            using (var client = new CoreServiceUtility())
                            {
                                string id     = xReader.GetAttribute("ID"); // Get the id of item from List
                                string catman = "catman-";
                                string bptman = "bptman-";
                                if (id.StartsWith(catman))
                                {
                                    id = id.ToString().Replace(catman, string.Empty);
                                }
                                else if (id.StartsWith(bptman))
                                {
                                    id = id.ToString().Replace(bptman, string.Empty);
                                }
                                TcmUri uri = new TcmUri(id);
                                // Validate the the types of items
                                if (uri.ItemType == ItemType.Component || uri.ItemType == ItemType.Page || uri.ItemType == ItemType.StructureGroup || uri.ItemType == ItemType.Category)
                                {
                                    string        publishedCotexts     = null;
                                    List <string> publishedPurposeList = new List <string>();
                                    try
                                    {
                                        var publishInfo = client.GetListPublishInfo(id);
                                        //Validate item is published
                                        if (publishInfo.Count() > 0)
                                        {
                                            foreach (var info in publishInfo)
                                            {
                                                if (!String.IsNullOrEmpty(info.TargetPurpose))
                                                {
                                                    //Validate item is published from current publication
                                                    if (client.IsPublished(id, info.TargetPurpose))
                                                    {
                                                        publishedPurposeList.Add(info.TargetPurpose);
                                                    }
                                                }
                                                else
                                                {
                                                    Trace.TraceError($"TargetInfo is NUll");
                                                }
                                            }

                                            if (publishedPurposeList.Count > 0)
                                            {
                                                publishedCotexts = String.Join(",", publishedPurposeList.Distinct());
                                                xWriter.WriteAttributeString("PublishedTo", publishedCotexts);     // Add the data into the list
                                            }
                                            else
                                            {
                                                xWriter.WriteAttributeString("PublishedTo", "-");
                                            }
                                        }
                                        else
                                        {
                                            xWriter.WriteAttributeString("PublishedTo", "-");
                                        }
                                    }
                                    catch (Exception ex)
                                    {
                                        Trace.TraceError("Exception :" + ex.Message + "Stack Trace :" + ex.StackTrace);
                                    }
                                }
                                else
                                {
                                    xWriter.WriteAttributeString("PublishedTo", "N/A");
                                    xReader.MoveToElement();
                                }
                            }
                        }
                    }
                    catch (Exception ex)
                    {
                        Trace.TraceError("Exception: " + ex.Message + "Stack Trace :" + ex.StackTrace);
                    }
                    if (xReader.IsEmptyElement)
                    {
                        xWriter.WriteEndElement();
                    }
                    break;

                case XmlNodeType.EndElement:
                    xWriter.WriteEndElement();
                    break;

                case XmlNodeType.CDATA:
                    xWriter.WriteCData(xReader.Value);
                    break;

                case XmlNodeType.Comment:
                    xWriter.WriteComment(xReader.Value);
                    break;

                case XmlNodeType.DocumentType:
                    xWriter.WriteDocType(xReader.Name, null, null, null);
                    break;

                case XmlNodeType.EntityReference:
                    xWriter.WriteEntityRef(xReader.Name);
                    break;

                case XmlNodeType.ProcessingInstruction:
                    xWriter.WriteProcessingInstruction(xReader.Name, xReader.Value);
                    break;

                case XmlNodeType.SignificantWhitespace:
                    xWriter.WriteWhitespace(xReader.Value);
                    break;

                case XmlNodeType.Text:
                    xWriter.WriteString(xReader.Value);
                    break;

                case XmlNodeType.Whitespace:
                    xWriter.WriteWhitespace(xReader.Value);
                    break;
                }
                xReader.Read();
            }
            ;
            xWriter.Flush();
            xReader = new XmlTextReader(new StringReader(sWriter.ToString()));
            xReader.MoveToContent();
            return(xReader);
        }
Exemplo n.º 21
0
        public void Split(ESplitType splitType, int splitSize, string fileSuffixXpath)
        {
            _data.Read();

            //Capture all of the items before the first element
            while (_data.NodeType != XmlNodeType.Element)
            {
                _output.WriteNode(_data, true);
            }

            //Prepare the document header and footer sections for use later...
            _output.WriteStartElement(_data.Name);
            _output.WriteAttributes(_data, true);
            var header = _outputBuilder.ToString() + ">";
            var footer = "</" + _data.Name + ">";

            //skip past the first node
            _data.Read();

            int elementCounter = 0;
            int splitCount     = 0;

            bool emptyDocument = false;

            FileInfo dataFI         = new FileInfo(_dataPath);
            string   outputFileName = dataFI.Name.Substring(0, dataFI.Name.LastIndexOf("."));

            StreamWriter writer = null;

            while (!_data.EOF)
            {
                //Only count the nodes that interest us...
                if (!IgnorableNodeType(_data.NodeType))
                {
                    elementCounter++;
                }
                else
                {
                    emptyDocument = false;
                }

                //copy everything from the reader
                _output.WriteNode(_data, true);

                if ((splitType == ESplitType.ElementCount && elementCounter >= splitSize) || (splitType == ESplitType.Filesize && (_outputBuilder.Length - header.Length) >= splitSize * 1000))
                {
                    ////construct the final XML string
                    ExportXmlFile(footer, writer, outputFileName, splitCount);

                    //reset counters
                    splitCount++;
                    elementCounter = 0;
                    //reset string builder
                    _outputBuilder.Length = 0;
                    _outputBuilder.Append(header);
                    emptyDocument = true;
                }
            }

            //If there is anything left, export it - no footer required!
            if (_outputBuilder.Length > 0)
            {
                ExportXmlFile("", writer, outputFileName, splitCount);
            }

            SplitTotal = splitCount;
        }