/// <summary>
/// Reads the response.
/// </summary>
/// <param name="ewsXmlReader">The XML reader.</param>
/// <param name="responseHeaders">HTTP response headers</param>
/// <returns>Service response.</returns>
protected object ReadResponse(EwsServiceXmlReader ewsXmlReader, WebHeaderCollection responseHeaders)
{
object serviceResponse;
this.ReadPreamble(ewsXmlReader);
ewsXmlReader.ReadStartElement(XmlNamespace.Soap, XmlElementNames.SOAPEnvelopeElementName);
this.ReadSoapHeader(ewsXmlReader);
ewsXmlReader.ReadStartElement(XmlNamespace.Soap, XmlElementNames.SOAPBodyElementName);
ewsXmlReader.ReadStartElement(XmlNamespace.Messages, this.GetResponseXmlElementName());
if (responseHeaders != null)
{
serviceResponse = this.ParseResponse(ewsXmlReader, responseHeaders);
}
else
{
serviceResponse = this.ParseResponse(ewsXmlReader);
}
ewsXmlReader.ReadEndElementIfNecessary(XmlNamespace.Messages, this.GetResponseXmlElementName());
ewsXmlReader.ReadEndElement(XmlNamespace.Soap, XmlElementNames.SOAPBodyElementName);
ewsXmlReader.ReadEndElement(XmlNamespace.Soap, XmlElementNames.SOAPEnvelopeElementName);
return(serviceResponse);
}
/// <summary>
/// Loads from XML.
/// </summary>
/// <param name="reader">The reader.</param>
internal void LoadFromXml(EwsServiceXmlReader reader)
{
reader.ReadStartElement(XmlNamespace.Types, XmlElementNames.Resolution);
reader.ReadStartElement(XmlNamespace.Types, XmlElementNames.Mailbox);
this.mailbox.LoadFromXml(reader, XmlElementNames.Mailbox);
reader.Read();
if (reader.IsStartElement(XmlNamespace.Types, XmlElementNames.Contact))
{
this.contact = new Contact(this.owner.Session);
// Contacts returned by ResolveNames should behave like Contact.Load with FirstClassPropertySet specified.
this.contact.LoadFromXml(
reader,
true, /* clearPropertyBag */
PropertySet.FirstClassProperties,
false); /* summaryPropertiesOnly */
reader.ReadEndElement(XmlNamespace.Types, XmlElementNames.Resolution);
}
else
{
reader.EnsureCurrentNodeIsEndElement(XmlNamespace.Types, XmlElementNames.Resolution);
}
}
/// <summary>
/// Loads an entry, consisting of a key value pair, into this dictionary from the specified reader.
/// </summary>
/// <param name="reader">The reader.</param>
private void LoadEntry(EwsServiceXmlReader reader)
{
EwsUtilities.Assert(
reader != null,
"UserConfigurationDictionary.LoadEntry",
"reader is null");
object key;
object value = null;
// Position at DictionaryKey
reader.ReadStartElement(this.Namespace, XmlElementNames.DictionaryKey);
key = this.GetDictionaryObject(reader);
// Position at DictionaryValue
reader.ReadStartElement(this.Namespace, XmlElementNames.DictionaryValue);
string nil = reader.ReadAttributeValue(XmlNamespace.XmlSchemaInstance, XmlAttributeNames.Nil);
bool hasValue = (nil == null) || (!Convert.ToBoolean(nil));
if (hasValue)
{
value = this.GetDictionaryObject(reader);
}
this.dictionary.Add(key, value);
}
/// <summary>
/// Parses the response.
/// </summary>
/// <param name="reader">The reader.</param>
/// <returns>Response object.</returns>
internal override object ParseResponse(EwsServiceXmlReader reader)
{
GetUserAvailabilityResults serviceResponse = new GetUserAvailabilityResults();
if (this.IsFreeBusyViewRequested)
{
serviceResponse.AttendeesAvailability = new ServiceResponseCollection <AttendeeAvailability>();
reader.ReadStartElement(XmlNamespace.Messages, XmlElementNames.FreeBusyResponseArray);
do
{
reader.Read();
if (reader.IsStartElement(XmlNamespace.Messages, XmlElementNames.FreeBusyResponse))
{
AttendeeAvailability freeBusyResponse = new AttendeeAvailability();
freeBusyResponse.LoadFromXml(reader, XmlElementNames.ResponseMessage);
if (freeBusyResponse.ErrorCode == ServiceError.NoError)
{
freeBusyResponse.LoadFreeBusyViewFromXml(reader, this.Options.RequestedFreeBusyView);
}
serviceResponse.AttendeesAvailability.Add(freeBusyResponse);
}
}while (!reader.IsEndElement(XmlNamespace.Messages, XmlElementNames.FreeBusyResponseArray));
}
if (this.IsSuggestionsViewRequested)
{
serviceResponse.SuggestionsResponse = new SuggestionsResponse();
reader.ReadStartElement(XmlNamespace.Messages, XmlElementNames.SuggestionsResponse);
serviceResponse.SuggestionsResponse.LoadFromXml(reader, XmlElementNames.ResponseMessage);
if (serviceResponse.SuggestionsResponse.ErrorCode == ServiceError.NoError)
{
serviceResponse.SuggestionsResponse.LoadSuggestedDaysFromXml(reader);
}
reader.ReadEndElement(XmlNamespace.Messages, XmlElementNames.SuggestionsResponse);
}
return(serviceResponse);
}
/// <summary>
/// Reads response elements from XML.
/// </summary>
/// <param name="reader">The reader.</param>
internal override void ReadElementsFromXml(EwsServiceXmlReader reader)
{
this.ClientExtensions.Clear();
base.ReadElementsFromXml(reader);
reader.ReadStartElement(XmlNamespace.Messages, XmlElementNames.ClientExtensions);
if (!reader.IsEmptyElement)
{
// Because we don't have an element for count of returned object,
// we have to test the element to determine if it is StartElement of return object or EndElement
reader.Read();
while (reader.IsStartElement(XmlNamespace.Types, XmlElementNames.ClientExtension))
{
ClientExtension clientExtension = new ClientExtension();
clientExtension.LoadFromXml(reader, XmlNamespace.Types, XmlElementNames.ClientExtension);
this.ClientExtensions.Add(clientExtension);
reader.EnsureCurrentNodeIsEndElement(XmlNamespace.Types, XmlElementNames.ClientExtension);
reader.Read();
}
reader.EnsureCurrentNodeIsEndElement(XmlNamespace.Messages, XmlElementNames.ClientExtensions);
}
reader.Read();
if (reader.IsStartElement(XmlNamespace.Messages, XmlElementNames.ClientExtensionRawMasterTableXml))
{
this.rawMasterTableXml = reader.ReadElementValue();
}
}
/// <summary>
/// Read Conversations from XML.
/// </summary>
/// <param name="reader">The reader.</param>
internal override void ReadElementsFromXml(EwsServiceXmlReader reader)
{
this.Conversation = new ConversationResponse(this.propertySet);
reader.ReadStartElement(XmlNamespace.Messages, XmlElementNames.Conversation);
this.Conversation.LoadFromXml(reader, XmlNamespace.Messages, XmlElementNames.Conversation);
}
/// <summary>
/// Reads response elements from XML.
/// </summary>
/// <param name="reader">The reader.</param>
internal override void ReadElementsFromXml(EwsServiceXmlReader reader)
{
base.ReadElementsFromXml(reader);
reader.ReadStartElement(XmlNamespace.Messages, XmlElementNames.Attachments);
if (!reader.IsEmptyElement)
{
reader.Read(XmlNodeType.Element);
if (this.attachment == null)
{
if (string.Equals(reader.LocalName, XmlElementNames.FileAttachment, StringComparison.OrdinalIgnoreCase))
{
this.attachment = new FileAttachment(reader.Service);
}
else if (string.Equals(reader.LocalName, XmlElementNames.ItemAttachment, StringComparison.OrdinalIgnoreCase))
{
this.attachment = new ItemAttachment(reader.Service);
}
}
if (this.attachment != null)
{
this.attachment.LoadFromXml(reader, reader.LocalName);
}
reader.ReadEndElement(XmlNamespace.Messages, XmlElementNames.Attachments);
}
}
/// <summary>
/// Reads response elements from XML.
/// </summary>
/// <param name="reader">The reader.</param>
internal override void ReadElementsFromXml(EwsServiceXmlReader reader)
{
this.Rooms.Clear();
base.ReadElementsFromXml(reader);
reader.ReadStartElement(XmlNamespace.Messages, XmlElementNames.Rooms);
if (!reader.IsEmptyElement)
{
// Because we don't have an element for count of returned object,
// we have to test the element to determine if it is StartElement of return object or EndElement
reader.Read();
while (reader.IsStartElement(XmlNamespace.Types, XmlElementNames.Room))
{
reader.Read(); // skip the start <Room>
EmailAddress emailAddress = new EmailAddress();
emailAddress.LoadFromXml(reader, XmlElementNames.RoomId);
this.Rooms.Add(emailAddress);
reader.ReadEndElement(XmlNamespace.Types, XmlElementNames.Room);
reader.Read();
}
reader.EnsureCurrentNodeIsEndElement(XmlNamespace.Messages, XmlElementNames.Rooms);
}
}
/// <summary>
/// Read Photo results from XML.
/// </summary>
/// <param name="reader">The reader.</param>
internal override void ReadElementsFromXml(EwsServiceXmlReader reader)
{
bool hasChanged = reader.ReadElementValue <bool>(XmlNamespace.Messages, XmlElementNames.HasChanged);
reader.ReadStartElement(XmlNamespace.Messages, XmlElementNames.PictureData);
byte[] photoData = reader.ReadBase64ElementValue();
// We only get a content type if we get a photo
if (photoData.Length > 0)
{
this.Results.Photo = photoData;
this.Results.ContentType = reader.ReadElementValue(XmlNamespace.Messages, XmlElementNames.ContentType);
}
if (hasChanged)
{
if (this.Results.Photo.Length == 0)
{
this.Results.Status = GetUserPhotoStatus.PhotoOrUserNotFound;
}
else
{
this.Results.Status = GetUserPhotoStatus.PhotoReturned;
}
}
else
{
this.Results.Status = GetUserPhotoStatus.PhotoUnchanged;
}
}
/// <summary>
/// Reads response elements from XML.
/// </summary>
/// <param name="reader">The reader.</param>
internal override void ReadElementsFromXml(EwsServiceXmlReader reader)
{
this.searchableMailboxes.Clear();
base.ReadElementsFromXml(reader);
reader.ReadStartElement(XmlNamespace.Messages, XmlElementNames.SearchableMailboxes);
if (!reader.IsEmptyElement)
{
do
{
reader.Read();
if (reader.IsStartElement(XmlNamespace.Types, XmlElementNames.SearchableMailbox))
{
this.searchableMailboxes.Add(SearchableMailbox.LoadFromXml(reader));
}
}while (!reader.IsEndElement(XmlNamespace.Messages, XmlElementNames.SearchableMailboxes));
}
reader.Read();
if (reader.IsStartElement(XmlNamespace.Messages, XmlElementNames.FailedMailboxes))
{
this.FailedMailboxes = FailedSearchMailbox.LoadFailedMailboxesXml(XmlNamespace.Messages, reader);
}
}
/// <summary>
/// Loads from XML.
/// </summary>
/// <param name="reader">The reader.</param>
internal void LoadFromXml(EwsServiceXmlReader reader)
{
EwsUtilities.Assert(
reader != null,
"UserConfiguration.LoadFromXml",
"reader is null");
reader.ReadStartElement(XmlNamespace.Messages, XmlElementNames.UserConfiguration);
reader.Read(); // Position at first property element
do
{
if (reader.NodeType == XmlNodeType.Element)
{
switch (reader.LocalName)
{
case XmlElementNames.UserConfigurationName:
string responseName = reader.ReadAttributeValue(XmlAttributeNames.Name);
EwsUtilities.Assert(
string.Compare(this.name, responseName, StringComparison.Ordinal) == 0,
"UserConfiguration.LoadFromXml",
"UserConfigurationName does not match: Expected: " + this.name + " Name in response: " + responseName);
reader.SkipCurrentElement();
break;
case XmlElementNames.ItemId:
this.itemId = new ItemId();
this.itemId.LoadFromXml(reader, XmlElementNames.ItemId);
break;
case XmlElementNames.Dictionary:
this.dictionary.LoadFromXml(reader, XmlElementNames.Dictionary);
break;
case XmlElementNames.XmlData:
this.xmlData = Convert.FromBase64String(reader.ReadElementValue());
break;
case XmlElementNames.BinaryData:
this.binaryData = Convert.FromBase64String(reader.ReadElementValue());
break;
default:
EwsUtilities.Assert(
false,
"UserConfiguration.LoadFromXml",
"Xml element not supported: " + reader.LocalName);
break;
}
}
// If XmlData was loaded, read is skipped because GetXmlData positions the reader at the next property.
reader.Read();
}while (!reader.IsEndElement(XmlNamespace.Messages, XmlElementNames.UserConfiguration));
}
/// <summary>
/// Reads the response.
/// </summary>
/// <param name="ewsXmlReader">The XML reader.</param>
/// <returns>Service response.</returns>
protected object ReadResponse(EwsServiceXmlReader ewsXmlReader)
{
object serviceResponse;
this.ReadPreamble(ewsXmlReader);
ewsXmlReader.ReadStartElement(XmlNamespace.Soap, XmlElementNames.SOAPEnvelopeElementName);
this.ReadSoapHeader(ewsXmlReader);
ewsXmlReader.ReadStartElement(XmlNamespace.Soap, XmlElementNames.SOAPBodyElementName);
ewsXmlReader.ReadStartElement(XmlNamespace.Messages, this.GetResponseXmlElementName());
serviceResponse = this.ParseResponse(ewsXmlReader);
ewsXmlReader.ReadEndElementIfNecessary(XmlNamespace.Messages, this.GetResponseXmlElementName());
ewsXmlReader.ReadEndElement(XmlNamespace.Soap, XmlElementNames.SOAPBodyElementName);
ewsXmlReader.ReadEndElement(XmlNamespace.Soap, XmlElementNames.SOAPEnvelopeElementName);
return(serviceResponse);
}
/// <summary>
/// Read Personas from XML.
/// </summary>
/// <param name="reader">The reader.</param>
internal override void ReadElementsFromXml(EwsServiceXmlReader reader)
{
EwsUtilities.Assert(
this.Results.Personas != null,
"FindPeopleResponse.ReadElementsFromXml",
"Personas is null.");
reader.ReadStartElement(XmlNamespace.Messages, XmlElementNames.People);
if (!reader.IsEmptyElement)
{
do
{
reader.Read();
if (reader.NodeType == XmlNodeType.Element)
{
Persona item = EwsUtilities.CreateEwsObjectFromXmlElementName <Persona>(reader.Service, reader.LocalName);
if (item == null)
{
reader.SkipCurrentElement();
}
else
{
// Don't clear propertyBag because all properties have been initialized in the persona constructor.
item.LoadFromXml(reader, false, null, false);
this.Results.Personas.Add(item);
}
}
}while (!reader.IsEndElement(XmlNamespace.Messages, XmlElementNames.People));
}
reader.Read();
if (reader.IsStartElement(XmlNamespace.Messages, XmlElementNames.TotalNumberOfPeopleInView) && !reader.IsEmptyElement)
{
this.Results.TotalCount = reader.ReadElementValue <int>();
reader.Read();
}
if (reader.IsStartElement(XmlNamespace.Messages, XmlElementNames.FirstMatchingRowIndex) && !reader.IsEmptyElement)
{
this.Results.FirstMatchingRowIndex = reader.ReadElementValue <int>();
reader.Read();
}
if (reader.IsStartElement(XmlNamespace.Messages, XmlElementNames.FirstLoadedRowIndex) && !reader.IsEmptyElement)
{
this.Results.FirstLoadedRowIndex = reader.ReadElementValue <int>();
reader.Read();
}
}
/// <summary>
/// Reads response elements from XML.
/// </summary>
/// <param name="reader">The reader.</param>
internal override void ReadElementsFromXml(EwsServiceXmlReader reader)
{
base.ReadElementsFromXml(reader);
reader.ReadStartElement(XmlNamespace.Messages, XmlElementNames.Attachments);
reader.Read(XmlNodeType.Element);
this.attachment.LoadFromXml(reader, reader.LocalName);
reader.ReadEndElement(XmlNamespace.Messages, XmlElementNames.Attachments);
}
/// <summary>
/// Reads response elements from XML.
/// </summary>
/// <param name="reader">The reader.</param>
internal override void ReadElementsFromXml(EwsServiceXmlReader reader)
{
base.ReadElementsFromXml(reader);
reader.ReadStartElement(XmlNamespace.Messages, XmlElementNames.Token);
this.Id = reader.ReadElementValue(XmlNamespace.Types, XmlElementNames.Id);
this.TokenType = (ClientAccessTokenType)Enum.Parse(typeof(ClientAccessTokenType), reader.ReadElementValue(XmlNamespace.Types, XmlElementNames.TokenType));
this.TokenValue = reader.ReadElementValue(XmlNamespace.Types, XmlElementNames.TokenValue);
this.TTL = int.Parse(reader.ReadElementValue(XmlNamespace.Types, XmlElementNames.TTL));
reader.ReadEndElementIfNecessary(XmlNamespace.Messages, XmlElementNames.Token);
}
/// <summary>
/// Reads response elements from XML.
/// </summary>
/// <param name="reader">The reader.</param>
internal override void ReadElementsFromXml(EwsServiceXmlReader reader)
{
reader.ReadStartElement(XmlNamespace.Messages, XmlElementNames.RootFolder);
this.results.TotalCount = reader.ReadAttributeValue <int>(XmlAttributeNames.TotalItemsInView);
this.results.MoreAvailable = !reader.ReadAttributeValue <bool>(XmlAttributeNames.IncludesLastItemInRange);
// Ignore IndexedPagingOffset attribute if MoreAvailable is false.
this.results.NextPageOffset = results.MoreAvailable ? reader.ReadNullableAttributeValue <int>(XmlAttributeNames.IndexedPagingOffset) : null;
reader.ReadStartElement(XmlNamespace.Types, XmlElementNames.Folders);
if (!reader.IsEmptyElement)
{
do
{
reader.Read();
if (reader.NodeType == XmlNodeType.Element)
{
Folder folder = EwsUtilities.CreateEwsObjectFromXmlElementName <Folder>(reader.Service, reader.LocalName);
if (folder == null)
{
reader.SkipCurrentElement();
}
else
{
folder.LoadFromXml(
reader,
true, /* clearPropertyBag */
this.propertySet,
true /* summaryPropertiesOnly */);
this.results.Folders.Add(folder);
}
}
}while (!reader.IsEndElement(XmlNamespace.Types, XmlElementNames.Folders));
}
reader.ReadEndElement(XmlNamespace.Messages, XmlElementNames.RootFolder);
}
/// <summary>
/// Loads from XML.
/// </summary>
/// <param name="reader">The reader.</param>
internal void LoadFromXml(EwsServiceXmlReader reader)
{
reader.ReadStartElement(XmlNamespace.Messages, XmlElementNames.DLExpansion);
if (!reader.IsEmptyElement)
{
int totalItemsInView = reader.ReadAttributeValue <int>(XmlAttributeNames.TotalItemsInView);
this.includesAllMembers = reader.ReadAttributeValue <bool>(XmlAttributeNames.IncludesLastItemInRange);
for (int i = 0; i < totalItemsInView; i++)
{
EmailAddress emailAddress = new EmailAddress();
reader.ReadStartElement(XmlNamespace.Types, XmlElementNames.Mailbox);
emailAddress.LoadFromXml(reader, XmlElementNames.Mailbox);
this.members.Add(emailAddress);
}
reader.ReadEndElement(XmlNamespace.Messages, XmlElementNames.DLExpansion);
}
}
/// <summary>
/// Parses the response.
/// </summary>
/// <param name="reader">The reader.</param>
/// <returns>Response object.</returns>
internal override object ParseResponse(EwsServiceXmlReader reader)
{
reader.ReadStartElement(XmlNamespace.Messages, XmlElementNames.ResponseMessages);
GetStreamingEventsResponse response = new GetStreamingEventsResponse(this);
response.LoadFromXml(reader, XmlElementNames.GetStreamingEventsResponseMessage);
reader.ReadEndElementIfNecessary(XmlNamespace.Messages, XmlElementNames.ResponseMessages);
return(response);
}
/// <summary>
/// Loads the free busy view from XML.
/// </summary>
/// <param name="reader">The reader.</param>
/// <param name="viewType">Type of free/busy view.</param>
internal void LoadFreeBusyViewFromXml(EwsServiceXmlReader reader, FreeBusyViewType viewType)
{
reader.ReadStartElement(XmlNamespace.Messages, XmlElementNames.FreeBusyView);
string viewTypeString = reader.ReadElementValue(XmlNamespace.Types, XmlElementNames.FreeBusyViewType);
this.viewType = (FreeBusyViewType)Enum.Parse(typeof(FreeBusyViewType), viewTypeString, false);
do
{
reader.Read();
if (reader.IsStartElement())
{
switch (reader.LocalName)
{
case XmlElementNames.MergedFreeBusy:
string mergedFreeBusy = reader.ReadElementValue();
for (int i = 0; i < mergedFreeBusy.Length; i++)
{
this.mergedFreeBusyStatus.Add((LegacyFreeBusyStatus)Byte.Parse(mergedFreeBusy[i].ToString()));
}
break;
case XmlElementNames.CalendarEventArray:
do
{
reader.Read();
if (reader.IsStartElement(XmlNamespace.Types, XmlElementNames.CalendarEvent))
{
CalendarEvent calendarEvent = new CalendarEvent();
calendarEvent.LoadFromXml(reader, XmlElementNames.CalendarEvent);
this.calendarEvents.Add(calendarEvent);
}
}while (!reader.IsEndElement(XmlNamespace.Types, XmlElementNames.CalendarEventArray));
break;
case XmlElementNames.WorkingHours:
this.workingHours = new WorkingHours();
this.workingHours.LoadFromXml(reader, reader.LocalName);
break;
}
}
}while (!reader.IsEndElement(XmlNamespace.Messages, XmlElementNames.FreeBusyView));
}
/// <summary>
/// Extracts the dictionary object (key or entry value) type from the specified reader.
/// </summary>
/// <param name="reader">The reader.</param>
/// <returns>Dictionary object type.</returns>
private UserConfigurationDictionaryObjectType GetObjectType(EwsServiceXmlReader reader)
{
EwsUtilities.Assert(
reader != null,
"UserConfigurationDictionary.LoadFromXml",
"reader is null");
reader.ReadStartElement(this.Namespace, XmlElementNames.Type);
string type = reader.ReadElementValue();
return(GetObjectType(type));
}
/// <summary>
/// Reads response elements from XML.
/// </summary>
/// <param name="reader">The reader.</param>
internal override void ReadElementsFromXml(EwsServiceXmlReader reader)
{
reader.ReadStartElement(XmlNamespace.Messages, XmlElementNames.ReturnValue);
using (XmlReader returnValueReader = reader.GetXmlReaderForNode())
{
this.ReturnValue = new SafeXmlDocument();
this.ReturnValue.Load(returnValueReader);
}
reader.SkipCurrentElement();
reader.ReadEndElementIfNecessary(XmlNamespace.Messages, XmlElementNames.ReturnValue);
}
/// <summary>
/// Parses the response.
/// </summary>
/// <param name="reader">The reader.</param>
/// <returns>Service response collection.</returns>
internal override object ParseResponse(EwsServiceXmlReader reader)
{
ServiceResponseCollection <TResponse> serviceResponses = new ServiceResponseCollection <TResponse>();
reader.ReadStartElement(XmlNamespace.Messages, XmlElementNames.ResponseMessages);
for (int i = 0; i < this.GetExpectedResponseMessageCount(); i++)
{
// Read ahead to see if we've reached the end of the response messages early.
reader.Read();
if (reader.IsEndElement(XmlNamespace.Messages, XmlElementNames.ResponseMessages))
{
break;
}
TResponse response = this.CreateServiceResponse(reader.Service, i);
response.LoadFromXml(reader, this.GetResponseMessageXmlElementName());
// Add the response to the list after it has been deserialized because the response
// list updates an overall result as individual responses are added to it.
serviceResponses.Add(response);
}
// If there's a general error in batch processing,
// the server will return a single response message containing the error
// (for example, if the SavedItemFolderId is bogus in a batch CreateItem
// call). In this case, throw a ServiceResponsException. Otherwise this
// is an unexpected server error.
if (serviceResponses.Count < this.GetExpectedResponseMessageCount())
{
if ((serviceResponses.Count == 1) && (serviceResponses[0].Result == ServiceResult.Error))
{
throw new ServiceResponseException(serviceResponses[0]);
}
else
{
throw new ServiceXmlDeserializationException(
string.Format(
Strings.TooFewServiceReponsesReturned,
this.GetResponseMessageXmlElementName(),
this.GetExpectedResponseMessageCount(),
serviceResponses.Count));
}
}
reader.ReadEndElementIfNecessary(XmlNamespace.Messages, XmlElementNames.ResponseMessages);
return(serviceResponses);
}
/// <summary>
/// Loads from XML.
/// </summary>
/// <param name="reader">The reader.</param>
internal void LoadFromXml(EwsServiceXmlReader reader)
{
reader.ReadStartElement(XmlNamespace.Messages, XmlElementNames.Notification);
do
{
NotificationGroup notifications = new NotificationGroup();
notifications.SubscriptionId = reader.ReadElementValue(XmlNamespace.Types, XmlElementNames.SubscriptionId);
notifications.Events = new Collection <NotificationEvent>();
lock (this)
{
this.events.Add(notifications);
}
do
{
reader.Read();
if (reader.IsStartElement())
{
string eventElementName = reader.LocalName;
EventType eventType;
if (GetEventsResults.XmlElementNameToEventTypeMap.TryGetValue(eventElementName, out eventType))
{
if (eventType == EventType.Status)
{
// We don't need to return status events
reader.ReadEndElementIfNecessary(XmlNamespace.Types, eventElementName);
}
else
{
this.LoadNotificationEventFromXml(
reader,
eventElementName,
eventType,
notifications);
}
}
else
{
reader.SkipCurrentElement();
}
}
}while (!reader.IsEndElement(XmlNamespace.Messages, XmlElementNames.Notification));
reader.Read();
}while (!reader.IsEndElement(XmlNamespace.Messages, XmlElementNames.Notifications));
}
/// <summary>
/// Reads response elements from XML.
/// </summary>
/// <param name="reader">The reader.</param>
internal override void ReadElementsFromXml(EwsServiceXmlReader reader)
{
base.ReadElementsFromXml(reader);
reader.ReadStartElement(XmlNamespace.Messages, XmlElementNames.RootItemId);
string changeKey = reader.ReadAttributeValue(XmlAttributeNames.RootItemChangeKey);
if (!string.IsNullOrEmpty(changeKey) && this.attachment.Owner != null)
{
this.attachment.Owner.RootItemId.ChangeKey = changeKey;
}
reader.ReadEndElementIfNecessary(XmlNamespace.Messages, XmlElementNames.RootItemId);
}
/// <summary>
/// Load from xml
/// </summary>
/// <param name="reader">The reader</param>
/// <returns>Mailbox hold object</returns>
internal static MailboxHoldResult LoadFromXml(EwsServiceXmlReader reader)
{
List <MailboxHoldStatus> statuses = new List <MailboxHoldStatus>();
reader.ReadStartElement(XmlNamespace.Messages, XmlElementNames.MailboxHoldResult);
MailboxHoldResult holdResult = new MailboxHoldResult();
holdResult.HoldId = reader.ReadElementValue(XmlNamespace.Types, XmlElementNames.HoldId);
// the query could be empty means there won't be Query element, hence needs to read and check
// if the next element is not Query, then it means already read MailboxHoldStatuses element
reader.Read();
holdResult.Query = string.Empty;
if (reader.IsStartElement(XmlNamespace.Types, XmlElementNames.Query))
{
holdResult.Query = reader.ReadElementValue(XmlNamespace.Types, XmlElementNames.Query);
reader.ReadStartElement(XmlNamespace.Types, XmlElementNames.MailboxHoldStatuses);
}
do
{
reader.Read();
if (reader.IsStartElement(XmlNamespace.Types, XmlElementNames.MailboxHoldStatus))
{
string mailbox = reader.ReadElementValue(XmlNamespace.Types, XmlElementNames.Mailbox);
HoldStatus status = (HoldStatus)Enum.Parse(typeof(HoldStatus), reader.ReadElementValue(XmlNamespace.Types, XmlElementNames.Status));
string additionalInfo = reader.ReadElementValue(XmlNamespace.Types, XmlElementNames.AdditionalInfo);
statuses.Add(new MailboxHoldStatus(mailbox, status, additionalInfo));
}
}while (!reader.IsEndElement(XmlNamespace.Messages, XmlElementNames.MailboxHoldResult));
holdResult.Statuses = statuses.Count == 0 ? null : statuses.ToArray();
return(holdResult);
}
/// <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>
/// Extracts a dictionary object (key or entry value) as a string list from the
/// specified reader.
/// </summary>
/// <param name="reader">The reader.</param>
/// <param name="type">The object type.</param>
/// <returns>String list representing a dictionary object.</returns>
private List <string> GetObjectValue(EwsServiceXmlReader reader, UserConfigurationDictionaryObjectType type)
{
EwsUtilities.Assert(
reader != null,
"UserConfigurationDictionary.LoadFromXml",
"reader is null");
List <string> values = new List <string>();
reader.ReadStartElement(this.Namespace, XmlElementNames.Value);
do
{
string value = null;
if (reader.IsEmptyElement)
{
// Only string types can be represented with empty values.
switch (type)
{
case UserConfigurationDictionaryObjectType.String:
case UserConfigurationDictionaryObjectType.StringArray:
value = string.Empty;
break;
default:
EwsUtilities.Assert(
false,
"UserConfigurationDictionary.GetObjectValue",
"Empty element passed for type: " + type.ToString());
break;
}
}
else
{
value = reader.ReadElementValue();
}
values.Add(value);
reader.Read(); // Position at next element or DictionaryKey/DictionaryValue end element
}while (reader.IsStartElement(this.Namespace, XmlElementNames.Value));
return(values);
}
/// <summary>
/// Loads the suggested days from XML.
/// </summary>
/// <param name="reader">The reader.</param>
internal void LoadSuggestedDaysFromXml(EwsServiceXmlReader reader)
{
reader.ReadStartElement(XmlNamespace.Messages, XmlElementNames.SuggestionDayResultArray);
do
{
reader.Read();
if (reader.IsStartElement(XmlNamespace.Types, XmlElementNames.SuggestionDayResult))
{
Suggestion daySuggestion = new Suggestion();
daySuggestion.LoadFromXml(reader, reader.LocalName);
this.daySuggestions.Add(daySuggestion);
}
}while (!reader.IsEndElement(XmlNamespace.Messages, XmlElementNames.SuggestionDayResultArray));
}
/// <summary>
/// Loads from XML.
/// </summary>
/// <param name="reader">The reader.</param>
internal void LoadFromXml(EwsServiceXmlReader reader)
{
reader.ReadStartElement(XmlNamespace.Messages, XmlElementNames.ResolutionSet);
int totalItemsInView = reader.ReadAttributeValue <int>(XmlAttributeNames.TotalItemsInView);
this.includesAllResolutions = reader.ReadAttributeValue <bool>(XmlAttributeNames.IncludesLastItemInRange);
for (int i = 0; i < totalItemsInView; i++)
{
NameResolution nameResolution = new NameResolution(this);
nameResolution.LoadFromXml(reader);
this.items.Add(nameResolution);
}
reader.ReadEndElement(XmlNamespace.Messages, XmlElementNames.ResolutionSet);
}
/// <summary>
/// Reads response elements from XML.
/// </summary>
/// <param name="reader">The reader.</param>
internal override void ReadElementsFromXml(EwsServiceXmlReader reader)
{
base.ReadElementsFromXml(reader);
reader.ReadStartElement(XmlNamespace.Messages, XmlElementNames.AlternateId);
string alternateIdClass = reader.ReadAttributeValue(XmlNamespace.XmlSchemaInstance, XmlAttributeNames.Type);
int aliasSeparatorIndex = alternateIdClass.IndexOf(':');
if (aliasSeparatorIndex > -1)
{
alternateIdClass = alternateIdClass.Substring(aliasSeparatorIndex + 1);
}
// Alternate Id classes are responsible fro reading the AlternateId end element when necessary
switch (alternateIdClass)
{
case AlternateId.SchemaTypeName:
this.convertedId = new AlternateId();
break;
case AlternatePublicFolderId.SchemaTypeName:
this.convertedId = new AlternatePublicFolderId();
break;
case AlternatePublicFolderItemId.SchemaTypeName:
this.convertedId = new AlternatePublicFolderItemId();
break;
default:
EwsUtilities.Assert(
false,
"ConvertIdResponse.ReadElementsFromXml",
string.Format("Unknown alternate Id class: {0}", alternateIdClass));
break;
}
this.convertedId.LoadAttributesFromXml(reader);
reader.ReadEndElementIfNecessary(XmlNamespace.Messages, XmlElementNames.AlternateId);
}
