public static void ProcessRecord(Action action, ManageInboxRule.ThrowTerminatingErrorDelegate handleError, object identity) { try { action(); } catch (InboxRuleOperationException ex) { handleError(new InvalidOperationException(ex.Message), ErrorCategory.InvalidOperation, identity); } catch (RulesTooBigException) { handleError(new InvalidOperationException(Strings.ErrorInboxRuleTooBig), ErrorCategory.InvalidOperation, identity); } }
public static void VerifyRange <T>(T min, T max, bool allowEqual, ManageInboxRule.ThrowTerminatingErrorDelegate errorHandler, LocalizedString errorMessage) { if (min == null || max == null) { return; } int num = ((IComparable)((object)min)).CompareTo(max); if (!allowEqual && num == 0) { errorHandler(new LocalizedException(errorMessage), ErrorCategory.InvalidArgument, null); } if (num > 0) { errorHandler(new LocalizedException(errorMessage), ErrorCategory.InvalidArgument, null); } }
internal void ValidateInterdependentParameters(ManageInboxRule.ThrowTerminatingErrorDelegate writeError) { if (base.IsModified(InboxRuleSchema.ReceivedAfterDate) || base.IsModified(InboxRuleSchema.ReceivedBeforeDate)) { ManageInboxRule.VerifyRange <ExDateTime?>(this.ReceivedAfterDate, this.ReceivedBeforeDate, false, writeError, Strings.ErrorInvalidDateRangeCondition); } if (base.IsModified(InboxRuleSchema.ExceptIfReceivedAfterDate) || base.IsModified(InboxRuleSchema.ExceptIfReceivedBeforeDate)) { ManageInboxRule.VerifyRange <ExDateTime?>(this.ExceptIfReceivedAfterDate, this.ExceptIfReceivedBeforeDate, false, writeError, Strings.ErrorInvalidDateRangeException); } if (base.IsModified(InboxRuleSchema.WithinSizeRangeMinimum) || base.IsModified(InboxRuleSchema.WithinSizeRangeMaximum)) { ManageInboxRule.VerifyRange <ByteQuantifiedSize?>(this.WithinSizeRangeMinimum, this.WithinSizeRangeMaximum, true, writeError, Strings.ErrorInvalidSizeRangeCondition); } if (base.IsModified(InboxRuleSchema.ExceptIfWithinSizeRangeMinimum) || base.IsModified(InboxRuleSchema.ExceptIfWithinSizeRangeMaximum)) { ManageInboxRule.VerifyRange <ByteQuantifiedSize?>(this.ExceptIfWithinSizeRangeMinimum, this.ExceptIfWithinSizeRangeMaximum, true, writeError, Strings.ErrorInvalidSizeRangeException); } }
public static ADRecipientOrAddress[] ResolveRecipients(IList <RecipientIdParameter> recipientIDs, DataAccessHelper.GetDataObjectDelegate getRecipientObject, IRecipientSession recipientSession, ManageInboxRule.ThrowTerminatingErrorDelegate errorHandler) { if (recipientIDs == null || recipientIDs.Count == 0) { return(null); } ADRecipientOrAddress[] array = new ADRecipientOrAddress[recipientIDs.Count]; int num = 0; foreach (RecipientIdParameter recipientIdParameter in recipientIDs) { try { recipientIdParameter.SearchWithDisplayName = false; ADRecipient adEntry = (ADRecipient)getRecipientObject(recipientIdParameter, recipientSession, null, null, new LocalizedString?(Strings.ErrorRecipientNotFound(recipientIdParameter.ToString())), new LocalizedString?(Strings.ErrorRecipientNotUnique(recipientIdParameter.ToString()))); array[num++] = new ADRecipientOrAddress(new Participant(adEntry)); } catch (ManagementObjectNotFoundException) { MimeRecipient mimeRecipient = null; try { mimeRecipient = MimeRecipient.Parse(recipientIdParameter.RawIdentity, AddressParserFlags.IgnoreComments | AddressParserFlags.AllowSquareBrackets); } catch (MimeException) { } if (mimeRecipient == null || string.IsNullOrEmpty(mimeRecipient.Email) || !SmtpAddress.IsValidSmtpAddress(mimeRecipient.Email)) { errorHandler(new LocalizedException(Strings.ErrorInboxRuleUserInvalid(recipientIdParameter.ToString())), ErrorCategory.InvalidArgument, null); } string text = string.Empty; try { text = mimeRecipient.DisplayName; } catch (MimeException) { } if (string.IsNullOrEmpty(text)) { text = mimeRecipient.Email; } array[num++] = new ADRecipientOrAddress(new Participant(text, mimeRecipient.Email, "smtp")); } } return(array); }
public static MailboxFolder ResolveMailboxFolder(MailboxFolderIdParameter folderId, DataAccessHelper.GetDataObjectDelegate getUserHandler, DataAccessHelper.GetDataObjectDelegate getFolderHandler, IRecipientSession resolveUserSession, ADSessionSettings sessionSettings, ADUser adUser, ManageInboxRule.ThrowTerminatingErrorDelegate errorHandler) { if (!ManageInboxRule.TryValidateFolderId(folderId, getUserHandler, getFolderHandler, resolveUserSession, adUser, errorHandler)) { return(null); } MailboxFolder result; using (MailboxFolderDataProvider mailboxFolderDataProvider = new MailboxFolderDataProvider(sessionSettings, adUser, "ResolveMailboxFolder")) { result = (MailboxFolder)getFolderHandler(folderId, mailboxFolderDataProvider, null, null, new LocalizedString?(Strings.ErrorMailboxFolderNotFound(folderId.ToString())), new LocalizedString?(Strings.ErrorMailboxFolderNotUnique(folderId.ToString()))); } return(result); }
private static bool TryValidateFolderId(MailboxFolderIdParameter folderId, DataAccessHelper.GetDataObjectDelegate getUserHandler, DataAccessHelper.GetDataObjectDelegate getFolderHandler, IRecipientSession resolveUserSession, ADUser adUser, ManageInboxRule.ThrowTerminatingErrorDelegate errorHandler) { if (folderId != null) { if (folderId.RawOwner != null) { ADUser aduser = (ADUser)getUserHandler(folderId.RawOwner, resolveUserSession, null, null, new LocalizedString?(Strings.ErrorMailboxNotFound(folderId.RawOwner.ToString())), new LocalizedString?(Strings.ErrorMailboxNotUnique(folderId.RawOwner.ToString()))); if (!aduser.Identity.Equals(adUser.Identity)) { errorHandler(new LocalizedException(Strings.ErrorConflictingMailboxFolder(adUser.Identity.ToString(), folderId.ToString())), ErrorCategory.InvalidOperation, null); } } if (folderId.InternalMailboxFolderId == null) { folderId.InternalMailboxFolderId = new Microsoft.Exchange.Data.Storage.Management.MailboxFolderId(adUser.Id, folderId.RawFolderStoreId, folderId.RawFolderPath); } return(true); } return(false); }
public static AggregationSubscriptionIdentity[] ResolveSubscriptions(ICollection <AggregationSubscriptionIdentity> ids, ADUser mailboxOwner, ManageInboxRule.ThrowTerminatingErrorDelegate errorHandler) { if (ids == null || ids.Count == 0) { return(new AggregationSubscriptionIdentity[0]); } List <AggregationSubscriptionIdentity> list = new List <AggregationSubscriptionIdentity>(ids.Count); PimSubscriptionProxy[] allSubscriptions = InboxRuleDataProvider.GetAllSubscriptions(mailboxOwner); List <AggregationSubscriptionIdentity> list2 = new List <AggregationSubscriptionIdentity>(allSubscriptions.Length); foreach (PimSubscriptionProxy pimSubscriptionProxy in allSubscriptions) { list2.Add(pimSubscriptionProxy.Subscription.SubscriptionIdentity); } foreach (AggregationSubscriptionIdentity aggregationSubscriptionIdentity in ids) { if (!list2.Contains(aggregationSubscriptionIdentity)) { errorHandler(new LocalizedException(Strings.InvalidSubscription(aggregationSubscriptionIdentity.ToString())), ErrorCategory.InvalidArgument, null); } else if (!list.Contains(aggregationSubscriptionIdentity)) { list.Add(aggregationSubscriptionIdentity); } } return(list.ToArray()); }
public static MessageClassification[] ResolveMessageClassifications(ICollection <MessageClassificationIdParameter> ids, IConfigurationSession configurationSession, ManageInboxRule.ThrowTerminatingErrorDelegate errorHandler) { if (ids == null || ids.Count == 0) { return(new MessageClassification[0]); } ADObjectId rootId = MessageClassificationIdParameter.DefaultRoot(configurationSession); List <MessageClassification> list = new List <MessageClassification>(ids.Count); foreach (MessageClassificationIdParameter messageClassificationIdParameter in ids) { IEnumerable <MessageClassification> objects = messageClassificationIdParameter.GetObjects <MessageClassification>(rootId, configurationSession); using (IEnumerator <MessageClassification> enumerator2 = objects.GetEnumerator()) { if (!enumerator2.MoveNext()) { errorHandler(new LocalizedException(Strings.InvalidMessageClassification(messageClassificationIdParameter.ToString())), ErrorCategory.InvalidArgument, null); } do { list.Add(enumerator2.Current); }while (enumerator2.MoveNext()); } } return(list.ToArray()); }