Table of contents
TOC
Réduire la table des matières
Développer la table des matières
Dernière mise à jour: 29/06/2018

Créer une application avec les API Office 365

Concerne : Office 365

La fonctionnalité d’API Office 365 est également disponible via Microsoft Graph, une API unifiée qui inclut des API provenant d’autres services Microsoft tels qu’Outlook, OneDrive, OneNote, Planner et Office Graph, accessibles via un seul point de terminaison et avec un seul jeton d’accès. Nous vous recommandons l’utilisation de Microsoft Graph dans vos applications lorsque cela est possible.

Les API Office 365 sont des services REST qui proposent un accès aux données d'Office 365 telles que le courrier, les calendriers ou les contacts à partir d'Exchange Online, les fichiers et dossiers de SharePoint Online et de OneDrive Entreprise, et les utilisateurs et groupes d'Azure Active Directory.

Vous ne développez pas d'applications iOS ? Utilisez le contrôle situé dans le coin supérieur droit de cette page pour sélectionner le type d'application que vous développez.

Cette documentation couvre des fonctionnalités actuellement en préversion.

Créer une application iOS avec les API Office 365

Vous pouvez créer des applications iOS qui s'intègrent parfaitement avec les API Office 365. Lors de la création de votre application iOS, vous pouvez la programmer directement autour des API REST pour qu'elle interagisse avec Office 365, ou vous pouvez utiliser le kit de développement logiciel (SDK, Software Development Kit) iOS d'Office 365, qui est un modèle d'objet construit sur les API REST et permettant de créer une application. Dans cet article, nous vous guiderons à travers la création d'une application iOS de base utilisant le SDK iOS d'Office 365 pour récupérer les e-mails d'un utilisateur et les afficher sur leur équipement mobile. Cette procédure pas à pas se base sur l'exemple Office 365 Connect.

Référez-vous aux liens suivants pour consulter des exemples de code Office 365 iOS :

Remarque Ces exemples de code utilisent le SDK Office 365 pour iOS pour se connecter à Office 365.

Avant de commencer

Avant de pouvoir créer des applications qui accéderont aux API Office 365, vous devez configurer votre environnement de développement. Il s'agit de trois tâches uniques qui vous assureront de disposer du bon environnement et de tous les outils nécessaires pour réussir :

  1. Installez l'environnement de développement d'application iOS que vous utiliserez pour créer vos applications. Cette opération inclut l'installation et la configuration de l'environnement CocoaPods.

  2. Obtenez un abonnement Office 365 Business pour accéder aux API Office 365.

  3. Associez votre compte Office 365 à Azure Active Directory pour pouvoir créer et gérer des applications.

Si vous n'avez pas encore accompli ces étapes, jetez un œil à l'article Configurer votre environnement de développement Office 365 où vous trouverez des instructions détaillées.

Créer votre application et ajouter des dépendances

Lors de cette étape, vous allez créer un projet iOS et utiliser CocoaPods pour ajouter des dépendances au SDK Office 365 pour iOS et à la bibliothèque d'authentification Azure Active Directory (ADAL, Azure Active Directory Authentication Library) pour iOS.

Créer le projet SimpleMailApp

  1. Ouvrez Xcode
  2. Choisissez Fichier > Nouveau > Projet.
  3. Sélectionnez le modèle Application avec affichage unique dans la section Application* des modèles de projet **iOS, puis cliquez sur Suivant.
  4. Spécifiez SimpleMailApp en tant que Nom de produit, sélectionnez Objective-C en tant que Langage, Universel dans Appareils, une valeur dans Identificateur d'organisation, puis cliquez sur Suivant.
  5. Sélectionnez l'emplacement de votre projet, indiquez s'il doit être sous contrôle de version, puis cliquez sur Créer.
  6. Une fois le projet créé, fermez Xcode.

Comme les commandes Cocoapods doivent être exécutées à partir de la racine du dossier de projet, accédez au répertoire du projet dans Terminal. Si vous n'avez pas modifié l'emplacement par défaut lors de la création du projet, celui-ci sera situé au sein du répertoire SimpleMailApp sur le Bureau.

Activez Cocoapods pour le projet SimpleMailApp

  1. Exécutez la commande suivante pour initialiser le fichier Podfile pour votre projet.

        pod init
    
  2. Ouvrez ensuite le Podfile à l’aide de la commande suivante.

        Open podfile
    
  3. Déclarez les dépendances pour le SDK Office 365 pour iOS et le SDK ADAL pour iOS en ajoutant les définitions suivantes au fichier Podfile que vous avez ouvert.

    pod 'ADALiOS', '~> 1.2.0'
    pod 'Office365', '= 0.9.0'
    

    Ces définitions doivent se situer entre les instructions target et end. Le résultat ressemble donc à ceci :

    target 'SimpleMailApp' do
    pod 'ADALiOS', '~> 1.2.0'
    pod 'Office365', '= 0.9.0'
    end
    
  4. Fermez le Podfile.

Remarque Le SDK Office 365 pour iOS est actuellement en préversion développeur. Il est donc susceptible d'être modifié avant sa finalisation, certaines de ces modifications pouvant même briser le code qui a été écrit en utilisant le SDK. Le SDK utilise la convention de Gestion sémantique de version, dans laquelle la compatibilité est exprimée par l'utilisation d'un numéro de version en trois parties : majeur.mineur.patch. Tant que la version 1.0 n'est pas atteinte, le numéro mineur de la version est incrémenté pour chaque rupture ou modification significative.

Configurer les dépendances pour le projet SimpleMailApp

Pour configurer ces dépendance et les ajouter dans un nouvel espace de travail avec le projet existant, exécutez la commande suivante à partir du Terminal.

pod install

Enregistrer votre application auprès d'Azure Active Directory

  1. Connectez-vous au portail de gestion Azure en utilisant vos identifiants pour site de développement Office 365.

  2. Cliquez sur Active Directory dans le menu situé à gauche, puis cliquez sur le répertoire de votre site de développement Office 365. Portail de gestion Microsoft Azure

  3. Dans le menu supérieur, cliquez sur Applications.

  4. Cliquez sur Ajouter dans le menu inférieur.
    Ajouter une application sur le portail de gestion Azure

  5. Sur la page Que souhaitez-vous faire ?, cliquez sur Ajouter une application développée par mon organisation.

  6. Sur la page Parlez-nous de votre application, spécifiez SimpleMailApp en tant que nom d'application et sélectionnez APPLICATION CLIENTE NATIVE en tant que Type.

  7. Cliquez sur l'icône de flèche située dans le coin inférieur droit de la page.

  8. Sur la page Informations sur l'application, spécifiez un URI de redirection. Pour les besoins de cet exemple vous pouvez spécifier http://localhost/simplemailappproject. Notez cet URI quelque part : vous en aurez besoin lorsque vous coderez le projet SimpleMailApp plus tard. Cochez la case située dans le coin inférieur droit de la page.

  9. Une fois l’application ajoutée, vous serez redirigé vers la page de démarrage rapide de l’application. Là, cliquez sur Configurer dans le menu supérieur.

  10. Dans autorisations pour d'autres applications, cliquez sur Ajouter une application.

  11. Cliquez sur Office 365 Exchange Online, puis sur l'icône de coche. Ajouter une application sur le portail de gestion Azure

  12. Sous autorisations pour d'autres applications, cliquez sur la colonne Autorisations déléguées pour Office 365 Exchange Online et sélectionnez Envoyer un e-mail en tant qu'utilisateur.
    Ajouter une application sur le portail de gestion Azure

    Il s'agit des autorisations qui seront présentées à l'utilisateur de votre application lorsque Azure lui demandera d'accepter la demande d'autorisation de votre application. En règle générale, nous vous conseillons de ne demander que les services réellement requis par votre application et de spécifier, pour chaque service, le niveau d'autorisation le moins élevé qui permette malgré tout à votre application d'exécuter ses fonctions.

  13. Copiez la valeur de ID client ; vous en aurez besoin lorsque vous coderez le projet SimpleMailApp plus tard.

  14. Cliquez sur Enregistrer dans le menu inférieur.

Coder votre application

Ouvrez l'espace de travail SimpleMailApp dans Xcode.

S'authentifier auprès d'Azure AD et obtenir le jeton d'accès

Un jeton d'accès est nécessaire pour accéder aux API Office 365. Votre application doit donc implémenter la logique nécessaire pour récupérer et gérer les jetons d'accès. La Bibliothèque d'authentification Azure Active Directory (ADAL) pour iOS et OSX vous offre la possibilité de gérer l'authentification au sein de votre application en quelques lignes de code seulement. Vous pouvez en apprendre plus sur l'authentification auprès d'Azure Active Directory en consultant la page Qu'est-ce qu'Azure Active Directory ? sur Azure.com. La première chose à faire est de créer un fichier d'en-tête et une classe, AuthenticationManager, qui utilise l'ADAL pour iOS et OSX afin de gérer l'authentification de votre application.

Pour créer la classe AuthenticationManager
  1. Faites un clic droit sur le dossier du projet SimpleMailApp, sélectionnez Nouveau fichier et, dans la section iOS, cliquez sur Classe Cocoa Touch puis sur Suivant.

  2. SaisissezAuthenticationManager dans Classe et NSObject dans Sous-classe de :, puis cliquez sur Suivant.

  3. Cliquez sur Créer pour créer les fichiers de classe et d'en-tête.

Pour coder le fichier d'en-tête AuthenticationManager
  1. Importez les fichiers d'en-tête nécessaires du SDK Office 365 iOS et du SDK ADAL, en ajoutant les lignes de code suivantes à AuthenticationManager.h.

    #import <Foundation/Foundation.h>
    #import <ADALiOS/ADAuthenticationContext.h>
    #import <ADALiOS/ADAuthenticationSettings.h>
    #import <ADALiOS/ADLogger.h>
    #import <ADALiOS/ADInstanceDiscovery.h>
    #import <office365_odata_base/office365_odata_base.h>
    
  2. Déclarez une propriété pour l'objet ADALDependencyResolver du SDK ADAL, qui utilise l'injection de dépendance pour fournir un accès aux objets d'authentification.

    @property (readonly, nonatomic) ADALDependencyResolver *dependencyResolver;
    
  3. Spécifiez la classe AuthenticationManager en tant que singleton.

    +(AuthenticationManager *)sharedInstance;
    
  4. Déclarez les méthodes de récupération et d'effacement des jetons d'accès et d'actualisation.

    //retrieve token
    -(void)acquireAuthTokenWithResourceId:(NSString *)resourceId completionHandler:(void (^)(BOOL authenticated))completionBlock;
    //clear token
    -(void)clearCredentials;
    
Pour coder la classe AuthenticationManager
  1. Au dessus de la déclaration @implementation, déclarez les variables statiques pour l'URI de redirection, l'ID client et l'autorité.

    static NSString * const REDIRECT_URL_STRING = @"redirectUri";
    static NSString * const CLIENT_ID           = @"clientID";
    static NSString * const AUTHORITY           = @"https://login.microsoftonline.com/common";
    

    Remplacez redirectUri par la valeur que vous avez copiée lorsque vous avez enregistrez votre application auprès d'Azure AD à l'étape 8, et clientID par la valeur que vous avez spécifiée à l'étape 13 de la même procédure.

  2. Dans la déclaration interface*, déclarez les propriétés suivantes au-dessus de **@implementation.

    @interface AuthenticationManager ()
    @property (strong,    nonatomic) ADAuthenticationContext *authContext;
    @property (readwrite, nonatomic) ADALDependencyResolver  *dependencyResolver;
    @property (readonly, nonatomic) NSURL    *redirectURL;
    @property (readonly, nonatomic) NSString *authority;
    @property (readonly, nonatomic) NSString *clientId;
    @end
    
  3. Ajoutez le code pour le constructeur dans l'implémentation.

    -(instancetype)init
    {
    self = [super init];
    if (self) {
        // These are settings that you need to set based on your
        // client registration in Azure AD.
        _redirectURL = [NSURL URLWithString:REDIRECT_URL_STRING];
        _authority = AUTHORITY;
        _clientId = CLIENT_ID;
    }
    return self;
    }
    
  4. Ajoutez le code suivant pour utiliser un seul gestionnaire d'authentification pour l'application.

    +(AuthenticationManager *)sharedInstance
    {
    static AuthenticationManager *sharedInstance;
    static dispatch_once_t onceToken;
    
    // Initialize the AuthenticationManager only once.
    dispatch_once(&onceToken, ^{
        sharedInstance = [[AuthenticationManager alloc] init];
    });
    
    return sharedInstance;
    }
    
  5. Faites l'acquisition des jetons d'accès et d'actualisation pour l'utilisateur à partir d'Azure AD.

    -(void)acquireAuthTokenWithResourceId:(NSString *)resourceId completionHandler:(void (^)(BOOL authenticated))completionBlock
    {
        ADAuthenticationError *error;
    self.authContext = [ADAuthenticationContext authenticationContextWithAuthority:self.authority error:&error];
    [self.authContext acquireTokenWithResource:resourceId
                                      clientId:self.clientId
                                   redirectUri:self.redirectURL
                               completionBlock:^(ADAuthenticationResult *result) {
                                   if (AD_SUCCEEDED != result.status) {
                                       completionBlock(NO);
                                   }
                                   else {
                                       NSUserDefaults *userDefaults = [NSUserDefaults standardUserDefaults];
                                       [userDefaults setObject:result.tokenCacheStoreItem.userInformation.userId
                                                        forKey:@"LogInUser"];
                                       [userDefaults synchronize];
                                       self.dependencyResolver = [[ADALDependencyResolver alloc] initWithContext:self.authContext
                                                                                                      resourceId:resourceId
                                                                                                        clientId:self.clientId
                                                                                                     redirectUri:self.redirectURL];
                                       completionBlock(YES);
                                   }
                               }];
    }
    

    Lors de la première exécution de l'application, une demande est envoyé à l'URL spécifiée pour la const AUTHORITY (voir l'étape 1). Vous êtes ensuite redirigé avec une page de connexion où vous pouvez entrer vos informations d'identification. Si votre connexion est un succès, la réponse contient les jetons d'accès et d'actualisation. Lors des exécutions ultérieures de l'application, le gestionnaire d'authentification utilisera le jeton d'accès ou d'actualisation pour authentifier les demandes des clients, sauf si le cache des jetons est effacé.

  6. Enfin, ajoutez le code permettant de déconnecter l'utilisateur en effaçant le cache des jetons et en supprimant les cookies de l'application.

    -(void)clearCredentials{
    id<ADTokenCacheStoring> cache = [ADAuthenticationSettings sharedInstance].defaultTokenCacheStore;
    ADAuthenticationError *error;
    
       if ([[cache allItemsWithError:&error] count] > 0)
        [cache removeAllWithError:&error];
        NSHTTPCookieStorage *cookieStore = [NSHTTPCookieStorage sharedHTTPCookieStorage];
    for (NSHTTPCookie *cookie in cookieStore.cookies) {
        [cookieStore deleteCookie:cookie];
    }
    }
    

Se connecter à Office 365

Vous devez ensuite ajouter une classe à votre projet afin de vous connecter à Office 365 et d'utiliser le service de découverte pour récupérer les points de terminaison du service Exchange.

Pour créer les fichiers de classe et d'en-tête Office365ClientFetcher
  1. Faites un clic droit sur le dossier du projet SimpleMailApp, sélectionnez Nouveau fichier et, dans la section iOS, cliquez sur Classe Cocoa Touch puis sur Suivant.

  2. SaisissezOffice365ClientFetcher dans Classe et NSObject dans Sous-classe de :, puis cliquez sur Suivant.

  3. Cliquez sur Créer pour créer les fichiers de classe et d'en-tête.

Pour coder le fichier d'en-tête Office365ClientFetcher
  1. Importez les fichiers d'en-tête nécessaires du SDK Office 365 iOS, en ajoutant les lignes de code suivantes à Office365ClientFetcher.h.

    #import <Foundation/Foundation.h>
    #import <office365_odata_base/office365_odata_base.h>
    #import <office365_exchange_sdk/office365_exchange_sdk.h>
    #import "MSDiscoveryClient.h"
    #import <MSOutlookServicesClient.h>
    
  2. Déclarez les méthodes qui permettront de récupérer les clients d'Outlook et du service de découverte.

    -(void)fetchOutlookClient:(void (^)(MSOutlookServicesClient *outlookClient))callback;
    -(void)fetchDiscoveryClient:(void (^)(MSDiscoveryClient *discoveryClient))callback;
    
Pour coder la classe Office365ClientFetcher
  1. Importez les fichiers d'en-tête Office365ClientFetcher et AuthenticationManager.

    #import "Office365ClientFetcher.h"
    #import "AuthenticationManager.h"
    
  2. Ajoutez le code d'implémentation à la classe Office365ClientFetcher.

    -(void)fetchOutlookClient:(void (^)(MSOutlookServicesClient *outlookClient))callback
    {
    // Get an instance of the authentication controller.
    AuthenticationManager *authenticationManager = [AuthenticationManager sharedInstance];
    [authenticationManager acquireAuthTokenWithResourceId:@"https://outlook.office365.com/"
                                           completionHandler:^(BOOL authenticated) {
        if(authenticated){
            NSUserDefaults *userDefaults = [NSUserDefaults standardUserDefaults];
            NSDictionary *serviceEndpoints = [userDefaults objectForKey:@"O365ServiceEndpoints"];
            // Gets the MSOutlookServicesClient with the URL for the Mail service.
            callback([[MSOutlookServicesClient alloc] initWithUrl:serviceEndpoints[@"Mail"]
                                       dependencyResolver:authenticationManager.dependencyResolver]);
        }
        else{
            //Display an alert in case of an error
            dispatch_async(dispatch_get_main_queue(), ^{
                NSLog(@"Error in the authentication");
                UIAlertView *alert = [[UIAlertView alloc] initWithTitle:@"Error"
                                                                message:@"Authentication failed. Check the log for errors."
                                                               delegate:self
                                                      cancelButtonTitle:@"OK"
                                                      otherButtonTitles:nil];
                [alert show];
            });
        }
    }];
    }
    -(void)fetchDiscoveryClient:(void (^)(MSDiscoveryClient *discoveryClient))callback
    {
    AuthenticationManager *authenticationManager = [AuthenticationManager sharedInstance];
    [authenticationManager acquireAuthTokenWithResourceId:@"https://api.office.com/discovery/"
                                        completionHandler:^(BOOL authenticated) {
        if (authenticated) {
            callback([[MSDiscoveryClient alloc] initWithUrl:@"https://api.office.com/discovery/v1.0/me/"
                                         dependencyResolver:authenticationManager.dependencyResolver]);
        }
        else {
            dispatch_async(dispatch_get_main_queue(), ^{
                NSLog(@"Error in the authentication");
                UIAlertView *alert = [[UIAlertView alloc] initWithTitle:@"Error"
                                                                message:@"Authentication failed. This may be because the Internet connection is offline  or perhaps the credentials are incorrect. Check the log for errors and try again."
                                                               delegate:self
                                                      cancelButtonTitle:@"OK"
                                                      otherButtonTitles:nil];
                [alert show];
            });
        }
    }];
    }
    

Le contrôleur d'affichage

Vous devez ensuite appeler les méthodes pour vous connecter aux services Office 365, déclencher l'authentification et afficher les résultats dans l'interface utilisateur (IU). Ici, vous allez créer une classe Contrôleur d'affichage contenant les contrôles d'IU, en utilisant les mêmes noms que ceux utilisés dans l'exemple de code Office 365 iOS Connect pour le contrôleur d'affichage et les contrôles d'IU. Cela vous permettra de télécharger et d'utiliser le plan conceptuel de l'exemple Connect, vous permettant de sauter les étapes habituellement nécessaires pour connecter le plan conceptuel à un contrôleur d'affichage.

Pour ajouter le contrôleur d'affichage
  1. Faites un clic droit sur le projet SimpleMailApp, sélectionnez Nouveau fichier et, dans la section iOS, cliquez sur Classe Cocoa Touch puis sur Suivant.

  2. Sélectionnez UIViewController dans Sous-classe de : et spécifiez SendMailViewController en tant que Classe avant de cliquer sur Suivant.

  3. Cliquez sur Créer pour créer les fichiers de classe et d'en-tête.

Pour coder le contrôleur d'affichage

Pour commencer, importez les fichiers d'en-tête nécessaires en ajoutant les lignes de code suivantes dans SendMailViewController.m.

#import "SendMailViewController.h"
#import "Office365ClientFetcher.h"
#import "AuthenticationManager.h"
#import "MSDiscoveryServiceInfoCollectionFetcher.h"

Déclarez ensuite les propriétés et méthodes suivantes dans l'interface SendMailViewController.

@interface SendMailViewController ()

@property (weak, nonatomic) IBOutlet UILabel *headerLabel;
@property (weak, nonatomic) IBOutlet UITextView *mainContentTextView;
@property (weak, nonatomic) IBOutlet UITextView *statusTextView;
@property (weak, nonatomic) IBOutlet UITextField *emailTextField;
@property (weak, nonatomic) IBOutlet UIBarButtonItem *disconnectBarButtonItem;
@property (weak, nonatomic) IBOutlet UIButton *sendMailButton;
@property (weak, nonatomic) IBOutlet UIActivityIndicatorView *activityIndicator;

@property (strong, nonatomic) Office365ClientFetcher *baseController;
@property (strong, nonatomic) NSMutableDictionary *serviceEndpointLookup;

-(IBAction)sendMailTapped:(id)sender;
-(IBAction)disconnectTapped:(id)sender;

@end

Ajoutez maintenant le code suivant pour l'implémentation de SendMailViewController.

@implementation SendMailViewController

#pragma mark - Properties
-(Office365ClientFetcher *)baseController
{
    if (!_baseController) {
        _baseController = [[Office365ClientFetcher alloc] init];
    }

    return _baseController;
}

#pragma mark - Lifecycle Methods
- (void)viewDidLoad
{
    [super viewDidLoad];

    self.disconnectBarButtonItem.enabled = NO;
    self.sendMailButton.hidden = YES;
    self.emailTextField.hidden = YES;
    self.mainContentTextView.hidden = YES;
    self.headerLabel.hidden = YES;

    [self connectToOffice365];
}

#pragma mark - IBActions
//Send a mail message when the Send button is clicked
-(IBAction)sendMailTapped:(id)sender
{
    [self sendMailMessage];
}

// Clear the token cache and update the UI when the Disconnect button is tapped
-(IBAction)disconnectTapped:(id)sender
{
    self.disconnectBarButtonItem.enabled = NO;
    self.sendMailButton.hidden = YES;
    self.mainContentTextView.text = @"You're no longer connected to Office 365.";
    self.headerLabel.hidden = YES;
    self.emailTextField.hidden = YES;
    self.statusTextView.hidden = YES;

    // Clear the access and refresh tokens from the credential cache. You need to clear cookies
    // since ADAL uses information stored in the cookies to get a new access token.
    AuthenticationManager *authenticationManager = [AuthenticationManager sharedInstance];
    [authenticationManager clearCredentials];
}

#pragma mark - Helper Methods
-(void)connectToOffice365
{
    [self.baseController fetchDiscoveryClient:^(MSDiscoveryClient *discoveryClient) {
        MSDiscoveryServiceInfoCollectionFetcher *servicesInfoFetcher = [discoveryClient getservices];

        // Call the Discovery Service and get back an array of service endpoint information
        NSURLSessionTask *servicesTask = [servicesInfoFetcher readWithCallback:^(NSArray *serviceEndpoints, MSODataException *error) {
            if (serviceEndpoints) {

                self.serviceEndpointLookup = [[NSMutableDictionary alloc] init];

                for(MSDiscoveryServiceInfo *serviceEndpoint in serviceEndpoints) {
                    self.serviceEndpointLookup[serviceEndpoint.capability] = serviceEndpoint.serviceEndpointUri;
                }

                // Keep track of the service endpoints in the user defaults
                NSUserDefaults *userDefaults = [NSUserDefaults standardUserDefaults];

                [userDefaults setObject:self.serviceEndpointLookup
                                 forKey:@"O365ServiceEndpoints"];

                [userDefaults synchronize];

                dispatch_async(dispatch_get_main_queue(), ^{

                    NSString *userEmail = [userDefaults stringForKey:@"LogInUser"];
                    NSArray *parts = [userEmail componentsSeparatedByString: @"@"];

                    self.headerLabel.text = [NSString stringWithFormat:@"Hi %@!", parts[0]];
                    self.headerLabel.hidden = NO;
                    self.mainContentTextView.hidden = NO;
                    self.emailTextField.text = userEmail;
                    self.statusTextView.text = @"";
                    self.disconnectBarButtonItem.enabled = YES;
                    self.sendMailButton.hidden = NO;
                    self.emailTextField.hidden = NO;
                });
            }
            else {
                dispatch_async(dispatch_get_main_queue(), ^{
                    NSLog(@"Error in the authentication: %@", error);

                    UIAlertView *alert = [[UIAlertView alloc] initWithTitle:@"Error"
                                                                    message:@"Authentication failed. This may be because the Internet connection is offline  or perhaps the credentials are incorrect. Check the log for errors and try again."
                                                                   delegate:nil
                                                          cancelButtonTitle:@"OK"
                                                          otherButtonTitles:nil];
                    [alert show];
                });
            }
        }];

        [servicesTask resume];
    }];
}

-(void)sendMailMessage
{
    MSOutlookServicesMessage *message = [self buildMessage];

    [self.baseController fetchOutlookClient:^(MSOutlookServicesClient *outlookClient) {
        dispatch_async(dispatch_get_main_queue(), ^{
            // Show the activity indicator
            [self.activityIndicator startAnimating];
        });

        MSOutlookServicesUserFetcher *userFetcher = [outlookClient getMe];
        MSOutlookServicesUserOperations *userOperations = [userFetcher operations];

        // Send the mail message. This results in a call to the service.
        NSURLSessionTask *task = [userOperations sendMailWithMessage:message
                                                     saveToSentItems:YES
                                                            callback:^(int returnValue, MSODataException *error) {
            NSString *statusText;

            if (error == nil) {
                statusText = @"Check your inbox, you have a new message. :)";
            }
            else {
                statusText = @"The email could not be sent. Check the log for errors.";
                NSLog(@"%@",[error localizedDescription]);
            }

            // Update the UI.
            dispatch_async(dispatch_get_main_queue(), ^{
                self.statusTextView.text = statusText;
                [self.activityIndicator stopAnimating];
            });
        }];

        [task resume];
    }];
}

//Compose the mail message
-(MSOutlookServicesMessage *)buildMessage
{
    // Create a new message. Set properties on the message.
    MSOutlookServicesMessage *message = [[MSOutlookServicesMessage alloc] init];
    message.Subject = @"Welcome to Office 365 development on iOS with the Office 365 Connect sample";

    // Get the recipient's email address.
    // See the helper method getRecipients to understand the usage.
    NSString *toEmail = self.emailTextField.text;

    MSOutlookServicesRecipient *recipient = [[MSOutlookServicesRecipient alloc] init];

    recipient.EmailAddress = [[MSOutlookServicesEmailAddress alloc] init];
    recipient.EmailAddress.Address = [toEmail stringByTrimmingCharactersInSet:[NSCharacterSet whitespaceCharacterSet]];

    message.ToRecipients = (NSMutableArray<MSOutlookServicesRecipient> *)[[NSMutableArray alloc] initWithObjects:recipient, nil];

    // Get the email text and put in the email body.
    NSString *filePath = [[NSBundle mainBundle] pathForResource:@"EmailBody" ofType:@"html" ];
    NSString *body = [NSString stringWithContentsOfFile:filePath encoding:NSUTF8StringEncoding error:nil];
    message.Body = [[MSOutlookServicesItemBody alloc] init];
    message.Body.ContentType = MSOutlookServices_BodyType_HTML;
    message.Body.Content = body;

    return message;
}

@end
Main.storyboard

Comme le contrôleur d'affichage que vous avez créé porte le même nom que celui présent dans l'exemple Office 365 iOS Connect, et que les contrôles de spécifications du code portent également le même nom que dans l'exemple de code, vous pouvez utiliser le plan conceptuel de l'exemple. Pour obtenir le plan conceptuel, téléchargez l'exemple et localisez le fichier Main.storyboard dans le dossier O365-iOS-Connect-master\Sample\O365-iOS-Connect\Base.lproj du téléchargement.

Copiez ce fichier dans le dossier SimpleMailApp\SimpleMailApp\Base.lproj de votre projet, en écrasant la version du fichier qui existe déjà à cet emplacement.

Source e-mail

La dernière étape consiste à créer un fichier HTML que l'exemple utilise pour construire le corps de l'e-mail. Ajoutez un fichier HTML à votre projet et nommez-le EmailBody.html. Vous pouvez le personnaliser comme vous le souhaitez, ou utiliser le code suivant pour effectuer un test de base.

<html>
    <body>
        <p>Sent from SimpleMailApp iOS sample</p>
    </body>
</html>

Tester votre application

Générez et exécutez l'application à partir de Xcode. Cette opération lancera le simulateur iOS. Vous verrez alor un lien Connexion à Office 365. Cliquez dessus. Vous êtes alors invité à entrer vos informations d'identification. Après vous être connecté, vous verrez une zone de texte contenant l'adresse e-mail du compte avec lequel vous vous êtes connecté, ainsi qu'un lien Envoyer. Cliquez sur Envoyer pour envoyer un e-mail à l'adresse indiquée dans la zone de texte.

Étapes suivantes

Maintenant que vous avez créé une application utilisant l'API Courrier, vous pouvez explorer les autres API REST Office 365 disponibles pour vos applications.

Ressources supplémentaires

Vous souhaitez développer des applications Android ? Utilisez le contrôle situé dans le coin supérieur droit de cette page pour sélectionner le type d'application que vous développez.

Créer une application Android avec les API Office 365

Pour vous donner un avant-goût de ce que vous pouvez faire avec les API REST Office 365, cet article vous montre comment créer une application simple capable de récupérer des informations à partir d'un serveur Exchange Online.

Capture d'écran de l'application exécutée dans la fenêtre d'un émulateur. Les actions disponibles sont affichées sur les boutons.

Avant de commencer à travailler sur votre première application Office 365, vous devez accomplir un certain nombre de tâches uniques et vous assurer de disposer de tous les bons outils. Après cela, vous pourrez commencer à développer votre première application.

Avant de commencer

Avant de pouvoir créer des applications qui accéderont aux API Office 365, vous devez configurer votre environnement de développement. Il s'agit de trois tâches uniques qui vous assureront de disposer du bon environnement et de tous les outils nécessaires pour réussir :

  1. Installez l'environnement de développement d'application Android que vous utiliserez pour créer vos applications.
  2. Obtenez un abonnement Office 365 Business pour accéder aux API Office 365.
  3. Associez votre compte Office 365 à Azure AD pour pouvoir créer et gérer des applications.

Si vous n'avez pas encore accompli ces étapes, jetez un œil à l'article Configurer votre environnement de développement Office 365 où vous trouverez des instructions détaillées.

Créer votre application et ajouter des dépendances

Au cours de cette étape, vous allez créer une application et ajouter le SDK Office 365 pour Android et la bibliothèque d'authentification Azure Active Directory pour Android au projet. Des sources pour ces deux bibliothèques sont disponibles sur GitHub. Vous pouvez également télécharger les binaires du SDK Office 365 à partir de Bintray si vous préférez.

Ajouter des dépendances pour Android Studio

Vous pouvez utiliser le support intégré de Graddle dans Android Studio pour gérer les dépendances de votre application. Pour ajouter les dépendances à votre application :

  1. Créez une nouvelle application Android dans Android Studio.
  2. Localisez app/build.gradle dans votre module d'application et ajoutez les dépendances suivantes. Nous utiliserons uniquement « outlook-services », mais nous les répertorions toutes ici en guise de référence.
dependencies {
    // base OData library:
    compile group: 'com.microsoft.services', name: 'odata-engine-core', version: '+'
    compile group: 'com.microsoft.services', name: 'odata-engine-android-impl', version: '+', ext:'aar'

    // choose the discovery and outlook services
    compile group: 'com.microsoft.services', name: 'discovery-services', version: '+'
    compile group: 'com.microsoft.services', name: 'outlook-services', version: '+'

    // Azure Active Directory Authentication Library
    compile group: 'com.microsoft.aad', name: 'adal', version: '+'
    }

Ajouter des dépendances pour Eclipse

Si vous utilisez Eclipse, vous aurez un peu plus de travail pour ajouter la bibliothèque d'authentification Azure Active Directory pour les bibliothèques Android et SDK Office 365 à votre espace de travail. Pour ajouter les dépendances à votre espace de travail :

  1. Téléchargez ou clonez la Bibliothèque d'authentification Azure Active Directory.

  2. Lancez Eclipse et créez un nouvel espace de travail pour votre application.

  3. Importez le projet AuthenticationActivity au sein de votre nouvel espace de travail à partir de la bibliothèque d'authentification Azure Active Directory.

  4. Ajoutez la bibliothèque de support Android au projet AuthenticationActivity. Pour ce faire, faites un clic droit sur le projet, choisissez Outils Android, puis Ajouter une bibliothèque de support.

  5. Téléchargez la dernière version de la bibliothèque gson.

  6. Ajoutez le fichier jar gson au dossier libs du projet AuthenticationActivity.

  7. Ajoutez les fichiers jar à partir du SDK Office 365 pour Android. Vous pouvez télécharger les fichiers jar depuis Bintray ou cloner et générer le SDK Office 365 pour Android, puis copier les fichiers jar dans votre projet.

Pour télécharger les fichiers jar

Téléchargez les fichiers jar pour le SDK Office 365 pour Android à partir de Bintray. Vous devez ajouter les fichiers jar suivants dans le dossier libs :

  • odata-engine-android-impl-0.11.1jar
  • outlook-services-0.11.1.jar
  • fichier-services-0.11.1.jar
  • discovery-services-0.11.1.jar
    Remarque Vous pouvez utiliser la version 0.11.1 ou ultérieure pour les jars.
Pour générer les fichiers jar
1. Clonez le [SDK Office 365 pour Android](https://github.com/OfficeDev/Office-365-SDK-for-Android).
2. Allez dans le répertoire sdk.
3. Exécutez `.\gradlew clean`.
4. Exécutez `.\gradlew assemble`.

Mettre à jour le manifeste

Vous devrez ajouter deux autorisations à votre fichier AndroidManifest.xml pour que votre application puisse accéder à Azure AD et à Office 365.

<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />

Intégrer les services Office 365

Avant de commencer à écrire le code de votre application Office 365, vous avez un peu travail. Vous devez en effet enregistrer votre application auprès d'Azure AD et définir les autorisation pour que votre application puisse accéder aux services Office 365. Cette opération n'est nécessaire qu'une seule fois pour chaque application.

Enregistrer votre application auprès d'Azure AD
  1. Connectez-vous au portail de gestion Azure en utilisant vos identifiants pour site de développement Office 365.

  2. Cliquez sur Active Directory dans le menu situé à gauche, puis cliquez sur le répertoire de votre site de développement Office 365.

    Une capture d'écran du site Web du Portail de gestion Azure. L'élément « Active Directory » est sélectionné dans le volet de navigation de gauche. Dans le volet principal, l'onglet Répertoire est sélectionné. Le nom du répertoire actuel est mis en surbrillance.

  3. Dans le menu supérieur, sélectionnez Applications.

  4. Cliquez sur Ajouter dans le menu inférieur.

    Une capture d'écran de la page d'informations du répertoire. Dans la barre de menu située en bas de la page, l'icône Nouveau est mise en surbrillance.

  5. Sur la page Que souhaitez-vous faire ?, cliquez sur Ajouter une application développée par mon organisation.

  6. Sur la page Parlez-nous de votre application, donnez un nom à votre application et sélectionnez APPLICATION CLIENTE NATIVE en tant que Type.

  7. Cliquez sur l'icône de flèche située dans le coin inférieur droit de la page.

  8. Sur la page Informations sur l’application, spécifiez un URI de redirection. Pour les besoins de cet exemple, vous pouvez spécifier http://localhost/simplemailapp puis cocher la case située dans le coin inférieur droit de la page.

  9. Une fois l’application ajoutée, la page de démarrage rapide de l’application s'affiche.

Votre application est désormais enregistrée auprès d'Azure AD et bénéficie d'un ID client. Cette information vous sera utile plus tard, lorsque vous configurerez votre application. Il reste cependant plusieurs aspects importants à configurer pour votre application.

Ajouter des services Office 365 et définir les autorisations

Vous devez maintenant spécifier les autorisations exactes que les API Office 365 doivent accorder à votre application. Pour cela, vous devez ajouter à votre application un accès au service Office 365 contenant l'API dont vous avez besoin, puis spécifier les autorisations dont vous aurez besoin auprès des API de ce service. L'application de cet exemple doit lire la boîte de réception de l'utilisateur. Vous devez donc définir l'autorisation requise comme suit.

  1. Dans le portail de gestion Azure, faites défiler la page de configuration de votre application jusqu'en bas et, sous autorisations pour d'autres applications, sélectionnez Ajouter une application.

    Une capture d'écran de la page de configuration d'application pour votre application, sur le site web du portail de gestion Azure. Sous la section intitulée « autorisation pour d'autres applications », le bouton « Ajouter une application » est en surbrillance.

  2. Sélectionnez le service Office 365 Exchange Online.

    1. Sélectionnez le nom du service et cliquez sur le symbole plus pour ajouter le service.
    2. Le service est ensuite répertorié sous la colonne Sélectionné.
    3. Cliquez sur l'icône en forme de coche pour enregistrer vos choix. Une capture d'écran de la page « autorisations pour d'autres applications ». Les applications disponibles sont répertoriées dans un tableau. Une icône plus est présente à côté du nom de chacune des applications. Tout à droite se trouve une colonne qui répertorie les applications que vous avez ajoutées à votre application. L'icône de coche située au bas de la page est mise en surbrillance.

      Vous êtes redirigé vers la page de configuration de votre application.

  3. Sous autorisations pour d'autres applications, cliquez sur la colonne Autorisations déléguées pour Office 365 Exchange Online et spécifiez l'autorisation Lire les e-mails de l'utilisateur.

    Une capture d'écran de la page de configuration d'application pour votre application, sur le site web du portail de gestion Azure. Sous la section de page intitulée « autorisations pour d'autres applications », les applications que vous venez d'ajouter sont répertoriées dans un tableau. Prèss du nom de chaque application se trouve une colonne intitulée « Autorisations déléguées ». Cette colonne présente un menu déroulant contenant les autorisations que vous pouvez demander pour votre application à partir de chaque application que vous avez ajoutée.

    Il s'agit des autorisations qui seront présentées à l'utilisateur de votre application lorsque Azure lui demandera d'accepter la demande d'autorisation de votre application. En règle générale, nous vous conseillons de ne demander que les services réellement requis par votre application et de spécifier, pour chaque service, le niveau d'autorisation le moins élevé qui permette malgré tout à votre application d'exécuter ses fonctions.

Coder votre application

L'exemple de code suivant constitue une application simple qui utilise toutes les fonctions Azure AD et Office 365 dont vous avez besoin pour créer une application Android.

Se connecter à Office 365

Avant d'appeler un service Office 365 vous devez authentifier votre application auprès d'Azure AD. Vous pouvez en apprendre plus sur l'authentification auprès d'Azure Active Directory en consultant la page Qu'est-ce qu'Azure Active Directory ? sur Azure.com.

Le code suivant définit un objet AuthentificationController qui utilise deux objets de la bibliothèque d'authentification Azure Active Directory pour gérer l'authentification de votre application.

Le premier, ADALDependencyResolver, utilise une injection de dépendance pour offrir un accès à l'objet AuthentificationController au reste de votre application. Le second, AuthenticationContext, gère l'authentification auprès d'Azure AD. Voici ce qu'il fait :

  1. Il présente une interface d'authentification à l'utilisateur la première fois que celui-ci se connecte à Office 365.

  2. Il stocke le jeton d'accès pour l'application, afin que les clients du service puissent accéder aux jetons.

  3. Il actualise le jeton d'accès si nécessaire. Si cela s'avère nécessaire, il présentera une nouvelle fois l'interface d'authentification.

Lorsque vous exécutez l'application, des informations sur le jeton sont envoyées au journal d'application. Ces informations doivent normalement être utilisées dans une application et ne pas être affichées.

package com.microsoft.office365.auth_discover_snack;

import android.app.Activity;
import android.util.Log;

import com.google.common.util.concurrent.SettableFuture;
import com.microsoft.aad.adal.AuthenticationCallback;
import com.microsoft.aad.adal.AuthenticationContext;
import com.microsoft.aad.adal.AuthenticationResult.AuthenticationStatus;
import com.microsoft.aad.adal.PromptBehavior;
import com.microsoft.services.odata.impl.ADALDependencyResolver;
import com.microsoft.services.odata.interfaces.DependencyResolver;

public class AuthenticationController {
    private AuthenticationContext authContext;
    private ADALDependencyResolver dependencyResolver;
    private Activity contextActivity;
    private String resourceId;

    public static synchronized AuthenticationController getInstance() {
        if (INSTANCE == null) {
            INSTANCE = new AuthenticationController();
        }
        return INSTANCE;
    }
    private static AuthenticationController INSTANCE;

private AuthenticationController() {
    resourceId = Constants.DISCOVERY_RESOURCE_ID;
}

public void setContextActivity(final Activity contextActivity) {
    this.contextActivity = contextActivity;
}

public void setResourceId(final String resourceId) {
    this.resourceId = resourceId;
    this.dependencyResolver.setResourceId(resourceId);
}

public SettableFuture<Boolean> initialize() {

    final SettableFuture<Boolean> result = SettableFuture.create();

    if (verifyAuthenticationContext()) {
        getAuthenticationContext().acquireToken(
                this.contextActivity,
                this.resourceId,
                Constants.CLIENT_ID,
                Constants.REDIRECT_URI,
                PromptBehavior.Auto,
                new AuthenticationCallback<AuthenticationResult>() {

                    @Override
                    public void onSuccess(final AuthenticationResult authenticationResult) {
                        if (authenticationResult != null && authenticationResult.getStatus() == AuthenticationStatus.Succeeded) {
                            dependencyResolver = new ADALDependencyResolver(
                                    getAuthenticationContext(),
                                    resourceId,
                                    Constants.CLIENT_ID);
                            Log.i("AuthenticationController", "initialize - Token acquired\n" +
                                            "    Token info:\n" +
                                            "      TenantId - " + authenticationResult.getTenantId() + "\n" +
                                            "      AccessToken - " + authenticationResult.getAccessToken() + "\n" +
                                            "      AccessTokenType - " + authenticationResult.getAccessTokenType() + "\n" +
                                            "      RefreshToken - " + authenticationResult.getRefreshToken() + "\n" +
                                            "      ExpiresOn - " + authenticationResult.getExpiresOn() + "\n" +
                                            "      IsMultiResourceRefreshToken - " + authenticationResult.getIsMultiResourceRefreshToken() + "\n" +
                                            "      IdToken - " + authenticationResult.getIdToken() + "\n" +
                                            "    User info:\n" +
                                            "      DisplayableId - " + authenticationResult.getUserInfo().getDisplayableId() + "\n" +
                                            "      UserId - " + authenticationResult.getUserInfo().getUserId() + "\n" +
                                            "      FamilyName - " + authenticationResult.getUserInfo().getFamilyName() + "\n" +
                                            "      GivenName - " + authenticationResult.getUserInfo().getGivenName()
                            );
                            result.set(true);
                        }
                    }

                    @Override
                    public void onError(Exception t) {
                        Log.e("AuthenticationController", "initialize - " + t.getMessage());
                        result.setException(t);
                    }
                }
        );
    } else {
        result.setException(new Throwable("Auth context verification failed. Did you set a context activity?"));
    }
    return result;
}

public AuthenticationContext getAuthenticationContext() {
    if (authContext == null) {
        try {
            authContext = new AuthenticationContext(this.contextActivity, Constants.AUTHORITY_URL, false);
        } catch (Throwable t) {
            Log.e("AuthenticationController", "getAuthenticationContext - " + t.toString());
        }
    }
    return authContext;
}

public DependencyResolver getDependencyResolver() {
    return getInstance().dependencyResolver;
}

private boolean verifyAuthenticationContext() {
    if (this.contextActivity == null) {
        Log.e("AuthenticationController", "verifyAuthenticationContext - " + "Must set context activity");
        return false;
    }
    return true;
}
}

Utiliser le service de découverte

Le servie de découverte fournit à votre application les emplacements des points de terminaison pour les services Office 365. Vous pouvez obtenir des informations concernant le fournisseur, la version de l'API et l'URI du point de terminaison du service, ainsi que d'autres renseignements.

L'objet DiscoveryController utilise l'objet DiscoveryClient du SDK Office 365 pour Android afin d'obtenir une liste de services à partir d'Office 365. Il envoie la liste au fichier journal de l'application. Cependant, dans votre application, vous utiliserez la liste de services pour trouver les points de terminaison des services Office 365.

package com.microsoft.office365.auth_discover_snack;

import android.util.Log;

import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.SettableFuture;
import com.microsoft.discoveryservices.ServiceInfo;
import com.microsoft.discoveryservices.odata.DiscoveryClient;
import com.microsoft.services.odata.impl.ADALDependencyResolver;

import java.util.List;

public class DiscoveryController {
private List<ServiceInfo> mServices;

public static synchronized DiscoveryController getInstance() {
    if (INSTANCE == null) {
        INSTANCE = new DiscoveryController();
    }
    return INSTANCE;
}
private static DiscoveryController INSTANCE;

public SettableFuture<Boolean> initialize() {

    final SettableFuture<Boolean> result = SettableFuture.create();

    AuthenticationController.getInstance().setResourceId(Constants.DISCOVERY_RESOURCE_ID);
    ADALDependencyResolver dependencyResolver = (ADALDependencyResolver) AuthenticationController
            .getInstance().getDependencyResolver();

    DiscoveryClient discoveryClient = new DiscoveryClient(Constants.DISCOVERY_RESOURCE_URL, dependencyResolver);

    try {
        ListenableFuture<List<ServiceInfo>> services = discoveryClient.getservices().read();
        Futures.addCallback(services,
                new FutureCallback<List<ServiceInfo>>() {
                    @Override
                    public void onSuccess(final List<ServiceInfo> services) {
                        getInstance().mServices = services;
                        StringBuilder servicesLogDescription = new StringBuilder();
                        servicesLogDescription.append("initialize - Services discovered\n");
                        servicesLogDescription.append("    Service info:\n");

                        String serviceProperty;
                        for (ServiceInfo service : services){
                            serviceProperty = "      ServiceName - " + service.getserviceName() + "\n";
                            servicesLogDescription.append(serviceProperty);
                            serviceProperty = "      ServiceId - " + service.getserviceId() + "\n";
                            servicesLogDescription.append(serviceProperty);
                            serviceProperty = "      Capability - " + service.getcapability() + "\n";
                            servicesLogDescription.append(serviceProperty);
                            serviceProperty = "      EntityKey - " + service.getentityKey() + "\n";
                            servicesLogDescription.append(serviceProperty);
                            serviceProperty = "      ProviderName - " + service.getproviderName() + "\n";
                            servicesLogDescription.append(serviceProperty);
                            serviceProperty = "      ProviderId - " + service.getproviderId() + "\n";
                            servicesLogDescription.append(serviceProperty);
                            serviceProperty = "      ServiceApiVersion - " + service.getserviceApiVersion() + "\n";
                            servicesLogDescription.append(serviceProperty);
                            serviceProperty = "      ServiceEndpointUri - " + service.getserviceEndpointUri() + "\n";
                            servicesLogDescription.append(serviceProperty);
                            serviceProperty = "      ServiceResourceId - " + service.getserviceResourceId() + "\n";
                            servicesLogDescription.append(serviceProperty);
                            serviceProperty = "      ServiceAccountType - " + service.getserviceAccountType() + "\n";
                            servicesLogDescription.append(serviceProperty);
                        }

                        Log.i("DiscoveryController", servicesLogDescription.toString());
                        result.set(true);
                    }

                    @Override
                    public void onFailure(final Throwable t) {
                        Log.e("DiscoveryController", "discoverServices - " + t.getMessage());
                        result.setException(t);
                    }
                });
    } catch (Exception e) {
        Log.e("DiscoveryController", "discoverServices - " + e.getMessage());
        result.setException(e);
    }
    return result;
}

public ServiceInfo getService(String capability) {
    if (mServices == null)
        throw new NullPointerException("Services have not been discovered. "
                + "Use discoverServices function first.");
    for (ServiceInfo service : mServices)
        if (service.getcapability().equals(capability))
            return service;

    return null;
}
}

Accéder aux données de l'API Office 365

Maintenant qu'elle dispose d'un AuthentificationController pour gérer l'authentification auprès d'Azure AD et d'un DiscoveryController qui fournit les points de terminaison des services Office 365, votre application est prête à effectuer des appels lui permettant récupérer des informations à partir d'Office 365.

L'objet MailController utilise ces deux objets pour obtenir une liste des e-mails présents dans la boîte de réception de l'utilisateur. Une fois encore, cette application simple se contente d'écrire les lignes d'objet dans le fichier journal de l'application.

package com.microsoft.office365.auth_discover_snack;

import android.util.Log;

import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.SettableFuture;
import com.microsoft.discoveryservices.ServiceInfo;
import com.microsoft.outlookservices.Message;
import com.microsoft.outlookservices.odata.OutlookClient;
import com.microsoft.services.odata.impl.ADALDependencyResolver;

import java.util.List;

public class MailController {

public static synchronized MailController getInstance() {
    if (INSTANCE == null) {
        INSTANCE = new MailController();
    }
    return INSTANCE;
}
private static MailController INSTANCE;

public SettableFuture<Boolean> initialize() {

    final SettableFuture<Boolean> result = SettableFuture.create();

    ServiceInfo service = DiscoveryController.getInstance().getService(Constants.MAIL_CAPABILITY);

    AuthenticationController.getInstance().setResourceId(service.getserviceResourceId());
    ADALDependencyResolver dependencyResolver = (ADALDependencyResolver) AuthenticationController
            .getInstance().getDependencyResolver();

    OutlookClient mailClient = new OutlookClient(service.getserviceEndpointUri(), dependencyResolver);

    try {
        ListenableFuture<List<Message>> mailItems = mailClient
                .getMe()
                .getFolder("Inbox")
                .getMessages()
                .read();
        Futures.addCallback(mailItems,
                new FutureCallback<List<Message>>() {
                    @Override
                    public void onSuccess(final List<Message> mailItems) {
                        StringBuilder mailItemsLogDescription = new StringBuilder();
                        mailItemsLogDescription.append("initialize - Mail retrieved\n");
                        mailItemsLogDescription.append("    Mail items::\n");

                        String mailItemSubject;
                        for (Message mailItem : mailItems){
                            mailItemSubject = "      Subject: " + mailItem.getSubject() + "\n";
                            mailItemsLogDescription.append(mailItemSubject);
                        }

                        Log.i("MailController", mailItemsLogDescription.toString());
                        result.set(true);
                    }

                    @Override
                    public void onFailure(final Throwable t) {
                        Log.e("MailController", "initialize - " + t.getMessage());
                        result.setException(t);
                    }
                });
    } catch (Exception e) {
        Log.e("MailController", "initialize - " + e.getMessage());
        result.setException(e);
    }
    return result;
}
}

Contexte et activité de l'application

Il existe deux autres classes dont vous aurez besoin pour cette première application Office 365. La première est une classe de constantes qui contient des information définissant votre application. Les trois premières constantes fournissent les points de terminaison pour l'authentification Azure AD et le service de découverte Office 365. Les deux constantes suivantes sont les informations d'identification que vous avez créées lorsque vous avez enregistré votre application auprès d'Azure AD. La dernière constante spécifie que votre application a besoin d'un accès au services d'e-mails d'Office 365.

package com.microsoft.office365.auth_discover_snack;

interface Constants {
public static final String AUTHORITY_URL = "https://login.microsoftonline.com/common";
public static final String DISCOVERY_RESOURCE_URL = "https://api.office.com/discovery/v1.0/me/";
public static final String DISCOVERY_RESOURCE_ID = "https://api.office.com/discovery/";
public static final String CLIENT_ID = "<Assigned by Azure AD when you registered your app.>";
public static final String REDIRECT_URI = "<Defined when you registered your app.>";

public static final String MAIL_CAPABILITY = "Mail";

}

La deuxième classe est la classe d'activité qui fournit l'interface utilisateur (IU) de l'application. L'IU consiste en trois boutons. L'un authentifie l'application, l'autre obtient les informations du point de terminaison à partir du service de découverte et le dernier obtient les e-mails présents dans votre boûte de réception à partir du service d'e-mails. La seule méthode supplémentaire nécessaire est la méthode onActivityResult qui est appelée lorsque AuthentificationActivity est terminée.

package com.microsoft.office365.auth_discover_snack;

import android.content.Intent;
import android.os.Bundle;
import android.support.v7.app.ActionBarActivity;
import android.util.Log;
import android.view.View;

import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.SettableFuture;

public class MainActivity extends ActionBarActivity {

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
}

public void onAuthenticateButtonClick(View v){
    AuthenticationController.getInstance().setContextActivity(this);
    SettableFuture<Boolean> authenticated = AuthenticationController.getInstance().initialize();

    Futures.addCallback(authenticated, new FutureCallback<Boolean>() {
        @Override
        public void onSuccess(Boolean result) {
            Log.i("MainActivity", "onAuthenticateButtonClick - Authentication successful");
        }
        @Override
        public void onFailure(final Throwable t) {
            Log.e("MainActivity", "onAuthenticateButtonClick - " + t.getMessage());
        }
    });
}

public void onDiscoverButtonClick(View v){
    SettableFuture<Boolean> discovered = DiscoveryController.getInstance().initialize();

    Futures.addCallback(discovered, new FutureCallback<Boolean>() {
        @Override
        public void onSuccess(Boolean result) {
            Log.i("MainActivity", "onDiscoverButtonClick - Services discovered");
        }
        @Override
        public void onFailure(final Throwable t) {
            Log.e("MainActivity", "onDiscoverButtonClick - " + t.getMessage());
        }
    });
}

public void onGetMailButtonClick(View v) {
    SettableFuture<Boolean> mailRetrieved = MailController.getInstance().initialize();

    Futures.addCallback(mailRetrieved, new FutureCallback<Boolean>() {
        @Override
        public void onSuccess(Boolean result) {
            Log.i("MainActivity", "onGetMailButtonClick - Mail retrieved");
        }
        @Override
        public void onFailure(final Throwable t) {
            Log.e("MainActivity", "onGetMailButtonClick - " + t.getMessage());
        }
    });
}

@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    Log.i("MainActivity", "onActivityResult - AuthenticationActivity has come back with results");
    super.onActivityResult(requestCode, resultCode, data);
    AuthenticationController
            .getInstance()
            .getAuthenticationContext()
            .onActivityResult(requestCode, resultCode, data);
}
}

Interface utilisateur

Le dernier élément dont vous aurez besoin est une interface utilisateur qui exercent les services Azure AD et Office 365. Cette disposition propose trois boutons qui font exactement cela.

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools" android:layout_width="match_parent"
    android:layout_height="match_parent" android:paddingLeft="@dimen/activity_horizontal_margin"
    android:paddingRight="@dimen/activity_horizontal_margin"
    android:paddingTop="@dimen/activity_vertical_margin"
    android:paddingBottom="@dimen/activity_vertical_margin" tools:context=".MainActivity">

    <Button
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="AUTHENTICATE TO OFFICE 365"
        android:id="@+id/authenticateButton"
        android:layout_alignParentLeft="true"
        android:layout_alignParentStart="true"
        android:layout_marginTop="21dp"
        android:onClick="onAuthenticateButtonClick" />

    <Button
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="DISCOVERY SERVICES"
        android:id="@+id/discoverButton"
        android:layout_below="@+id/authenticateButton"
        android:layout_alignParentLeft="true"
        android:layout_alignParentStart="true"
        android:layout_marginTop="21dp"
        android:onClick="onDiscoverButtonClick" />

    <Button
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="GET MAIL"
        android:id="@+id/getMailButton"
        android:layout_below="@+id/discoverButton"
        android:layout_alignParentLeft="true"
        android:layout_alignParentStart="true"
        android:layout_marginTop="21dp"
        android:onClick="onGetMailButtonClick" />
</RelativeLayout>

Tester votre application

Exécutez l'application depuis votre IDE pour voir le code en action. En démarrant l'application, vous voyez trois boutons. Lorsque vous cliquez sur chacun des boutons, les informations sont envoyées vers la fenêtre journal de votre IDE.

Capture d'écran de l'application exécutée dans la fenêtre d'un émulateur. Les actions disponibles sont affichées sur les boutons.

Lorsque vous cliquez sur le bouton Authenticate to Office 365, l'application appelle l'objet AuthentificationController qui, à son tour, appelle le workflow fourni par la bibliothèque d'authentification Azure Active Directory pour Android. Si aucun jeton valide n'est disponible, un formulaire de connexion à Office 365 s'affiche.

Capture d'écran de la page de connexion Office 365.

Après votre connexion, l'AuthentificationController écrit des informations concernant le jeton d'authentification dans la fenêtre journal.

Capture d'écran des informations de jeton renvoyées à partir d'Office 365. Ces informations incluent le jeton, sa date d'expiration et des informations concernant l'utilisateur, dont son adresse e-mail, son nom de famille et son prénom.

Cliquez sur le bouton DISCOVER SERVICES pour obtenir une liste de points de terminaison de service REST disponible à partir de votre serveur Office 365.

Capture d'écran de la liste des services REST Office 365. Cette liste comprend le nom du service, l'ID du service, la capacité, la clé d'entité, le nom du fournisseur, l'ID du fournisseur, la version de l'API de service, l'URI du point de terminaison de service, l'ID de ressource de service, et le type de compte de service.

Cliquez sur le bouton Get mail pour obtenir une liste des messages e-mail dans la boîte de réception de l'utilisateur. Cet exemple se contente de répertorier les objets de chaque e-mail.

Capture d'écran d'une liste de lignes d'objets d'e-mails dans la boîte de réception de l'utilisateur.

Étapes suivantes

Maintenant que vous avez créé une application simple qui vous permet d'obtenir des e-mails à partir d'Office 365, vous êtes prêt à vous attaquer à une application plus complexe qui vous montrera comment utiliser l'ensemble de l'API REST.

Ressources supplémentaires

Vous ne développez pas d'applications Angular ? Utilisez le contrôle situé dans le coin supérieur droit pour sélectionner le type d'application que vous développez.

Créer une application Angular avec des API Office 365

Avant de commencer à travailler sur votre première application Angular avec Office 365, vous devez accomplir un certain nombre de tâches uniques, dont la configuration de votre environnement de développement Office 365, et vous assurer d'avoir les bons outils.

Après cette configuration, nous vous guideront à travers la création d'une application Angular simple, SimpleMailApp, qui utilisera la bibliothèque d'authentification Active Directory (ADAL) pour Javascript afin d'authentifier l'utilisateur, et des appels REST pour récupérer les e-mails de l'utilisateur à l'aide du partage de ressources cross-origin (CORS).

Capture d'écran de l'application

Cet article se concentre sur un Angular frontal, car ADAL JS a été conçue spécifiquement pour les applications monopages (SPA, Single-Page Applications). La bibliothèque suppose le modèle d'interactions requis par les SPA. L'utilisation de la bibliothèque sans Angular est bien sûr possible, mais elle demande d'écrire bien plus de code. Consultez l'article Créer des applications web JavaScript en utilisant CORS pour accéder aux API Office 365 si vous êtes intéressé par l'utilisation des API Office 365 sans ADAL JS.

Avant de commencer

Avant de pouvoir créer des applications qui accéderont aux API Office 365, vous devez configurer votre environnement de développement. Il s'agit de trois tâches uniques qui vous assureront de disposer du bon environnement et de tous les outils nécessaires pour réussir :

  1. Téléchargez des outils qui vous permettront de créer votre application Angular, dont un IDE, Git et Node.js.
  2. Obtenez un abonnement Office 365 Business pour accéder aux API Office 365.
  3. Associez votre compte Office 365 à Azure AD pour pouvoir créer et gérer des applications.

Si vous n'avez pas encore accompli ces étapes, jetez un œil à l'article Configurer votre environnement de développement Office 365 où vous trouverez des instructions détaillées.

Remarque Node.js, et plus particulièrement son gestionnaire de package (npm), est nécessaire aux opérations de cet article, afin d'installer les dépendances de projet. Il n'est pas indispensable pour développer avec les API Office 365.

Créer votre application et ajouter des dépendances

Lors de cette étape, vous allez configurer une application Angular en tirant parti d'un projet vide que nous avons développé, en y ajoutant la bibliothèque d'authentification Azure Active Directory (ADAL) pour JavaScript, et en configurant l'application pour lui permettre de communiquer avec Azure grâce à son enregistrement sur votre portail de gestion Azure.

Configurer le projet SimpleMailApp

Pour vous aider à vous lancer le plus rapidement possible, vous allez utiliser un projet vide que nous avons créé et que vous pouvez trouver sur GitHub.

  1. En utilisant Git, clonez le projet vide à partir de la ligne de commande.

    git clone https://github.com/OfficeDev/O365-Angular-GettingStarted.git

    Remarque Si vous n'êtes pas familier de Git, vous pouvez télécharger le code directement depuis GitHub.

  2. Passez ensuite au dossier de votre nouveau projet, et installez les dépendances de votre projet en utilisant npm, le gestionnaire de package pour Node.js.

    cd O365-Angular-GettingStarted/Starter
    npm install

Remarque Il existe également un dossier Completed dans le référentiel. Le projet présent dans ce dossier pourra être déployé dès que vous l'aurez configurez en vous servant de vos informations client Azure et que vous aurez installé les dépendances.

Ajouter ADAL JS au projet SimpleMailApp

ADAL JS est une bibliothèque JavaScript qui vous fournit une prise en charge complète pour la connexion d'utilisateurs Azure AD dans des applications monopages (SPA) telles que celle-ci, et pour consommer directement à partir des API web JavaScript sécurisées par Azure AD.

ADAL.js dispose de deux couches, dans deux fichiers :

  • adal.js Utilisable pour toutes les applications JavaScript. Ce fichier contient des fonctions de bas niveau telles que la logique spécifique au domaine, la génération et l'analyse de messages OAuth2, ou la mise en cache de jetons. Pour plus d'informations, voir Présentation d'ADAL JS v1.
  • adal-angular.js À inclure avec adal.js pour les applications Angular. Ce fichier contient des fonctions spécifiques compatibles avec l'infrastructure Angular.

Incluez ces deux fichiers dans votre projet pour accéder à un modèle de programmation permettant l'authentification Azure AD et pour appeler des API sécurisées par Azure AD comme l'API REST Outlook Courrier que nous appellerons plus loin dans l'article.

Vous pouvez obtenir les bits à partir de notre CDN.

La manière la plus simple d'inclure les dépendances ADAL est d'ajouter des balises script en utilisant les liens CDN en tant qu'attribut src à la fin de la balise <head> dans le fichier index.html situé dans Starter/public.

<script src="https://secure.aadcdn.microsoftonline-p.com/lib/1.0.0/js/adal.min.js"></script>
<script src="https://secure.aadcdn.microsoftonline-p.com/lib/1.0.0/js/adal-angular.min.js"></script>

Enregistrer votre application auprès d'Azure AD

Avant de commencer à écrire le code de votre application Office 365, un peu travail est nécessaire. Vous devez en effet enregistrer votre application auprès d'Azure AD et définir les autorisation pour que votre application puisse utiliser les services Office 365. Cette opération n'est nécessaire qu'une seule fois pour chaque application.

  1. Inscrivez-vous sur le portail de gestion Azure, en utilisant les informations d'identification de votre compte Office 365 Business.

  2. Cliquez sur le nœud Active Directory dans la colonne de gauche et sélectionnez le répertoire lié à votre abonnement Office 365.

    Portail de gestion Microsoft Azure

  3. Sélectionnez l’onglet Applications, puis Ajouter au bas de l'écran.

    Ajouter une application sur le portail de gestion Azure

  4. Dans la fenêtre qui s’ouvre, sélectionnez Ajouter une application développée par mon organisation. Cliquez ensuite sur la flèche pour continuer.

  5. Choisissez un nom pour votre application, comme par exemple SimpleMailApp et sélectionnez le type Application web et/ou API web. Cliquez ensuite sur la flèche pour continuer.

  6. La valeur de URL de connexion est l’URL où votre application sera hébergée. Utilisez http://127.0.0.1:8080/ pour cet exemple de projet.

  7. La valeur de URI ID d’application est un identifiant unique qui permet à Azure AD d’identifier votre application. Vous pouvez utiliser http://{votre_sous-domaine}/SimpleMailApp, où {votre_sous-domaine} est le sous-domaine de .onmicrosoft que vous avez spécifié lorsque que vous avez créé votre compte Office 365 Business. Cochez ensuite la case pour configurer votre application.

  8. Une fois l’application ajoutée, vous serez redirigé vers la page de démarrage rapide de l’application. Là, sélectionnez l'onglet Configurer.

  9. Faites défiler la page jusqu'à la section autorisations pour d’autres applications et cliquez sur le bouton Ajouter une application.

    Ajouter une application pour l'application web

  10. Dans cet article, nous allons vous montrer comment obtenir les e-mails d'un utilisateur. Ajoutez donc l'application Office 365 Exchange Online. Cliquez sur le signe plus dans la ligne de l’application, puis sur l'icône en forme de coche située en haut à droite pour l’ajouter. Cliquez ensuite sur l'icône coche située en bas à droit pour continuer.

    Ajouter des autorisations Exchange

  11. Sur la ligne Office 365 Exchange Online, sélectionnez Autorisations déléguées et, dans la liste de sélection, choisissez Lire les e-mails de l'utilisateur.

    Ajouter une application pour l'application web

    Il s'agit des autorisations qui seront présentées à l'utilisateur de votre application lorsque Azure lui demandera d'accepter la demande d'autorisation de votre application. En règle générale, nous vous conseillons de ne demander que les services réellement requis par votre application et de spécifier, pour chaque service, le niveau d'autorisation le moins élevé qui permette malgré tout à votre application d'exécuter ses fonctions.

  12. Cliquez sur Enregistrer pour enregistrer la configuration de l’application.

Configurer votre application pour autoriser le flux d’octroi implicite OAuth 2.0

Afin d’obtenir un jeton d’accès pour les requêtes d’API Office 365, votre application utilisera le flux d’octroi implicite OAuth. Vous devez mettre à jour le manifeste de l’application pour autoriser le flux d’octroi implicite OAuth car celui-ci n’est pas autorisé par défaut.

  1. Sélectionnez l’onglet Configurer de votre application dans le portail de gestion Azure.

  2. En utilisant le bouton Gérer le manifeste dans le tiroir, téléchargez le fichier manifeste pour l’application et enregistrez-le sur votre ordinateur.

  3. Ouvrez le fichier manifeste avec un éditeur de texte. Recherchez la propriété oauth2AllowImplicitFlow. Par défaut, elle est sur false ; changez-la en true et sauvegardez le fichier.

  4. En utilisant le bouton Gérer le manifeste, téléchargez le fichier manifeste mis à jour.

Vous avez maintenant créé votre application et l'avez enregistrée auprès d'Azure AD. La dernière étape consiste à ajouter du code qui permettra d'effectuer des demandes auprès de l'API Outlook Mail REST.

Coder votre application

Avant de poursuivre, vérifiez que vous êtes toujours dans le répertoire Starter du projet, et que vous avez bien inclus adal.js et adal-angular.hs dans index.html. Continuez ensuite pour vous authentifier auprès d'Azure AD.

S'authentifier auprès d'Azure AD et obtenir un jeton d'accès

ADAL pour JS fournit la fonctionnalité qui permet de gérer l'authentification dans votre application. Vous pouvez l'utiliser pour récupérer et mettre en cache des jetons d'accès et d'actualisation. Pour faire fonctionner l'authentification, nous avons uniquement besoin d'éditer le fichier app.js dans public/scripts.

Pour commencer, ajoutez AdalAngular en tant que module requis pour le module de votre application à la ligne 8.

angular
  .module('app', [
    'ngRoute', 
    'AdalAngular'
  ])

Nous allons ensuite configurer le service qu'AdalAngular nous fournit en le passant en tant qu'argument dans la fonction config de votre module, à la ligne 13. C'est également maintenant que allons ajouter le module $http d'Angular, car nous en avons besoin pour configurer le service.

function config($routeProvider, $httpProvider, adalAuthenticationServiceProvider) {

L'étape suivante consiste à initialiser adalAuthenticationServiceProvider dans la fonction config pour que l'API ADAL soit exposée et configurée pour votre application. Trois arguments sont nécessaires pour initialiser le fournisseur : tenant, clientId, et cacheLocation. La valeur de tenant est le sous-domaine de .onmicrosoft que vous avez spécifiée lorsque vous avez créé votre compte Office 365 Business. Le clientId est l'ID client de votre application, que vous pouvez trouver sur le portail de gestion Azure sous l'onglet Configurer de la page de votre application. Enfin, incluez cacheLocation avec pour valeur localStorage si votre application doit fonctionner dans Internet Explorer.

// Initialize the ADAL provider with your tenant name and clientID (found in the Azure Management Portal).
adalAuthenticationServiceProvider.init(
  {
    tenant: '{your_subdomain}.onmicrosoft.com',
    clientId: 'XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX',
    cacheLocation: 'localStorage'
  },
  $httpProvider
  );

À ce stade, vous avez configuré le module AdalAngular et vous pouvez l'utiliser pour authentifier les utilisateurs dans votre application. L'un des moyens les plus efficaces dans le faire dans une application Angular est de définir les routes qui nécessitent l'authentification de l'utilisateur. Dans notre exemple, nous voulons que l'application ne soit visible qu'aux seuls utilisateurs authentifiés. C'est pourquoi nous allons protéger la route racine dans la configuration $routeProvider en ajoutant le membre requireADLogin à l'objet que nous passons dans la méthode .when.

$routeProvider
  .when('/', {
    templateUrl: 'views/home.html',
    controller: 'HomeController',
    controllerAs: 'home',
    requireADLogin: true     // Designates that the user must be authenticated to view this page.
  })
  .otherwise({
    redirectTo: '/'
  });

Récupérer les e-mails d'un utilisateur à partir d'Office 365

À présent que vous avez authentifié votre utilisateur, vous pouvez effectuer des requêtes HTTP vers l'API REST Courrier en utilisant un jeton d'authentification. La prise en charge CORS pour l'API REST Fichiers, l'API REST Calendrier et l'API REST Contacts est également disponible.

Pour effectuer une requête HTTP vers l'API REST Courrier et récupérer les e-mails de l'utilisateur, vous devez déclarer l'URL de l'API REST Courrier au moment de l'initialisation afin qu'ADAL JS sache qu'il peut lui faire confiance. Vous allez utiliser pour cela le partage de ressources cross-origin (CORS). Vous pouvez pour cela passer un objet endpoints dans notre code adalAuthentificationServiceProvider.init dans app.js. Le point de terminaison que vous devez ajouter est https://outlook.office365.com.

var endpoints = {
  'https://outlook.office365.com': 'https://outlook.office365.com'
};

// Initialize the ADAL provider with your tenant name and clientID (found in the Azure Management Portal).
adalAuthenticationServiceProvider.init(
  {
    tenant: '{your_subdomain}.onmicrosoft.com',
    clientId: 'XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX',
    cacheLocation: 'localStorage',
    endpoints: endpoints
  },
  $httpProvider
  );

Maintenant qu'ADAL JS est configuré pour envoyer des requêtes HTTP à l'API REST Courrier à l'aide de CORS, la seule chose qui vous reste à faire est d'effectuer la requête HTTP qui récupérera les e-mails de l'utilisateur. Nous allons nous en occuper dans homeController.js, qui se situe dans le dossier public/controllers.

Ajoutez le code suivant à votre contrôleur vide. Il configure la requête HTTP et l'exécute. Lorsque la réponse est reçue, ses données sont jointes au modèle d'affichage pour qu'elles soient accessibles depuis l'affichage (public/views/home.html).

// Pass in the resource URL that you're requesting.
$http.get("https://outlook.office365.com/api/v1.0/me/messages")
  .then(function(response) {
    $log.debug('HTTP request to Mail API returned successfully.');
    vm.emails = response.data.value;
  }, function(error) {
    $log.error('HTTP request to Mail API failed.');
  });

Enfin, nous allons ajouter un peu de HTML pour afficher les données que vous venez de recevoir. Ajoutez le code suivant à home.html, situé dans le dossier public/views.

<div class="container-fluid">
  <row>
    <div class="col-md-8 col-md-offset-2" style="margin-top: 20px;">
      <table class="table table-hover">
        <thead>
          <tr>
            <th>From</th>
            <th>Subject</th>
            <th>Body Preview</th>
            <th>Web Link</th>
          </tr>
        </thead>
        <tbody>
          <tr ng-repeat="email in home.emails">
            <td>{{email.Sender.EmailAddress.Name}} ({{email.Sender.EmailAddress.Address}})</td>
            <td>{{email.Subject}}</td>
            <td>{{email.BodyPreview}}</td>
            <td><a href={{email.WebLink}}>View on OWA</a></td>
          </tr>

          <tr ng-if="home.emails.length == 0">
            <td colspan="4" align="center">Your inbox is empty.</td>
          </tr>
        </tbody>
      </table>
    </div>
  </row>
</div>

Tester votre application

Testons votre application pour nous assurer qu'elle authentifie correctement l'utilisateur auprès d'Azure AD et qu'elle récupère les e-mails de l'utilisateur. À partir d'une invite de commande dans votre répertoire Starter, entrez la commande node server.js. Elle va démarrer un serveur de développement en écoute sur le port 8080. Accédez à http://127.0.0.1:8080/ dans un navigateur web. Si vous avez suivi toutes les étapes correctement, votre application doit alors vous diriger vers une page de connexion Azure Active Directory. Connectez-vous en utilisant vos informations d'identification Office 365 (user@{votre_sous-domaine}.onmicrosoft.com) et vérifiez que vous revenez à l'application, où vous trouverez votre e-mail.

Félicitations ! Vous venez de créer une application Angular à l'aide des API Office 365.

Capture d'écran de l'application

Étapes suivantes

Maintenant que vous avez créé une application utilisant l'API Courrier, vous pouvez explorer les autres API REST Office 365 disponibles pour vos applications.

Ressources supplémentaires

Vous ne développez pas d'applications web ASP.NET MVC ? Utilisez le contrôle situé dans le coin supérieur droit pour sélectionner le type d'application que vous développez.

Créer une application ASP.NET MVC avec les API Office 365

Lorsque vous créez votre application, vous pouvez la programmer directement sur les API REST pour intéragir avec Office 365 ou vous pouvez utiliser les outils de développement Office pour Visual Studio.

Les outils de développement Office pour Visual Studio incluent des bibliothèques client et des améliorations de l'interface utilisateur qui aident à accéder aux services des API Office 365. Les bibliothèques client .NET Framework et JavaScript simplifient les interaction avec les API REST Office 365 à partir de l'équipement ou de la plateforme de votre choix. Les améliorations de l'interface utilisateur Visual Studio facilitent quant à elles l'ajout de services Office 365 à vos projets d'application.

Dans cette article, nous vous guiderons à travers la création dans Visual Studio d'une application MVC (Model-View Controller) simple qui utilisera les API Office 365. Cela implique de :

  1. Créer votre application et ajouter des dépendances
  2. Coder votre application
  3. Tester votre application

Avant de commencer

Avant de pouvoir créer des applications qui accéderont aux API Office 365, vous devez configurer votre environnement de développement. Il s'agit de trois tâches uniques qui vous assureront de disposer du bon environnement et de tous les outils nécessaires pour réussir :

  1. Téléchargez Viseual Studio et les outils de développement Office dont vous aurez besoin pour créer vos applications.
  2. Obtenez un abonnement Office 365 Business pour accéder aux API Office 365.
  3. Associez votre compte Office 365 à Azure AD pour pouvoir créer et gérer des applications.

Si vous n'avez pas encore accompli ces étapes, jetez un œil à l'article Configurer votre environnement de développement Office 365 où vous trouverez des instructions détaillées.


Créer votre application et ajouter des dépendances

Après avoir configuré votre environnement de développement, vous êtes prêt à utiliser Visual Studio pour créer une application web utilisant les API Office 365.

L'exemple que nous allons créer sera une application MVC utilisant l'authentification unique Azure AD pour authentifier l'utilisateur et lire ses informations de contacts à partir d'Office 365. Nous utiliserons pour modèle le projet MVC à client unique Office 365, disponible sur GitHub.

Sélectionnez la version de Visual Studio que vous utilisez :

  1. Dans Visual Studio, sélectionnez Fichier > Nouveau.
  2. Sous Visual C# > Web, sélectionnez Application web ASP.NET. Donnez un nom au projet et cliquez sur OK.
  3. Sélectionnez MVC.
  4. Sélectionnez Modifier l'authentification, puis Aucune authentification et cliquez deux fois sur OK pour créer le projet.

Les services de l'API Office 365 utilisent Azure AD pour fournir une authentification sécurisée aux données Office 365 des utilisateurs. Pour accéder aux API Office 365, vous devez enregistrer votre application auprès d'Azure AD.

Lorsque vous ajoutez un service Office 365 à votre projet, Visual Studio vous aide à enregistrer votre application

Si vous créez un projet Visual Studio, l'enregistrement de l'application est géré à votre place si vous y ajoutez un service Office 365. Au cours du processus d'ajout d'un service Office 365 à votre projet, Visual Studio vous permet de :

  • Enregistrer votre application auprès d'Azure AD, en spécifiant notamment si votre application est une application web ou une application native
  • Configurer les propriétés de l'application, telles que le nom de l'application, ses points de terminaison de redirection/réponse et l'étendue client
  • Enregistrer votre application auprès d'Azure AD
  • Vous connecter aux services Office 365
  • Indiquer les niveaux d'autorisation requis par votre application pour les API de ces services Office 365
  • Ajouter les packages NuGet nécessaires au projet, selon les services Office 365 auxquels votre application est connectée

Les modèles de projet suivants prennent en charge l'ajout des API Office 365 en tant que service connecté :

  • Applications .NET Windows Store 8.1
  • Applications universelles .NET Windows Store 8.1
  • Applications .NET Windows Phone 8.1
  • Applications .NET Windows Phone 8.1 Silverlight
  • Applications Windows Forms
  • Applications WPF
  • Applications web ASP.NET MVC
  • Applications ASP.NET Web Forms
  • Applications Xamarin Android et iOS
  • Applications hybrides multi-appareils (Cordova)

Utilisez le gestionnaire de services de Visual Studio pour enregistrer votre application et ajouter des API Office 365 à votre projet

Vous ajoutez et configurez les API Office 365 en utilisant le gestionnaire de services dans Visual Studio.

  1. Dans l'Explorateur de solutions, choisissez le nœud du projet.

  2. Faites un clic droit ou pressez et maintenez le nœud du projet, et choisissez Ajouter > Service connecté.

  3. Enregistrez votre application :

    En haut de la boîte de dialogue Gestionnaire de services, sélectionnez le lien Office 365, puis choisissez Enregistrer votre application. Connectez-vous en utilisant un compte administrateur client pour votre organisation de développement Office 365.

    Vous démarrez ainsi l'enregistrement de l'application dans Azure Active Directory, qui permet à votre application de s'authentifier via OAuth.

    Une fois que vous avez ouvert une session sur Office 365, une liste des services d'API Office 365 disponibles s'affiche. Vous voyez alors une liste d'API Office 365.

    Vous constaterez que la colonne Autorisations située à droite de chaque service est vide.

  4. Sélectionnez les API Office 365 auxquelles vous souhaitez vous connecter et spécifiez les niveaux d'autorisation pour chacune d'entre elles.

    1. Pour cet exemple, sélectionnez Utilisateurs et groupes. Choisissez Autorisations.

      Capture d'écran présentant la boîte de dialogue Gestionnaire de services dans laquelle l'API Office 365 du service Utilisateurs et groupes est sélectionnée et le lien Autorisations est mis en surbrillance.

    2. Sélectionnez Activer la connexion et lire le profil des utilisateurs et choisissez Appliquer.

      Capture d'écran présentant la boîte de dialogue Autorisations Utilisateurs et groupes dans laquelle l'autorisation Activer la connexion et le profil des utilisateurs est sélectionnée.

    3. Sélectionnez ensuite Contacts. Choisissez Autorisations.

    4. Sélectionnez Lire les contacts des utilisateurs et choisissez Appliquer.

      Lorsque vous effectuez ceci, Visual Studio ajoute les services Office 365 qui contiennent les API que vous avez sélectionnées à votre application dans Azure AD, et définit les niveaux d'autorisation pour les API sur les niveaux que vous avez spécifié.

  5. Définissez les propriétés de votre application :

    Choisissez Propriétés de l'application dans la boite de dialogue du Gestionnaire de services.

    Les propriétés de l'application que vous pouvez définir diffèrent selon que votre projet d'application est un service web, une application web ou une application native comme un projet de téléphone mobile.

    Par exemple, dans le cas d'une application web telle que celle que nous sommes en train de créer, vous pouvez choisir de rendre l'application disponible aux organisations Office 365 autres que votre organisation de développement.

    Nous allons pour le moment laisser les propriétés de l'application telles qu'elles sont.

    La boîte de dialogue Gestionnaire de services répertorie maintenant :

    • Les services que vous avez choisi d'ajouter à votre projet.
    • Les autorisations pour chaque service.

      Capture d'écran de la boîte de dialogue Gestionnaire de services après la configuration des API Utilisateurs et groupes et Contact, indiquant que les deux API possèdent des autorisations de lecture.

  6. Sélectionnez OK.

À ce stade, Visual Studio ajoute les packages NuGet au projet. Les packages NuGet ajoutés varient en fonction des API Office 365 que vous avez ajoutées.

  1. Dans l' Explorateur de solutions, choisissez le nœud de projet auquel vous souhaitez ajouter un service Office 365.

  2. Faites un clic droit ou pressez et maintenez le nœud du projet, et choisissez Ajouter > Service connecté.

  3. Sur l'onglet Microsoft, sélectionnez API Office 365 et choisissez Configurer.

    La boîte de dialogue Configurer les services d'API Office 365 apparaît alors.

  4. Enregistrez votre application :

    Sur la page Sélectionner un domaine, entrez ou sélectionnez le domaine Office 365 dans lequel vous souhaitez enregistrer votre application ; par exemple, contoso.onmicrosoft.com. Cliquez sur Suivant. Vous devrez peut-être ouvrir une session dans Office 365 si vous n'êtes pas déjà connecté.

    Sur la page Configurer l'application, choisissez de créer une nouvelle application Azure AD.

    Cochez la case pour utiliser l'authentification unique dans votre application. Comme l'authentification unique nécessite SSL, la sélection de cette option active automatiquement SSL dans votre projet.

    Cliquez sur Suivant.

    Visual Studio enregistre votre application.

  5. Sélectionnez les API Office 365 auxquelles vous souhaitez vous connecter et spécifiez les niveaux d'autorisation pour chacune d'entre elles. Pour cet exemple :

    1. Sélectionnez Contacts.

    2. Cochez Lire vos contacts.

    3. Sélectionnez Utilisateurs et groupes.

    4. Cochez Se connecter et lire votre profil.

  6. Sélectionnez Terminer.

À ce stade, Visual Studio ajoute les packages NuGet au projet. Les packages NuGet ajoutés varient en fonction des API Office 365 que vous avez ajoutées.


Coder votre application

Après avoir ajouté les services Office 365 à votre projet, vous devrez écrire le code qui authentifiera l'utilisateur de l'application et accèdera à ses données Office 365.

Le processus d'authentification est différent selon que vous créez une application web, telle qu'une application MVC, ou une application native, telle qu'une application du Windows Store.

L'application ASP.NET MVC de cet exemple emploiera un cache de jetons persistant de la bibliothèque d'authentification Active Directory (ADAL) qui utilise une base de données pour la mise en cache. ADAL vous permet d'authentifier les utilisateurs sur Active Directory (AD), ici Azure AD, puis d'obtenir des jetons d'accès pour sécuriser les appels d'API.

Le développement de l'exemple se compose ensuite de trois grandes étapes :


Configurer votre projet pour l'authentification auprès Azure Active Directory

Puisque l'exemple que nous développons nécessite uniquement d'authentifier les informations d'identification Office 365, nous utiliserons OWIN   Katana et la bibliothèque d'authentification Active Directory (ADAL).

Mais tout d'abord, vous devez configurer le projet pour lui permettre d'utiliser le protocole SSL (Secure Sockets Layer).

Activez le protocole SSL pour votre projet

Par défaut, Visual Studio ne configure pas votre projet pour le protocole SSL. Si vous n'avez pas encore activé le protocole SSL dans votre projet, vous devez le faire maintenant, puis mettre à jour les services Office 365 avec l'URL de redirection appropriée.

Pour activer le protocole SSL :

  1. Dans l’ Explorateur de solutions, choisissez le nom du projet.
  2. Dans Propriétés, définissez SSL Enabled sur True.

    Visual Studio spécifie une valeur pour l'URL SSL.

Mettez ensuite l'application à jour pour utiliser le point de terminaison HTTPS pour la page d'accueil :

  1. Dans l’Explorateur de solutions, faites un clic droit sur le projet et sélectionnez Propriétés.
  2. Sélectionnez l'onglet Web. Sous Serveurs, définissezURL du projet sur le point de terminaison HTTPS que Visual Studio a créé pour l'URL SSL.

Enfin, mettez à jour les services Office 365 :

  1. Dans l'Explorateur de solutions, faites un clic droit sur le projet et sélectionnez Ajouter > Service connecté. Connectez-vous si nécessaire.

    Visual Studio vous indique qu'une ou plusieurs des URL de redirection de votre projet n'existent pas au sein de l'entrée correspondant à votre application dans Azure AD.

  2. Cliquez sur Oui pour ajouter l'URL de redirection sécurisée à l'entrée de votre application dans Azure AD.

  3. Cliquez sur OK pour sortir du gestionnaire de services.
Gérer les packages NuGet nécessaires à l'authentification

Vous devez installer les packages Azure AD et OWIN Katana suivants pour l'authentification :

Ces packages peuvent également installer un certain nombre de packages NuGet en tant que dépendances.

Pour télécharger et installer les packages NuGet :

  1. Dans l'Explorateur de solutions, faites un clic droit sur le projet.
  2. Sélectionnez Gérer les packages NuGet...
  3. Dans Gérer les packages NuGet, choisissez En ligne.
  4. Utilisez la zone de recherche pour trouver le package nécessaire.
  5. Sélectionnez le package et cliquez sur Installer.
  6. Dans Sélectionner des projets, cliquez sur OK.
  7. Acceptez toutes les licences lorsque vous y êtes invité.
Mettre à jour le fichier web.config pour activer l'authentification

Lorsque vous avez ajouté des services Office 365 à votre projet, Visual Studio a ajouté les propriétés suivantes au registre de votre application dans Azure AD, ainsi qu'au fichier web.config de votre solution.

<add key="ida:ClientId" value="app-azure-ad-client-id" />
<add key="ida:ClientSecret" value="app-azure-ad-password" />
<add key="ida:TenantId" value="azure-tenant-where-app-is-registered" />
<add key="ida:AADInstance" value="https://login.microsoftonline.com/" 
Créer une base de données pour gérer les jetons d'authentification ADAL

Ajoutez ensuite une base de donnée pour le projet. Elle agira en tant que cache de jetons ADAL.

Pour plus d'informations sur le cache de jetons ADAL, consultez Le nouveau cache de jetons dans ADAL v2.

Pour ajouter la base de données qui servira de cache de jetons ADAL :

  1. Dans l'Explorateur de solutions, faites un clic droit sur le dossier App_Data et sélectionnez Ajouter > Nouvel élément...
  2. Assurez-vous que Données soit bien sélectionné, puis sélectionnez Base de données SQL Server. Nommez la base de données ADALTokenCacheDb et cliquez sur Ajouter.

Assurez-vous que la connexion à la base de données ait bien été ajoutée au web.config du projet :

  1. Dans l'Explorateur de solutions, double-cliquez sur web.config.
  2. Assurez-vous que la section suivante a été ajoutée au fichier web.config après la section appSettings. Si ce n'est pas le cas, ajoutez-la :

    <connectionStrings>
    <add name="DefaultConnection"
        connectionString="Data Source=(LocalDB)\v11.0;AttachDbFilename=|DataDirectory|\ADALTokenCacheDb.mdf;Integrated Security=True" providerName="System.Data.SqlClient" />
    </connectionStrings>
    
  3. Enregistrez le fichier.

Copier les fichiers nécessaires à l'authentification

Vous allez ensuite importer des fichiers du projet GitHub projet MVC à client unique Office 365.

Pour copier des fichiers du projet GitHub :

  1. Dans un navigateur, accédez au fichier sur lequel vous souhaitez copier. (Les fichiers sont répertoriés ci-dessous).
  2. Faites un clic droit sur le bouton Raw, puis sélectionnez Enregistrer la cible sous
  3. Enregistrez le fichier sur votre ordinateur.
  4. Dans l'Explorateur de solutions de Visual Studio, sous le nœud du projet, faites un clic droit sur le dossier spécifié, comme indiqué ci-dessous, et sélectionnez Ajouter > Élément existant.
  5. Sélectionnez le fichier là où vous l'avez enregistré sur votre ordinateur.

Copiez les fichiers suivants dans le dossier Modèles du projet. Ces classes montrent comment un cache de jetons ADAL persistant peut être construit et utilisé pour stocker des jetons.

Créez un nouveau dossier, Utils.

  1. Dans l’Explorateur de solutions, faites un clic droit sur le projet et sélectionnez Ajouter > Nouveau dossier.
  2. Nommez le dossier Utils.

Copiez le fichier suivant dans ce nouveau dossier. Cette classe d'assistance contient des variables membres qui lisent les valeurs du fichier web.config de votre projet. Vous en aurez besoin pour créer l'objet d'authentification ADAL au démarrage.

Enfin, copiez le fichier _LoginPartial.cshtml dans le dossier Views > Shared de votre projet.


Authentifier auprès d'Azure Active Directory

Maintenant que le projet est configuré pour l'authentification, nous pouvons ajouter la fonctionnalité qui gère l'authentification auprès d'Azure AD.

Configurer l'authentification unique Azure AD

Vous devez ajouter une classe de démarrage OWIN au projet, pour gérer réellement l'authentification. Pour ajouter la classe de démarrage OWIN :

  1. Dans l’Explorateur de solutions, faites un clic droit sur le projet et sélectionnez Ajouter > Nouvel élément...
  2. Dans Ajouter un nouvel élément, sous Web, sélectionnez Général, puis sélectionnez Classe de démarrage OWIN.
  3. Dans Nom, entrez Startup.
  4. Sélectionnez Ajouter.

Une nouvelle classe de démarrage est ajoutée à votre projet.

Ajoutons ensuite le code qui gère l'authentification :

  1. Remplacez les références d'espace de noms du fichier par les éléments suivants.

    
        using Microsoft.IdentityModel.Clients.ActiveDirectory;
        using Microsoft.Owin.Security;
        using Microsoft.Owin.Security.Cookies;
        using Microsoft.Owin.Security.OpenIdConnect;
        using O365_WebApp_SingleTenant.Models;
        using O365_WebApp_SingleTenant.Utils;
        using Owin;
        using System;
        using System.IdentityModel.Claims;
        using System.Threading.Tasks;
        using System.Web;
        using Microsoft.Owin;
    
  2. Ajoutez la méthode suivante, ConfigureAuth, à la classe Startup.

    
        public void ConfigureAuth(IAppBuilder app)
        {
            app.SetDefaultSignInAsAuthenticationType(CookieAuthenticationDefaults.AuthenticationType);
    
            app.UseCookieAuthentication(new CookieAuthenticationOptions());
    
            app.UseOpenIdConnectAuthentication(
                new OpenIdConnectAuthenticationOptions
                {
                    ClientId = SettingsHelper.ClientId,
                    Authority = SettingsHelper.Authority,
    
                    Notifications = new OpenIdConnectAuthenticationNotifications()
                    {                       
                        // If there is a code in the OpenID Connect response, redeem it for an access token and refresh token, and store those away.
                        AuthorizationCodeReceived = (context) =>
                        {
                            var code = context.Code;
                            ClientCredential credential = new ClientCredential(SettingsHelper.ClientId, SettingsHelper.AppKey);
                            String signInUserId = context.AuthenticationTicket.Identity.FindFirst(ClaimTypes.NameIdentifier).Value;
    
                            AuthenticationContext authContext = new AuthenticationContext(SettingsHelper.Authority, new ADALTokenCache(signInUserId));
                            AuthenticationResult result = authContext.AcquireTokenByAuthorizationCode(code, new Uri(HttpContext.Current.Request.Url.GetLeftPart(UriPartial.Path)), credential, SettingsHelper.AADGraphResourceId);
    
                            return Task.FromResult(0);
                        },
                        RedirectToIdentityProvider = (context) =>
                        {
                            // This ensures that the address used for sign in and sign out is picked up dynamically from the request
                            // this allows you to deploy your app (to Azure Web Sites, for example)without having to change settings
                            // Remember that the base URL of the address used here must be provisioned in Azure AD beforehand.
                            string appBaseUrl = context.Request.Scheme + "://" + context.Request.Host + context.Request.PathBase;
                            context.ProtocolMessage.RedirectUri = appBaseUrl + "/";
                            context.ProtocolMessage.PostLogoutRedirectUri = appBaseUrl;
    
                            return Task.FromResult(0);
                        },
                        AuthenticationFailed = (context) =>
                        {
                            // Suppress the exception if you don't want to see the error
                            context.HandleResponse();
                            return Task.FromResult(0);
                        }
                    }
    
                });
        }
    
  3. Ajoutez du code à la méthode Startup.Configuration qui appelle la méthode ConfigureAuth.

        public void Configuration(IAppBuilder app)
        {
            ConfigureAuth(app);
        }
    
Ajouter un contrôleur pour la connexion et la déconnexion d'Office 365

Ajoutez un contrôleur de compte pour gérer la connexion et la déconnexion :

  1. Dans l'Explorateur de solutions, faites un clic droit sur le dossier Contrôleurs et sélectionnez Ajouter > Contrôleur...
  2. Sélectionnez Contrôleur MVC 5 - Vide et choisissez Ajouter.
  3. En guise de nom pour le contrôleur, entrez AccountControlleret choisissez Ajouter.
  4. Remplacez les références d'espace de noms dans le fichier contrôleur par les éléments suivants.

        using Microsoft.IdentityModel.Clients.ActiveDirectory;
        using Microsoft.Owin.Security;
        using Microsoft.Owin.Security.Cookies;
        using Microsoft.Owin.Security.OpenIdConnect;
        using O365_WebApp_SingleTenant.Utils;
        using System.Security.Claims;
        using System.Web;
        using System.Web.Mvc;
    
  5. Supprimez la méthode Index ().

  6. Ajoutez les méthodes suivantes à la classe AccountController pour gérer la connexion et la déconnexion.

        public void SignIn()
        {
            if (!Request.IsAuthenticated)
            {
                HttpContext.GetOwinContext().Authentication.Challenge(new AuthenticationProperties { RedirectUri = "/" }, OpenIdConnectAuthenticationDefaults.AuthenticationType);
            }
        }
        public void SignOut()
        {
            string callbackUrl = Url.Action("SignOutCallback", "Account", routeValues: null, protocol: Request.Url.Scheme);
    
            HttpContext.GetOwinContext().Authentication.SignOut(
                new AuthenticationProperties { RedirectUri = callbackUrl },
                OpenIdConnectAuthenticationDefaults.AuthenticationType, CookieAuthenticationDefaults.AuthenticationType);
        }
    
        public ActionResult SignOutCallback()
        {
            if (Request.IsAuthenticated)
            {
                // Redirect to home page if the user is authenticated.
                return RedirectToAction("Index", "Home");
            }
    
            return View();
        }
    


Accéder aux API Office 365

Vous êtes maintenant prêt à ajouter le code qui accèdera aux données Office 365 de l'utilisateur.

Créer le modèle pour l'affichage des informations sur les contacts

Vous devez tout d'abord créer la classe sur laquelle nous baserons l'affichage Contact :

  1. Dans l'Explorateur de solutions, faites un clic droit sur le dossier Modèles et sélectionnez Ajouter > Classe...
  2. Sélectionnez Classe, entrez MyContact en tant que nom, et cliquez sur Ajouter.
  3. Dans la classe, ajoutez la ligne de code suivante.

    
        public class MyContact
        {
            public string Name { get; set; }
        }
    
  4. Enregistrez le fichier.

Ajouter un contrôleur pour les informations de contact

Ensuite, ajoutez un contrôleur pour les informations de contact des utilisateurs :

  1. Dans l'Explorateur de solutions, faites un clic droit sur le dossier Contrôleurs et sélectionnez Ajouter > Contrôleur
  2. Sélectionnez Contrôleur MVC 5 - Vide et choisissez Ajouter.
  3. Entrez le nom de contrôleur ContactsController et cliquez sur Ajouter.

    Visual Studio ajoute un nouveau contrôleur vide au projet.

  4. Remplacez les références d'espace de noms dans le fichier contrôleur par les éléments suivants.

        using Microsoft.IdentityModel.Clients.ActiveDirectory;
        using Microsoft.Office365.Discovery;
        using Microsoft.Office365.OutlookServices;
        using O365_WebApp_SingleTenant.Models;
        using O365_WebApp_SingleTenant.Utils;
        using System.Collections.Generic;
        using System.Security.Claims;
        using System.Threading.Tasks;
        using System.Web.Mvc;
    

    Assurez-vous d'ajouter une référence d'espace de noms pour l'espace de noms Modèles de votre projet.

            using [projectname].Models;
    
  5. Ajoutez l'attribut [Authorize] à la classe ContactsController.

    L'attribut [Authorize] exige que l'utilisateur soit authentifié avant de pouvoir accéder à ce contrôleur.

        [Authorize]
        public class ContactsController : Controller
    
  6. Modifiez la méthode Index() pour qu'elle soit asynchrone.

        public async Task<ActionResult> Index()
    
  7. Ajoutez le code suivant à la méthode Index().

    Ce code crée le contexte d'authentification à l'aide de l'ID utilisateur Office 365 connecté et de l'autorité pour votre client Office 365.

            List<MyContact> myContacts = new List<MyContact>();
    
            var signInUserId = ClaimsPrincipal.Current.FindFirst(ClaimTypes.NameIdentifier).Value;
            var userObjectId = ClaimsPrincipal.Current.FindFirst("http://schemas.microsoft.com/identity/claims/objectidentifier").Value;
    
            AuthenticationContext authContext = new AuthenticationContext(SettingsHelper.Authority, new ADALTokenCache(signInUserId));
    
  8. Ajoutez un bloc try-catch directement sous le code ci-dessus dans la méthode Index().

    
            try
            {
    
            }
            catch (AdalException exception)
            {
                //handle token acquisition failure
                if (exception.ErrorCode == AdalError.FailedToAcquireTokenSilently)
                {
                    authContext.TokenCache.Clear();
    
                    //handle token acquisition failure
                }
            }
    
            return View(myContacts);
    
  9. Dans le bloc try du code ci-dessus, ajoutez le code suivant à la méthode Index().

    Ce code essaie d'acquérir un jeton d'accès au Service de découverte en transmettant l'ID client et le mot de passe de l'application, ainsi que les informations d'identification de l'utilisateur. Comme le jeton d'authentification de l'utilisateur a été mis en cache, le contrôleur peut acquérir le jeton d'accès nécessaire en mode silencieux, sans avoir à demander de nouveau à l'utilisateur ses informations d'identification.

    Avec le jeton d'accès, l'application peut créer un objet client service de découverte et utiliser l'objet client de découverte pour déterminer le point de terminaison de la ressource pour les API Contact du service Office 365.

                DiscoveryClient discClient = new DiscoveryClient(SettingsHelper.DiscoveryServiceEndpointUri,
                    async () =>
                    {
                        var authResult = await authContext.AcquireTokenSilentAsync(SettingsHelper.DiscoveryServiceResourceId, new ClientCredential(SettingsHelper.ClientId, SettingsHelper.AppKey), new UserIdentifier(userObjectId, UserIdentifierType.UniqueId));
    
                        return authResult.AccessToken;
                    });
    
                var dcr = await discClient.DiscoverCapabilityAsync("Contacts");
    
  10. Enfin, directement sous le code ci-dessus dans le bloc try, ajoutez le code suivant à la méthode Index().

    Ce code contacte le point de terminaison de la ressource pour les API Contact du service Office 365, en mode silencieux, une fois encore, et transmet les informations d'identification de l'application et de l'utilisateur pour acquérir un jeton d'accès au service Outlook.

    Une fois le jeton d'accès reçu, le code peut initialiser un objet client Outlook. Le code utilise ensuite la propriété Me de l'objet client Outlook pour récupérer les informations de contacts pour cet utilisateur.

    Enfin, le contrôleur lit la liste des contacts de l'utilisateur et renvoie un affichage répertoriant leurs noms d'affichage.

    
                OutlookServicesClient exClient = new OutlookServicesClient(dcr.ServiceEndpointUri,
                    async () =>
                    {
                        var authResult = await authContext.AcquireTokenSilentAsync(dcr.ServiceResourceId, new ClientCredential(SettingsHelper.ClientId, SettingsHelper.AppKey), new UserIdentifier(userObjectId, UserIdentifierType.UniqueId));
    
                        return authResult.AccessToken;
                    });
    
                var contactsResult = await exClient.Me.Contacts.ExecuteAsync();
    
                do
                {
                    var contacts = contactsResult.CurrentPage;
                    foreach (var contact in contacts)
                    {
                        myContacts.Add(new MyContact { Name = contact.DisplayName });
                    }
    
                    contactsResult = await contactsResult.GetNextPageAsync();
    
                } while (contactsResult != null);
    

    La méthode Index() terminée devrait maintenant ressembler à cela.

        public async Task<ActionResult> Index()
        {
            List<MyContact> myContacts = new List<MyContact>();
    
            var signInUserId = ClaimsPrincipal.Current.FindFirst(ClaimTypes.NameIdentifier).Value;
            var userObjectId = ClaimsPrincipal.Current.FindFirst("http://schemas.microsoft.com/identity/claims/objectidentifier").Value;
    
            AuthenticationContext authContext = new AuthenticationContext(SettingsHelper.Authority, new ADALTokenCache(signInUserId));
    
            try
            {
                DiscoveryClient discClient = new DiscoveryClient(SettingsHelper.DiscoveryServiceEndpointUri,
                    async () =>
                    {
                        var authResult = await authContext.AcquireTokenSilentAsync(SettingsHelper.DiscoveryServiceResourceId, new ClientCredential(SettingsHelper.ClientId, SettingsHelper.AppKey), new UserIdentifier(userObjectId, UserIdentifierType.UniqueId));
    
                        return authResult.AccessToken;
                    });
    
                var dcr = await discClient.DiscoverCapabilityAsync("Contacts");                
    
                OutlookServicesClient exClient = new OutlookServicesClient(dcr.ServiceEndpointUri,
                    async () =>
                    {
                        var authResult = await authContext.AcquireTokenSilentAsync(dcr.ServiceResourceId, new ClientCredential(SettingsHelper.ClientId, SettingsHelper.AppKey), new UserIdentifier(userObjectId, UserIdentifierType.UniqueId));
    
                        return authResult.AccessToken;
                    });
    
                var contactsResult = await exClient.Me.Contacts.ExecuteAsync();
    
                do
                {
                    var contacts = contactsResult.CurrentPage;
                    foreach (var contact in contacts)
                    {
                        myContacts.Add(new MyContact { Name = contact.DisplayName });
                    }
    
                    contactsResult = await contactsResult.GetNextPageAsync();
    
                } while (contactsResult != null);
            }
            catch (AdalException exception)
            {
                //handle token acquisition failure
                if (exception.ErrorCode == AdalError.FailedToAcquireTokenSilently)
                {
                    authContext.TokenCache.Clear();
    
                    //handle token acquisition failure
                }
            }
    
            return View(myContacts);
        }
    
Créer l'affichage pour les données de contacts

Vous pouvez maintenant créer l'affichage pour les informations de contact de l'utilisateur. Vous le ferez en basant l'affichage sur la classe MyContact que vous avez créée tout à l'heure.

  1. Dans l'Explorateur de solutions, faites un clic droit sur le dossier Contacts et sélectionnez Ajouter > Affichage.
  2. Dans la boîte de dialogue Ajouter un affichage, définissez le nouvel affichage :
    • Pour Nom de l'affichage, entrez Index.
    • Pour Modèle, sélectionnez Liste.
    • Pour Classe modèle, sélectionnez MyContact.
    • Sélectionnez Ajouter.
  1. Dans l'Explorateur de solutions, dans le dossier Partagé, double-cliquez sur le fichier _Layout.cshtml.

  2. Ajoutez un lien d'action pour la page MyContacts et injectez la classe partielle pour la connexion de l'utilisateur.

  3. Mettez à jour le code HTML de la barre de navigation à partir de ce qui a été généré automatiquement.

            <div class="navbar-collapse collapse">
                <ul class="nav navbar-nav">
                    <li>@Html.ActionLink("Home", "Index", "Home")</li>
                    <li>@Html.ActionLink("About", "About", "Home")</li>
                    <li>@Html.ActionLink("Contact", "Contact", "Home")</li>
                </ul>
            </div>
    

    Pour les éléments suivants, ajoutez un lien d'action pour la page MyContacts et injectez la classe partielle pour la connexion de l'utilisateur.

            <div class="navbar-collapse collapse">
                <ul class="nav navbar-nav">
                    <li>@Html.ActionLink("Home", "Index", "Home")</li>
                    <li>@Html.ActionLink("About", "About", "Home")</li>
                    <li>@Html.ActionLink("Contact", "Contact", "Home")</li>
                    <li>@Html.ActionLink("My Contacts", "Index", "Contacts")</li>
                </ul>
                @Html.Partial("_LoginPartial")
            </div>
    


Tester votre application

Vous êtes maintenant prêt à exécuter la solution. Appuyez sur F5 pour déboguer votre application web.

S'il s'agit d'un nouvel environnement de développement, Visual Studio peut vous inviter à configurer le certificat SSL IIS. Sélectionnez Oui deux fois pour continuer.

  1. Visual Studio lancera l'application web dans le navigateur que vous avez sélectionné dans Visual Studio.

  2. Cliquez sur Se connecter, dans l'angle supérieur droit de la page, et connectez-vous au client Office 365 sur lequel vous avez enregistré votre application Web.

    Étant donné que seuls les utilisateurs de votre organisation sont autorisés à se connecter à une application à client unique, aucun consentement n'est nécessaire. Si votre application était mutualisée, Azure AD afficherait une page de consentement répertoriant les autorisations demandées à l'application, afin que vous puissiez consentir à accorder ces autorisations à l'application.

  3. Une fois que vous êtes connecté, vous devriez voir votre adresse e-mail et Déconnexion s'afficher dans la barre de navigation en haut de la page d'accueil.

  4. Cliquez sur Mes contacts.

    La page Mes contacts récupérera et affichera les noms de tous les contacts Exchange de votre client.

Vous avez maintenant un projet d'application web que vous pouvez personnaliser pour y intégrer les API Office 365.

Étapes suivantes

Explorez les API REST Office 365 disponibles pour vos applications.

Visitez le Référentiel d'exemples de code Office sur GitHub pour télécharger ou explorer des exemples de code utilisant les API Office 365 dans un large éventail de projets, notamment :

Ressources supplémentaires

© 2018 Microsoft