Gérer les règles de boîte de réception à l’aide d’EWS dans Exchange
Découvrez comment obtenir, créer, mettre à jour et supprimer des règles de boîte de réception à l’aide de l’API managée EWS ou EWS dans Exchange.
Vous pouvez obtenir, créer, mettre à jour et supprimer des règles de boîte de réception à l’aide de l’API managée EWS ou EWS. Quelle que soit la technologie que vous utilisez, vous obtenez et modifiez des règles de boîte de réception en tant que collection, plutôt qu’individuellement. Vous utilisez la même méthode ou opération pour créer des règles, mettre à jour des règles existantes et supprimer des règles.
Tableau 1. Méthodes et opérations pour obtenir et modifier des règles de boîte de réception
| Afin de... | Méthode d'API managée EWS | Opération EWS |
|---|---|---|
| Obtenir des règles de boîte de réception |
ExchangeService.GetInboxRules |
GetInboxRules |
| Créer, mettre à jour ou supprimer des règles de boîte de réception |
ExchangeService.UpdateInboxRules |
UpdateInboxRules |
Pour créer, mettre à jour ou supprimer des règles de boîte de réception à l’aide de l’API managée EWS ou EWS, vous devez supprimer la règle Outlook, si elle existe. Si vous utilisez l’API managée EWS, vous devez définir le paramètre removeOutlookRulesBlob sur true dans l’appel de méthode ExchangeService.UpdateInboxRules . Si vous utilisez EWS, vous définissez la valeur de l’élément RemoveOutlookRuleBlob sur true dans l’opération UpdateInboxRules . Nous vous recommandons de vérifier la propriété RuleCollection.OutlookRuleBlobExists (si vous utilisez l’API managée EWS) ou l’élément OutlookRuleBlobExists (si vous utilisez EWS) avant de mettre à jour les règles de boîte de réception. Si cette propriété ou cet élément a la valeur true, votre application doit avertir l’utilisateur que toutes les règles désactivées seront perdues dans le cadre de la mise à jour et continuer uniquement avec son autorisation.
Lorsque vous appelez la méthode UpdateInboxRules , EWS supprime les règles d’envoi côté client. Les règles d’envoi côté client sont stockées sur le client dans le message FAI (Folder Associated Information) de règle et nulle part ailleurs. EWS supprime ce message FAI de règle par défaut, en fonction de l’attente qu’Outlook le recrée. Toutefois, Outlook ne peut pas recréer des règles qui n’existent pas en tant que règle étendue, et les règles d’envoi côté client n’existent pas en tant que règles étendues. Par conséquent, ces règles sont perdues. Nous vous suggérons d’en tenir compte lors de la conception de votre solution.
Remarque
Les exemples de code d’API managée EWS de cet article utilisent un ensemble commun de méthodes utilitaires. Ces méthodes sont omises des exemples de code par souci de concision.
Obtenir des règles de boîte de réception à l’aide de l’API managée EWS
Pour obtenir les règles de boîte de réception actuelles, utilisez la méthode ExchangeService.GetInboxRules . Cette méthode renvoie un objet RuleCollection qui contient toutes les règles de boîte de réception actuelles.
Dans cet exemple, chaque règle de la boîte de réception active est passée à une fonction d’assistance ( ParseRuleDetails ) pour afficher les détails de la règle.
using System;
using System.Collections.Generic;
using Microsoft.Exchange.WebServices.Data;
private static void GetInboxRules(ExchangeService service, string emailAddress)
{
RuleCollection inboxRules = null;
Console.WriteLine("Retrieving inbox rules...");
// Get the rules from the user's Inbox.
try
{
inboxRules = service.GetInboxRules(emailAddress);
}
catch (ServiceResponseException ex)
{
Console.WriteLine("Error getting inbox rules: {0}", ex.ErrorCode.ToString());
return;
}
// Loop through the rules and print out the details of each.
foreach (Rule rule in inboxRules)
{
Console.WriteLine("\n***************************************************************");
Console.WriteLine("Rule: {0}", rule.DisplayName);
Console.WriteLine("Rule ID: {0}", rule.Id);
Console.WriteLine("Priority: {0}", rule.Priority);
Console.WriteLine("Enabled: {0}", rule.IsEnabled.ToString());
Console.WriteLine("Error: {0}", rule.IsInError.ToString());
Console.WriteLine("Supported: {0}", (!rule.IsNotSupported).ToString());
ParseRuleDetails(service, rule);
}
}
Obtenir des règles de boîte de réception à l’aide d’EWS
La requête SOAP EWS suivante utilise l’opération GetInboxRules pour récupérer les règles de boîte de réception pour sadie@contoso.com.
<?xml version="1.0" encoding="utf-8"?>
<soap:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:m="https://schemas.microsoft.com/exchange/services/2006/messages"
xmlns:t="https://schemas.microsoft.com/exchange/services/2006/types"
xmlns:soap="https://schemas.xmlsoap.org/soap/envelope/">
<soap:Header>
<t:RequestServerVersion Version="Exchange2013" />
</soap:Header>
<soap:Body>
<m:GetInboxRules>
<m:MailboxSmtpAddress>sadie@contoso.com</m:MailboxSmtpAddress>
</m:GetInboxRules>
</soap:Body>
</soap:Envelope>
La réponse SOAP EWS suivante contient les règles de boîte de réception actuelles pour sadie@contoso.com.
<?xml version="1.0" encoding="utf-8"?>
<s:Envelope xmlns:s="https://schemas.xmlsoap.org/soap/envelope/">
<s:Header>
<h:ServerVersionInfo MajorVersion="15" MinorVersion="0" MajorBuildNumber="712" MinorBuildNumber="22" Version="V2_3"
xmlns:h="https://schemas.microsoft.com/exchange/services/2006/types"
xmlns="https://schemas.microsoft.com/exchange/services/2006/types"
xmlns:xsd="http://www.w3.org/2001/XMLSchema"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" />
</s:Header>
<s:Body xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
<GetInboxRulesResponse ResponseClass="Success" xmlns="https://schemas.microsoft.com/exchange/services/2006/messages">
<ResponseCode>NoError</ResponseCode>
<OutlookRuleBlobExists>false</OutlookRuleBlobExists>
<InboxRules>
<Rule xmlns="https://schemas.microsoft.com/exchange/services/2006/types">
<RuleId>AQAAAAAAASY=</RuleId>
<DisplayName>Alfred</DisplayName>
<Priority>1</Priority>
<IsEnabled>true</IsEnabled>
<Conditions>
<FromAddresses>
<Address>
<Name>Alfred Welker</Name>
<EmailAddress>/o=First Organization/ou=Exchange Administrative Group (FYDIBOHF23SPDLT)/cn=Recipients/cn=9a83e6380cae41918c71e7921d960b5a-Alfre</EmailAddress>
<RoutingType>EX</RoutingType>
</Address>
</FromAddresses>
</Conditions>
<Actions>
<MoveToFolder>
<FolderId Id="AAMkADg1OWUwODcyLTg4M2MtNDAyMS05YjI0LTI5ZGM5OTU4Njk3YwAuAAAAAADPriAxh444TpHj2GoQxWQNAQAN+VjmVZl5Rq1ymCq5eFKOAAAAABSyAAA=" ChangeKey="AQAAAA==" />
</MoveToFolder>
<StopProcessingRules>true</StopProcessingRules>
</Actions>
</Rule>
<Rule xmlns="https://schemas.microsoft.com/exchange/services/2006/types">
<RuleId>AQAAAAAAASQ=</RuleId>
<DisplayName>Important</DisplayName>
<Priority>2</Priority>
<IsEnabled>true</IsEnabled>
<Conditions>
<ContainsSubjectStrings>
<String>Urgent</String>
</ContainsSubjectStrings>
<FromAddresses>
<Address>
<Name>Hope Gross</Name>
<EmailAddress>/o=First Organization/ou=Exchange Administrative Group (FYDIBOHF23SPDLT)/cn=Recipients/cn=9b55e4100c064d9d8c5f72ff36802ed3-Hope</EmailAddress>
<RoutingType>EX</RoutingType>
</Address>
</FromAddresses>
</Conditions>
<Actions>
<MarkImportance>High</MarkImportance>
<StopProcessingRules>true</StopProcessingRules>
</Actions>
</Rule>
</InboxRules>
</GetInboxRulesResponse>
</s:Body>
</s:Envelope>
Créer des règles de boîte de réception à l’aide de l’API managée EWS
Pour créer une règle, incluez un objet CreateRuleOperation dans la collection d’objets RuleOperation passés à la méthode ExchangeService.UpdateInboxRules .
Dans cet exemple, une nouvelle règle est créée pour déplacer les messages envoyés vers une liste de distribution appelée « Sales » vers un sous-dossier de la boîte de réception, également appelé « Sales ».
using System;
using System.Collections.Generic;
using Microsoft.Exchange.WebServices.Data;
private static void CreateInboxRule(ExchangeService service, string emailAddress)
{
// Before modifying the rules on the server, determine
// whether an Outlook rules BLOB exists. Updating rules
// via EWS requires removal of the Outlook BLOB. This can
// result in any rules that the user has disabled via the Outlook
// UI to be lost.
RuleCollection currentRules = null;
try
{
currentRules = service.GetInboxRules(emailAddress);
}
catch (ServiceResponseException ex)
{
Console.WriteLine("Error getting inbox rules: {0}", ex.ErrorCode.ToString());
}
if (currentRules != null && currentRules.OutlookRuleBlobExists)
{
Console.WriteLine("WARNING: Adding a new rule will delete the Outlook rule BLOB.");
Console.WriteLine("This can lead to a loss of any disabled rules.");
Console.Write("Hit Y to proceed (any other key to cancel): ");
ConsoleKeyInfo cki = Console.ReadKey();
if (cki.KeyChar != 'Y' && cki.KeyChar != 'y')
{
Console.WriteLine("\nCanceling addition of new rule...");
return;
}
Console.WriteLine();
}
Console.WriteLine("Adding \"Sales\" rule.");
Rule newRule = new Rule();
// Creating a rule called "Sales"
newRule.DisplayName = "Sales";
// Conditions
// When messages are sent to the "Sales" address (sales@contoso.com),
newRule.Conditions.SentToAddresses.Add("Sales", "sales@contoso.com");
FolderId moveToFolderId = GetFolderIdByName(service, WellKnownFolderName.Inbox, "Sales");
if (moveToFolderId == null)
{
throw new ArgumentException("Invalid subfolder specified");
}
// Actions
// Move the message to the "Sales" folder
newRule.Actions.MoveToFolder = moveToFolderId;
// And stop processing more rules
newRule.Actions.StopProcessingRules = true;
// Exceptions
// Except if the message is from Hope Gross (hope@contoso.com).
newRule.Exceptions.FromAddresses.Add("Hope Gross", "hope@contoso.com");
Console.WriteLine("Rule: {0}", newRule.DisplayName);
ParseRuleDetails(service, newRule);
// Add the new rule to the CreateRule operation.
CreateRuleOperation createMoveIfFromSalesRule = new CreateRuleOperation(newRule);
try
{
// Update rules. Note that this method can accept
// an array of rule operations, enabling you to batch
// updates.
service.UpdateInboxRules(new RuleOperation[] { createMoveIfFromSalesRule }, true);
}
catch (UpdateInboxRulesException ex)
{
Console.WriteLine("Error updating Inbox rules: {0}", ex.ErrorCode.ToString());
return;
}
Console.WriteLine("Rule added.");
}
Créer des règles de boîte de réception à l’aide d’EWS
La requête SOAP EWS suivante crée la règle « Sales » dans sadie@contoso.comla boîte de réception de .
<?xml version="1.0" encoding="utf-8"?>
<soap:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:m="https://schemas.microsoft.com/exchange/services/2006/messages"
xmlns:t="https://schemas.microsoft.com/exchange/services/2006/types"
xmlns:soap="https://schemas.xmlsoap.org/soap/envelope/">
<soap:Header>
<t:RequestServerVersion Version="Exchange2013" />
</soap:Header>
<soap:Body>
<m:UpdateInboxRules>
<m:RemoveOutlookRuleBlob>true</m:RemoveOutlookRuleBlob>
<m:Operations>
<t:CreateRuleOperation>
<t:Rule>
<t:DisplayName>Sales</t:DisplayName>
<t:Priority>1</t:Priority>
<t:IsEnabled>true</t:IsEnabled>
<t:IsInError>false</t:IsInError>
<t:Conditions>
<t:SentToAddresses>
<t:Address>
<t:Name>Sales</t:Name>
<t:EmailAddress>sales@contoso.com</t:EmailAddress>
</t:Address>
</t:SentToAddresses>
</t:Conditions>
<t:Exceptions>
<t:FromAddresses>
<t:Address>
<t:Name>Hope Gross</t:Name>
<t:EmailAddress>hope@contoso.com</t:EmailAddress>
</t:Address>
</t:FromAddresses>
</t:Exceptions>
<t:Actions>
<t:MoveToFolder>
<t:FolderId Id="AAMkADg1OWUwODcyLTg4M2MtNDAyMS05YjI0LTI5ZGM5OTU4Njk3YwAuAAAAAADPriAxh444TpHj2GoQxWQNAQAN+VjmVZl5Rq1ymCq5eFKOAAAAABSxAAA="
ChangeKey="AQAAABYAAAAN+VjmVZl5Rq1ymCq5eFKOAAAAABTZ" />
</t:MoveToFolder>
<t:StopProcessingRules>true</t:StopProcessingRules>
</t:Actions>
</t:Rule>
</t:CreateRuleOperation>
</m:Operations>
</m:UpdateInboxRules>
</soap:Body>
</soap:Envelope>
Mettre à jour les règles de boîte de réception à l’aide de l’API managée EWS
Pour mettre à jour une règle, incluez un objet SetRuleOperation dans la collection d’objets RuleOperation transmis à la méthode UpdateInboxRules .
Dans cet exemple, la règle « Sales » est mise à jour pour ajouter une exception. Si l’objet contient le mot « Urgent », les messages ne sont pas déplacés vers le sous-dossier « Ventes ».
using System;
using System.Collections.Generic;
using Microsoft.Exchange.WebServices.Data;
private static void UpdateInboxRule(ExchangeService service, string emailAddress)
{
// Before modifying the rules on the server, determine
// whether an Outlook rules BLOB exists. Updating rules
// via EWS requires removal of the Outlook BLOB. This can
// result in any rules that the user has disabled via the Outlook
// UI to be lost.
RuleCollection currentRules = null;
try
{
currentRules = service.GetInboxRules(emailAddress);
}
catch (ServiceResponseException ex)
{
Console.WriteLine("Error getting inbox rules: {0}", ex.ErrorCode.ToString());
}
if (currentRules != null && currentRules.OutlookRuleBlobExists)
{
Console.WriteLine("WARNING: Updating an existing rule will delete the Outlook rule BLOB.");
Console.WriteLine("This can lead to a loss of any disabled rules.");
Console.Write("Hit Y to proceed (any other key to cancel): ");
ConsoleKeyInfo cki = Console.ReadKey();
if (cki.KeyChar != 'Y' && cki.KeyChar != 'y')
{
Console.WriteLine("\nCanceling update of rule...");
return;
}
Console.WriteLine();
}
// Look for the rule called "Sales" and modify it
// to add an exception if "Urgent" is in the subject.
Console.WriteLine("Updating rule \"Sales\"...");
Rule ruleToUpdate = null;
foreach (Rule rule in currentRules)
{
if (rule.DisplayName == "Sales")
{
ruleToUpdate = rule;
break;
}
}
if (ruleToUpdate == null)
{
Console.WriteLine("Could not find a rule called \"Sales\", canceling update.");
return;
}
// Add the exception.
ruleToUpdate.Exceptions.ContainsSubjectStrings.Add("Urgent");
SetRuleOperation setRuleOperation = new SetRuleOperation(ruleToUpdate);
try
{
// Update rules. Note that this method can accept
// an array of rule operations, enabling you to batch
// updates.
service.UpdateInboxRules(new RuleOperation[] { setRuleOperation }, true);
}
catch (UpdateInboxRulesException ex)
{
Console.WriteLine("Error updating Inbox rules: {0}", ex.ErrorCode.ToString());
return;
}
Console.WriteLine("Rule updated.");
}
Mettre à jour les règles de boîte de réception à l’aide d’EWS
La requête SOAP EWS suivante met à jour la règle « Sales » dans sadie@contoso.comla boîte de réception de .
<?xml version="1.0" encoding="utf-8"?>
<soap:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:m="https://schemas.microsoft.com/exchange/services/2006/messages"
xmlns:t="https://schemas.microsoft.com/exchange/services/2006/types"
xmlns:soap="https://schemas.xmlsoap.org/soap/envelope/">
<soap:Header>
<t:RequestServerVersion Version="Exchange2013" />
</soap:Header>
<soap:Body>
<m:UpdateInboxRules>
<m:RemoveOutlookRuleBlob>true</m:RemoveOutlookRuleBlob>
<m:Operations>
<t:SetRuleOperation>
<t:Rule>
<t:RuleId>AQAAAATnzOA=</t:RuleId>
<t:DisplayName>Sales</t:DisplayName>
<t:Priority>1</t:Priority>
<t:IsEnabled>true</t:IsEnabled>
<t:IsInError>false</t:IsInError>
<t:Conditions>
<t:SentToAddresses>
<t:Address>
<t:Name>Sales</t:Name>
<t:EmailAddress>sales@contoso.com</t:EmailAddress>
<t:RoutingType>SMTP</t:RoutingType>
</t:Address>
</t:SentToAddresses>
</t:Conditions>
<t:Exceptions>
<t:ContainsSubjectStrings>
<t:String>Urgent</t:String>
</t:ContainsSubjectStrings>
<t:FromAddresses>
<t:Address>
<t:Name>Hope Gross</t:Name>
<t:EmailAddress>hope@contoso.com</t:EmailAddress>
<t:RoutingType>SMTP</t:RoutingType>
</t:Address>
</t:FromAddresses>
</t:Exceptions>
<t:Actions>
<t:MoveToFolder>
<t:FolderId Id="AAMkADg1OWUwODcyLTg4M2MtNDAyMS05YjI0LTI5ZGM5OTU4Njk3YwAuAAAAAADPriAxh444TpHj2GoQxWQNAQAN+VjmVZl5Rq1ymCq5eFKOAAAAABSxAAA="
ChangeKey="AQAAAA==" />
</t:MoveToFolder>
<t:StopProcessingRules>true</t:StopProcessingRules>
</t:Actions>
</t:Rule>
</t:SetRuleOperation>
</m:Operations>
</m:UpdateInboxRules>
</soap:Body>
</soap:Envelope>
Supprimer les règles de boîte de réception à l’aide de l’API managée EWS
Pour supprimer une règle, incluez un objet DeleteRuleOperation dans la collection d’objets RuleOperation transmis à la méthode UpdateInboxRules .
Dans cet exemple, la règle « Sales » est supprimée.
using System;
using System.Collections.Generic;
using Microsoft.Exchange.WebServices.Data;
private static void DeleteInboxRule(ExchangeService service, string emailAddress)
{
// Before modifying the rules on the server, determine
// whether an Outlook rules BLOB exists. Updating rules
// via EWS requires removal of the Outlook BLOB. This can
// result in any rules that the user has disabled via the Outlook
// UI to be lost.
RuleCollection currentRules = null;
try
{
currentRules = service.GetInboxRules(emailAddress);
}
catch (ServiceResponseException ex)
{
Console.WriteLine("Error getting inbox rules: {0}", ex.ErrorCode.ToString());
}
if (currentRules != null && currentRules.OutlookRuleBlobExists)
{
Console.WriteLine("WARNING: Deleting a rule will delete the Outlook rule BLOB.");
Console.WriteLine("This can lead to a loss of any disabled rules.");
Console.Write("Hit Y to proceed (any other key to cancel): ");
ConsoleKeyInfo cki = Console.ReadKey();
if (cki.KeyChar != 'Y' && cki.KeyChar != 'y')
{
Console.WriteLine("\nCancelling deletion of new rule...");
return;
}
Console.WriteLine();
}
// Look for the rule called "Sales" and delete it.
Console.WriteLine("Deleting rule \"Sales\"...");
string ruleId = string.Empty;
foreach (Rule rule in currentRules)
{
if (rule.DisplayName == "Sales")
{
ruleId = rule.Id;
break;
}
}
if (string.IsNullOrEmpty(ruleId))
{
Console.WriteLine("Could not find a rule called \"Sales\", canceling delete.");
return;
}
DeleteRuleOperation deleteRuleOperation = new DeleteRuleOperation(ruleId);
try
{
// Update rules. Note that this method can accept
// an array of rule operations, enabling you to batch
// updates.
service.UpdateInboxRules(new RuleOperation[] { deleteRuleOperation }, true);
}
catch (UpdateInboxRulesException ex)
{
Console.WriteLine("Error updating Inbox rules: {0}", ex.ErrorCode.ToString());
return;
}
Console.WriteLine("Rule deleted.");
}
Supprimer des règles de boîte de réception à l’aide d’EWS
La requête SOAP EWS suivante supprime les règles « Sales » de sadie@contoso.comla boîte de réception de .
<?xml version="1.0" encoding="utf-8"?>
<soap:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:m="https://schemas.microsoft.com/exchange/services/2006/messages"
xmlns:t="https://schemas.microsoft.com/exchange/services/2006/types"
xmlns:soap="https://schemas.xmlsoap.org/soap/envelope/">
<soap:Header>
<t:RequestServerVersion Version="Exchange2013" />
</soap:Header>
<soap:Body>
<m:UpdateInboxRules>
<m:RemoveOutlookRuleBlob>true</m:RemoveOutlookRuleBlob>
<m:Operations>
<t:DeleteRuleOperation>
<t:RuleId>AQAAAATnzOA=</t:RuleId>
</t:DeleteRuleOperation>
</m:Operations>
</m:UpdateInboxRules>
</soap:Body>
</soap:Envelope>
Source des exemples de méthodes utilitaires
Les exemples d’API managée EWS de cet article utilisent les méthodes utilitaires incluses dans l’exemple suivant.
private static void ParseRuleDetails(ExchangeService service, Rule rule)
{
// Conditions
string conditions = ParseRulePredicates(rule.Conditions, false);
if (!string.IsNullOrEmpty(conditions))
{
Console.WriteLine("When a message:");
Console.WriteLine(conditions);
}
// Actions
string actions = ParseRuleActions(service, rule.Actions);
if (!string.IsNullOrEmpty(actions))
{
Console.WriteLine("Take the following action(s):");
Console.WriteLine(actions);
}
// Exceptions
string exceptions = ParseRulePredicates(rule.Exceptions, true);
if (!string.IsNullOrEmpty(exceptions))
{
Console.WriteLine("Except when the message:");
Console.WriteLine(exceptions);
}
}
private static string ParseRulePredicates(RulePredicates predicates, bool isExceptions)
{
string humanReadablePredicates = string.Empty;
foreach (string category in predicates.Categories)
{
humanReadablePredicates = AppendToHumanReadableString(humanReadablePredicates,
"has the category \"" + category + "\"", isExceptions);
}
foreach (string bodyString in predicates.ContainsBodyStrings)
{
humanReadablePredicates = AppendToHumanReadableString(humanReadablePredicates,
"has \"" + bodyString + "\" in the body", isExceptions);
}
foreach (string headerString in predicates.ContainsHeaderStrings)
{
humanReadablePredicates = AppendToHumanReadableString(humanReadablePredicates,
"has \"" + headerString + "\" in the headers", isExceptions);
}
foreach (string recipientString in predicates.ContainsRecipientStrings)
{
humanReadablePredicates = AppendToHumanReadableString(humanReadablePredicates,
"has \"" + recipientString + "\" in the recipient's address", isExceptions);
}
foreach (string senderString in predicates.ContainsSenderStrings)
{
humanReadablePredicates = AppendToHumanReadableString(humanReadablePredicates,
"has \"" + senderString + "\" in the sender's address", isExceptions);
}
foreach (string subjectOrBodyString in predicates.ContainsSubjectOrBodyStrings)
{
humanReadablePredicates = AppendToHumanReadableString(humanReadablePredicates,
"has \"" + subjectOrBodyString + "\" in the subject or body", isExceptions);
}
foreach (string subjectString in predicates.ContainsSubjectStrings)
{
humanReadablePredicates = AppendToHumanReadableString(humanReadablePredicates,
"has \"" + subjectString + "\" in the subject", isExceptions);
}
if (predicates.FlaggedForAction != null)
{
humanReadablePredicates = AppendToHumanReadableString(humanReadablePredicates,
"is flagged for \"" + predicates.FlaggedForAction.Value + "\" action", isExceptions);
}
foreach (EmailAddress fromAddress in predicates.FromAddresses)
{
humanReadablePredicates = AppendToHumanReadableString(humanReadablePredicates,
"is from " + fromAddress.Name + " (" + fromAddress.Address + ")", isExceptions);
}
foreach (string fromConnectedAccount in predicates.FromConnectedAccounts)
{
humanReadablePredicates = AppendToHumanReadableString(humanReadablePredicates,
"is from the \"" + fromConnectedAccount + "\" account", isExceptions);
}
if (predicates.HasAttachments)
{
humanReadablePredicates = AppendToHumanReadableString(humanReadablePredicates,
"has an attachment", isExceptions);
}
if (predicates.Importance != null)
{
humanReadablePredicates = AppendToHumanReadableString(humanReadablePredicates,
"is marked as " + predicates.Importance.Value + " importance", isExceptions);
}
if (predicates.IsApprovalRequest)
{
humanReadablePredicates = AppendToHumanReadableString(humanReadablePredicates,
"is an approval request", isExceptions);
}
if (predicates.IsAutomaticForward)
{
humanReadablePredicates = AppendToHumanReadableString(humanReadablePredicates,
"is an automatic forward", isExceptions);
}
if (predicates.IsAutomaticReply)
{
humanReadablePredicates = AppendToHumanReadableString(humanReadablePredicates,
"is an automatic reply", isExceptions);
}
if (predicates.IsEncrypted)
{
humanReadablePredicates = AppendToHumanReadableString(humanReadablePredicates,
"is encrypted", isExceptions);
}
if (predicates.IsMeetingRequest)
{
humanReadablePredicates = AppendToHumanReadableString(humanReadablePredicates,
"is a meeting request", isExceptions);
}
if (predicates.IsMeetingResponse)
{
humanReadablePredicates = AppendToHumanReadableString(humanReadablePredicates,
"is a meeting response", isExceptions);
}
if (predicates.IsNonDeliveryReport)
{
humanReadablePredicates = AppendToHumanReadableString(humanReadablePredicates,
"is a non-delivery report", isExceptions);
}
if (predicates.IsPermissionControlled)
{
humanReadablePredicates = AppendToHumanReadableString(humanReadablePredicates,
"is a rights-managed message", isExceptions);
}
if (predicates.IsReadReceipt)
{
humanReadablePredicates = AppendToHumanReadableString(humanReadablePredicates,
"is a read receipt", isExceptions);
}
if (predicates.IsSigned)
{
humanReadablePredicates = AppendToHumanReadableString(humanReadablePredicates,
"is signed", isExceptions);
}
if (predicates.IsVoicemail)
{
humanReadablePredicates = AppendToHumanReadableString(humanReadablePredicates,
"is a voicemail", isExceptions);
}
foreach (string messageClass in predicates.ItemClasses)
{
humanReadablePredicates = AppendToHumanReadableString(humanReadablePredicates,
"has a message class of \"" + messageClass + "\"", isExceptions);
}
foreach (string messageClassification in predicates.MessageClassifications)
{
humanReadablePredicates = AppendToHumanReadableString(humanReadablePredicates,
"has a classification of \"" + messageClassification + "\"", isExceptions);
}
if (predicates.NotSentToMe)
{
humanReadablePredicates = AppendToHumanReadableString(humanReadablePredicates,
"is not sent to me", isExceptions);
}
if (predicates.Sensitivity != null)
{
humanReadablePredicates = AppendToHumanReadableString(humanReadablePredicates,
"has a sensitivity of \"" + predicates.Sensitivity.Value + "\"", isExceptions);
}
if (predicates.SentCcMe)
{
humanReadablePredicates = AppendToHumanReadableString(humanReadablePredicates,
"has me on the CC line", isExceptions);
}
if (predicates.SentOnlyToMe)
{
humanReadablePredicates = AppendToHumanReadableString(humanReadablePredicates,
"is sent ONLY to me", isExceptions);
}
foreach (EmailAddress sentToAddress in predicates.SentToAddresses)
{
humanReadablePredicates = AppendToHumanReadableString(humanReadablePredicates,
"is sent to " + sentToAddress.Name + " (" + sentToAddress.Address + ")", isExceptions);
}
if (predicates.SentToMe)
{
humanReadablePredicates = AppendToHumanReadableString(humanReadablePredicates,
"has me on the To line", isExceptions);
}
if (predicates.SentToOrCcMe)
{
humanReadablePredicates = AppendToHumanReadableString(humanReadablePredicates,
"has me on the To or CC line", isExceptions);
}
if (predicates.WithinDateRange != null)
{
if (predicates.WithinDateRange.Start != null)
{
humanReadablePredicates = AppendToHumanReadableString(humanReadablePredicates,
"was received after " + predicates.WithinDateRange.Start.ToString(), isExceptions);
}
if (predicates.WithinDateRange.End != null)
{
humanReadablePredicates = AppendToHumanReadableString(humanReadablePredicates,
"was recieved before " + predicates.WithinDateRange.End.ToString(), isExceptions);
}
}
if (predicates.WithinSizeRange != null)
{
if (predicates.WithinSizeRange.MinimumSize != null)
{
humanReadablePredicates = AppendToHumanReadableString(humanReadablePredicates,
"is larger than " + predicates.WithinSizeRange.MinimumSize + " kb", isExceptions);
}
if (predicates.WithinSizeRange.MaximumSize != null)
{
humanReadablePredicates = AppendToHumanReadableString(humanReadablePredicates,
"is smaller than " + predicates.WithinSizeRange.MaximumSize + " kb", isExceptions);
}
}
return humanReadablePredicates;
}
private static string ParseRuleActions(ExchangeService service, RuleActions actions)
{
string humanReadableActions = string.Empty;
foreach (string category in actions.AssignCategories)
{
humanReadableActions = AppendToHumanReadableString(humanReadableActions,
"assign the \"" + category + "\" category", false);
}
if (actions.CopyToFolder != null)
{
humanReadableActions = AppendToHumanReadableString(humanReadableActions,
"move to the \"" + GetFolderNameFromId(service, actions.CopyToFolder) + "\" folder", false);
}
if (actions.Delete)
{
humanReadableActions = AppendToHumanReadableString(humanReadableActions,
"delete the message", false);
}
foreach (EmailAddress forwardAddress in actions.ForwardAsAttachmentToRecipients)
{
humanReadableActions = AppendToHumanReadableString(humanReadableActions,
"forward as an attachment to " + forwardAddress.Name + " (" +
forwardAddress.Address + ")", false);
}
foreach (EmailAddress forwardAddress in actions.ForwardToRecipients)
{
humanReadableActions = AppendToHumanReadableString(humanReadableActions,
"forward to " + forwardAddress.Name + " (" + forwardAddress.Address + ")", false);
}
if (actions.MarkAsRead)
{
humanReadableActions = AppendToHumanReadableString(humanReadableActions,
"mark the message as read", false);
}
if (actions.MarkImportance != null)
{
humanReadableActions = AppendToHumanReadableString(humanReadableActions,
"mark the message with " + actions.MarkImportance.Value + " importance", false);
}
if (actions.MoveToFolder != null)
{
humanReadableActions = AppendToHumanReadableString(humanReadableActions,
"move the message to the \"" + GetFolderNameFromId(service, actions.MoveToFolder) + "\" folder", false);
}
if (actions.PermanentDelete)
{
humanReadableActions = AppendToHumanReadableString(humanReadableActions,
"permanently delete the message", false);
}
foreach (EmailAddress redirectAddress in actions.RedirectToRecipients)
{
humanReadableActions = AppendToHumanReadableString(humanReadableActions,
"redirect the message to " + redirectAddress.Name + " (" +
redirectAddress.Address + ")", false);
}
foreach (MobilePhone smsRecipient in actions.SendSMSAlertToRecipients)
{
humanReadableActions = AppendToHumanReadableString(humanReadableActions,
"send SMS alert to " + smsRecipient.Name + " (" +
smsRecipient.PhoneNumber + ")", false);
}
if (actions.ServerReplyWithMessage != null)
{
humanReadableActions = AppendToHumanReadableString(humanReadableActions,
"have the server reply with a template message, ID=" +
actions.ServerReplyWithMessage.UniqueId, false);
}
if (actions.StopProcessingRules)
{
humanReadableActions = AppendToHumanReadableString(humanReadableActions,
"stop processing more rules", false);
}
return humanReadableActions;
}
private static string AppendToHumanReadableString(string humanReadableString, string appendString, bool isExceptions)
{
// Conditions and Actions are AND'ed together
string logicalOperator = "AND";
if (isExceptions)
{
// Exceptions are OR'ed
logicalOperator = "OR";
}
if (!string.IsNullOrEmpty(humanReadableString))
{
// There's already an item in the list, so we need to
// add the operator
humanReadableString += "\n " + logicalOperator + " ";
}
else
{
humanReadableString += " ";
}
humanReadableString += appendString;
return humanReadableString;
}
private static string GetFolderNameFromId(ExchangeService service, FolderId folderId)
{
string folderName = string.Empty;
Folder folder = null;
try
{
folder = Folder.Bind(service, folderId);
}
catch (ServiceResponseException)
{
Console.WriteLine("Unable to bind to the folder specified.");
}
if (folder != null)
folderName = folder.DisplayName;
return folderName;
}
private static FolderId GetFolderIdByName(ExchangeService service, WellKnownFolderName parentWellKnownFolder, string subFolderName)
{
FolderId returnId = null;
Folder parentFolder = null;
try
{
parentFolder = Folder.Bind(service, parentWellKnownFolder);
}
catch (ServiceResponseException)
{
Console.WriteLine("Unable to bind to the {} folder.", parentWellKnownFolder.ToString());
}
if (parentFolder == null)
return null;
SearchFilter searchFilter = new SearchFilter.IsEqualTo(FolderSchema.DisplayName, subFolderName);
FolderView view = new FolderView(10);
view.PropertySet = new PropertySet(BasePropertySet.IdOnly);
view.PropertySet.Add(FolderSchema.DisplayName);
view.Traversal = FolderTraversal.Shallow;
FindFoldersResults searchResults = null;
try
{
searchResults = parentFolder.FindFolders(searchFilter, view);
}
catch (ServiceResponseException ex)
{
Console.WriteLine("Error searching for {0} folder: {1}", subFolderName,
ex.ErrorCode.ToString());
}
foreach (Folder subFolder in searchResults.Folders)
{
if (subFolder.DisplayName == subFolderName)
returnId = subFolder.Id;
break;
}
return returnId;
}
Voir aussi
Commentaires
Bientôt disponible : Tout au long de 2024, nous allons supprimer progressivement GitHub Issues comme mécanisme de commentaires pour le contenu et le remplacer par un nouveau système de commentaires. Pour plus d’informations, consultez https://aka.ms/ContentUserFeedback.
Envoyer et afficher des commentaires pour