/// <summary>
/// Reads response elements from XML.
/// </summary>
/// <param name="reader">The reader.</param>
internal override void ReadElementsFromXml(EwsServiceXmlReader reader)
{
this.retentionPolicyTags.Clear();
base.ReadElementsFromXml(reader);
reader.ReadStartElement(XmlNamespace.Messages, XmlElementNames.RetentionPolicyTags);
if (!reader.IsEmptyElement)
{
do
{
reader.Read();
if (reader.IsStartElement(XmlNamespace.Types, XmlElementNames.RetentionPolicyTag))
{
this.retentionPolicyTags.Add(RetentionPolicyTag.LoadFromXml(reader));
}
}while (!reader.IsEndElement(XmlNamespace.Messages, XmlElementNames.RetentionPolicyTags));
reader.ReadEndElementIfNecessary(XmlNamespace.Messages, XmlElementNames.RetentionPolicyTags);
}
}
/// <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.Notification);
this.subscriptionId = reader.ReadElementValue(XmlNamespace.Types, XmlElementNames.SubscriptionId);
this.previousWatermark = reader.ReadElementValue(XmlNamespace.Types, XmlElementNames.PreviousWatermark);
this.moreEventsAvailable = reader.ReadElementValue <bool>(XmlNamespace.Types, XmlElementNames.MoreEvents);
do
{
reader.Read();
if (reader.IsStartElement())
{
string eventElementName = reader.LocalName;
EventType eventType;
if (xmlElementNameToEventTypeMap.Member.TryGetValue(eventElementName, out eventType))
{
this.newWatermark = reader.ReadElementValue(XmlNamespace.Types, XmlElementNames.Watermark);
if (eventType == EventType.Status)
{
// We don't need to return status events
reader.ReadEndElementIfNecessary(XmlNamespace.Types, eventElementName);
}
else
{
this.LoadNotificationEventFromXml(
reader,
eventElementName,
eventType);
}
}
else
{
reader.SkipCurrentElement();
}
}
}while (!reader.IsEndElement(XmlNamespace.Messages, XmlElementNames.Notification));
}
/// <summary>
/// Loads from XML.
/// </summary>
/// <param name="reader">The reader.</param>
/// <param name="propertyBag">The property bag.</param>
internal override sealed void LoadPropertyValueFromXml(EwsServiceXmlReader reader, PropertyBag propertyBag)
{
ResponseActions value = ResponseActions.None;
reader.EnsureCurrentNodeIsStartElement(XmlNamespace.Types, this.XmlElementName);
if (!reader.IsEmptyElement)
{
do
{
reader.Read();
if (reader.IsStartElement())
{
value |= GetResponseAction(reader.LocalName);
}
}while (!reader.IsEndElement(XmlNamespace.Types, this.XmlElementName));
}
propertyBag[this] = value;
}
/// <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.TimeZoneDefinitions);
if (!reader.IsEmptyElement)
{
do
{
reader.Read();
if (reader.IsStartElement(XmlNamespace.Types, XmlElementNames.TimeZoneDefinition))
{
TimeZoneDefinition timeZoneDefinition = new TimeZoneDefinition();
timeZoneDefinition.LoadFromXml(reader);
this.timeZones.Add(timeZoneDefinition.ToTimeZoneInfo(reader.Service));
}
}while (!reader.IsEndElement(XmlNamespace.Messages, XmlElementNames.TimeZoneDefinitions));
}
}
/// <summary>
/// Read items from XML.
/// </summary>
/// <param name="reader">The reader.</param>
/// <param name="propertySet">The property set.</param>
/// <param name="destinationList">The list in which to add the read items.</param>
private static void InternalReadItemsFromXml(
EwsServiceXmlReader reader,
PropertySet propertySet,
IList <TItem> destinationList)
{
EwsUtilities.Assert(
destinationList != null,
"FindItemResponse.InternalReadItemsFromXml",
"destinationList is null.");
reader.ReadStartElement(XmlNamespace.Types, XmlElementNames.Items);
if (!reader.IsEmptyElement)
{
do
{
reader.Read();
if (reader.NodeType == XmlNodeType.Element)
{
TItem item = EwsUtilities.CreateEwsObjectFromXmlElementName <TItem>(reader.Service, reader.LocalName);
if (item == null)
{
reader.SkipCurrentElement();
}
else
{
item.LoadFromXml(
reader,
true, /* clearPropertyBag */
propertySet,
true /* summaryPropertiesOnly */);
destinationList.Add(item);
}
}
}while (!reader.IsEndElement(XmlNamespace.Types, XmlElementNames.Items));
}
}
/// <summary>
/// Parses the message XML.
/// </summary>
/// <param name="reader">The reader.</param>
private void ParseMessageXml(EwsServiceXmlReader reader)
{
do
{
reader.Read();
if (reader.IsStartElement())
{
switch (reader.LocalName)
{
case XmlElementNames.Value:
this.errorDetails.Add(reader.ReadAttributeValue(XmlAttributeNames.Name), reader.ReadElementValue());
break;
case XmlElementNames.FieldURI:
this.errorProperties.Add(ServiceObjectSchema.FindPropertyDefinition(reader.ReadAttributeValue(XmlAttributeNames.FieldURI)));
break;
case XmlElementNames.IndexedFieldURI:
this.errorProperties.Add(
new IndexedPropertyDefinition(
reader.ReadAttributeValue(XmlAttributeNames.FieldURI),
reader.ReadAttributeValue(XmlAttributeNames.FieldIndex)));
break;
case XmlElementNames.ExtendedFieldURI:
ExtendedPropertyDefinition extendedPropDef = new ExtendedPropertyDefinition();
extendedPropDef.LoadFromXml(reader);
this.errorProperties.Add(extendedPropDef);
break;
default:
break;
}
}
}
while (!reader.IsEndElement(XmlNamespace.Messages, XmlElementNames.MessageXml));
}
/// <summary>
/// Read Person from XML.
/// </summary>
/// <param name="reader">The reader.</param>
internal override void ReadElementsFromXml(EwsServiceXmlReader reader)
{
EwsUtilities.Assert(
this.People != null,
"GetPeopleInsightsResponse.ReadElementsFromXml",
"People is null.");
reader.ReadStartElement(XmlNamespace.Messages, XmlElementNames.People);
if (!reader.IsEmptyElement)
{
do
{
reader.Read();
if (reader.NodeType == XmlNodeType.Element)
{
Person item = new Person();
item.LoadFromXml(reader, XmlNamespace.Types, XmlElementNames.Person);
this.People.Add(item);
}
}while (!reader.IsEndElement(XmlNamespace.Messages, XmlElementNames.People));
}
}
/// <summary>
/// Loads from XML.
/// </summary>
/// <param name="reader">The reader.</param>
/// <param name="localElementName">Name of the local element.</param>
internal override void LoadFromXml(EwsServiceXmlReader reader, string localElementName)
{
reader.EnsureCurrentNodeIsStartElement(XmlNamespace.Types, localElementName);
reader.ReadStartElement(XmlNamespace.Types, this.InnerCollectionXmlElementName);
base.LoadFromXml(reader, this.InnerCollectionXmlElementName);
reader.ReadEndElementIfNecessary(XmlNamespace.Types, this.InnerCollectionXmlElementName);
reader.Read();
if (reader.IsStartElement(XmlNamespace.Types, XmlElementNames.UnknownEntries))
{
do
{
reader.Read();
if (reader.IsStartElement(XmlNamespace.Types, XmlElementNames.UnknownEntry))
{
this.unknownEntries.Add(reader.ReadElementValue());
}
}while (!reader.IsEndElement(XmlNamespace.Types, XmlElementNames.UnknownEntries));
}
}
/// <summary>
/// Load failed mailboxes xml
/// </summary>
/// <param name="rootXmlNamespace">Root xml namespace</param>
/// <param name="reader">The reader</param>
/// <returns>Array of failed mailboxes</returns>
internal static FailedSearchMailbox[] LoadFailedMailboxesXml(XmlNamespace rootXmlNamespace, EwsServiceXmlReader reader)
{
List <FailedSearchMailbox> failedMailboxes = new List <FailedSearchMailbox>();
reader.EnsureCurrentNodeIsStartElement(rootXmlNamespace, XmlElementNames.FailedMailboxes);
do
{
reader.Read();
if (reader.IsStartElement(XmlNamespace.Types, XmlElementNames.FailedMailbox))
{
string mailbox = reader.ReadElementValue(XmlNamespace.Types, XmlElementNames.Mailbox);
int errorCode = 0;
int.TryParse(reader.ReadElementValue(XmlNamespace.Types, XmlElementNames.ErrorCode), out errorCode);
string errorMessage = reader.ReadElementValue(XmlNamespace.Types, XmlElementNames.ErrorMessage);
bool isArchive = false;
bool.TryParse(reader.ReadElementValue(XmlNamespace.Types, XmlElementNames.IsArchive), out isArchive);
failedMailboxes.Add(new FailedSearchMailbox(mailbox, errorCode, errorMessage, isArchive));
}
}while (!reader.IsEndElement(rootXmlNamespace, XmlElementNames.FailedMailboxes));
return(failedMailboxes.Count == 0 ? null : failedMailboxes.ToArray());
}
/// <summary>
/// Parses the response.
/// See O15:324151 on why we need to override ParseResponse here instead of calling the one in MultiResponseServiceRequest.cs
/// </summary>
/// <param name="reader">The reader.</param>
/// <returns>Service response collection.</returns>
internal override object ParseResponse(EwsServiceXmlReader reader)
{
ServiceResponseCollection <SearchMailboxesResponse> serviceResponses = new ServiceResponseCollection <SearchMailboxesResponse>();
reader.ReadStartElement(XmlNamespace.Messages, XmlElementNames.ResponseMessages);
while (true)
{
// 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;
}
SearchMailboxesResponse response = new SearchMailboxesResponse();
response.LoadFromXml(reader, this.GetResponseMessageXmlElementName());
serviceResponses.Add(response);
}
reader.ReadEndElementIfNecessary(XmlNamespace.Messages, XmlElementNames.ResponseMessages);
return(serviceResponses);
}
/// <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>
/// Loads response from XML.
/// </summary>
/// <param name="reader">The reader.</param>
/// <param name="xmlElementName">Name of the XML element.</param>
internal void LoadFromXml(EwsServiceXmlReader reader, string xmlElementName)
{
if (!reader.IsStartElement(XmlNamespace.Messages, xmlElementName))
{
reader.ReadStartElement(XmlNamespace.Messages, xmlElementName);
}
this.result = reader.ReadAttributeValue <ServiceResult>(XmlAttributeNames.ResponseClass);
if (this.result == ServiceResult.Success || this.result == ServiceResult.Warning)
{
if (this.result == ServiceResult.Warning)
{
this.errorMessage = reader.ReadElementValue(XmlNamespace.Messages, XmlElementNames.MessageText);
}
else
{
reader.ReadElementValue();
if (reader.IsStartElement(XmlNamespace.Messages, XmlElementNames.MessageText))
{
this.errorMessage = reader.ReadElementValue(XmlNamespace.Messages, XmlElementNames.MessageText);
}
}
this.errorCode = reader.ReadElementValue <ServiceError>(XmlNamespace.Messages, XmlElementNames.ResponseCode);
if (this.result == ServiceResult.Warning)
{
reader.ReadElementValue <int>(XmlNamespace.Messages, XmlElementNames.DescriptiveLinkKey);
}
// If batch processing stopped, EWS returns an empty element. Skip over it.
if (this.BatchProcessingStopped)
{
do
{
reader.Read();
}while (!reader.IsEndElement(XmlNamespace.Messages, xmlElementName));
}
else
{
this.ReadElementsFromXml(reader);
reader.ReadEndElementIfNecessary(XmlNamespace.Messages, xmlElementName);
}
}
else
{
this.errorMessage = reader.ReadElementValue(XmlNamespace.Messages, XmlElementNames.MessageText);
this.errorCode = reader.ReadElementValue <ServiceError>(XmlNamespace.Messages, XmlElementNames.ResponseCode);
reader.ReadElementValue <int>(XmlNamespace.Messages, XmlElementNames.DescriptiveLinkKey);
while (!reader.IsEndElement(XmlNamespace.Messages, xmlElementName))
{
reader.Read();
if (reader.IsStartElement())
{
if (!this.LoadExtraErrorDetailsFromXml(reader, reader.LocalName))
{
reader.SkipCurrentElement();
}
}
}
}
this.MapErrorCodeToErrorMessage();
this.Loaded();
}
/// <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();
// Sometimes Exchange Online returns blank CalendarEventArray tag like bellow.
// <CalendarEventArray xmlns="http://schemas.microsoft.com/exchange/services/2006/types" />
// So we have to check the end of CalendarEventArray tag.
if (reader.LocalName == XmlElementNames.FreeBusyView)
{
// There is no the end tag of CalendarEventArray, but the reader is reading the end tag of FreeBusyView.
break;
}
else if (reader.LocalName == XmlElementNames.WorkingHours)
{
// There is no the end tag of CalendarEventArray, but the reader is reading the start tag of WorkingHours.
goto case XmlElementNames.WorkingHours;
}
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>
/// Reads ItemList from XML
/// </summary>
/// <param name="reader">The reader.</param>
private void ReadItemList(EwsServiceXmlReader reader)
{
do
{
reader.Read();
InsightValue item = null;
if (reader.NodeType == XmlNodeType.Element && reader.LocalName == XmlElementNames.Item)
{
switch (reader.ReadAttributeValue("xsi:type"))
{
case XmlElementNames.StringInsightValue:
item = new StringInsightValue();
item.LoadFromXml(reader, reader.LocalName);
this.ItemList.InternalAdd(item);
break;
case XmlElementNames.ProfileInsightValue:
item = new ProfileInsightValue();
item.LoadFromXml(reader, reader.LocalName);
this.ItemList.InternalAdd(item);
break;
case XmlElementNames.JobInsightValue:
item = new JobInsightValue();
item.LoadFromXml(reader, reader.LocalName);
this.ItemList.InternalAdd(item);
break;
case XmlElementNames.UserProfilePicture:
item = new UserProfilePicture();
item.LoadFromXml(reader, reader.LocalName);
this.ItemList.InternalAdd(item);
break;
case XmlElementNames.EducationInsightValue:
item = new EducationInsightValue();
item.LoadFromXml(reader, reader.LocalName);
this.ItemList.InternalAdd(item);
break;
case XmlElementNames.SkillInsightValue:
item = new SkillInsightValue();
item.LoadFromXml(reader, reader.LocalName);
this.ItemList.InternalAdd(item);
break;
case XmlElementNames.ComputedInsightValue:
item = new ComputedInsightValue();
item.LoadFromXml(reader, reader.LocalName);
this.ItemList.InternalAdd(item);
break;
case XmlElementNames.MeetingInsightValue:
item = new MeetingInsightValue();
item.LoadFromXml(reader, reader.LocalName);
this.ItemList.InternalAdd(item);
break;
case XmlElementNames.EmailInsightValue:
item = new EmailInsightValue();
item.LoadFromXml(reader, reader.LocalName);
this.ItemList.InternalAdd(item);
break;
case XmlElementNames.DelveDocument:
item = new DelveDocument();
item.LoadFromXml(reader, reader.LocalName);
this.ItemList.InternalAdd(item);
break;
case XmlElementNames.CompanyInsightValue:
item = new CompanyInsightValue();
item.LoadFromXml(reader, reader.LocalName);
this.ItemList.InternalAdd(item);
break;
case XmlElementNames.OutOfOfficeInsightValue:
item = new OutOfOfficeInsightValue();
item.LoadFromXml(reader, reader.LocalName);
this.ItemList.InternalAdd(item);
break;
}
}
}while (!reader.IsEndElement(XmlNamespace.Types, XmlElementNames.ItemList));
}
/// <summary>
/// Reads response elements from XML.
/// </summary>
/// <param name="reader">The reader.</param>
internal override void ReadElementsFromXml(EwsServiceXmlReader reader)
{
this.Changes.SyncState = reader.ReadElementValue(XmlNamespace.Messages, XmlElementNames.SyncState);
this.Changes.MoreChangesAvailable = !reader.ReadElementValue <bool>(XmlNamespace.Messages, this.GetIncludesLastInRangeXmlElementName());
reader.ReadStartElement(XmlNamespace.Messages, XmlElementNames.Changes);
if (!reader.IsEmptyElement)
{
do
{
reader.Read();
if (reader.IsStartElement())
{
TChange change = this.CreateChangeInstance();
switch (reader.LocalName)
{
case XmlElementNames.Create:
change.ChangeType = ChangeType.Create;
break;
case XmlElementNames.Update:
change.ChangeType = ChangeType.Update;
break;
case XmlElementNames.Delete:
change.ChangeType = ChangeType.Delete;
break;
case XmlElementNames.ReadFlagChange:
change.ChangeType = ChangeType.ReadFlagChange;
break;
default:
reader.SkipCurrentElement();
break;
}
if (change != null)
{
reader.Read();
reader.EnsureCurrentNodeIsStartElement();
switch (change.ChangeType)
{
case ChangeType.Delete:
case ChangeType.ReadFlagChange:
change.Id = change.CreateId();
change.Id.LoadFromXml(reader, change.Id.GetXmlElementName());
if (change.ChangeType == ChangeType.ReadFlagChange)
{
reader.Read();
reader.EnsureCurrentNodeIsStartElement();
ItemChange itemChange = change as ItemChange;
EwsUtilities.Assert(
itemChange != null,
"SyncResponse.ReadElementsFromXml",
"ReadFlagChange is only valid on ItemChange");
itemChange.IsRead = reader.ReadElementValue <bool>(XmlNamespace.Types, XmlElementNames.IsRead);
}
break;
default:
change.ServiceObject = EwsUtilities.CreateEwsObjectFromXmlElementName <TServiceObject>(
reader.Service,
reader.LocalName);
change.ServiceObject.LoadFromXml(
reader,
true, /* clearPropertyBag */
this.propertySet,
this.SummaryPropertiesOnly);
break;
}
reader.ReadEndElementIfNecessary(XmlNamespace.Types, change.ChangeType.ToString());
this.changes.Add(change);
}
}
}while (!reader.IsEndElement(XmlNamespace.Messages, XmlElementNames.Changes));
}
}
/// <summary>
/// Loads from XML.
/// </summary>
/// <param name="reader">The reader.</param>
/// <param name="propertyBag">The property bag.</param>
internal override sealed void LoadPropertyValueFromXml(EwsServiceXmlReader reader, PropertyBag propertyBag)
{
EffectiveRights value = EffectiveRights.None;
reader.EnsureCurrentNodeIsStartElement(XmlNamespace.Types, this.XmlElementName);
if (!reader.IsEmptyElement)
{
do
{
reader.Read();
if (reader.IsStartElement())
{
switch (reader.LocalName)
{
case XmlElementNames.CreateAssociated:
if (reader.ReadElementValue <bool>())
{
value |= EffectiveRights.CreateAssociated;
}
break;
case XmlElementNames.CreateContents:
if (reader.ReadElementValue <bool>())
{
value |= EffectiveRights.CreateContents;
}
break;
case XmlElementNames.CreateHierarchy:
if (reader.ReadElementValue <bool>())
{
value |= EffectiveRights.CreateHierarchy;
}
break;
case XmlElementNames.Delete:
if (reader.ReadElementValue <bool>())
{
value |= EffectiveRights.Delete;
}
break;
case XmlElementNames.Modify:
if (reader.ReadElementValue <bool>())
{
value |= EffectiveRights.Modify;
}
break;
case XmlElementNames.Read:
if (reader.ReadElementValue <bool>())
{
value |= EffectiveRights.Read;
}
break;
case XmlElementNames.ViewPrivateItems:
if (reader.ReadElementValue <bool>())
{
value |= EffectiveRights.ViewPrivateItems;
}
break;
}
}
}while (!reader.IsEndElement(XmlNamespace.Types, this.XmlElementName));
}
propertyBag[this] = value;
}
/// <summary>
/// Load from xml
/// </summary>
/// <param name="reader">The reader</param>
/// <returns>Search result object</returns>
internal static SearchMailboxesResult LoadFromXml(EwsServiceXmlReader reader)
{
SearchMailboxesResult searchResult = new SearchMailboxesResult();
reader.ReadStartElement(XmlNamespace.Messages, XmlElementNames.SearchMailboxesResult);
List <MailboxQuery> searchQueries = new List <MailboxQuery>();
do
{
reader.Read();
if (reader.IsStartElement(XmlNamespace.Types, XmlElementNames.SearchQueries))
{
reader.ReadStartElement(XmlNamespace.Types, XmlElementNames.MailboxQuery);
string query = reader.ReadElementValue(XmlNamespace.Types, XmlElementNames.Query);
reader.ReadStartElement(XmlNamespace.Types, XmlElementNames.MailboxSearchScopes);
List <MailboxSearchScope> mailboxSearchScopes = new List <MailboxSearchScope>();
do
{
reader.Read();
if (reader.IsStartElement(XmlNamespace.Types, XmlElementNames.MailboxSearchScope))
{
string mailbox = reader.ReadElementValue(XmlNamespace.Types, XmlElementNames.Mailbox);
reader.ReadStartElement(XmlNamespace.Types, XmlElementNames.SearchScope);
string searchScope = reader.ReadElementValue(XmlNamespace.Types, XmlElementNames.SearchScope);
reader.ReadEndElement(XmlNamespace.Types, XmlElementNames.MailboxSearchScope);
mailboxSearchScopes.Add(new MailboxSearchScope(mailbox, (MailboxSearchLocation)Enum.Parse(typeof(MailboxSearchLocation), searchScope)));
}
}while (!reader.IsEndElement(XmlNamespace.Types, XmlElementNames.MailboxSearchScopes));
reader.ReadEndElementIfNecessary(XmlNamespace.Types, XmlElementNames.MailboxSearchScopes);
searchQueries.Add(new MailboxQuery(query, mailboxSearchScopes.ToArray()));
}
}while (!reader.IsEndElement(XmlNamespace.Types, XmlElementNames.SearchQueries));
reader.ReadEndElementIfNecessary(XmlNamespace.Types, XmlElementNames.SearchQueries);
searchResult.SearchQueries = searchQueries.ToArray();
searchResult.ResultType = (SearchResultType)Enum.Parse(typeof(SearchResultType), reader.ReadElementValue(XmlNamespace.Types, XmlElementNames.ResultType));
searchResult.ItemCount = int.Parse(reader.ReadElementValue(XmlNamespace.Types, XmlElementNames.ItemCount));
searchResult.Size = ulong.Parse(reader.ReadElementValue(XmlNamespace.Types, XmlElementNames.Size));
searchResult.PageItemCount = int.Parse(reader.ReadElementValue(XmlNamespace.Types, XmlElementNames.PageItemCount));
searchResult.PageItemSize = ulong.Parse(reader.ReadElementValue(XmlNamespace.Types, XmlElementNames.PageItemSize));
do
{
reader.Read();
if (reader.IsStartElement(XmlNamespace.Types, XmlElementNames.KeywordStats))
{
searchResult.KeywordStats = LoadKeywordStatsXml(reader);
}
if (reader.IsStartElement(XmlNamespace.Types, XmlElementNames.Items))
{
searchResult.PreviewItems = LoadPreviewItemsXml(reader);
}
if (reader.IsStartElement(XmlNamespace.Types, XmlElementNames.FailedMailboxes))
{
searchResult.FailedMailboxes = FailedSearchMailbox.LoadFailedMailboxesXml(XmlNamespace.Types, reader);
}
if (reader.IsStartElement(XmlNamespace.Types, XmlElementNames.Refiners))
{
List <SearchRefinerItem> refiners = new List <SearchRefinerItem>();
do
{
reader.Read();
if (reader.IsStartElement(XmlNamespace.Types, XmlElementNames.Refiner))
{
refiners.Add(SearchRefinerItem.LoadFromXml(reader));
}
}while (!reader.IsEndElement(XmlNamespace.Types, XmlElementNames.Refiners));
if (refiners.Count > 0)
{
searchResult.Refiners = refiners.ToArray();
}
}
if (reader.IsStartElement(XmlNamespace.Types, XmlElementNames.MailboxStats))
{
List <MailboxStatisticsItem> mailboxStats = new List <MailboxStatisticsItem>();
do
{
reader.Read();
if (reader.IsStartElement(XmlNamespace.Types, XmlElementNames.MailboxStat))
{
mailboxStats.Add(MailboxStatisticsItem.LoadFromXml(reader));
}
}while (!reader.IsEndElement(XmlNamespace.Types, XmlElementNames.MailboxStats));
if (mailboxStats.Count > 0)
{
searchResult.MailboxStats = mailboxStats.ToArray();
}
}
}while (!reader.IsEndElement(XmlNamespace.Messages, XmlElementNames.SearchMailboxesResult));
return(searchResult);
}
/// <summary>
/// Load from xml
/// </summary>
/// <param name="reader">The reader</param>
/// <returns>Non indexable item object</returns>
internal static NonIndexableItem LoadFromXml(EwsServiceXmlReader reader)
{
NonIndexableItem result = null;
if (reader.IsStartElement(XmlNamespace.Types, XmlElementNames.NonIndexableItemDetail))
{
ItemId itemId = null;
ItemIndexError errorCode = ItemIndexError.None;
string errorDescription = null;
bool isPartiallyIndexed = false;
bool isPermanentFailure = false;
int attemptCount = 0;
DateTime? lastAttemptTime = null;
string additionalInfo = null;
string sortValue = null;
do
{
reader.Read();
if (reader.IsStartElement(XmlNamespace.Types, XmlElementNames.ItemId))
{
itemId = new ItemId();
itemId.ReadAttributesFromXml(reader);
}
else if (reader.IsStartElement(XmlNamespace.Types, XmlElementNames.ErrorDescription))
{
errorDescription = reader.ReadElementValue(XmlNamespace.Types, XmlElementNames.ErrorDescription);
}
else if (reader.IsStartElement(XmlNamespace.Types, XmlElementNames.IsPartiallyIndexed))
{
isPartiallyIndexed = reader.ReadElementValue <bool>(XmlNamespace.Types, XmlElementNames.IsPartiallyIndexed);
}
else if (reader.IsStartElement(XmlNamespace.Types, XmlElementNames.IsPermanentFailure))
{
isPermanentFailure = reader.ReadElementValue <bool>(XmlNamespace.Types, XmlElementNames.IsPermanentFailure);
}
else if (reader.IsStartElement(XmlNamespace.Types, XmlElementNames.AttemptCount))
{
attemptCount = reader.ReadElementValue <int>(XmlNamespace.Types, XmlElementNames.AttemptCount);
}
else if (reader.IsStartElement(XmlNamespace.Types, XmlElementNames.LastAttemptTime))
{
lastAttemptTime = reader.ReadElementValue <DateTime>(XmlNamespace.Types, XmlElementNames.LastAttemptTime);
}
else if (reader.IsStartElement(XmlNamespace.Types, XmlElementNames.AdditionalInfo))
{
additionalInfo = reader.ReadElementValue(XmlNamespace.Types, XmlElementNames.AdditionalInfo);
}
else if (reader.IsStartElement(XmlNamespace.Types, XmlElementNames.SortValue))
{
sortValue = reader.ReadElementValue(XmlNamespace.Types, XmlElementNames.SortValue);
}
}while (!reader.IsEndElement(XmlNamespace.Types, XmlElementNames.NonIndexableItemDetail));
result = new NonIndexableItem
{
ItemId = itemId,
ErrorCode = errorCode,
ErrorDescription = errorDescription,
IsPartiallyIndexed = isPartiallyIndexed,
IsPermanentFailure = isPermanentFailure,
AttemptCount = attemptCount,
LastAttemptTime = lastAttemptTime,
AdditionalInfo = additionalInfo,
SortValue = sortValue,
};
}
return(result);
}
/// <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();
}
if (reader.IsStartElement(XmlNamespace.Messages, XmlElementNames.FindPeopleTransactionId) && !reader.IsEmptyElement)
{
this.TransactionId = reader.ReadElementValue <string>();
reader.Read();
}
// Future proof by skipping any additional elements before returning
while (!reader.IsEndElement(XmlNamespace.Messages, XmlElementNames.FindPeopleResponse))
{
reader.Read();
}
}
/// <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);
int totalItemsInView = reader.ReadAttributeValue <int>(XmlAttributeNames.TotalItemsInView);
bool moreItemsAvailable = !reader.ReadAttributeValue <bool>(XmlAttributeNames.IncludesLastItemInRange);
// Ignore IndexedPagingOffset attribute if moreItemsAvailable is false.
int?nextPageOffset = moreItemsAvailable ? reader.ReadNullableAttributeValue <int>(XmlAttributeNames.IndexedPagingOffset) : null;
if (!this.isGrouped)
{
this.results = new FindItemsResults <TItem>();
this.results.TotalCount = totalItemsInView;
this.results.NextPageOffset = nextPageOffset;
this.results.MoreAvailable = moreItemsAvailable;
InternalReadItemsFromXml(
reader,
this.propertySet,
this.results.Items);
}
else
{
this.groupedFindResults = new GroupedFindItemsResults <TItem>();
this.groupedFindResults.TotalCount = totalItemsInView;
this.groupedFindResults.NextPageOffset = nextPageOffset;
this.groupedFindResults.MoreAvailable = moreItemsAvailable;
reader.ReadStartElement(XmlNamespace.Types, XmlElementNames.Groups);
if (!reader.IsEmptyElement)
{
do
{
reader.Read();
if (reader.IsStartElement(XmlNamespace.Types, XmlElementNames.GroupedItems))
{
string groupIndex = reader.ReadElementValue(XmlNamespace.Types, XmlElementNames.GroupIndex);
List <TItem> itemList = new List <TItem>();
InternalReadItemsFromXml(
reader,
this.propertySet,
itemList);
reader.ReadEndElement(XmlNamespace.Types, XmlElementNames.GroupedItems);
this.groupedFindResults.ItemGroups.Add(new ItemGroup <TItem>(groupIndex, itemList));
}
}while (!reader.IsEndElement(XmlNamespace.Types, XmlElementNames.Groups));
}
}
reader.ReadEndElement(XmlNamespace.Messages, XmlElementNames.RootFolder);
reader.Read();
if (reader.IsStartElement(XmlNamespace.Messages, XmlElementNames.HighlightTerms) &&
!reader.IsEmptyElement)
{
do
{
reader.Read();
if (reader.NodeType == XmlNodeType.Element)
{
HighlightTerm term = new HighlightTerm();
term.LoadFromXml(
reader,
XmlNamespace.Types,
XmlElementNames.HighlightTerm);
this.results.HighlightTerms.Add(term);
}
}while (!reader.IsEndElement(XmlNamespace.Messages, XmlElementNames.HighlightTerms));
}
}
/// <summary>
/// Tries to read element from XML.
/// </summary>
/// <param name="reader">The reader.</param>
/// <returns>True if element was read.</returns>
internal override bool TryReadElementFromXml(EwsServiceXmlReader reader)
{
switch (reader.LocalName)
{
case XmlElementNames.Periods:
do
{
reader.Read();
if (reader.IsStartElement(XmlNamespace.Types, XmlElementNames.Period))
{
TimeZonePeriod period = new TimeZonePeriod();
period.LoadFromXml(reader);
// OM:1648848 Bad timezone data from clients can include duplicate rules
// for one year, with duplicate ID. In that case, let the first one win.
if (!this.periods.ContainsKey(period.Id))
{
this.periods.Add(period.Id, period);
}
else
{
reader.Service.TraceMessage(
TraceFlags.EwsTimeZones,
string.Format(
"An entry with the same key (Id) '{0}' already exists in Periods. Cannot add another one. Existing entry: [Name='{1}', Bias='{2}']. Entry to skip: [Name='{3}', Bias='{4}'].",
period.Id,
this.Periods[period.Id].Name,
this.Periods[period.Id].Bias,
period.Name,
period.Bias));
}
}
}while (!reader.IsEndElement(XmlNamespace.Types, XmlElementNames.Periods));
return(true);
case XmlElementNames.TransitionsGroups:
do
{
reader.Read();
if (reader.IsStartElement(XmlNamespace.Types, XmlElementNames.TransitionsGroup))
{
TimeZoneTransitionGroup transitionGroup = new TimeZoneTransitionGroup(this);
transitionGroup.LoadFromXml(reader);
this.transitionGroups.Add(transitionGroup.Id, transitionGroup);
}
}while (!reader.IsEndElement(XmlNamespace.Types, XmlElementNames.TransitionsGroups));
return(true);
case XmlElementNames.Transitions:
do
{
reader.Read();
if (reader.IsStartElement())
{
TimeZoneTransition transition = TimeZoneTransition.Create(this, reader.LocalName);
transition.LoadFromXml(reader);
this.transitions.Add(transition);
}
}while (!reader.IsEndElement(XmlNamespace.Types, XmlElementNames.Transitions));
return(true);
default:
return(false);
}
}
/// <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 Conversations from XML.
/// </summary>
/// <param name="reader">The reader.</param>
internal override void ReadElementsFromXml(EwsServiceXmlReader reader)
{
EwsUtilities.Assert(
this.Results.Conversations != null,
"FindConversationResponse.ReadElementsFromXml",
"conversations is null.");
EwsUtilities.Assert(
this.Results.HighlightTerms != null,
"FindConversationResponse.ReadElementsFromXml",
"highlightTerms is null.");
reader.ReadStartElement(XmlNamespace.Messages, XmlElementNames.Conversations);
if (!reader.IsEmptyElement)
{
do
{
reader.Read();
if (reader.NodeType == XmlNodeType.Element)
{
Conversation item = EwsUtilities.CreateEwsObjectFromXmlElementName <Conversation>(reader.Service, reader.LocalName);
if (item == null)
{
reader.SkipCurrentElement();
}
else
{
item.LoadFromXml(
reader,
true, /* clearPropertyBag */
null,
false /* summaryPropertiesOnly */);
this.Results.Conversations.Add(item);
}
}
}while (!reader.IsEndElement(XmlNamespace.Messages, XmlElementNames.Conversations));
}
reader.Read();
if (reader.IsStartElement(XmlNamespace.Messages, XmlElementNames.HighlightTerms) &&
!reader.IsEmptyElement)
{
do
{
reader.Read();
if (reader.NodeType == XmlNodeType.Element)
{
HighlightTerm term = new HighlightTerm();
term.LoadFromXml(
reader,
XmlNamespace.Types,
XmlElementNames.HighlightTerm);
this.Results.HighlightTerms.Add(term);
}
}while (!reader.IsEndElement(XmlNamespace.Messages, XmlElementNames.HighlightTerms));
}
if (reader.IsStartElement(XmlNamespace.Messages, XmlElementNames.TotalConversationsInView) && !reader.IsEmptyElement)
{
this.Results.TotalCount = reader.ReadElementValue <int>();
reader.Read();
}
if (reader.IsStartElement(XmlNamespace.Messages, XmlElementNames.IndexedOffset) && !reader.IsEmptyElement)
{
this.Results.IndexedOffset = reader.ReadElementValue <int>();
reader.Read();
}
}
/// <summary>
/// Tries to read element from XML.
/// </summary>
/// <param name="reader">The reader.</param>
/// <returns>True if appropriate element was read.</returns>
internal override bool TryReadElementFromXml(EwsServiceXmlReader reader)
{
switch (reader.LocalName)
{
case XmlElementNames.MeetingTime:
this.meetingTime = reader.ReadElementValueAsUnbiasedDateTimeScopedToServiceTimeZone();
return(true);
case XmlElementNames.IsWorkTime:
this.isWorkTime = reader.ReadElementValue <bool>();
return(true);
case XmlElementNames.SuggestionQuality:
this.quality = reader.ReadElementValue <SuggestionQuality>();
return(true);
case XmlElementNames.AttendeeConflictDataArray:
if (!reader.IsEmptyElement)
{
do
{
reader.Read();
if (reader.IsStartElement())
{
Conflict conflict = null;
switch (reader.LocalName)
{
case XmlElementNames.UnknownAttendeeConflictData:
conflict = new Conflict(ConflictType.UnknownAttendeeConflict);
break;
case XmlElementNames.TooBigGroupAttendeeConflictData:
conflict = new Conflict(ConflictType.GroupTooBigConflict);
break;
case XmlElementNames.IndividualAttendeeConflictData:
conflict = new Conflict(ConflictType.IndividualAttendeeConflict);
break;
case XmlElementNames.GroupAttendeeConflictData:
conflict = new Conflict(ConflictType.GroupConflict);
break;
default:
EwsUtilities.Assert(
false,
"TimeSuggestion.TryReadElementFromXml",
string.Format("The {0} element name does not map to any AttendeeConflict descendant.", reader.LocalName));
// The following line to please the compiler
break;
}
conflict.LoadFromXml(reader, reader.LocalName);
this.conflicts.Add(conflict);
}
}while (!reader.IsEndElement(XmlNamespace.Types, XmlElementNames.AttendeeConflictDataArray));
}
return(true);
default:
return(false);
}
}
/// <summary>
/// Tries to read element from XML.
/// </summary>
/// <param name="reader">The reader.</param>
/// <returns>True if element was read.</returns>
internal override bool TryReadElementFromXml(EwsServiceXmlReader reader)
{
do
{
reader.Read();
InsightValue item = null;
if (reader.NodeType == XmlNodeType.Element && reader.LocalName == XmlElementNames.Item)
{
switch (reader.ReadAttributeValue("xsi:type"))
{
case XmlElementNames.StringInsightValue:
item = new StringInsightValue();
item.LoadFromXml(reader, reader.LocalName);
this.ItemList.InternalAdd(item);
break;
case XmlElementNames.ProfileInsightValue:
item = new ProfileInsightValue();
item.LoadFromXml(reader, reader.LocalName);
this.ItemList.InternalAdd(item);
break;
case XmlElementNames.JobInsightValue:
item = new JobInsightValue();
item.LoadFromXml(reader, reader.LocalName);
this.ItemList.InternalAdd(item);
break;
case XmlElementNames.UserProfilePicture:
item = new UserProfilePicture();
item.LoadFromXml(reader, reader.LocalName);
this.ItemList.InternalAdd(item);
break;
case XmlElementNames.EducationInsightValue:
item = new EducationInsightValue();
item.LoadFromXml(reader, reader.LocalName);
this.ItemList.InternalAdd(item);
break;
case XmlElementNames.SkillInsightValue:
item = new SkillInsightValue();
item.LoadFromXml(reader, reader.LocalName);
this.ItemList.InternalAdd(item);
break;
case XmlElementNames.ComputedInsightValue:
item = new ComputedInsightValue();
item.LoadFromXml(reader, reader.LocalName);
this.ItemList.InternalAdd(item);
break;
case XmlElementNames.MeetingInsightValue:
item = new MeetingInsightValue();
item.LoadFromXml(reader, reader.LocalName);
this.ItemList.InternalAdd(item);
break;
case XmlElementNames.EmailInsightValue:
item = new EmailInsightValue();
item.LoadFromXml(reader, reader.LocalName);
this.ItemList.InternalAdd(item);
break;
case XmlElementNames.DelveDocument:
item = new DelveDocument();
item.LoadFromXml(reader, reader.LocalName);
this.ItemList.InternalAdd(item);
break;
default:
return(false);
}
}
else
{
return(false);
}
} while (!reader.IsEndElement(XmlNamespace.Messages, XmlElementNames.ItemList));
return(true);
}
/// <summary>
/// Load from xml
/// </summary>
/// <param name="reader">The reader</param>
/// <returns>Discovery search configuration object</returns>
internal static DiscoverySearchConfiguration LoadFromXml(EwsServiceXmlReader reader)
{
List <SearchableMailbox> mailboxes = new List <SearchableMailbox>();
reader.EnsureCurrentNodeIsStartElement(XmlNamespace.Types, XmlElementNames.DiscoverySearchConfiguration);
DiscoverySearchConfiguration configuration = new DiscoverySearchConfiguration();
configuration.SearchId = reader.ReadElementValue(XmlNamespace.Types, XmlElementNames.SearchId);
// 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 SearchableMailboxes element
configuration.SearchQuery = string.Empty;
configuration.InPlaceHoldIdentity = string.Empty;
configuration.ManagedByOrganization = string.Empty;
configuration.Language = string.Empty;
do
{
reader.Read();
if (reader.IsStartElement(XmlNamespace.Types, XmlElementNames.SearchQuery))
{
configuration.SearchQuery = reader.ReadElementValue(XmlNamespace.Types, XmlElementNames.SearchQuery);
reader.ReadEndElementIfNecessary(XmlNamespace.Types, XmlElementNames.SearchQuery);
}
else if (reader.IsStartElement(XmlNamespace.Types, XmlElementNames.SearchableMailboxes))
{
// search object without any source mailbox is possible, hence need to check if element is empty
if (!reader.IsEmptyElement)
{
while (!reader.IsEndElement(XmlNamespace.Types, XmlElementNames.SearchableMailboxes))
{
reader.Read();
if (reader.IsStartElement(XmlNamespace.Types, XmlElementNames.SearchableMailbox))
{
mailboxes.Add(SearchableMailbox.LoadFromXml(reader));
reader.ReadEndElementIfNecessary(XmlNamespace.Types, XmlElementNames.SearchableMailbox);
}
}
}
}
else if (reader.IsStartElement(XmlNamespace.Types, XmlElementNames.InPlaceHoldIdentity))
{
configuration.InPlaceHoldIdentity = reader.ReadElementValue(XmlNamespace.Types, XmlElementNames.InPlaceHoldIdentity);
reader.ReadEndElementIfNecessary(XmlNamespace.Types, XmlElementNames.InPlaceHoldIdentity);
}
else if (reader.IsStartElement(XmlNamespace.Types, XmlElementNames.ManagedByOrganization))
{
configuration.ManagedByOrganization = reader.ReadElementValue(XmlNamespace.Types, XmlElementNames.ManagedByOrganization);
reader.ReadEndElementIfNecessary(XmlNamespace.Types, XmlElementNames.ManagedByOrganization);
}
else if (reader.IsStartElement(XmlNamespace.Types, XmlElementNames.Language))
{
configuration.Language = reader.ReadElementValue(XmlNamespace.Types, XmlElementNames.Language);
reader.ReadEndElementIfNecessary(XmlNamespace.Types, XmlElementNames.Language);
}
else
{
break;
}
}while (!reader.IsEndElement(XmlNamespace.Types, XmlElementNames.DiscoverySearchConfiguration));
configuration.SearchableMailboxes = mailboxes.Count == 0 ? null : mailboxes.ToArray();
return(configuration);
}
/// <summary>
/// Load preview items xml
/// </summary>
/// <param name="reader">The reader</param>
/// <returns>Array of preview items</returns>
private static SearchPreviewItem[] LoadPreviewItemsXml(EwsServiceXmlReader reader)
{
List <SearchPreviewItem> previewItems = new List <SearchPreviewItem>();
reader.EnsureCurrentNodeIsStartElement(XmlNamespace.Types, XmlElementNames.Items);
do
{
reader.Read();
if (reader.IsStartElement(XmlNamespace.Types, XmlElementNames.SearchPreviewItem))
{
SearchPreviewItem previewItem = new SearchPreviewItem();
do
{
reader.Read();
if (reader.IsStartElement(XmlNamespace.Types, XmlElementNames.Id))
{
previewItem.Id = new ItemId();
previewItem.Id.ReadAttributesFromXml(reader);
}
else if (reader.IsStartElement(XmlNamespace.Types, XmlElementNames.ParentId))
{
previewItem.ParentId = new ItemId();
previewItem.ParentId.ReadAttributesFromXml(reader);
}
else if (reader.IsStartElement(XmlNamespace.Types, XmlElementNames.Mailbox))
{
previewItem.Mailbox = new PreviewItemMailbox();
previewItem.Mailbox.MailboxId = reader.ReadElementValue(XmlNamespace.Types, XmlElementNames.MailboxId);
previewItem.Mailbox.PrimarySmtpAddress = reader.ReadElementValue(XmlNamespace.Types, XmlElementNames.PrimarySmtpAddress);
}
else if (reader.IsStartElement(XmlNamespace.Types, XmlElementNames.UniqueHash))
{
previewItem.UniqueHash = reader.ReadElementValue(XmlNamespace.Types, XmlElementNames.UniqueHash);
}
else if (reader.IsStartElement(XmlNamespace.Types, XmlElementNames.SortValue))
{
previewItem.SortValue = reader.ReadElementValue(XmlNamespace.Types, XmlElementNames.SortValue);
}
else if (reader.IsStartElement(XmlNamespace.Types, XmlElementNames.OwaLink))
{
previewItem.OwaLink = reader.ReadElementValue(XmlNamespace.Types, XmlElementNames.OwaLink);
}
else if (reader.IsStartElement(XmlNamespace.Types, XmlElementNames.Sender))
{
previewItem.Sender = reader.ReadElementValue(XmlNamespace.Types, XmlElementNames.Sender);
}
else if (reader.IsStartElement(XmlNamespace.Types, XmlElementNames.ToRecipients))
{
previewItem.ToRecipients = GetRecipients(reader, XmlElementNames.ToRecipients);
}
else if (reader.IsStartElement(XmlNamespace.Types, XmlElementNames.CcRecipients))
{
previewItem.CcRecipients = GetRecipients(reader, XmlElementNames.CcRecipients);
}
else if (reader.IsStartElement(XmlNamespace.Types, XmlElementNames.BccRecipients))
{
previewItem.BccRecipients = GetRecipients(reader, XmlElementNames.BccRecipients);
}
else if (reader.IsStartElement(XmlNamespace.Types, XmlElementNames.CreatedTime))
{
previewItem.CreatedTime = DateTime.Parse(reader.ReadElementValue(XmlNamespace.Types, XmlElementNames.CreatedTime));
}
else if (reader.IsStartElement(XmlNamespace.Types, XmlElementNames.ReceivedTime))
{
previewItem.ReceivedTime = DateTime.Parse(reader.ReadElementValue(XmlNamespace.Types, XmlElementNames.ReceivedTime));
}
else if (reader.IsStartElement(XmlNamespace.Types, XmlElementNames.SentTime))
{
previewItem.SentTime = DateTime.Parse(reader.ReadElementValue(XmlNamespace.Types, XmlElementNames.SentTime));
}
else if (reader.IsStartElement(XmlNamespace.Types, XmlElementNames.Subject))
{
previewItem.Subject = reader.ReadElementValue(XmlNamespace.Types, XmlElementNames.Subject);
}
else if (reader.IsStartElement(XmlNamespace.Types, XmlElementNames.Preview))
{
previewItem.Preview = reader.ReadElementValue(XmlNamespace.Types, XmlElementNames.Preview);
}
else if (reader.IsStartElement(XmlNamespace.Types, XmlElementNames.Size))
{
previewItem.Size = ulong.Parse(reader.ReadElementValue(XmlNamespace.Types, XmlElementNames.Size));
}
else if (reader.IsStartElement(XmlNamespace.Types, XmlElementNames.Importance))
{
previewItem.Importance = (Importance)Enum.Parse(typeof(Importance), reader.ReadElementValue(XmlNamespace.Types, XmlElementNames.Importance));
}
else if (reader.IsStartElement(XmlNamespace.Types, XmlElementNames.Read))
{
previewItem.Read = bool.Parse(reader.ReadElementValue(XmlNamespace.Types, XmlElementNames.Read));
}
else if (reader.IsStartElement(XmlNamespace.Types, XmlElementNames.HasAttachment))
{
previewItem.HasAttachment = bool.Parse(reader.ReadElementValue(XmlNamespace.Types, XmlElementNames.HasAttachment));
}
else if (reader.IsStartElement(XmlNamespace.Types, XmlElementNames.ExtendedProperties))
{
previewItem.ExtendedProperties = LoadExtendedPropertiesXml(reader);
}
}while (!reader.IsEndElement(XmlNamespace.Types, XmlElementNames.SearchPreviewItem));
previewItems.Add(previewItem);
}
}while (!reader.IsEndElement(XmlNamespace.Types, XmlElementNames.Items));
return(previewItems.Count == 0 ? null : previewItems.ToArray());
}
