Accès et gestion des données Microsoft 365 avec Microsoft Graph

Optimisez l’accès et la gestion des données Microsoft 365 avec le client Graph d’Aspose.Email

Microsoft Graph est une API REST pour accéder aux données Microsoft 365. L’implémentation du client Graph dans Aspose.Email pour .NET permet l’accès à Microsoft Graph depuis notre API. Dans les exemples ci‑dessous, nous créerons une instance de MS Graph Client, en fournissant le jeton. Ensuite, nous examinerons les principales méthodes pour gérer les dossiers, les mettre à jour, les copier et les supprimer. Les messages, leur contenu et leurs pièces jointes peuvent également être consultés ou modifiés avec notre MS Graph Client. La gestion des catégories, règles, blocs‑notes et remplacements est une fonctionnalité étendue du Microsoft Graph Client par Aspose.Email.

Authentifiez‑vous et effectuez des requêtes avec IGraphClient en utilisant MSAL sous .NET

Pour interagir avec les services Microsoft Graph, vous devrez créer un IGraphClient objet. Une fois authentifié, ce client vous permet d’effectuer diverses requêtes de service. Le GetClient méthode, qui crée le IGraphClient, nécessite un ITokenProvider implémentation comme premier paramètre. Cette ITokenProvider est responsable de fournir le jeton d’authentification nécessaire. Pour obtenir le jeton, nous utiliserons le Bibliothèque d’authentification Microsoft (MSAL) pour .NET.

Voici comment configurer le processus d’authentification :

Étape 1 : Configurer l’authentification

Les étapes suivantes vous guideront sur la façon d’obtenir un jeton d’autorisation :

  1. Créez la classe AccessParameters.

    Définissez une classe AccessParameters pour stocker vos informations d’identification.

public class AccessParameters
{
    public string TenantId { get; init; }
    public string ClientId { get; init; }
    public string ClientSecret { get; init; }
    public string UserId { get; init; }
    public Uri Authority => new ($"https://login.microsoftonline.com/{TenantId}");
    public string ApiUrl => "https://graph.microsoft.com/.default";
}

  1. Ajoutez le Package MSAL.NET.

    Installez le Microsoft.Identity.Client Package NuGet, qui contient les binaires MSAL.NET nécessaires à l’authentification.

  2. Implémentez l’interface ITokenProvider.

    Créez un GraphTokenProvider classe qui implémente le ITokenProvider interface. Cette classe utilisera la bibliothèque MSAL.NET pour acquérir un jeton d’accès.

using Microsoft.Identity.Client;
using Microsoft.Identity.Web;
using Aspose.Email.Clients;

public class GraphTokenProvider : ITokenProvider
{
    private readonly IConfidentialClientApplication _app;
    private readonly string[] _scopes;
    private string? _token;

    public GraphTokenProvider(AccessParameters accessParams)
    {
        _app = ConfidentialClientApplicationBuilder.Create(accessParams.ClientId)
            .WithClientSecret(accessParams.ClientSecret)
            .WithAuthority(accessParams.Authority)
            .Build();

        _app.AddInMemoryTokenCache();

        _scopes = new[] { accessParams.ApiUrl };
    }

    public void Dispose()
    {
        throw new NotImplementedException();
    }

    public OAuthToken GetAccessToken()
    {
        return GetAccessToken(false);
    }

    public OAuthToken GetAccessToken(bool ignoreExistingToken)
    {
        if (!ignoreExistingToken && _token != null)
        {
            return new OAuthToken(_token);
        }

        _token = GetAccessTokenAsync().GetAwaiter().GetResult();
        return new OAuthToken(_token);
    }

    private async Task<string?> GetAccessTokenAsync()
    {
        AuthenticationResult? result;

        try
        {
            result = await _app.AcquireTokenForClient(_scopes)
                .ExecuteAsync();

            Console.WriteLine("Token acquired");
        }
        catch (MsalServiceException ex) when (ex.Message.Contains("AADSTS70011"))
        {
            Console.WriteLine("Scope provided is not supported");
            result = null;
        }

        if (result == null) return null;
        _token = result.AccessToken;
        return result.AccessToken;
    }

Étape 2 : Créer une instance ITokenProvider

Après avoir défini le GraphTokenProvider classe, vous pouvez créer une instance de AccessParameters et utilisez-le pour instancier le GraphTokenProvider.

var accessParams = new AccessParameters()
{
    TenantId = "Your Tenant ID",
    ClientId = "Your Client ID",
    ClientSecret = "Your Client Secret",
    UserId = "User's Object ID"
};

var tokenProvider = new GraphTokenProvider(accessParams);

Étape 3 : Faire des requêtes avec IGraphClient

Enfin, utilisez le GraphTokenProvider pour créer une authentification IGraphClient et commencez à faire des requêtes de service.

using var client = GraphClient.GetClient(tokenProvider, accessParams.TenantId);

client.Resource = ResourceType.Users;
client.ResourceId = accessParams.UserId;

Une fois ces étapes terminées, votre IGraphClient est maintenant prêt à interagir avec les services Microsoft Graph en utilisant des requêtes authentifiées.

Connexion aux points de terminaison GCC High

Le GraphClient prend en charge la connexion aux points de terminaison GCC High en utilisant le EndPoint propriété. L’exemple de code suivant montre comment configurer le GraphClient pour se connecter au point de terminaison GCC High afin de lister les dossiers et récupérer les messages.

client.EndPoint = "https://graph.microsoft.us";

var folders = client.ListFolders();
string folderId = folders.Find(x => x.DisplayName == "Inbox").ItemId;
var msgs = client.ListMessages(folderId);

Gérer les dossiers avec IGraphClient

List Folders

En appelant ListFolders méthode du MS Graph Client, il est possible d’obtenir la liste des dossiers. Chaque dossier possède un ensemble de paramètres comme DisplayName, qui peut être lu dans FolderInfo type.

var folders = client.ListFolders();

foreach (var folder in folders)
{
    Console.WriteLine(folder.DisplayName);
}

Mettre à jour les dossiers

Pour créer un dossier avec MS Graph Client, utilisez CreateFolder méthode. Vous obtiendrez un FolderInfo objet et la possibilité d’accéder à DisplayName, ItemId, HasSubFolders et d’autres propriétés.

var folderInfo = client.CreateFolder("FolderName");
folderInfo.DisplayName = "FolderAnotherName";
client.UpdateFolder(folderInfo);

Copier des dossiers

CopyFolder Cette méthode est la principale pour copier l’objet dossier avec MS Graph.

var folderInfo1 = client.CreateFolder("Folder1");
var folderInfo2 = client.CreateFolder("Folder2");
    
// copy Folder2 to Folder1
client.CopyFolder(folderInfo1.ItemId, folderInfo2.ItemId);

Déplacer et supprimer des dossiers

Utiliser MoveFolder Cette méthode est utilisée pour déplacer le dossier, elle accepte newParentId et itemId. Supprimer Cette méthode est utilisée pour supprimer un élément par son ID.

var folderInfo1 = client.CreateFolder("Folder1");
var folderInfo2 = client.CreateFolder("Folder2");
    
// move Folder2 to Folder1
client.MoveFolder(folderInfo1.ItemId, folderInfo2.ItemId);
    
// delete Folder1
client.Delete(folderInfo1.ItemId)

Gérer les messages avec IGraphClient

MS Graph Client, implémenté dans Aspose.Email pour .NET, fournit un ensemble de méthodes pour gérer les messages et les pièces jointes :

Lister les messages

var folders = client.ListFolders();

foreach (var folder in folders)
{
    if (folder.DisplayName.Equals("Inbox"))
    {
        // list messages in inbox
        var inboxMessages = client.ListMessages(folder.ItemId);

        foreach (var messageInfo in inboxMessages)
        {
            Console.WriteLine(messageInfo.Subject);
        }
    }
}

Filtrer les messages par date d’envoi

Le OrderBy La méthode de la collection de bibliothèque vous permet de récupérer les messages avec différents ordres de tri (ascendant et descendant) basés sur la date d’envoi. L’exemple de code suivant montre comment trier les messages par leur date d’envoi :

IGraphClient client = GraphClient.GetClient(provider, TenantId);

var builder = new GraphQueryBuilder();

// create orderby messages query 'DESC'
builder.SentDate.OrderBy(false);
var messagePageInfo = client.ListMessages(KnownFolders.Inbox, new PageInfo(10), builder.GetQuery());
var messages = messagePageInfo.Items;

builder.Clear();

// create orderby messages query 'ASC'
builder.SentDate.OrderBy(true);
messagePageInfo = client.ListMessages(KnownFolders.Inbox, new PageInfo(10), builder.GetQuery());
messages = messagePageInfo.Items;

Énumérer les messages avec prise en charge de la pagination

L’API permet la pagination et le filtrage des messages lors de leur listage. Cela est particulièrement utile pour les boîtes aux lettres contenant un grand nombre de messages, car cela permet de gagner du temps en ne récupérant que les informations de synthèse nécessaires.

L’exemple de code et les étapes ci-dessous démontrent comment récupérer les messages du dossier Inbox en utilisant la pagination et les filtres.

  1. Tout d’abord, initiez le client.
  2. Ensuite, définissez le nombre d’éléments à afficher par page, par exemple, 10.
  3. Créez un filtre pour ne récupérer que les messages non lus en utilisant le GraphQueryBuilder classe. Le builder.IsRead.Equals(false) définit la condition pour filtrer les messages non lus.
  4. Appelez le ListMessages méthode sur l’objet client, spécifiant le dossier (Inbox) et le nombre d’éléments par page (PageInfo(itemsPerPage)) comme paramètres. Elle transmet également l’objet de requête pour appliquer le filtre des messages non lus. L’objet PageInfo retourné (pageInfo) contient les messages récupérés pour la page actuelle dans la propriété Items.
  5. Créez une boucle qui continue jusqu’à ce que la dernière page soit atteinte (pageInfo.LastPage est false). Les messages récupérés sont ajoutés à la liste existante de messages avec messages.AddRange(pageInfo.Items).
//  reading unread messages with paging
using var client = GraphClient.GetClient(tokenProvider, config.Tenant);

// paging option
var itemsPerPage = 10;
// create unread messages filter
GraphQueryBuilder builder = new GraphQueryBuilder();
builder.IsRead.Equals(false);
var query = builder.GetQuery();

// list messages
var pageInfo = client.ListMessages(KnownFolders.Inbox, new PageInfo(itemsPerPage), query);
var  messages = pageInfo.Items;

while (!pageInfo.LastPage)
{
    pageInfo = client.ListMessages(KnownFolders.Inbox, pageInfo.NextPage, query);
    messages.AddRange(pageInfo.Items);
}

// set messages state as read
foreach (var message in messages)
{
    client.SetRead(message.ItemId);
}

Récupérer les messages

var folders = client.ListFolders();

foreach (var folder in folders)
{
    if (folder.DisplayName.Equals("Inbox"))
    {
        // list messages in inbox
        var inboxMessages = client.ListMessages(folder.ItemId);

        if (inboxMessages.Count > 0)
        {
            // fetch the first message in inbox
            var msg = client.FetchMessage(inboxMessages[0].ItemId);
            
            Console.WriteLine(msg.BodyHtml);
        }
        
    }
}

Créer des messages

var msg = new MapiMessage(OutlookMessageFormat.Unicode)
{
    Subject = "My message",
    Body = "Hi, it is my message"
};

msg.Recipients.Add("sam@to.com", "Sam", MapiRecipientType.MAPI_TO);

// create message in inbox
client.CreateMessage(KnownFolders.Inbox, msg);

Envoyer des messages

// prepare the message
var msg = new MapiMessage(OutlookMessageFormat.Unicode)
{
    Subject = "My message",
    Body = "Hi, it is my message"
};

msg.Recipients.Add("sam@to.com", "Sam", MapiRecipientType.MAPI_TO);
msg.SetProperty(KnownPropertyList.SenderName, "John");
msg.SetProperty(KnownPropertyList.SentRepresentingEmailAddress, "John@from.com");

// send message
client.Send(msg);

Envoyer des brouillons de messages

// prepare the message
var msg = new MapiMessage(OutlookMessageFormat.Unicode)
{
    Subject = "My message",
    Body = "Hi, it is my message"
};

msg.Recipients.Add("sam@to.com", "Sam", MapiRecipientType.MAPI_TO);
msg.SetProperty(KnownPropertyList.SenderName, "John");
msg.SetProperty(KnownPropertyList.SentRepresentingEmailAddress, "John@from.com");

// add message to Draft folder
var draftMessage = client.CreateMessage(KnownFolders.Drafts, msg);

// send a draft message
client.Send(draftMessage.ItemId);

Envoyer des messages EML

Créer et envoyer des e‑mails est simple avec l’objet MailMessage. L’exemple de code suivant montre comment créer et envoyer un message e‑mail en utilisant l’API Graph :

// prepare the message
var eml = new MailMessage
{
    From = "from@domain.com",
    To = "to1@domain.com, to2@domain.com",
    Subject = "New message",
    HtmlBody = "<html><body>This is the HTML body</body></html>"
};

// send the message
graphClient.Send(eml);
graphClient.Create(KnownFolders.Inbox, eml);

Copier les messages


// copy message to Inbox folder
var copiedMsg = client.CopyMessage(KnownFolders.Inbox, msg.ItemId);

Déplacer les messages

// move message to Inbox folder
var movedMsg = client.MoveMessage(KnownFolders.Inbox, msg.ItemId);

Gérer les pièces jointes


// create an attachment
var attachment = new MapiAttachment();
attachment.SetProperty(KnownPropertyList.DisplayName, "My Attachment");
attachment.SetProperty(KnownPropertyList.AttachDataBinary, new byte[1024]);

// add an attachment to message
var createdAttachment = client.CreateAttachment(messageInfo.ItemId, attachment);

// fetch a message attachment
var fetchedAttachment = client.FetchAttachment(createdAttachment.ItemId);

// delete a message attachment 
client.DeleteAttachment(createdAttachment.ItemId);

// list the message attachments
var attachments = client.ListAttachments(messageInfo.ItemId);

Gérer les éléments Outlook avec le client Graph

Gérer les événements de calendrier

Aspose.Email propose des API pour accéder, gérer et interagir avec les événements de calendrier. À cette fin, il offre les méthodes suivantes dans le IGraphClient interface:

  • ListCalendars() – Récupère une collection d’informations sur les calendriers.
  • ListCalendarItems(string id) – Récupère une collection d’éléments de calendrier associés à l’ID de calendrier spécifié.
  • FetchCalendarItem(string id) – Récupère un élément de calendrier spécifique basé sur l’ID fourni.
  • CreateCalendarItem(string calId, MapiCalendar mapiCalendar) – Crée un nouvel élément de calendrier dans le calendrier spécifié.
  • UpdateCalendarItem(MapiCalendar mapiCalendar) – Met à jour un élément de calendrier existant.
  • UpdateCalendarItem(MapiCalendar mapiCalendar, UpdateSettings updateSettings) – Met à jour un élément de calendrier existant avec les paramètres de mise à jour spécifiés.

L’exemple de code suivant montre comment interagir avec les événements de calendrier dans un client Microsoft Graph API en utilisant les méthodes fournies par Aspose.Email :


// List Calendars
CalendarInfoCollection calendars = graphClient.ListCalendars();

// List Calendar Items
MapiCalendarCollection calendarItems = graphClient.ListCalendarItems("calendarId");

// Fetch Calendar Item
MapiCalendar calendarItem = graphClient.FetchCalendarItem("calendarItemId");

// Create Calendar Item
MapiCalendar newCalendarItem = new MapiCalendar(
    location: "Conference Room",
    summary: "Team Meeting",
    description: "Discuss project status and updates.",
    startDate: startDate,
    endDate: endDate
);

MapiCalendar createdCalendarItem = graphClient.CreateCalendarItem("calendarId", newCalendarItem);

// Update Calendar Item
createdCalendarItem.Location = "Zoom Meeting";
MapiCalendar updatedCalendarItem = graphClient.UpdateCalendarItem(createdCalendarItem);

Gérer les catégories

Pour gérer les catégories avec MS Graph via Aspose.Email pour .NET, utilisez les méthodes suivantes :

// create a custom category with Orange color
var category = client.CreateCategory("My custom category", CategoryPreset.Preset1);

// fetch a category
var fetchedCategory = client.FetchCategory(category.Id);

// update category (change color to brown)
fetchedCategory.Preset = CategoryPreset.Preset2;
var updatedCategory = client.UpdateCategory(fetchedCategory);

// list available categories
var categories = client.ListCategories();

foreach (var cat in categories)
{
    Console.WriteLine(cat.DisplayName);
}

// delete a category
client.Delete(fetchedCategory.Id);

Gérer les contacts

Aspose.Email propose des API pour accéder, gérer et interagir avec les éléments de contact. À cette fin, il offre les méthodes suivantes dans le IGraphClient interface:

  • ListContacts(string id) – Récupère une collection de contacts MAPI associés à l’ID du dossier spécifié.
  • FetchContact(string id) – Récupère un contact spécifique basé sur l’ID d’élément fourni.
  • CreateContact(string folderId, MapiContact contact) – Crée un nouveau contact dans le dossier spécifié.
  • UpdateContact(MapiContact contact) – Met à jour un contact existant.

L’exemple de code suivant montre comment interagir avec les contacts dans un client Microsoft Graph API en utilisant les méthodes fournies par Aspose.Email :

// List Contacts
MapiContactCollection contacts = graphClient.ListContacts("contactFolderId");

// Fetch Contact
MapiContact contact = graphClient.FetchContact("contactId");

// Create Contact
MapiContact newContact = new MapiContact("Jane Smith", "jane.smith@example.com", "XYZ Corporation", "777-888-999");

MapiContact createdContact = graphClient.CreateContact("contactFolderId", newContact);

// Update Contact
createdContact.Telephones.PrimaryTelephoneNumber = "888-888-999";

MapiContact updatedContact = graphClient.UpdateContact(createdContact);

Gérer les substitutions

Pour gérer les substitutions avec MS Graph via Aspose.Email pour .NET, utilisez les méthodes suivantes :

// Create an user's override
var userOverride = client.CreateOrUpdateOverride
    (new MailAddress("JohnBrown@someorg.com", "JohnBrown"), ClassificationType.Focused);

// list the overrides
var overrides = client.ListOverrides();

// update override
userOverride.Sender.DisplayName = "John Brown";
var updatedOverride = client.UpdateOverride(userOverride);

// delete override
client.Delete(updatedOverride.Id);

Gérer les règles

Pour gérer les règles avec MS Graph via Aspose.Email pour .NET, utilisez les méthodes suivantes :

// Create a rule
var rule = PrepareRule("user@someorg.com", "User");
var createdRule = client.CreateRule(rule);

// List all rules defined for Inbox
var rules = client.ListRules();

// Fetch a rule
var fetchedRule = client.FetchRule(createdRule.RuleId);

// Update a rule
fetchedRule.DisplayName = "Renamed rule";
fetchedRule.IsEnabled = false;
var updatedRule = client.UpdateRule(createdRule);

// Delete a rule
client.Delete(updatedRule.RuleId);

InboxRule PrepareRule(string email, string displayName)
{
    var rule = new InboxRule()
    {
        DisplayName = "My rule",
        Priority = 1,
        IsEnabled = true,
        Conditions = new RulePredicates(),
        Actions = new RuleActions()
    };

    rule.Conditions.ContainsSenderStrings = new StringCollection { displayName };
    rule.Actions.ForwardToRecipients = new MailAddressCollection
        { new MailAddress(email, displayName, true) };
    rule.Actions.StopProcessingRules = true;

    return rule;
}

Gérer les blocs-notes

Pour gérer les blocs-notes avec MS Graph via Aspose.Email pour .NET, utilisez les méthodes suivantes :

// create a OneNote notebook
var newNotebook = new Notebook()
{
    DisplayName = "My Notebook"
};
var createdNotebook = client.CreateNotebook(newNotebook);

// fetch a notebook
var fetchedNotebook = client.FetchNotebook(createdNotebook.Id);

// list the notebooks
var notebooks = client.ListNotebooks();

Gestion des tâches dans Microsoft Graph

Aspose.Email fournit aux développeurs des API pour accéder, gérer et interagir avec les tâches et les listes de tâches des utilisateurs en utilisant les méthodes suivantes de IGraphClient interface:

L’exemple de code suivant montre comment gérer les listes de tâches :

// List Task Lists
var taskLists = graphClient.ListTaskLists();

foreach (var tList in taskLists)
{
    Console.WriteLine($"Task List: {tList.DisplayName}");
}

// Get Task List
var taskList = graphClient.GetTaskList("taskListId");

// Delete Task List
graphClient.DeleteTaskList("taskListId");

L’exemple de code suivant montre comment gérer les tâches :

// List Tasks in a Task List
MapiTaskCollection tasks = graphClient.ListTasks("taskListId");

// Fetch Task
MapiTask task = graphClient.FetchTask("taskId");

// Create Task
var newTask = new MapiTask
{
    Subject = "New Task",
    DueDate = new DateTime(2023, 12, 31),
    Status = MapiTaskStatus.NotStarted
};

MapiTask createdTask = graphClient.CreateTask(newTask, "taskListUri");

// Update Task
createdTask.Subject = "Updated Task Subject";
MapiTask updatedTask = graphClient.UpdateTask(createdTask);

// Update Task with UpdateSettings
var updateSettings = new UpdateSettings { SkipAttachments  = true };
MapiTask updatedTaskWithSettings = graphClient.UpdateTask(createdTask, updateSettings);
Création d'un projet dans le centre d'administration Azure Active Directory Gestion des dossiers de messagerie dans Microsoft Graph (Aspose.Email)