/// <summary>
/// Load from XML.
/// </summary>
/// <param name="reader">The reader.</param>
internal override void InternalLoadFromXml(EwsServiceXmlReader reader)
{
base.InternalLoadFromXml(reader);
this.itemId = new ItemId();
this.itemId.LoadFromXml(reader, reader.LocalName);
reader.Read();
this.ParentFolderId = new FolderId();
this.ParentFolderId.LoadFromXml(reader, XmlElementNames.ParentFolderId);
switch (this.EventType)
{
case EventType.Moved:
case EventType.Copied:
reader.Read();
this.oldItemId = new ItemId();
this.oldItemId.LoadFromXml(reader, reader.LocalName);
reader.Read();
this.OldParentFolderId = new FolderId();
this.OldParentFolderId.LoadFromXml(reader, reader.LocalName);
break;
default:
break;
}
}
/// <summary>
/// Loads from XML.
/// </summary>
/// <param name="reader">The reader.</param>
/// <param name="allowNoMoreElements">If true the function returns false rather than throw an exception
/// if the last element has been read.</param>
internal bool LoadFromXml(EwsServiceXmlReader reader, bool allowNoMoreElements)
{
reader.Read();
if (allowNoMoreElements && reader.NodeType == System.Xml.XmlNodeType.EndElement)
{
return(false);
}
reader.EnsureCurrentNodeIsStartElement(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);
}
return(true);
}
/// <summary>
/// Reads response elements from XML.
/// </summary>
/// <param name="reader">The reader.</param>
internal override void ReadElementsFromXml(EwsServiceXmlReader reader)
{
if (this.ErrorCode == ServiceError.NoError)
{
this.delegateUserResponses = new Collection <DelegateUserResponse>();
reader.Read();
if (reader.IsStartElement(XmlNamespace.Messages, XmlElementNames.ResponseMessages))
{
int delegateUserIndex = 0;
do
{
reader.Read();
if (reader.IsStartElement(XmlNamespace.Messages, XmlElementNames.DelegateUserResponseMessageType))
{
DelegateUser delegateUser = null;
if (this.readDelegateUsers && (this.delegateUsers != null))
{
delegateUser = this.delegateUsers[delegateUserIndex];
}
DelegateUserResponse delegateUserResponse = new DelegateUserResponse(readDelegateUsers, delegateUser);
delegateUserResponse.LoadFromXml(reader, XmlElementNames.DelegateUserResponseMessageType);
this.delegateUserResponses.Add(delegateUserResponse);
delegateUserIndex++;
}
}while (!reader.IsEndElement(XmlNamespace.Messages, XmlElementNames.ResponseMessages));
}
}
}
/// <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>
/// 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>
/// 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>
/// Load from xml
/// </summary>
/// <param name="reader">The reader</param>
/// <returns>List of non indexable item statistic object</returns>
internal static List <NonIndexableItemStatistic> LoadFromXml(EwsServiceXmlReader reader)
{
List <NonIndexableItemStatistic> results = new List <NonIndexableItemStatistic>();
reader.Read();
if (reader.IsStartElement(XmlNamespace.Messages, XmlElementNames.NonIndexableItemStatistics))
{
do
{
reader.Read();
if (reader.IsStartElement(XmlNamespace.Types, XmlElementNames.NonIndexableItemStatistic))
{
string mailbox = reader.ReadElementValue(XmlNamespace.Types, XmlElementNames.Mailbox);
int itemCount = reader.ReadElementValue <int>(XmlNamespace.Types, XmlElementNames.ItemCount);
string errorMessage = null;
if (reader.IsStartElement(XmlNamespace.Types, XmlElementNames.ErrorMessage))
{
errorMessage = reader.ReadElementValue(XmlNamespace.Types, XmlElementNames.ErrorMessage);
}
results.Add(new NonIndexableItemStatistic {
Mailbox = mailbox, ItemCount = itemCount, ErrorMessage = errorMessage
});
}
}while (!reader.IsEndElement(XmlNamespace.Messages, XmlElementNames.NonIndexableItemStatistics));
}
return(results);
}
/// <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);
this.periods.Add(period.Id, period);
}
}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>
/// 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>
/// 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>
/// 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>
/// 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)
{
this.Manifests.Clear();
base.ReadElementsFromXml(reader);
reader.Read(XmlNodeType.Element);
// We can have a response from Exchange 2013 (first time this API was introduced)
// or the newer response, starting in Exchange 2013 SP1, (X-EWS-TargetVersion: 2.5 or above)
bool exchange2013Response;
if (XmlElementNames.Manifests.Equals(reader.LocalName))
{
exchange2013Response = true;
}
else if (XmlElementNames.Apps.Equals(reader.LocalName))
{
exchange2013Response = false;
}
else
{
throw new ServiceXmlDeserializationException(
string.Format(
Strings.UnexpectedElement,
EwsUtilities.GetNamespacePrefix(XmlNamespace.Messages),
XmlElementNames.Manifests,
XmlNodeType.Element,
reader.LocalName,
reader.NodeType));
}
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();
if (exchange2013Response)
{
this.ReadFromExchange2013(reader);
}
else
{
this.ReadFromExchange2013Sp1(reader);
}
}
reader.EnsureCurrentNodeIsEndElement(XmlNamespace.Messages, exchange2013Response ? XmlElementNames.Manifests : XmlElementNames.Apps);
}
/// <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);
if (!reader.IsEmptyElement)
{
do
{
reader.Read();
if (reader.IsStartElement())
{
TEntry entry = this.CreateEntry(reader);
if (entry != null)
{
entry.LoadFromXml(reader, reader.LocalName);
this.InternalAdd(entry);
}
else
{
reader.SkipCurrentElement();
}
}
}while (!reader.IsEndElement(XmlNamespace.Types, localElementName));
}
}
/// <summary>
/// Loads extra error details from XML
/// </summary>
/// <param name="reader">The reader.</param>
/// <param name="xmlElementName">The current element name of the extra error details.</param>
/// <returns>
/// True if the expected extra details is loaded;
/// False if the element name does not match the expected element.
/// </returns>
internal override bool LoadExtraErrorDetailsFromXml(EwsServiceXmlReader reader, string xmlElementName)
{
bool baseReturnVal = base.LoadExtraErrorDetailsFromXml(reader, xmlElementName);
if (reader.IsStartElement(XmlNamespace.Messages, XmlElementNames.ErrorSubscriptionIds))
{
do
{
reader.Read();
if (reader.NodeType == System.Xml.XmlNodeType.Element &&
reader.LocalName == XmlElementNames.SubscriptionId)
{
this.ErrorSubscriptionIds.Add(
reader.ReadElementValue(XmlNamespace.Messages, XmlElementNames.SubscriptionId));
}
}while (!reader.IsEndElement(XmlNamespace.Messages, XmlElementNames.ErrorSubscriptionIds));
return(true);
}
else
{
return(baseReturnVal);
}
}
/// <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>
/// 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.UserOptions:
if (!reader.IsEmptyElement)
{
do
{
reader.Read();
if (reader.IsStartElement(XmlNamespace.Types, XmlElementNames.VotingOptionData))
{
VotingOptionData option = new VotingOptionData();
option.LoadFromXml(reader, reader.LocalName);
this.userOptions.Add(option);
}
}while (!reader.IsEndElement(XmlNamespace.Types, XmlElementNames.UserOptions));
}
return(true);
case XmlElementNames.VotingResponse:
this.votingResponse = reader.ReadElementValue <string>();
return(true);
default:
return(false);
}
}
/// <summary>
/// Read attribution blobs from XML
/// </summary>
/// <param name="reader">XML reader</param>
/// <returns>Whether reading succeeded</returns>
internal bool LoadAttributionsFromXml(EwsServiceXmlReader reader)
{
if (!reader.IsEmptyElement)
{
string localName = reader.LocalName;
this.attributionList = new List <string>();
do
{
reader.Read();
if (reader.NodeType == XmlNodeType.Element &&
reader.LocalName == XmlElementNames.Attribution)
{
string s = reader.ReadElementValue();
if (!string.IsNullOrEmpty(s))
{
this.attributionList.Add(s);
}
}
}while (!reader.IsEndElement(XmlNamespace.Types, localName));
this.Attributions = this.attributionList.ToArray();
}
return(true);
}
/// <summary>
/// Loads from XML
/// </summary>
/// <param name="reader">The reader.</param>
/// <param name="xmlNamespace">The XML namespace.</param>
/// <param name="xmlElementName">Name of the XML element.</param>
/// <param name="readAction"></param>
private void InternalLoadFromXml(
EwsServiceXmlReader reader,
XmlNamespace xmlNamespace,
string xmlElementName,
Func <EwsServiceXmlReader, bool> readAction)
{
reader.EnsureCurrentNodeIsStartElement(xmlNamespace, xmlElementName);
this.ReadAttributesFromXml(reader);
if (!reader.IsEmptyElement)
{
do
{
reader.Read();
switch (reader.NodeType)
{
case XmlNodeType.Element:
if (!readAction(reader))
{
reader.SkipCurrentElement();
}
break;
case XmlNodeType.Text:
this.ReadTextValueFromXml(reader);
break;
}
}while (!reader.IsEndElement(xmlNamespace, xmlElementName));
}
}
/// <summary>
/// Load from xml.
/// </summary>
/// <param name="reader">The reader.</param>
/// <returns>Retention policy tag object.</returns>
internal static RetentionPolicyTag LoadFromXml(EwsServiceXmlReader reader)
{
reader.EnsureCurrentNodeIsStartElement(XmlNamespace.Types, XmlElementNames.RetentionPolicyTag);
RetentionPolicyTag retentionPolicyTag = new RetentionPolicyTag();
retentionPolicyTag.DisplayName = reader.ReadElementValue(XmlNamespace.Types, XmlElementNames.DisplayName);
retentionPolicyTag.RetentionId = new Guid(reader.ReadElementValue(XmlNamespace.Types, XmlElementNames.RetentionId));
retentionPolicyTag.RetentionPeriod = reader.ReadElementValue <int>(XmlNamespace.Types, XmlElementNames.RetentionPeriod);
retentionPolicyTag.Type = reader.ReadElementValue <ElcFolderType>(XmlNamespace.Types, XmlElementNames.Type);
retentionPolicyTag.RetentionAction = reader.ReadElementValue <RetentionActionType>(XmlNamespace.Types, XmlElementNames.RetentionAction);
// Description is not a required property.
reader.Read();
if (reader.IsStartElement(XmlNamespace.Types, XmlElementNames.Description))
{
retentionPolicyTag.Description = reader.ReadElementValue(XmlNamespace.Types, XmlElementNames.Description);
}
retentionPolicyTag.IsVisible = reader.ReadElementValue <bool>(XmlNamespace.Types, XmlElementNames.IsVisible);
retentionPolicyTag.OptedInto = reader.ReadElementValue <bool>(XmlNamespace.Types, XmlElementNames.OptedInto);
retentionPolicyTag.IsArchive = reader.ReadElementValue <bool>(XmlNamespace.Types, XmlElementNames.IsArchive);
return(retentionPolicyTag);
}
/// <summary>
/// Loads from XML.
/// </summary>
/// <param name="reader">The reader.</param>
/// <param name="xmlNamespace">The XML namespace.</param>
/// <param name="localElementName">Name of the local element.</param>
internal override void LoadFromXml(
EwsServiceXmlReader reader,
XmlNamespace xmlNamespace,
string localElementName)
{
reader.EnsureCurrentNodeIsStartElement(xmlNamespace, localElementName);
if (!reader.IsEmptyElement)
{
do
{
reader.Read();
if (reader.IsStartElement())
{
TComplexProperty complexProperty = this.CreateComplexProperty(reader.LocalName);
if (complexProperty != null)
{
complexProperty.LoadFromXml(reader, reader.LocalName);
this.InternalAdd(complexProperty, true);
}
else
{
reader.SkipCurrentElement();
}
}
}while (!reader.IsEndElement(xmlNamespace, localElementName));
}
}
/// <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)
{
bool result = base.TryReadElementFromXml(reader);
if (!result)
{
if (reader.LocalName == XmlElementNames.FieldURIOrConstant)
{
reader.Read();
reader.EnsureCurrentNodeIsStartElement();
if (reader.IsStartElement(XmlNamespace.Types, XmlElementNames.Constant))
{
this.value = reader.ReadAttributeValue(XmlAttributeNames.Value);
result = true;
}
else
{
result = PropertyDefinitionBase.TryLoadFromXml(reader, ref this.otherPropertyDefinition);
}
}
}
return(result);
}
/// <summary>
/// Loads from XML to update itself.
/// </summary>
/// <param name="reader">The reader.</param>
/// <param name="xmlNamespace">The XML namespace.</param>
/// <param name="xmlElementName">Name of the XML element.</param>
internal override void UpdateFromXml(
EwsServiceXmlReader reader,
XmlNamespace xmlNamespace,
string xmlElementName)
{
reader.EnsureCurrentNodeIsStartElement(xmlNamespace, xmlElementName);
if (!reader.IsEmptyElement)
{
int index = 0;
do
{
reader.Read();
if (reader.IsStartElement())
{
TComplexProperty complexProperty = this.CreateComplexProperty(reader.LocalName);
TComplexProperty actualComplexProperty = this[index++];
if (complexProperty == null || !complexProperty.GetType().IsInstanceOfType(actualComplexProperty))
{
throw new ServiceLocalException(Strings.PropertyTypeIncompatibleWhenUpdatingCollection);
}
actualComplexProperty.UpdateFromXml(reader, xmlNamespace, reader.LocalName);
}
}while (!reader.IsEndElement(xmlNamespace, xmlElementName));
}
}
/// <summary>
/// Read the response from Exchange 2013.
/// This method assumes that the reader is currently at the Manifests element.
/// </summary>
/// <param name="reader">The reader.</param>
private void ReadFromExchange2013Sp1(EwsServiceXmlReader reader)
{
////<GetAppManifestsResponse ResponseClass="Success" xmlns="http://schemas.microsoft.com/exchange/services/2006/messages">
//// <ResponseCode>NoError</ResponseCode>
//// <m:Apps xmlns:m="http://schemas.microsoft.com/exchange/services/2006/messages">
//// <t:App xmlns:t="http://schemas.microsoft.com/exchange/services/2006/types"> <--- reader should be at this node at the beginning of the loop
//// <t:Metadata>
//// <t:EndNodeUrl>http://o15.officeredir.microsoft.com/r/rlidMktplcExchRedirect?app=outlook.exe&ver=15&clid=1033&p1=15d0d766d0&p2=4&p3=0&p4=WA&p5=en-US\WA102996382&Scope=2&CallBackURL=https%3a%2f%2fexhv-4880%2fecp%2fExtension%2finstallFromURL.slab%3fexsvurl%3d1&DeployId=EXHV-4680dom.extest.microsoft.com</t:EndNodeUrl>
//// <t:AppStatus>2.3</t:AppStatus>
//// <t:ActionUrl>http://o15.officeredir.microsoft.com/r/rlidMktplcExchRedirect?app=outlook.exe&ver=15&clid=1033&p1=15d0d766d0&p2=4&p3=0&p4=WA&p5=en-US\WA102996382&Scope=2&CallBackURL=https%3a%2f%2fexhv-4880%2fecp%2fExtension%2finstallFromURL.slab%3fexsvurl%3d1&DeployId=EXHV-4680dom.extest.microsoft.com</t:ActionUrl>
//// </t:Metadata>
//// <t:Manifest>[base 64 encoded manifest]</t:Manifest>
//// </t:App>
//// <t:App xmlns:t="http://schemas.microsoft.com/exchange/services/2006/types">
//// ....
//// <m:Apps> <----- reader should be at this node at the end of the loop
while (reader.IsStartElement(XmlNamespace.Types, XmlElementNames.App))
{
ClientApp clientApp = new ClientApp();
clientApp.LoadFromXml(reader, XmlElementNames.App);
this.Apps.Add(clientApp);
this.Manifests.Add(clientApp.Manifest);
reader.EnsureCurrentNodeIsEndElement(XmlNamespace.Types, XmlElementNames.App);
reader.Read();
}
}
/// <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);
if (!reader.IsEmptyElement)
{
do
{
reader.Read();
if (reader.NodeType == XmlNodeType.Element)
{
TItem item = EwsUtilities.CreateEwsObjectFromXmlElementName <Item>(
reader.Service,
reader.LocalName) as TItem;
if (item == null)
{
reader.SkipCurrentElement();
}
else
{
item.LoadFromXml(reader, true /* clearPropertyBag */);
this.items.Add(item);
}
}
}while (!reader.IsEndElement(XmlNamespace.Types, localElementName));
}
}
/// <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;
default:
return(false);
}
}
else
{
return(false);
}
} while (!reader.IsEndElement(XmlNamespace.Messages, XmlElementNames.ItemList));
return(true);
}
/// <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.TimeZone:
LegacyAvailabilityTimeZone legacyTimeZone = new LegacyAvailabilityTimeZone();
legacyTimeZone.LoadFromXml(reader, reader.LocalName);
this.timeZone = legacyTimeZone.ToTimeZoneInfo();
return(true);
case XmlElementNames.WorkingPeriodArray:
List <WorkingPeriod> workingPeriods = new List <WorkingPeriod>();
do
{
reader.Read();
if (reader.IsStartElement(XmlNamespace.Types, XmlElementNames.WorkingPeriod))
{
WorkingPeriod workingPeriod = new WorkingPeriod();
workingPeriod.LoadFromXml(reader, reader.LocalName);
workingPeriods.Add(workingPeriod);
}
}while (!reader.IsEndElement(XmlNamespace.Types, XmlElementNames.WorkingPeriodArray));
// Availability supports a structure that can technically represent different working
// times for each day of the week. This is apparently how the information is stored in
// Exchange. However, no client (Outlook, OWA) either will let you specify different
// working times for each day of the week, and Outlook won't either honor that complex
// structure if it happens to be in Exchange.
// So here we'll do what Outlook and OWA do: we'll use the start and end times of the
// first working period, but we'll use the week days of all the periods.
this.startTime = workingPeriods[0].StartTime;
this.endTime = workingPeriods[0].EndTime;
foreach (WorkingPeriod workingPeriod in workingPeriods)
{
foreach (DayOfTheWeek dayOfWeek in workingPeriods[0].DaysOfWeek)
{
if (!this.daysOfTheWeek.Contains(dayOfWeek))
{
this.daysOfTheWeek.Add(dayOfWeek);
}
}
}
return(true);
default:
return(false);
}
}
/// <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>
/// Loads from XML.
/// </summary>
/// <param name="reader">The reader.</param>
internal void LoadFromXml(EwsServiceXmlReader reader)
{
do
{
reader.Read();
if (reader.NodeType == XmlNodeType.Element)
{
this.TryReadElementFromXml(reader);
}
}while (!reader.IsEndElement(XmlNamespace.Types, XmlElementNames.PersonaPostalAddress));
}
/// <summary>
/// Load from XML.
/// </summary>
/// <param name="reader">The reader.</param>
internal override void InternalLoadFromXml(EwsServiceXmlReader reader)
{
base.InternalLoadFromXml(reader);
this.folderId = new FolderId();
this.folderId.LoadFromXml(reader, reader.LocalName);
reader.Read();
this.ParentFolderId = new FolderId();
this.ParentFolderId.LoadFromXml(reader, XmlElementNames.ParentFolderId);
switch (this.EventType)
{
case EventType.Moved:
case EventType.Copied:
reader.Read();
this.oldFolderId = new FolderId();
this.oldFolderId.LoadFromXml(reader, reader.LocalName);
reader.Read();
this.OldParentFolderId = new FolderId();
this.OldParentFolderId.LoadFromXml(reader, reader.LocalName);
break;
case EventType.Modified:
reader.Read();
if (reader.IsStartElement())
{
reader.EnsureCurrentNodeIsStartElement(XmlNamespace.Types, XmlElementNames.UnreadCount);
this.unreadCount = int.Parse(reader.ReadValue());
}
break;
default:
break;
}
}
