/// <summary>
 /// Read SOAP header and extract server version
 /// </summary>
 /// <param name="jsonHeader">The json header.</param>
 private void ReadSoapHeader(JsonObject jsonHeader)
 {
     if (jsonHeader.ContainsKey(XmlElementNames.ServerVersionInfo))
     {
         this.Service.ServerInfo = ExchangeServerInfo.Parse(jsonHeader.ReadAsJsonObject(XmlElementNames.ServerVersionInfo));
     }
 }
        /// <summary>
        /// Parses the specified json object.
        /// </summary>
        /// <param name="jsonObject">The json object.</param>
        /// <returns></returns>
        internal static ExchangeServerInfo Parse(JsonObject jsonObject)
        {
            ExchangeServerInfo info = new ExchangeServerInfo();

            info.MajorVersion     = jsonObject.ReadAsInt("MajorVersion");
            info.MinorVersion     = jsonObject.ReadAsInt("MinorVersion");
            info.MajorBuildNumber = jsonObject.ReadAsInt("MajorBuildNumber");
            info.MinorBuildNumber = jsonObject.ReadAsInt("MinorBuildNumber");
            info.VersionString    = jsonObject.ReadAsString("Version");
            return(info);
        }
        /// <summary>
        /// Parse current element to extract server information
        /// </summary>
        /// <param name="reader">EwsServiceXmlReader</param>
        /// <returns>ExchangeServerInfo</returns>
        internal static ExchangeServerInfo Parse(EwsServiceXmlReader reader)
        {
            EwsUtilities.Assert(
                                reader.HasAttributes, 
                                "ExchangeServerVersion.Parse",
                                "Current element doesn't have attributes");

            ExchangeServerInfo info = new ExchangeServerInfo();
            info.MajorVersion = reader.ReadAttributeValue<int>("MajorVersion");
            info.MinorVersion = reader.ReadAttributeValue<int>("MinorVersion");
            info.MajorBuildNumber = reader.ReadAttributeValue<int>("MajorBuildNumber");
            info.MinorBuildNumber = reader.ReadAttributeValue<int>("MinorBuildNumber");
            info.VersionString = reader.ReadAttributeValue("Version");
            return info;
        }
Exemple #4
0
        /// <summary>
        /// Read SOAP header and extract server version
        /// </summary>
        /// <param name="reader">EwsServiceXmlReader</param>
        private void ReadSoapHeader(EwsServiceXmlReader reader)
        {
            reader.ReadStartElement(XmlNamespace.Soap, XmlElementNames.SOAPHeaderElementName);
            do
            {
                reader.Read();

                // Is this the ServerVersionInfo?
                if (reader.IsStartElement(XmlNamespace.Types, XmlElementNames.ServerVersionInfo))
                {
                    this.Service.ServerInfo = ExchangeServerInfo.Parse(reader);
                }

                // Ignore anything else inside the SOAP header
            }while (!reader.IsEndElement(XmlNamespace.Soap, XmlElementNames.SOAPHeaderElementName));
        }
        /// <summary>
        /// Parse current element to extract server information
        /// </summary>
        /// <param name="reader">EwsServiceXmlReader</param>
        /// <returns>ExchangeServerInfo</returns>
        internal static ExchangeServerInfo Parse(EwsServiceXmlReader reader)
        {
            EwsUtilities.Assert(
                reader.HasAttributes,
                "ExchangeServerVersion.Parse",
                "Current element doesn't have attributes");

            ExchangeServerInfo info = new ExchangeServerInfo();

            info.MajorVersion     = reader.ReadAttributeValue <int>("MajorVersion");
            info.MinorVersion     = reader.ReadAttributeValue <int>("MinorVersion");
            info.MajorBuildNumber = reader.ReadAttributeValue <int>("MajorBuildNumber");
            info.MinorBuildNumber = reader.ReadAttributeValue <int>("MinorBuildNumber");
            info.VersionString    = reader.ReadAttributeValue("Version");
            return(info);
        }
        /// <summary>
        /// Read SOAP header and extract server version
        /// </summary>
        /// <param name="reader">EwsServiceXmlReader</param>
        private async System.Threading.Tasks.Task ReadSoapHeaderAsync(EwsServiceXmlReader reader, CancellationToken token)
        {
            await reader.ReadStartElementAsync(XmlNamespace.Soap, XmlElementNames.SOAPHeaderElementName, token);

            do
            {
                await reader.ReadAsync(token);

                // Is this the ServerVersionInfo?
                if (reader.IsStartElement(XmlNamespace.Types, XmlElementNames.ServerVersionInfo))
                {
                    this.Service.ServerInfo = ExchangeServerInfo.Parse(reader);
                }

                // Ignore anything else inside the SOAP header
            }while (!reader.IsEndElement(XmlNamespace.Soap, XmlElementNames.SOAPHeaderElementName));
        }
Exemple #7
0
        /// <summary>
        /// Reads the SOAP fault.
        /// </summary>
        /// <param name="reader">The reader.</param>
        /// <returns>SOAP fault details.</returns>
        protected SoapFaultDetails ReadSoapFault(EwsServiceXmlReader reader)
        {
            SoapFaultDetails soapFaultDetails = null;

            try
            {
                this.ReadXmlDeclaration(reader);

                reader.Read();
                if (!reader.IsStartElement() || (reader.LocalName != XmlElementNames.SOAPEnvelopeElementName))
                {
                    return(soapFaultDetails);
                }

                // EWS can sometimes return SOAP faults using the SOAP 1.2 namespace. Get the
                // namespace URI from the envelope element and use it for the rest of the parsing.
                // If it's not 1.1 or 1.2, we can't continue.
                XmlNamespace soapNamespace = EwsUtilities.GetNamespaceFromUri(reader.NamespaceUri);
                if (soapNamespace == XmlNamespace.NotSpecified)
                {
                    return(soapFaultDetails);
                }

                reader.Read();

                // EWS doesn't always return a SOAP header. If this response contains a header element,
                // read the server version information contained in the header.
                if (reader.IsStartElement(soapNamespace, XmlElementNames.SOAPHeaderElementName))
                {
                    do
                    {
                        reader.Read();

                        if (reader.IsStartElement(XmlNamespace.Types, XmlElementNames.ServerVersionInfo))
                        {
                            this.Service.ServerInfo = ExchangeServerInfo.Parse(reader);
                        }
                    }while (!reader.IsEndElement(soapNamespace, XmlElementNames.SOAPHeaderElementName));

                    // Queue up the next read
                    reader.Read();
                }

                // Parse the fault element contained within the SOAP body.
                if (reader.IsStartElement(soapNamespace, XmlElementNames.SOAPBodyElementName))
                {
                    do
                    {
                        reader.Read();

                        // Parse Fault element
                        if (reader.IsStartElement(soapNamespace, XmlElementNames.SOAPFaultElementName))
                        {
                            soapFaultDetails = SoapFaultDetails.Parse(reader, soapNamespace);
                        }
                    }while (!reader.IsEndElement(soapNamespace, XmlElementNames.SOAPBodyElementName));
                }

                reader.ReadEndElement(soapNamespace, XmlElementNames.SOAPEnvelopeElementName);
            }
            catch (XmlException)
            {
                // If response doesn't contain a valid SOAP fault, just ignore exception and
                // return null for SOAP fault details.
            }

            return(soapFaultDetails);
        }
        /// <summary>
        /// Read ServerVersionInfo SOAP header.
        /// </summary>
        /// <param name="reader">EwsXmlReader</param>
        private ExchangeServerInfo ReadServerVersionInfo(EwsXmlReader reader)
        {
            ExchangeServerInfo serverInfo = new ExchangeServerInfo();
            do
            {
                reader.Read();

                if (reader.IsStartElement())
                {
                    switch (reader.LocalName)
                    {
                        case XmlElementNames.MajorVersion:
                            serverInfo.MajorVersion = reader.ReadElementValue<int>();
                            break;
                        case XmlElementNames.MinorVersion:
                            serverInfo.MinorVersion = reader.ReadElementValue<int>();
                            break;
                        case XmlElementNames.MajorBuildNumber:
                            serverInfo.MajorBuildNumber = reader.ReadElementValue<int>();
                            break;
                        case XmlElementNames.MinorBuildNumber:
                            serverInfo.MinorBuildNumber = reader.ReadElementValue<int>();
                            break;
                        case XmlElementNames.Version:
                            serverInfo.VersionString = reader.ReadElementValue();
                            break;
                        default:
                            break;
                    }
                }
            }
            while (!reader.IsEndElement(XmlNamespace.Autodiscover, XmlElementNames.ServerVersionInfo));

            return serverInfo;
        }