/// <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) { 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> /// 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> /// 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> /// <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 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> /// 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> /// 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> /// 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> /// 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> /// 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> /// 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> /// 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> /// 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> /// Reads response elements from XML. /// </summary> /// <param name="reader">The reader.</param> internal override void ReadElementsFromXml(EwsServiceXmlReader reader) { base.ReadElementsFromXml(reader); if (this.ErrorCode == ServiceError.NoError && reader.IsStartElement(XmlNamespace.NotSpecified, XmlElementNames.WasFirstInstall)) { this.wasFirstInstall = reader.ReadElementValue <bool>(XmlNamespace.NotSpecified, XmlElementNames.WasFirstInstall); } }
/// <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> /// 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 virtual bool LoadExtraErrorDetailsFromXml(EwsServiceXmlReader reader, string xmlElementName) { if (reader.IsStartElement(XmlNamespace.Messages, XmlElementNames.MessageXml) && !reader.IsEmptyElement) { this.ParseMessageXml(reader); return(true); } else { 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.Read(); if (reader.IsStartElement(XmlNamespace.Messages, XmlElementNames.MovedItemId)) { this.MovedItemId = new ItemId(); this.MovedItemId.LoadFromXml(reader, XmlNamespace.Messages, XmlElementNames.MovedItemId); reader.ReadEndElementIfNecessary(XmlNamespace.Messages, XmlElementNames.MovedItemId); } }
/// <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) { if (reader.IsStartElement(XmlNamespace.Types, XmlElementNames.Rule)) { Rule rule = new Rule(); rule.LoadFromXml(reader, XmlElementNames.Rule); this.rules.Add(rule); return(true); } else { return(false); } }
/// <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> /// 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 from xml /// </summary> /// <param name="reader">The reader</param> /// <returns>Non indexable item details result object</returns> internal static NonIndexableItemDetailsResult LoadFromXml(EwsServiceXmlReader reader) { NonIndexableItemDetailsResult nonIndexableItemDetailsResult = new NonIndexableItemDetailsResult(); reader.ReadStartElement(XmlNamespace.Messages, XmlElementNames.NonIndexableItemDetailsResult); do { reader.Read(); if (reader.IsStartElement(XmlNamespace.Types, XmlElementNames.Items)) { List <NonIndexableItem> nonIndexableItems = new List <NonIndexableItem>(); if (!reader.IsEmptyElement) { do { reader.Read(); NonIndexableItem nonIndexableItem = NonIndexableItem.LoadFromXml(reader); if (nonIndexableItem != null) { nonIndexableItems.Add(nonIndexableItem); } }while (!reader.IsEndElement(XmlNamespace.Types, XmlElementNames.Items)); nonIndexableItemDetailsResult.Items = nonIndexableItems.ToArray(); } } if (reader.IsStartElement(XmlNamespace.Types, XmlElementNames.FailedMailboxes)) { nonIndexableItemDetailsResult.FailedMailboxes = FailedSearchMailbox.LoadFailedMailboxesXml(XmlNamespace.Types, reader); } }while (!reader.IsEndElement(XmlNamespace.Messages, XmlElementNames.NonIndexableItemDetailsResult)); return(nonIndexableItemDetailsResult); }
/// <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> /// 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> /// Load extended properties xml /// </summary> /// <param name="reader">The reader</param> /// <returns>Extended properties collection</returns> private static ExtendedPropertyCollection LoadExtendedPropertiesXml(EwsServiceXmlReader reader) { ExtendedPropertyCollection extendedProperties = new ExtendedPropertyCollection(); reader.EnsureCurrentNodeIsStartElement(XmlNamespace.Types, XmlElementNames.ExtendedProperties); do { reader.Read(); if (reader.IsStartElement(XmlNamespace.Types, XmlElementNames.ExtendedProperty)) { extendedProperties.LoadFromXml(reader, XmlElementNames.ExtendedProperty); } }while (!reader.IsEndElement(XmlNamespace.Types, XmlElementNames.ExtendedProperties)); return(extendedProperties.Count == 0 ? null : extendedProperties); }
/// <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> /// Get collection of recipients /// </summary> /// <param name="reader">The reader</param> /// <param name="elementName">Element name</param> /// <returns>Array of recipients</returns> private static string[] GetRecipients(EwsServiceXmlReader reader, string elementName) { List <string> toRecipients = new List <string>(); do { if (reader.IsStartElement(XmlNamespace.Types, XmlElementNames.SmtpAddress)) { toRecipients.Add(reader.ReadElementValue(XmlNamespace.Types, XmlElementNames.SmtpAddress)); } reader.Read(); }while (!reader.IsEndElement(XmlNamespace.Types, elementName)); return(toRecipients.Count == 0 ? null : toRecipients.ToArray()); }