Table of contents
TOC
Inhaltsverzeichnis reduzieren
Inhaltsverzeichnis erweitern
Zuletzt aktualisiert: 29.06.2018

Erstellen einer App mit Office 365-APIs

Gilt für: Office 365

Die Office 365 API-Funktionalität ist auch über Microsoft Graphverfügbar, einer Unified API, die APIs von anderen Microsoft-Diensten wie Outlook, OneDrive, OneNote, Planner und Office Graph enthält und über einen einzigen Endpunkt sowie mit einem einzigen Zugriffstoken erreichbar ist. Wir empfehlen Ihnen, wenn möglich Microsoft Graph in Ihren Apps zu verwenden.

Die Office 365-APIs sind REST-Dienste, die den Zugriff auf Office 365-Daten wie E-Mails, Kalender und Kontakte aus Exchange Online, Dateien und Ordner aus SharePoint Online und OneDrive for Business sowie Benutzer und Gruppen aus Azure Active Directory ermöglichen.

Sie entwickeln keine iOS-Anwendungen? Verwenden Sie das Steuerelement in der oberen rechten Ecke dieser Seite, um die Art der App auszuwählen, die Sie entwickeln.

Diese Dokumentation umfasst Features, die sich derzeit in der Vorschau befinden.

Erstellen einer iOs-App mit Office 365-APIs

Sie können iOS-Anwendungen erstellen, die mit Office 365-APIs integriert werden können. Wenn Sie Ihre iOS-App erstellen, können Sie direkt mit den REST-APIs programmieren, um mit Office 365 zu interagieren, oder Sie können das Office 365 iOS SDKverwenden, das ein Objektmodell ist, das auf den REST APIs aufbaut, um die App zu erstellen. In diesem Thema führen wir Sie durch die Erstellung einer grundlegenden iOS-App, die das Office 365 iOS SDK verwendet, um die E-Mails eines Benutzers abzurufen und auf seinem Gerät anzuzeigen. Die Übersicht basiert auf dem Beispiel von Office 365 Connect.

Im Folgenden finden Sie Beispiele für Office 365 iOS-Code:

Hinweis Diese Code-Beispiele verwenden das Office 365 SDK für iOS zur Verbindung mit Office 365.

Vor der Bereitstellung

Bevor Sie Anwendungen erstellen können, die auf die Office 365-APIs zugreifen, müssen Sie Ihre Entwicklerumgebung einrichten. Dies besteht aus drei einmaligen Aufgaben, um sicherzustellen, dass Sie die Tools und die Umgebung haben, um erfolgreich zu sein:

  1. Richten Sie die iOS-App-Entwicklungsumgebung ein, mit der Sie Ihre Apps erstellen. Dies beinhaltet die Installation und Einrichtung der CocoaPods-Umgebung.

  2. Melden Sie ein Office 365 Business-Konto an, um auf die Office 365-APIs zuzugreifen.

  3. Verknüpfen Sie Ihr Office 365-Abonnement mit Azure Active Directory, damit Sie Apps erstellen und verwalten können.

Wenn Sie noch einen dieser Schritte durchführen müssen, finden Sie unter Einrichten Ihrer Office 365-Entwicklungsumgebung detaillierte Anweisungen zum Einrichten.

Erstellen Sie Ihre App und fügen Sie Abhängigkeiten hinzu

Dazu erstellen Sie ein iOS-Projekt und verwenden CocoaPods, um Abhängigkeiten zum Office 365 SDK für iOS und der Azure Active Directory Authentifizierungsbibliothek (ADAL) für iOS hinzuzufügen.

Erstellen Sie das SimpleMailApp-Projekt

  1. Öffnen Sie Xcode
  2. Wählen Sie Datei > Neu > Projekt aus.
  3. Wählen Sie die Vorlage Single View Application im Abschnitt Anwendungen* der **iOS-Projektvorlagen und wählen Sie dann Weiter.
  4. Geben Sie SimpleMailApp als Produktname an, wählen Sie Objective-C für Sprache, Universal für Geräte, einen Wert für Organisationsbezeichner und wählen Sie dann Weiter.
  5. Wählen Sie den Speicherort für Ihr Projekt, geben Sie an, ob es unter Versionskontrolle stehen soll, und wählen Sie dann Erstellen.
  6. Nachdem das Projekt erstellt wurde, schließen Sie Xcode.

Die Cocoapods-Befehle müssen im Stammverzeichnis des Projektordners ausgeführt werden, also navigieren Sie vom Terminal aus zum Projektverzeichnis. Wenn Sie den Standardspeicherort beim Erstellen des Projekts nicht geändert haben, befindet sich das Projekt im Verzeichnis SimpleMailApp im Verzeichnis Desktop.

Cocoapods für das SimpleMailApp-Projekt aktivieren

  1. Führen Sie den folgenden Befehl aus, um das Podfile für Ihr Projekt zu initialisieren.

        pod init
    
  2. Öffnen Sie dann die Podfile-Datei mit dem folgenden Befehl.

        Open podfile
    
  3. Deklarieren Sie die Abhängigkeiten für das Office 365 SDK für iOS und das ADAL SDK für iOS, indem Sie die folgenden Definitionen zum geöffneten Podfile hinzufügen.

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

    Diese Definitionen sollten zwischen der Ziel- und der Endanweisung liegen, so dass das Ergebnis wie folgt aussieht.

    target 'SimpleMailApp' do
    pod 'ADALiOS', '~> 1.2.0'
    pod 'Office365', '= 0.9.0'
    end
    
  4. Schließen Sie das Podfile.

Hinweis Das Office 365 SDK für iOS befindet sich derzeit in der Entwickler-Vorschauversion, was bedeutet, dass es vor der Fertigstellung Änderungen unterliegt, möglicherweise sogar Änderungen, die den mit dem SDK geschriebenen Code beschädigen würden. Das SDK verwendet die Konvention Semantic Versioning, in der die Kompatibilität mit einer dreiteiligen Versionsnummer angegeben ist: major.minor.patch. Bis zum Erreichen der Version 1.0 wird die Nummer der Nebenversion für das Brechen und andere wesentliche Änderungen schrittweise erhöht.

Konfigurieren der Abhängigkeiten für das SimpleMailApp-Projekt

Um diese Abhängigkeiten zu konfigurieren und sie und das bestehende Projekt zu einem neuen Arbeitsbereich hinzuzufügen, führen Sie den folgenden Befehl vom Terminal aus.

pod install

Registrieren Ihrer Anwendung mit Azure Active Directory

  1. Melden Sie sich im Azure Management Portal mit den Zugangsdaten der Office 365 Entwicklerwebsite an.

  2. Klicken Sie im linken Menü auf Active Directory und dann auf das Verzeichnis für Ihre Office 365-Entwicklerseite. Azure Management Portal

  3. Klicken Sie im oberen Menü auf Anwendungen.

  4. Klicken Sie im Menü unten auf Hinzufügen.
    Azure Management Portal Anwendung hinzufügen

  5. Auf der Seite Was möchten Sie tun, klicken Sie auf Hinzufügen einer Anwendung, die meine Organisation entwickelt.

  6. Wählen Sie auf der Seite Teilen Sie uns etwas über Ihre Anwendung mit die Angabe SimpleMailApp für den Anwendungsnamen aus und wählen Sie dann NATIVE CLIENT APPLICATION als Typ.

  7. Klicken Sie in der unteren rechten Ecke der Seite auf das Pfeilsymbol.

  8. Geben Sie auf der Seite Anwendungsinformationen eine Umleitungs-URI an, für dieses Beispiel können Sie http://localhost/simplemailappprojectangeben. Notieren Sie die URI, da Sie diese später beim Codieren des SimpleMailApp-Projekts benötigen. Klicken Sie auf das Kontrollkästchen unten rechts auf der Seite.

  9. Nachdem die Anwendung erfolgreich hinzugefügt wurde, gelangen Sie zur Seite „Schnellstart“ für die Anwendung. Klicken Sie von hier aus im oberen Menü auf Konfigurieren.

  10. Klicken Sie in Berechtigungen für andere Anwendungen auf Anwendung hinzufügen.

  11. Klicken Sie auf Office 365 Exchange Online und klicken Sie dann auf das Häkchen-Symbol. Azure Management Portal Anwendung hinzufügen

  12. Klicken Sie unter Berechtigungen für andere Anwendungen auf die Spalte Delegierte Berechtigungen für Office 365 Exchange Online und wählen Sie E-Mail als Benutzer senden.
    Azure Management Portal Anwendung hinzufügen

    Dies sind die Berechtigungen, die Ihrem App-Benutzer angezeigt werden, wenn Azure ihn auffordert, der Berechtigungsanfrage Ihrer App zuzustimmen. Fordern Sie im Allgemeinen nur die Dienste an, die Ihre App tatsächlich benötigt und geben Sie in jedem Dienst die geringsten Berechtigungen an, die es Ihrer App ermöglichen, ihre Funktionen auszuführen.

  13. Kopieren Sie den für Client ID angegebenen Wert; diesen benötigen Sie später beim Codieren des SimpleMailApp-Projekts.

  14. Klicken Sie im Menü unten auf Speichern.

Codieren Sie Ihre App

Öffnen Sie den SimpleMailApp-Arbeitsbereich in Xcode.

Authentifizieren Sie sich bei Azure AD und rufen Sie das Zugriffstoken ab

Für den Zugriff auf Office 365-APIs ist ein Zugriffstoken erforderlich, sodass Ihre Anwendung die Logik zum Abrufen und Verwalten der Zugriffstoken implementieren muss. Die Azure Active Directory Authentifizierungsbibliothek (ADAL) für iOS und OSX bietet Ihnen die Möglichkeit, die Authentifizierung in Ihrer Anwendung mit nur wenigen Zeilen Code zu verwalten. Erfahren Sie mehr über die Authentifizierung mit Azure Active Directory in Was ist Azure Active Directory? auf Azure.com. Als erstes erstellen Sie eine Headerdatei und eine Klasse, AuthenticationManager, die ADAL für iOS und OSX verwendet, um die Authentifizierung für Ihre App zu verwalten.

So erstellen Sie die AuthenticationManager-Klasse
  1. Klicken Sie mit der rechten Maustaste auf den SimpleMailApp-Projektordner, wählen Sie Neue Datei und klicken Sie im Abschnitt iOS auf Cocoa Touch Class und dann auf Weiter.

  2. Geben Sie AuthenticationManager als Klasse, NSObject für Unterklasse von: an und klicken Sie dann auf Weiter.

  3. Klicken Sie auf Erstellen, um die Klasse und die Headerdateien zu erstellen.

So kodieren Sie die AuthenticationManager-Headerdatei
  1. Importieren Sie die erforderlichen Office 365 iOS SDK- und ADAL SDK-Headerdateien, indem Sie die folgenden Codeanweisungen in AuthenticationManager.h einfügen.

    #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. Deklarieren Sie eine Eigenschaft für das Objekt ADALDependencyResolver aus dem ADAL SDK, das den Zugriff auf die Authentifizierungsobjekte mittels Dependency Injection ermöglicht.

    @property (readonly, nonatomic) ADALDependencyResolver *dependencyResolver;
    
  3. Geben Sie die Klasse AuthenticationManager als Singleton an.

    +(AuthenticationManager *)sharedInstance;
    
  4. Deklarieren Sie die Methoden zum Abrufen und Löschen der Zugriffs- und Aktualisierungs-Token.

    //retrieve token
    -(void)acquireAuthTokenWithResourceId:(NSString *)resourceId completionHandler:(void (^)(BOOL authenticated))completionBlock;
    //clear token
    -(void)clearCredentials;
    
So kodieren Sie die AuthenticationManager-Klasse
  1. Oberhalb der Deklaration @implementation deklarieren Sie statische Variablen für die Umleitungs-URI, die Client-ID und die Autorität.

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

    Ersetzen Sie die redirectUri durch den Wert, den Sie aus Schritt 8 bei der Registrierung Ihrer App bei Azure AD kopiert haben, und die clientID durch den Wert, den Sie in Schritt 13 der gleichen Vorgehensweise angegeben haben.

  2. In der DeklarationSchnittstelle* über **@implementation, geben Sie die folgenden Eigenschaften an.

    @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. Fügen Sie Code für den Konstruktor zur Implementierung hinzu.

    -(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. Fügen Sie den folgenden Code hinzu, um einen einzigen Authentifizierungsmanager für die Anwendung zu verwenden.

    +(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. Erwerben Sie Zugangs- und Aktualisierungs-Token von Azure AD für den Benutzer.

    -(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);
                                   }
                               }];
    }
    

    Beim ersten Start der Anwendung wird eine Anforderung an die für die AUTHORITY const angegebene URL gesendet (siehe Schritt 1), die Sie auf eine Anmeldeseite weiterleitet, auf der Sie Ihre Zugangsdaten eingeben können. Wenn Ihr Login erfolgreich war, enthält die Antwort die Zugriffs- und Aktualisierungs-Token. Wenn die Anwendung zukünftig ausgeführt wird, verwendet der Authentifizierungsmanager das Zugriffs- oder Aktualisierungs-Token für die Authentifizierung von Client-Anforderungen, es sei denn, der Token-Cache wird gelöscht.

  6. Fügen Sie schließlich Code hinzu, um den Benutzer abzumelden, indem Sie den Token-Cache löschen und die Cookies der Anwendung entfernen.

    -(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];
    }
    }
    

Verbinden mit Office 365

Als nächstes müssen Sie Ihrem Projekt eine Klasse hinzufügen, um eine Verbindung zu Office 365 herzustellen, und den Ermittlungsdienst verwenden, um die Exchange-Dienst-Endpunkte abzurufen.

So erstellen Sie die Office365ClientFetcher-Klassen- und Headerdateien
  1. Klicken Sie mit der rechten Maustaste auf den SimpleMailApp-Projektordner, wählen Sie Neue Datei und klicken Sie im Abschnitt iOS auf Cocoa Touch Class und dann auf Weiter.

  2. Geben Sie Office365ClientFetcher als Klasse, NSObject für Unterklasse von: an und klicken Sie dann auf Weiter.

  3. Klicken Sie auf Erstellen, um die Klasse und die Headerdateien zu erstellen.

So kodieren Sie die Office365ClientFetcher-Header-Datei
  1. Importieren Sie die erforderlichen Office 365 iOS SDK-Headerdateien, indem Sie die folgenden Codeanweisungen in Office365ClientFetcher.h einfügen.

    #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. Deklarieren Sie die Methoden zum Abrufen der Outlook- und Ermittlungsdienst-Clients.

    -(void)fetchOutlookClient:(void (^)(MSOutlookServicesClient *outlookClient))callback;
    -(void)fetchDiscoveryClient:(void (^)(MSDiscoveryClient *discoveryClient))callback;
    
So kodieren Sie die Office365ClientFetcher-Klasse
  1. Importieren Sie die Office365ClientFetcher- und AuthenticationManager-Headerdateien.

    #import "Office365ClientFetcher.h"
    #import "AuthenticationManager.h"
    
  2. Fügen Sie den Implementierungscode der Office365ClientFetcher-Klasse hinzu.

    -(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];
            });
        }
    }];
    }
    

Der Ansichts-Controller

Als nächstes müssen Sie die Methoden zur Verbindung mit den Office 365-Diensten aufrufen, die die Authentifizierung auslösen und dann die Ergebnisse in der Benutzeroberfläche anzeigen. Hier werden Sie eine Ansichts-Controller-Klasse erstellen, die Steuerelemente der Benutzeroberfläche mit den gleichen Namen wie der Ansichts-Controller und die Steuerelemente der Benutzeroberfläche im Beispiel von Office 365 iOS Connect enthält. Auf diese Weise können Sie das Storyboard aus dem Connect-Beispiel herunterladen und verwenden, so dass Sie die Schritte überspringen können, die normalerweise erforderlich sind, um das Storyboard mit einem Ansichts-Controller zu verbinden.

So fügen Sie den Ansichts-Controller hinzu
  1. Klicken Sie mit der rechten Maustaste auf das SimpleMailApp-Projekt, wählen Sie Neue Datei und klicken Sie im Abschnitt iOS auf Cocoa Touch Class und dann auf Weiter.

  2. Wählen Sie UIViewController für Unterklasse von: und geben Sie SendMailViewController als Klasse an und klicken Sie dann auf Weiter.

  3. Klicken Sie auf Erstellen, um die Klasse und die Headerdateien zu erstellen.

So kodieren Sie den Ansichts-Controller

Zunächst importieren Sie die notwendigen Headerdateien, indem Sie die folgenden Code-Anweisungen zu SendMailViewController.m hinzufügen.

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

Als nächstes deklarieren Sie die folgenden Eigenschaften und Methoden in der Schnittstelle 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

Fügen Sie nun den folgenden Code für die Implementierung SendMailViewController hinzu.

@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

Da der von Ihnen erstellte Ansichts-Controller den gleichen Namen hat wie der im Office 365 iOS Connect-Beispiel, wobei der Code Steuerelemente mit den gleichen Namen wie die im Beispiel angibt, können Sie das Storyboard des Beispiels verwenden. Um das Storyboard abzurufen, laden Sie das Beispiel herunter und suchen Sie die Datei Main.storyboard im Ordner O365-iOS-Connect-master\Sample\O365-iOS-Connect\Base.lproj des Downloads.

Kopieren Sie diese Datei in den Ordner SimpleMailApp\SimpleMailApp\Base.lproj in Ihrem Projekt und überschreiben Sie die vorhandene Version der Datei an diesem Speicherort.

E-Mail-Quelle

Der letzte Schritt besteht darin, eine HTML-Datei zu erstellen, die das Beispiel verwendet, um den Text der E-Mail zu erstellen. Fügen Sie eine HTML-Datei zu Ihrem Projekt hinzu und nennen Sie sie EmailBody.html. Sie können sie nach Belieben anpassen oder den folgenden Code für einen Basistest verwenden.

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

Testen Sie Ihre App

Erstellen und Ausführen der Anwendung aus Xcode. Dies startet den iOS Simulator und Sie sehen einen Verbindung zu Office 365-Link. Klicken Sie darauf, so werden Sie aufgefordert, Ihre Zugangsdaten einzugeben. Nachdem Sie sich erfolgreich angemeldet haben, sehen Sie ein Textfeld mit der E-Mail-Adresse des angemeldeten Kontos und einem Link Versenden. Klicken Sie auf Versenden, um eine E-Mail an die im Textfeld angegebene Adresse zu senden.

Nächste Schritte

Nachdem Sie nun eine Anwendung erstellt haben, die die Mail-API verwendet, können Sie die anderen Office 365-REST-APIs für die Verwendung in Ihren Apps erkunden.

Zusätzliche Ressourcen

Sie entwickeln keine Android-Apps? Verwenden Sie das Steuerelement in der oberen rechten Ecke dieser Seite, um die Art der App auszuwählen, die Sie entwickeln.

Erstelle Sie eine App mit Office 365-APIs

Um Ihnen einen Eindruck davon zu vermitteln, was Sie mit den Office 365 REST-APIs tun können, zeigt Ihnen dieses Thema, wie Sie eine einfache Anwendung erstellen, die Informationen von einem Exchange Online-Server bezieht.

Ein Screenshot der App, die in einem Emulatorfenster läuft. Die verfügbaren Aktionen werden auf Schaltflächen angezeigt.

Bevor Sie mit der Arbeit an Ihrer ersten Office 365-Anwendung beginnen können, gibt es einige einmalige Aufgaben, die Sie erledigen müssen, und Sie darüberhinaus müssen sicherstellen, dass Sie über Ihre Tools verfügen. Danach können Sie mit Ihrer ersten App loslegen.

Vor der Bereitstellung

Bevor Sie Anwendungen erstellen können, die auf die Office 365-APIs zugreifen, müssen Sie Ihre Entwicklerumgebung einrichten. Dies besteht aus drei einmaligen Aufgaben, um sicherzustellen, dass Sie die Tools und die Umgebung haben, um erfolgreich zu sein:

  1. Richten Sie die Android-App-Entwicklungsumgebung ein, mit der Sie Ihre Apps erstellen.
  2. Melden Sie ein Office 365 Business-Konto an, um auf die Office 365-APIs zuzugreifen.
  3. Verknüpfen Sie Ihr Office 365-Abonnement mit Azure AD, damit Sie Apps erstellen und verwalten können.

Wenn Sie noch einen dieser Schritte durchführen müssen, finden Sie unter Einrichten Ihrer Office 365-Entwicklungsumgebung detaillierte Anweisungen zum Einrichten.

Erstellen Sie Ihre App und fügen Sie Abhängigkeiten hinzu

In diesem Schritt erstellen Sie eine App und fügen dem Projekt das Office 365 SDK für Android und die Azure Active Directory Authentifizierungsbibliothek für Android hinzu. Der Quellcode für diese beiden Bibliotheken ist bei GitHub erhältlich und Sie können die Binärdateien für das Office 365 SDK unter Bintray herunterladen, wenn Sie möchten.

Abhängigkeiten für Android Studio hinzufügen

Sie können die in Android Studio integrierte Unterstützung für Gradle verwenden, um die Abhängigkeiten für Ihre Anwendung zu verwalten. So fügen Sie die Abhängigkeiten zu Ihrer Anwendung hinzu:

  1. Erstellen Sie eine neue Android-Anwendung in Android Studio.
  2. Suchen Sie app/build.gradle in Ihrem App-Modul und fügen Sie die folgenden Abhängigkeiten hinzu. Wir verwenden nur "outlook-services", die hier jedoch alle als Referenz aufgeführt sind.
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: '+'
    }

Abhängigkeiten für Eclipse hinzufügen

Wenn Sie Eclipse verwenden, müssen Sie etwas mehr Arbeit von Hand erledigen, um die Azure Active Directory Authentifizierungsbibliothek für Android und Office 365 SDK-Bibliotheken zu Ihrem Arbeitsbereich hinzuzufügen. So fügen Sie die Abhängigkeiten zu Ihrem Arbeitsbereich hinzu:

  1. Laden oder klonen Sie die Azure Active Directory Authentifizierungsbibliothek.

  2. Starten Sie Eclipse und erstellen Sie einen neuen Arbeitsbereich für Ihre App.

  3. Importieren Sie das Projekt AuthenticationActivity aus der Azure Active Directory Authentifizierungsbibliothek in Ihren neuen Arbeitsbereich.

  4. Fügen Sie die Android-Unterstützungsbibliothek zum AuthenticationActivity-Projekt hinzu. Klicken Sie dazu mit der rechten Maustaste auf das Projekt, wählen Sie Android Tools und dann Unterstützungsbibliothek hinzufügen.

  5. Laden Sie die aktuelle Version der gson-Bibliothek herunter.

  6. Fügen Sie die gson jar-Datei zum libs-Ordner des AuthenticationActivity-Projekts hinzu.

  7. Fügen Sie die jar-Dateien aus dem Office 365 SDK für Android hinzu. Laden Sie entweder die jar-Dateien von Bintray herunter oder klonen und erstellen Sie das Office 365 SDK für Android und kopieren Sie dann die jar-Dateien in Ihr Projekt.

So laden Sie die jar-Dateien herunter

Laden Sie die jar-Dateien für das Office 365 SDK für Android von Bintray herunter. Sie müssen die folgenden jar-Dateien zum libs-Ordner hinzufügen:

  • odata-engine-android-impl-0.11.1jar
  • outlook-services-0.11.1.jar
  • file-services-0.11.1.jar
  • discovery-services-0.11.1.jar
    Hinweis Sie können für die jar-Dateien die Version 0.11.1 oder höher verwenden.
So erstellen Sie die jar-Dateien
1. Klonen Sie das [Office 365 SDK für Android](https://github.com/OfficeDev/Office-365-SDK-for-Android).
2. Wechseln Sie in das SDK-Verzeichnis.
3. Starten Sie `.\gradlew clean`.
4. Starten Sie `.\gradlew assemble`.

Aktualisieren des Manifests

Sie müssen Ihrer AndroidManifest.xml-Datei zwei Berechtigungen hinzufügen, damit Ihre Anwendung auf Azure AD und Office 365 zugreifen kann.

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

Office 365-Dienste integrieren

Bevor Sie mit dem Schreiben des Codes für Ihre Office 365-Anwendung beginnen, müssen Sie ein wenig Arbeit leisten, um Ihre Anwendung bei Azure AD zu registrieren und die Berechtigungen für Ihre Anwendung für den Zugriff auf Office 365-Dienste festzulegen. Sie müssen dies nur einmal pro Anwendung tun.

Registrieren der App bei Azure AD
  1. Melden Sie sich im Azure Management Portal mit den Zugangsdaten der Office 365-Entwicklerwebsite an.

  2. Klicken Sie im linken Menü auf Active Directory und dann auf das Verzeichnis für Ihre Office 365-Entwicklerseite.

    Ein Screenshot der Website des Azure Verwaltungsportals. Im linken Navigationsbereich wird der Eintrag "Active Directory" ausgewählt. Im Hauptfenster ist die Registerkarte Verzeichnis ausgewählt. Der Name des aktuellen Verzeichnisses wird hervorgehoben.

  3. Wählen Sie im oberen Menü Anwendungen aus.

  4. Klicken Sie im Menü unten auf Hinzufügen.

    Ein Screenshot der Verzeichnis-Informationsseite. In der Menüleiste unten auf der Seite ist das Symbol Neu hervorgehoben.

  5. Auf der Seite Was möchten Sie tun, klicken Sie auf Hinzufügen einer Anwendung, die meine Organisation entwickelt.

  6. Geben Sie Ihrer Anwendung auf der Seite Teilen Sie uns etwas über Ihre Anwendung mit einen Namen ein und wählen Sie dann NATIVE CLIENT APPLICATION als Typ.

  7. Klicken Sie in der unteren rechten Ecke der Seite auf das Pfeilsymbol.

  8. Geben Sie auf der Seite Anwendungsinformationen einen Umleitungs-URI an. Für dieses Beispiel können Sie http://localhost/simplemailapp angeben und dann das Kontrollkästchen unten rechts auf der Seite anklicken.

  9. Wenn die Anwendung erfolgreich hinzugefügt wurde, wird die Schnellstart-Seite für die Anwendung angezeigt.

Ihre Anwendung ist jetzt bei Azure AD registriert und hat eine Client-ID erhalten. Sie benötigen diese Informationen später wenn Sie Ihre Anwendung einrichten. Es gibt jedoch noch einige wichtige Aspekte Ihrer App zu konfigurieren.

Hinzufügen von Office 365-Diensten und Festlegen von Berechtigungen

Nun müssen Sie genau angeben, welche Berechtigungen Ihre App für die Office 365-APIs benötigt. Dazu fügen Sie Ihrer Anwendung Zugriff auf den Office 365-Dienst hinzu, der die gewünschte API enthält, und geben dann die erforderlichen Berechtigungen aus den APIs in diesem Dienst an. Die Beispielanwendung muss Lesezugriff auf den Posteingang des Benutzers haben, also richten Sie die erforderliche Berechtigung wie folgt ein.

  1. Scrollen Sie im Azure Verwaltungsportal auf der Konfigurationsseite Ihrer App zum Ende der Seite und wählen Sie unter Berechtigungen für andere AnwendungenAnwendung hinzufügen.

    Ein Screenshot der App-Konfigurationsseite für Ihre App, auf der Website des Azure Verwaltungsportals. Unter dem Abschnitt "Berechtigung für andere Anwendungen" wird die Schaltfläche "Anwendung hinzufügen" hervorgehoben.

  2. Wählen Sie den Dienst Office 365 Exchange Online.

    1. Wählen Sie den Servicenamen und klicken Sie auf das Plus-Symbol, um den Dienst hinzuzufügen.
    2. Der Dienst wird dann unter der Spalte ausgewählt aufgelistet.
    3. Klicken Sie auf das Häkchen-Symbol, um Ihre Auswahl zu speichern. Ein Screenshot der Seite "Berechtigungen für andere Anwendungen". Die verfügbaren Anwendungen sind in einer Tabelle aufgelistet. Neben dem Namen einer jeden App ist das Plus-Symbol. Ganz rechts befindet sich eine Spalte, die die Anwendungen auflistet, die Sie Ihrer App hinzugefügt haben. Ein Häkchen am unteren Rand der Seite ist markiert.

      Sie gelangen zurück auf die Konfigurationsseite Ihrer Anwendung.

  3. Klicken Sie unter Berechtigungen für andere Anwendungen auf die Spalte Delegierte Berechtigungen für Office 365 Exchange Online und geben Sie die Berechtigung Benutzer-Mail lesen an.

    Ein Screenshot der App-Konfigurationsseite für Ihre App, auf der Website des Azure Verwaltungsportals. Unter dem Seitenabschnitt 'Berechtigungen für andere Anwendungen' werden die soeben hinzugefügten Anwendungen in einer Tabelle aufgelistet. Neben dem Namen jeder Anwendung befindet sich eine Spalte namens "Delegierte Berechtigungen". Diese Spalte zeigt ein Dropdown-Menü mit den Berechtigungen, die Sie für Ihre Anwendung von jeder App, die Sie hinzugefügt haben, anfordern können.

    Dies sind die Berechtigungen, die Ihrem App-Benutzer angezeigt werden, wenn Azure ihn auffordert, der Berechtigungsanfrage Ihrer App zuzustimmen. Fordern Sie im Allgemeinen nur die Dienste an, die Ihre App tatsächlich benötigt und geben Sie in jedem Dienst die geringsten Berechtigungen an, die es Ihrer App ermöglichen, ihre Funktionen auszuführen.

Codieren Sie Ihre App

Das folgende Codebeispiel ist eine einfache Anwendung, die alle Funktionen von Azure AD und Office 365 nutzt, die Sie zum Erstellen einer Android-Anwendung benötigen.

Verbinden mit Office 365

Bevor Sie einen Office 365-Dienst aufrufen können, müssen Sie Ihre Anwendung bei Azure AD authentifizieren. Erfahren Sie mehr über die Authentifizierung mit Azure Active Directory in Was ist Azure Active Directory? auf Azure.com.

Der folgende Code definiert ein AuthenticationController-Objekt, das zwei Objekte aus der Azure Active Directory Authentifizierungsbibliothek verwendet, um die Authentifizierung Ihrer Anwendung zu verwalten.

Der erste, ADALDependencyResolver, verwendet Dependency Injection, um dem Rest Ihrer Anwendung Zugriff auf das AuthenticationController-Objekt zu ermöglichen. Der zweite, AuthenticationContext, verwaltet die Authentifizierung mit Azure AD. Er macht Folgendes:

  1. Er stellt dem Benutzer bei der ersten Anmeldung in Office 365 eine Authentifizierungs-Benutzeroberfläche zur Verfügung.

  2. Er speichert das Zugriffstoken für die Anwendung, damit Dienst-Clients auf die Token zugreifen können.

  3. Er aktualisiert das Zugriffstoken bei Bedarf. Falls erforderlich wird die Authentifizierungs-Benutzeroberfläche erneut angezeigt.

Wenn Sie die Anwendung ausführen, werden Informationen über das Token in das Anwendungsprotokoll übertragen. Diese Informationen werden normalerweise innerhalb einer Anwendung verwendet, anstatt angezeigt zu werden.

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;
}
}

Den Ermittlungsdienst verwenden

Der Ermittlungsdienst stellt Ihrer Anwendung die Endpunktpositionen für Office 365-Dienste zur Verfügung. Sie können Informationen über den Anbieter, die API-Version und den Dienst-Endpunkt-URI sowie weitere Informationen abrufen.

Das Objekt DiscoveryController verwendet das Objekt DiscoveryClient aus dem Office 365 SDK für Android, um eine Liste der Dienste von Office 365 abzurufen. Die Liste wird an die Protokolldatei der Anwendung gesendet, aber in Ihrer Anwendung verwenden Sie die Liste der Dienste, um die Endpunkte für Office 365-Dienste zu finden.

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;
}
}

Zugriff auf Office 365 API-Daten

Mit einem AuthenticationController zur Verwaltung der Authentifizierung mit dem Azure AD und einem DiscoveryController zur Bereitstellung der Endpunkte für Office 365-Dienste kann Ihre Anwendung Aufrufe tätigen, um Informationen von Office 365 abzurufen.

Das Objekt MailController verwendet beide, um eine Liste von E-Mails im Posteingang des Benutzers zu erhalten. Auch hier schreibt diese einfache Anwendung lediglich die Betreffzeilen in die Anwendungsprotokolldatei.

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;
}
}

Kontext und die Anwendungsaktivität

Es gibt zwei weitere Klassen, die Sie für diese erste Office 365-Anwendung benötigen. Die erste ist eine Konstantenklasse, die Informationen enthält, die Ihre Anwendung definiert. Die ersten drei Konstanten liefern die Endpunkte für die Azure AD-Authentifizierung und den Office 365 Ermittlungsdienst. Die nächsten beiden Konstanten sind die identifizierenden Informationen, die Sie erstellt haben, wenn Sie Ihre Anwendung in Azure AD registriert haben. Die letzte Konstante gibt an, dass Ihre Anwendung Zugriff auf Office 365-Mail-Dienste benötigt.

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";

}

Die zweite Klasse in der Aktivitätsklasse, die die Benutzeroberfläche für die Anwendung bereitstellt. Die Benutzeroberfläche besteht aus drei Schaltflächen, einer zum Authentifizieren der Anwendung, einer zum Abrufen von Endpunktinformationen vom Ermittlungsdienst und einer zum Abrufen der E-Mail in Ihrem Posteingang vom E-Mail-Dienst. Die einzige andere erforderliche Methode ist die Methode onActivityResult, die aufgerufen wird, wenn die AuthenticationActivity abgeschlossen ist.

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);
}
}

Benutzeroberfläche

Das letzte Stück, das Sie benötigen, ist eine Benutzeroberfläche, die die Dienste Azure AD und Office 365 ausübt. Dieses Layout bietet drei Schaltflächen, die genau das tun.

<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>

Testen Sie Ihre App

Führen Sie die Anwendung in Ihrer IDE aus, um den Code in Aktion zu sehen. Wenn Sie die Anwendung starten, sehen Sie drei Schaltflächen. Wenn Sie auf jede der Schaltflächen klicken, werden Informationen an das Protokollfenster Ihrer IDE gesendet.

Ein Screenshot der App, die in einem Emulatorfenster läuft. Die verfügbaren Aktionen werden auf Schaltflächen angezeigt.

Wenn Sie auf die Schaltfläche Für Office 365 authentifizieren klicken, ruft die Anwendung das Objekt AuthenticationController auf, das wiederum den Authentifizierungs-Workflow der Azure Active Directory Authentifizierungsbibliothek für Android aufruft. Wenn kein gültiges Token verfügbar ist, wird ein Formular zum Einloggen in Office 365 angezeigt.

Ein Screenshot der Office 365-Anmeldeseite.

Nachdem Sie sich angemeldet haben, schreibt der AuthenticationController Informationen über das Authentifizierungstoken in das Protokollfenster.

Ein Screenshot der von Office 365 zurückgegebenen Token-Informationen. Die Informationen umfassen das Token, das Ablaufdatum und Informationen über den Benutzer, einschließlich der E-Mail-Adresse, des Familiennamens und des Vornamens.

Klicken Sie auf die Schaltfläche DISCOVER SERVICES, um eine Liste der REST-Dienst-Endpunkte zu erhalten, die von Ihrem Office 365-Server verfügbar sind.

Ein Screenshot der Office 365-REST-Diensteliste. Die Liste enthält den Dienstnamen, die Dienst-ID, seine Fähigkeit, den Entitätsschlüssel, den Anbieternamen, die Anbieter-ID, die Dienst-API-Version, die Dienst-Endpunkt-URI, die Dienst-Ressourcen-ID und den Dienstkontotyp.

Klicken Sie auf die Schaltfläche E-Mail abrufen, um eine Liste der E-Mail-Nachrichten im Posteingang des Benutzers zu erhalten. Dieses Beispiel listet nur den Betreff jeder E-Mail-Nachricht auf.

Ein Screenshot einer Liste von E-Mail-Betreffzeilen aus dem Posteingang des Benutzers.

Nächste Schritte

Jetzt, da Sie eine einfache Anwendung erstellt haben, die E-Mails von Office 365 empfängt, können Sie einen Blick auf eine kompliziertere Anwendung werfen, die zeigt, wie man die gesamte REST-API verwendet.

Zusätzliche Ressourcen

Sie entwickeln keine Angular-Apps? Verwenden Sie das Steuerelement in der oberen rechten Ecke, um die Art der App auszuwählen, die Sie entwickeln.

Erstellen einer Angular-App mit Office 365-APIs

Bevor Sie mit der Arbeit an Ihrer ersten Angular-Anwendung mit Office 365 beginnen können, gibt es einige einmalige Aufgaben, die Sie erledigen müssen, darunter Einrichtung Ihrer Office 365-Entwicklungsumgebung und die Bereitstellung der richtigen Tools.

Nach der Einrichtung führen wir Sie durch die Erstellung einer einfachen Angular-App, nämlich der SimpleMailApp, die die Active Directory Authentifizierungsbibliothek (ADAL) für JavaScript verwendet, um einen Benutzer zu authentifizieren und REST-Aufrufe zum Abrufen der E-Mail dieses Benutzers mit cross-origin resource sharing (CORS) durchzuführen.

Screenshot der App

Dieser Artikel konzentriert sich auf ein Angular-Frontend, da ADAL JS für Single-Page-Anwendungen (SPAs) und Angular entwickelt wurde. Die Bibliothek übernimmt das Interaktionsmuster, das SPAs benötigen. Obwohl es möglich ist, die Bibliothek ohne Angular zu benutzen, wäre es dann notwendig, viel mehr Code zu schreiben. Lesen Sie Erstellen Sie JavaScript-Webanwendungen mit CORS, um auf Office 365-APIs zuzugreifen, wenn Sie daran interessiert sind, die Office 365-APIs ohne ADAL JS zu verwenden.

Vor der Bereitstellung

Bevor Sie Anwendungen erstellen können, die auf die Office 365-APIs zugreifen, müssen Sie Ihre Entwicklerumgebung einrichten. Dies besteht aus drei einmaligen Aufgaben, um sicherzustellen, dass Sie die Tools und die Umgebung haben, um erfolgreich zu sein:

  1. Laden Sie Tools herunter, um Ihre Angular-Anwendung zu erstellen, einschließlich einer IDE, Git und Node.js.
  2. Melden Sie ein Office 365 Business-Konto an, um auf die Office 365-APIs zuzugreifen.
  3. Verknüpfen Sie Ihr Office 365-Abonnement mit Azure AD, damit Sie Apps erstellen und verwalten können.

Wenn Sie noch einen dieser Schritte durchführen müssen, finden Sie unter Einrichten Ihrer Office 365-Entwicklungsumgebung detaillierte Anweisungen zum Einrichten.

Hinweis Node.js, insbesondere der Paket-Manager (npm), wird für diesen Artikel benötigt, um Projektabhängigkeiten zu installieren. Für die Entwicklung mit den Office 365-APIs ist dies nicht erforderlich.

Erstellen Sie Ihre App und fügen Sie Abhängigkeiten hinzu

In diesem Schritt richten Sie eine Angular-App ein, indem Sie ein von uns entwickeltes leeres Projekt nutzen, die Azure Active Directory Authentifizierungsbibliothek (ADAL) für JavaScript hinzufügen und Ihre Anwendung für die Kommunikation mit Azure einrichten, indem Sie sie in Ihrem Azure Verwaltungsportal registrieren.

Einrichten des SimpleMailApp-Projekts

Um so schnell wie möglich loslegen zu können, nutzen Sie ein von uns erstelltes leeres Projekt, das Sie auf GitHub finden.

  1. Mit Git klonen Sie das leere Projekt von der Befehlszeile aus.

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

    Hinweis Wenn Sie mit Git nicht vertraut sind, können Sie den Code direkt von GitHub herunterladen.

  2. Wechseln Sie dann in Ihren neuen Projektordner und installieren Sie Ihre Projektabhängigkeiten mit npm, dem Paket-Manager für Node.js.

    cd O365-Angular-GettingStarted/Starter
    npm install

Hinweis Es gibt auch einen Ordner Abgeschlossen im Repository. Das Projekt in diesem Ordner ist einsatzbereit, sobald Sie es mit Ihren Azure-Mandanteninformationen konfiguriert und die Abhängigkeiten installiert haben.

ADAL JS zum SimpleMailApp-Projekt hinzufügen

ADAL JS ist eine JavaScript-Bibliothek, die Ihnen vollständige Unterstützung sowohl für die Anmeldung von Azure AD-Benutzern in Single-Page-Anwendungen (SPAs) wie dieser bietet, als auch für den direkten Zugriff über JavaScript-Web-APIs, die durch Azure AD gesichert sind.

ADAL.js hat zwei Ebenen, in zwei Dateien:

  • adal.js Für alle JavaScript-Anwendungen verwenden. Sie enthält Low-Level-Funktionen wie domänenspezifische Logik, Erstellung und Analyse von OAuth2-Nachrichten und Caching-Tokens. Weitere Informationen finden Sie unter Einführung von ADAL JS v1.
  • adal-angular.js Zusammen mit adal.js für Angular-Anwendungen einschließen. Sie enthält spezifische Funktionen, die mit dem Angular-Framework kompatibel sind.

Fügen Sie diese beiden Dateien in Ihr Projekt ein, um Zugriff auf ein Programmiermodell für die Azure AD-Authentifizierung und den Aufruf von durch Azure AD gesicherten APIs wie die Outlook Mail-REST-API zu erhalten, die wir später in diesem Artikel aufrufen werden.

Sie können die Bits von unserem CDN beziehen.

Der einfachste Weg, die ADAL-Abhängigkeiten einzubinden, ist, script Tags unter Verwendung der CDN-Links als src Attribut am Ende des <head> Tags in der index.html Datei in Starter/public hinzuzufügen.

<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>

Registrieren der App bei Azure AD

Bevor Sie mit dem Schreiben des Codes für Ihre Office 365-Anwendung beginnen, müssen Sie ein wenig Arbeit leisten, um Ihre Anwendung bei Azure Active Directory zu registrieren und die Berechtigungen für Ihre Anwendung für den Zugriff auf Office 365-Dienste festzulegen. Sie müssen dies einmal pro Anwendung tun.

  1. Melden Sie sich im Azure Verwaltungsportalmit Ihrem Office 365 Geschäftskonto an.

  2. Klicken Sie in der linken Spalte auf den Knoten Active Directory und wählen Sie das mit Ihrem Office 365-Abonnement verknüpfte Verzeichnis aus.

    Azure Management Portal

  3. Wählen Sie die Registerkarte Anwendungen und dann hinzufügen am unteren Bildschirmrand.

    Azure Management Portal Anwendung hinzufügen

  4. Wählen Sie im Popup-Fenster Hinzufügen einer Anwendung, die meine Organisation entwickelt. Klicken Sie auf den Pfeil, um fortzufahren.

  5. Wählen Sie einen Namen für Ihre Anwendung, wie z.B. SimpleMailApp und wählen Sie Webanwendung und/oder Web API als Typ. Klicken Sie auf den Pfeil, um fortzufahren.

  6. Der Wert von Anmelde-URL ist die URL, unter der Ihre Anwendung gehostet wird. Verwenden Sie http://127.0.0.1:8080/ für das Beispielprojekt.

  7. Der Wert von App-ID-URI ist ein eindeutiger Bezeichner für Azure AD zur Identifizierung Ihrer App. Sie können http://{your_subdomain}/SimpleMailApp verwenden, wobei {your_subdomain} die Subdomain von .onmicrosoft ist, die Sie bei der Anmeldung für Ihr Office 365 Geschäftskonto angegeben haben. Klicken Sie dann auf das Häkchen, um Ihre Anwendung bereitzustellen.

  8. Nachdem die Anwendung erfolgreich hinzugefügt wurde, gelangen Sie zur Seite „Schnellstart“ für die Anwendung. Wählen Sie hier den Reiter Konfigurieren.

  9. Scrollen Sie zum Abschnitt Berechtigungen für andere Anwendungen und klicken Sie auf die Schaltfläche Anwendung hinzufügen.

    Anwendung für Webapplikation hinzufügen

  10. In diesem Artikel zeigen wir, wie man die E-Mail eines Benutzers abruft, also fügen Sie die Anwendung Office 365 Exchange Online hinzu. Klicken Sie auf das Pluszeichen zur Anmeldung in der Zeile der Anwendung und dann auf das Häkchen oben rechts, um es hinzuzufügen. Klicken Sie dann auf das Häkchen unten rechts, um fortzufahren.

    Exchange-Berechtigungen hinzufügen

  11. Wählen Sie in der Zeile Office 365 Exchange OnlineDelegierte Berechtigungen und wählen Sie in der Auswahlliste Benutzer-E-Mail lesen.

    Anwendung für Webapplikation hinzufügen

    Dies sind die Berechtigungen, die Ihrem App-Benutzer angezeigt werden, wenn Azure ihn auffordert, der Berechtigungsanfrage Ihrer App zuzustimmen. Fordern Sie im Allgemeinen nur die Dienste an, die Ihre App tatsächlich benötigt und geben Sie in jedem Dienst die geringsten Berechtigungen an, die es Ihrer App ermöglichen, ihre Funktionen auszuführen.

  12. Klicken Sie auf speichern, um die Konfiguration der App zu speichern.

Bitte konfigurieren Sie Ihre Anwendung so, dass der implizite Grant Flow von OAuth 2.0 zugelassen ist

Um ein Zugriffstoken für Office 365-API-Anforderungen abzufragen, verwendet Ihre Anwendung den impliziten OAuth-Grant-Flow. Sie müssen das Manifest der Anwendung aktualisieren, um den impliziten Grant Flow von OAuth zuzulassen, da er standardmäßig nicht zulässig ist.

  1. Wählen Sie die Registerkarte Konfigurieren des Eintrags Ihrer Anwendung im Azure Verwaltungsportal.

  2. Mit der Schaltfläche Manifest verwalten in der Schublade laden Sie die Manifestdatei für die Anwendung herunter und speichern sie auf Ihrem Computer.

  3. Öffnen Sie die Manifestdatei mit einem Texteditor. Suchen Sie nach der Eigenschaft oauth2AllowImplicitFlow. Standardmäßig ist sie auf falsch gesetzt; ändern Sie sie auf richtig und speichern Sie die Datei.

  4. Mit der Schaltfläche Manifest verwalten laden Sie die aktualisierte Manifestdatei hoch.

Sie haben nun Ihre App erfolgreich erstellt und bei Azure AD registriert. Der letzte Schritt ist das Hinzufügen von Code, um Anforderungen an die Outlook Mail-REST-API zu stellen.

Codieren Sie Ihre App

Bevor wir fortfahren, überprüfen Sie, ob Sie sich noch im Verzeichnis Starter des Projekts befinden und Sie adal.js und adal-angular.js in index.html mit eingeschlossen haben. Danach fahren Sie mit der Authentifizierung bei Azure AD fort.

Authentifizieren Sie sich bei Azure AD und rufen Sie das Zugriffstoken ab

ADAL für JS bietet die Funktionalität zur Verwaltung der Authentifizierung in Ihrer Anwendung. Sie können es für das Caching und das Abrufen von Zugriffs- und Aktualisierungs-Tokens verwenden. Wir müssen nur die Datei app.js in public/scripts bearbeiten, damit die Authentifizierung funktioniert.

Zunächst fügen Sie AdalAngular als erforderliches Modul für Ihr App-Modul in Zeile 8 hinzu.

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

Als nächstes konfigurieren wir den Dienst, den uns AdalAngular bietet, indem wir ihn als Argument in der Konfigurationsfunktion Ihres Moduls in Zeile 13 übergeben. Wir werden auch das $http-Modul von Angular zu diesem Zeitpunkt hinzufügen, da wir es zur Konfiguration des Dienstes benötigen.

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

Der nächste Schritt ist die Initialisierung von adalAuthenticationServiceProvider in der Funktion config, damit die ADAL-API für Ihre Anwendung freigegeben und konfiguriert wird. Es werden drei Argumente benötigt, um den Anbieter zu initialisieren: Mandant, ClientId und CacheLocation. Der Wert Mandant ist die Unterdomäne von .onmicrosoft, die Sie bei der Anmeldung für Ihr Office 365-Geschäftskonto angegeben haben. Die clientId ist die Client-ID Ihrer Anwendung, die Sie im Azure Verwaltungsportal unter dem Reiter Konfigurieren auf der Seite Ihrer Anwendung finden. Schließlich fügen Sie cacheLocation mit dem Wert localStorage ein, wenn Ihre Anwendung im Internet Explorer ausgeführt wird.

// 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
  );

Nun haben Sie das Modul AdalAngular konfiguriert und können damit Benutzer in Ihrer Anwendung authentifizieren. Ein effizienter Weg, dies in Angular-Anwendungen zu tun, ist es, festzulegen, für welche Routen der Benutzer authentifiziert werden muss. In unserem Beispiel wollen wir, dass nur authentifizierte Benutzer unsere Anwendung sehen können, also schützen Sie die Stamm-Route in der Konfiguration $routeProvider, indem Sie das Mitglied requireADLogin zum Objekt hinzufügen, das Sie an die Methode .when übergeben.

$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: '/'
  });

Abrufen der E-Mail eines Benutzers aus Office 365

Nachdem Sie Ihren Benutzer authentifiziert haben, können Sie HTTP-Anforderungen an die Mail-REST-API mit einem Authentifizierungstoken stellen. CORS-Unterstützung für die Dateien-REST-API, die Kalender-REST-API und die Kontakte-REST-API ist ebenfalls verfügbar.

Um die HTTP-Anforderung an die Mail-REST-API zu stellen, um die E-Mail des Benutzers abzurufen, müssen Sie die URL der Mail-REST-API zur Initialisierung deklarieren, damit ADAL JS ihr vertrauen kann, indem Sie das Cross-Origin Resource Sharing (CORS) verwenden. Sie können dies tun, indem Sie ein Endpunkte-Objekt an unseren adalAuthenticationServiceProvider.init Code in app.jsübergeben. Der Endpunkt, den Sie hinzufügen müssen, ist 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
  );

Jetzt, wo ADAL JS so eingerichtet ist, dass es HTTP-Anforderungen an die Mail-REST-API über CORS stellt, bleibt nur noch, die HTTP-Anforderungen zu stellen, um die E-Mail des Benutzers abzurufen. Wir tun dies in homeController.js, das sich im Ordner public/controller befindet.

Fügen Sie den folgenden Code zu Ihrem leeren Controller hinzu. Er richtet die HTTP-Anforderung ein und führt sie aus. Wenn die Antwort empfangen wird, hängt er die Daten aus der Antwort an das Ansichtsmodell an, um sie aus der Ansicht heraus zugänglich zu machen (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.');
  });

Zum Schluss fügen wir noch etwas HTML hinzu, um die soeben erhaltenen Daten anzuzeigen. Fügen Sie den folgenden Code zu home.html im Ordner public/views hinzu.

<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>

Testen Sie Ihre App

Lassen Sie uns Ihre Anwendung testen, um sicherzustellen, dass sie den Benutzer erfolgreich mit Azure AD authentifiziert und die E-Mail des Benutzers abruft. Aus einer Eingabeaufforderung im Verzeichnis Starter geben Sie den Befehl node server.js ein. Dadurch wird ein Entwicklungsserver gestartet, der auf Port 8080 lauscht. Navigieren Sie zu http://127.0.0.1:8080/ im Webbrowser. Wenn Sie die Schritte korrekt ausgeführt haben, sollte Ihre Anwendung Sie zu einer Azure Active Directory-Anmeldeseite führen. Melden Sie sich mit Ihren Office 365-Anmeldeinformationen an (user@{your_subdomain}.onmicrosoft.com) und überprüfen Sie, ob Sie zu der Anwendung zurückkehren, in der Sie Ihre E-Mail finden.

Ausgezeichnet. Sie haben gerade eine Angular-App mit den Office 365-APIs erstellt.

Screenshot der App

Nächste Schritte

Nachdem Sie nun eine Anwendung erstellt haben, die die Mail-API verwendet, können Sie die anderen Office 365-REST-APIs für die Verwendung in Ihren Apps erkunden.

Zusätzliche Ressourcen

Sie entwickeln keine ASP.NET MVC-Webanwendungen? Verwenden Sie das Steuerelement in der oberen rechten Ecke, um die Art der App auszuwählen, die Sie entwickeln.

Erstellen Sie eine ASP.NET MVC-App mit Office 365-APIs

Beim Erstellen Ihrer Anwendung können Sie direkt gegen die REST-APIs programmieren, um mit Office 365 zu interagieren, oder Sie können die Office Developer Tools für Visual Studio nutzen.

Die Office Developer Tools für Visual Studio enthalten Client-Bibliotheken und UI-Erweiterungen für den Zugriff auf die Office 365-API-Dienste. Das .NET Framework und die JavaScript-Client-Bibliotheken erleichtern Ihnen die Interaktion mit den Office 365 REST-APIs über das Gerät oder die Plattform Ihrer Wahl. Die Erweiterungen der Benutzeroberfläche für Visual Studio vereinfachen es, Office 365-Dienste zu Ihren App-Projekten hinzuzufügen.

In diesem Thema führen wir Sie durch die Erstellung einer einfachen MVC (Model-View-Controller)-Webanwendung, die die Office 365-APIs in Visual Studio verwendet. Dies umfasst Folgendes:

  1. Erstellen Sie Ihre App und fügen Sie Abhängigkeiten hinzu
  2. Codieren Sie Ihre App
  3. Testen Sie Ihre App

Vor der Bereitstellung

Bevor Sie Anwendungen erstellen können, die auf die Office 365-APIs zugreifen, müssen Sie Ihre Entwicklerumgebung einrichten. Dies besteht aus drei einmaligen Aufgaben, um sicherzustellen, dass Sie die Tools und die Umgebung haben, um erfolgreich zu sein:

  1. Laden Sie Visual Studio und die Office Developer Tools herunter, mit denen Sie Ihre Anwendungen erstellen.
  2. Melden Sie ein Office 365 Business-Konto an, um auf die Office 365-APIs zuzugreifen.
  3. Verknüpfen Sie Ihr Office 365-Abonnement mit Azure AD, damit Sie Apps erstellen und verwalten können.

Wenn Sie noch einen dieser Schritte durchführen müssen, finden Sie unter Einrichten Ihrer Office 365-Entwicklungsumgebung detaillierte Anweisungen zum Einrichten.


Erstellen Sie Ihre App und fügen Sie Abhängigkeiten hinzu

Nachdem Sie Ihre Entwicklungsumgebung eingerichtet haben, können Sie mit Visual Studio eine Webanwendung erstellen, die die Office 365-APIs verwendet.

Das Beispiel, das wir erstellen werden, ist ein Single-Tenant MVC, der Azure AD Single Sign-on verwendet, um die Kontaktinformationen des Benutzers aus Office 365 zu authentifizieren und zu lesen. Wir werden das Office 365 Single-Tenant MVC Projekt auf GitHub als Modell verwenden.

Wählen Sie die Version von Visual Studio, die Sie verwenden:

  1. Klicken Sie in Visual Studio auf Datei > Neu.
  2. Unter Visual C# > Web, wählen Sie ASP.NET-Webanwendung. Benennen Sie das Projekt und wählen Sie OK.
  3. Wählen Sie MVC.
  4. Wählen Sie Authentifizierung ändern, wählen Sie Keine Authentifizierung und wählen Sie OK zweimal, um das Projekt zu erstellen.

Die Office 365-API-Dienste verwenden Azure AD zur sicheren Authentifizierung der Office 365-Daten der Benutzer. Um auf die Office 365-APIs zugreifen zu können, müssen Sie Ihre Anwendung bei Azure AD registrieren.

Wenn Sie einen Office 365-Dienst zu Ihrem Projekt hinzufügen, unterstützt Sie Visual Studio bei der Registrierung Ihrer Anwendung

Wenn Sie ein Visual Studio-Projekt erstellen, wird die Anwendungsregistrierung für Sie durchgeführt, wenn Sie einen Office 365-Dienst zu Ihrem Projekt hinzufügen. Während des Hinzufügens eines Office 365-Dienstes zu Ihrem Projekt ermöglicht Ihnen Visual Studio:

  • Registrieren Sie Ihre Anwendung bei Azure AD, einschließlich der Angabe, ob es sich um eine Webanwendung oder eine systemeigene Anwendung handelt
  • Konfigurieren von App-Eigenschaften wie App-Name, Umleitungs-/Antwort-Endpunkte und Mandantenbereich
  • Registrieren der App bei Azure AD
  • Verbinden mit Office 365-Diensten
  • Geben Sie die Berechtigungsstufen an, die Ihre Anwendung für die APIs in diesen Office 365-Diensten benötigt
  • Fügen Sie die erforderlichen NuGet-Pakete zum Projekt hinzu, basierend auf den Office 365-Diensten, mit denen Ihre Anwendung verbunden ist

Die folgenden Projektvorlagen unterstützen das Hinzufügen von Office 365-APIs als verbundenen Dienst:

  • .NET Windows Store 8.1 Apps
  • .NET Windows Store 8.1 Universelle Anwendungen
  • .NET Windows Phone 8.1 Apps
  • NET Windows Phone 8.1 Silverlight Apps
  • Windows Forms Anwendungen
  • WPF Anwendungen
  • ASP.NET MVC Web-Anwendungen
  • ASP.NET Web Forms Anwendungen
  • Xamarin Android und iOS Anwendungen
  • Multi-Device Hybrid (Cordova) Anwendungen

Verwenden Sie den Visual Studio Service Manager, um Ihre Anwendung zu registrieren und Office 365-APIs hinzuzufügen

Dann fügen Sie Office 365-APIs hinzu und konfigurieren Sie sie mit dem Dienste-Manager in Visual Studio.

  1. Wählen Sie im Projektmappen-Explorer den Projektknoten.

  2. Klicken Sie mit der rechten Maustaste oder halten Sie den Projektknoten gedrückt und wählen Sie Hinzufügen > Verbundeter Dienst.

  3. Registrieren Sie Ihre App:

    Wählen Sie oben im Dialogfeld Dienste-Manager den Link Office 365 und dann Registrieren Sie Ihre App. Melden Sie sich mit einem Mandantenadministrator-Konto für Ihre Office 365-Entwicklerorganisation an.

    Dies startet die App-Registrierung in Microsoft Azure Active Directory, die es Ihrer App ermöglicht, sich über OAuth zu authentifizieren.

    Nachdem Sie sich bei Office 365 angemeldet haben, wird eine Liste der verfügbaren Office 365-APIs-Dienste angezeigt. Sie sehen eine Liste der Office 365-APIs.

    Sie werden sehen, dass die Spalte Berechtigungen rechts neben jedem Dienst leer ist.

  4. Wählen Sie die Office 365-APIs aus, mit denen Sie eine Verbindung herstellen möchten, und geben Sie die Berechtigungsstufen für die einzelnen APIs an.

    1. Für dieses Beispiel wählen Sie Benutzer und Gruppen. Wählen Sie Berechtigungen.

      Ein Screenshot, der das Dialogfeld Dienste-Manager mit dem ausgewählten Benutzer und Gruppen-Dienst Office 365-API und dem hervorgehobenen Link Berechtigungen zeigt.

    2. Wählen Sie Anmeldung aktivieren und Benutzerprofil lesen und wählen Sie Anwenden.

      Ein Screenshot, der das Dialogfeld "Benutzer- und Gruppenberechtigungen" mit der Option "Anmeldung aktivieren und Benutzerprofilberechtigung lesen" zeigt.

    3. Als nächstes wählen Sie Kontakte. Wählen Sie Berechtigungen.

    4. Wählen Sie Benutzerkontakte lesen und wählen Sie Anwenden.

      Wenn Sie dies tun, fügt Visual Studio die Office 365-Dienste, die die von Ihnen ausgewählten APIs enthalten, zu Ihrer Anwendung in Azure AD hinzu und setzt die Berechtigungsstufen für die APIs auf die von Ihnen angegebenen.

  5. Legen Sie Eigenschaften für Ihre Anwendung fest:

    Wählen Sie App-Eigenschaften im Dialogfenster Dienste-Manager.

    Die App-Eigenschaften, die Sie einstellen können, hängen davon ab, ob es sich bei Ihrem App-Projekt um einen Webservice oder eine Webanwendung oder um eine systemeigene Anwendung wie ein Mobiltelefonprojekt handelt.

    Beispielsweise können Sie diese Beispielanwendung für Webanwendungen wie die, die wir entwickeln, anderen Office 365-Organisationen als Ihrer Entwicklerorganisation zur Verfügung stellen.

    Im Moment lassen wir die App-Eigenschaften so, wie sie standardmäßig sind.

    Das Dialogfenster Dienste-Manager wird nun angezeigt:

    • Die Dienste, die Sie zu Ihrem Projekt hinzugefügt haben.
    • Die Berechtigungen für jeden Dienst.

      Ein Screenshot des Dialogfelds Dienste-Manager, nachdem die Benutzer- und Gruppen- und Kontakt-APIs konfiguriert wurden, zeigt, dass beide APIs Leseberechtigungen haben.

  6. Wählen Sie OK aus.

An dieser Stelle fügt Visual Studio die erforderlichen NuGet-Pakete zum Projekt hinzu. Die hinzugefügten NuGet-Pakete variieren je nach den Office 365-APIs, die Sie hinzufügen.

  1. Wählen Sie im Projektmappen-Explorer den Projektknoten, zu dem Sie einen Office 365-Dienst hinzufügen möchten.

  2. Klicken Sie mit der rechten Maustaste oder halten Sie den Projektknoten gedrückt und wählen Sie Hinzufügen > Verbundeter Dienst.

  3. In der Microsoft-Registerkarte wählen Sie Office 365 APIs und dann Konfigurieren.

    Das Dialogfenster Office 365-API-Dienste konfigurieren erscheint.

  4. Registrieren Sie Ihre App:

    Auf der SeiteDomäne auswählen wählen Sie die Office 365-Domäne aus, unter der Ihre App eingetragen werden soll, etwa: contoso.onmicrosoft.com. Wählen Sie Weiter aus. Möglicherweise müssen Sie sich bei Office 365 anmelden, wenn Sie noch nicht angemeldet sind.

    Wählen Sie auf der Seite Anwendung konfigurieren, ob Sie eine neue Azure AD-Anwendung erstellen möchten.

    Aktivieren Sie das Kontrollkästchen, um Single Sign-On mit Ihrer Anwendung zu verwenden. Da Single Sign-On SSL erfordert, aktiviert diese Option automatisch SSL in Ihrem Projekt.

    Wählen Sie Weiter aus.

    Visual Studio registriert Ihre Anwendung.

  5. Wählen Sie die Office 365-APIs aus, mit denen Sie eine Verbindung herstellen möchten, und geben Sie die Berechtigungsstufen für die einzelnen APIs an. Für dieses Beispiel:

    1. Wählen Sie Kontakte.

    2. Überprüfen Sie Lesen Sie Ihre Kontakte.

    3. Wählen Sie Benutzer und Gruppen.

    4. Überprüfen Sie Anmeldung und lesen Sie Ihr Profil.

  6. Wählen Sie Fertig stellen aus.

An dieser Stelle fügt Visual Studio die erforderlichen NuGet-Pakete zum Projekt hinzu. Die hinzugefügten NuGet-Pakete variieren je nach den von Ihnen hinzugefügten Office 365-APIs.


Codieren Sie Ihre App

Nachdem Sie die Office 365-Dienste zu Ihrem Projekt hinzugefügt haben, müssen Sie Code schreiben, der den Benutzer der Anwendung authentifiziert und auf dessen Office 365-Daten zugreift.

Der Authentifizierungsprozess hängt davon ab, ob Sie eine Webanwendung, wie z.B. eine MVC, oder eine native Anwendung, wie z.B. eine Windows Store-App, erstellen.

Dieses ASP.NET-MVC-Beispiel verwendet eine persistente Bibliothek, genanntActive Directory Authentifizierungsbibliothek (ADAL) Token-Cache, welche eine Datenbank für das Caching verwendet. ADAL ermöglicht es Ihnen, Benutzer bei Active Directory (AD), in diesem Fall Azure AD, zu authentifizieren und dann Zugriffstokens zum Sichern von API-Aufrufen zu erhalten.

Von dort aus besteht der Aufbau des Beispiels aus drei großen Schritten:


Konfigurieren Sie Ihr Projekt für die Authentifizierung mit Azure Active Directory

Da das von uns erstellte Beispiel nur Office 365-Anmeldeauthentifizierung erfordert, verwenden wir OWIN  Katana und die Active Directory Authentifizierungsbibliothek (ADAL).

Aber zuerst müssen Sie das Projekt so konfigurieren, dass es Secure Sockets Layer (SSL) verwendet.

SSL für Ihr Projekt aktivieren

Visual Studio konfiguriert Ihr Projekt standardmäßig nicht für SSL. Wenn Sie SSL in Ihrem Projekt noch nicht aktiviert haben, sollten Sie jetzt die Office 365-Dienste mit der entsprechenden Umleitungs-URL aktualisieren.

So aktivieren Sie SSL:

  1. Wählen Sie im Projektmappen-Explorer das Projekt aus.
  2. Unter Eigenschaften, setzen Sie SSL Aktiviert auf True.

    Visual Studio gibt einen Wert für die SSL-URL an.

Als nächstes aktualisieren Sie die Anwendung, um den HTTPS-Endpunkt für die Startseite zu verwenden:

  1. Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf das Projekt und wählen Sie Eigenschaften aus.
  2. Wählen Sie die Registerkarte Web. Setzen Sie unter Server die Projekt-URL auf den HTTPS-Endpunkt, den Visual Studio für die SSL-URLerstellt hat.

Aktivieren Sie zum Schluss die Office 365-Dienste:

  1. Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf das Projekt und wählen Sie Hinzufügen > Verbundener Dienst. Melden Sie sich ggf. an.

    Visual Studio meldet jetzt, dass eine oder mehrere Umleitungs-URLs in Ihrem Projekt nicht in Ihrem Anwendungseintrag in Azure AD vorhanden sind.

  2. Klicken Sie auf Ja, um die sichere Umleitungs-URL zu Ihrem Anwendungseintrag in Azure AD hinzuzufügen.

  3. Wählen Sie OK, um den Dienste-Manager zu beenden.
Verwalten Sie NuGet-Pakete, die für die Authentifizierung erforderlich sind

Sie müssen die folgenden Azure AD und OWIN Katana-Pakete für die Authentifizierung installieren:

Diese Pakete können auch ausgewählte NuGet-Pakete als Abhängigkeiten installieren.

Um die NuGet-Pakete herunterzuladen und zu installieren:

  1. Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf das Projekt.
  2. Wählen Sie NuGet-Pakete verwalten...
  3. Wählen Sie in NuGet-Pakete verwaltenOnline.
  4. Verwenden Sie das Suchfeld, um das gewünschte Paket zu finden.
  5. Wählen Sie das Paket und wählen Sie Installieren.
  6. Wählen Sie in Projekte auswählen und dort OK.
  7. Akzeptieren Sie alle Lizenzen nach Aufforderung.
Aktualisieren Sie die Datei web.config, um die Authentifizierung zu aktivieren

Wenn Sie Office 365-Dienste zu Ihrem Projekt hinzugefügt haben, hat Visual Studio die folgenden Eigenschaften zur Registrierung Ihrer Anwendung in Azure AD und zur Datei web.config in Ihrer Lösung hinzugefügt.

<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/" 
Erstellen einer Datenbank zur Verwaltung von ADAL-Authentifizierungstoken

Als nächstes fügen Sie dem Projekt eine Datenbank hinzu, die als ADAL-Token-Cache dient.

Weitere Informationen zum ADAL-Token-Cache finden Sie unter Der neue Token-Cache in ADAL v2.

Um die Datenbank hinzuzufügen, die als ADAL-Token-Cache fungiert:

  1. Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf den Ordner App_Data Ordner und wählen Sie dann Hinzufügen > Neues Objekt...
  2. Stellen Sie sicher, dass Daten ausgewählt ist und wählen Sie dann SQL Server Database. Nennen Sie die Datenbank ADALTokenCacheDb und wählen Sie Hinzufügen.

Stellen Sie sicher, dass die Datenbankverbindung zum Projekt web.config hinzugefügt wurde:

  1. Doppelklicken Sie im Projektmappen-Explorer auf web.config.
  2. Stellen Sie sicher, dass nach dem Abschnitt AppSettings der Datei web.config der folgende Abschnitt hinzugefügt wurde. Wenn er nicht da ist, fügen Sie ihn hinzu.

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

Kopieren von Dateien, die für die Authentifizierung benötigt werden

Als nächstes importieren Sie einige Dateien aus dem Office 365 Single-Tenant MVC Projekt GitHub-Projekt.

Um Dateien aus dem GitHub-Projekt zu kopieren:

  1. Navigieren Sie in einem Browser zu der Datei, die Sie kopieren möchten. (Die Dateien sind unten aufgelistet).
  2. Klicken Sie mit der rechten Maustaste auf die Schaltfläche Raw und wählen Sie Ziel speichern unter
  3. Speichern Sie die Datei auf dem Computer.
  4. Klicken Sie in Visual Studio im Projektmappen-Explorer unter dem Projektknoten mit der rechten Maustaste auf den angegebenen Ordner wie unten beschrieben und wählen Sie Hinzufügen > Vorhandenes Objekt.
  5. Wählen Sie die Datei von dem Ort aus, wo Sie sie auf Ihrem Computer gespeichert haben.

Kopieren Sie die folgenden Dateien in den Ordner Modelle im Projekt. Diese Klassen zeigen, wie ein persistenter ADAL-Token-Cache aufgebaut und zum Speichern von Token verwendet werden kann.

Erstellen Sie einen neuen Ordner, Utils.

  1. Im Projektmappen-Explorer klicken Sie mit rechts auf Ihr Projekt und wählen Sie Himzufügen > Neuer Ordner.
  2. Benennen Sie den Ordner Utils.

Kopieren Sie die folgende Datei hinein. Diese Helper-Klasse enthält Mitglieds-Variablen, die die Werte aus der web.config-Datei Ihres Projekts lesen, die Sie benötigen, um das ADAL-Authentifizierungsobjekt beim Start zu erstellen.

Schließlich kopieren Sie die Datei _LoginPartial.cshtml in den Ordner Ansichten > Geteilt Ihres Projekts.


Authentifizierung mit Azure Active Directory

Nun, da wir das Projekt für die Authentifizierung konfiguriert haben, können wir tatsächlich die Funktionalität hinzufügen, die die Authentifizierung mit Azure AD handhabt.

Azure AD Single Sign-On konfigurieren

Als nächstes müssen Sie dem Projekt eine OWIN-Startup-Klasse hinzufügen, um die Authentifizierung tatsächlich durchführen zu können. Um die OWIN-Startup-Klasse hinzuzufügen:

  1. Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf das > -Projekt und wählen Sie Hinzufügen | Neues Element aus...
  2. In Neues Element hinzufügen, unter Web, wählen Sie Allgemein, dann OWIN Startup-Klasse.
  3. Als Name geben Sie Startup ein.
  4. Klicken Sie auf Hinzufügen.

Eine neue Startup-Klasse wird Ihrem Projekt hinzugefügt.

Als nächstes fügen Sie den Code für die Authentifizierung hinzu:

  1. Ersetzen Sie die Namespace-Verweise in der Datei durch die folgenden.

    
        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. Fügen Sie die folgende Methode ConfigureAuth zur Startup-Klasse hinzu.

    
        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. Fügen Sie Code zur Methode Startup.Configuration hinzu, die die Methode ConfigureAuth aufruft.

        public void Configuration(IAppBuilder app)
        {
            ConfigureAuth(app);
        }
    
Hinzufügen eines Controllers zur An- und Abmeldung von Office 365

Fügen Sie einen Konto-Controller hinzu, um die An- und Abmeldung zu verwalten:

  1. Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf den Ordner Controller und wählen Sie Hinzufügen > Controller...
  2. Wählen Sie MVC 5 Controller - Empty und wählen Sie Hinzufügen.
  3. Geben Sie als Controller-Name AccountController ein und wählen Sie Hinzufügen.
  4. Ersetzen Sie die Namespace-Verweise in der Controller-Datei durch die folgenden.

        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. Löschen Sie dieMethode Index().

  6. Fügen Sie die folgenden Methoden zur Klasse AccountController hinzu, um die An- und Abmeldung zu behandeln.

        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();
        }
    


Zugriff auf Office 365-APIs

Jetzt sind Sie bereit, den Code hinzuzufügen, der auf die Office 365-Daten des Benutzers zugreift.

Erstellen des Modells für die Kontaktinformationsansicht

Zuerst müssen Sie die Klasse erstellen, auf der die Kontaktansicht basiert:

  1. Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf den Ordner Modelle und wählen Sie Hinzufügen > Klasse...
  2. Wählen Klasse, geben Sie MyContact als Namen ein und wählen Sie auf Hinzufügen.
  3. Fügen Sie in der Klasse die folgende Zeile Code hinzu.

    
        public class MyContact
        {
            public string Name { get; set; }
        }
    
  4. Speichern Sie die Datei.

Hinzufügen eines Controllers für Kontaktinformationen

Als nächstes fügen Sie einen Controller für die Kontaktinformationen der Benutzer hinzu:

  1. Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf den Ordner Controller und wählen Sie Hinzufügen > Controller.
  2. Wählen Sie MVC 5 Controller - Empty und wählen Sie Hinzufügen.
  3. Geben Sie unter Controllername ContactsController ein und wählen Sie Hinzufügen.

    Visual Studio fügt dem Projekt einen neuen leeren Controller hinzu.

  4. Ersetzen Sie die Namespace-Verweise in der Controller-Datei durch die folgenden.

        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;
    

    Stellen Sie sicher, dass Sie einen Namespace-Verweis für den Modelle-Namespace Ihres Projekts hinzufügen.

```C#
        using [projectname].Models;
```
  1. Fügen Sie das Attribut [Authorize] zur Klasse ContactsController hinzu.

    Das Attribut [Authorize] erfordert, dass der Benutzer authentifiziert wird, bevor er auf diesen Controller zugreifen kann.

        [Authorize]
        public class ContactsController : Controller
    
  2. Ändern Sie die Methode Index() auf asynchron.

        public async Task<ActionResult> Index()
    
  3. Fügen Sie den folgenden Code zur Index() Methode hinzu.

    Dieser Code erstellt den Authentifizierungskontext unter Verwendung der angemeldeten Office 365-Benutzer-ID und der Berechtigung für Ihren Office 365-Mandanten.

            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));
    
  4. Fügen Sie einen try-catch Block direkt unter dem obigen Code in der Index() Methode hinzu.

    
            try
            {
    
            }
            catch (AdalException exception)
            {
                //handle token acquisition failure
                if (exception.ErrorCode == AdalError.FailedToAcquireTokenSilently)
                {
                    authContext.TokenCache.Clear();
    
                    //handle token acquisition failure
                }
            }
    
            return View(myContacts);
    
  5. Fügen Sie im try-Block des obigen Codes den folgenden Code zur Index()-Methode hinzu.

    Dieser Code versucht, ein Zugriffstoken für den Discovery Service zu erhalten, indem er die Client-ID und das Anwendungskennwort sowie die Anmeldeinformationen des Benutzers übergibt. Da das Benutzerauthentifizierungstoken zwischengespeichert wurde, ist der Controller in der Lage, das erforderliche Zugriffstoken im Hintergrund zu erwerben, ohne den Benutzer erneut nach seinen Zugangsdaten fragen zu müssen.

    Mit dem Zugriffstoken kann die Anwendung ein Ermittlungsdienst-Client-Objekt erstellen und das Ermittlungs-Client-Objekt verwenden, um den Ressourcen-Endpunkt für die Office 365-Dienstkontakte-APIs zu bestimmen.

                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");
    
  6. Schließlich, direkt unter dem obigen Code im try-Block, fügen Sie den folgenden Code zur Index()-Methode hinzu.

    Dieser Code kontaktiert den Ressourcen-Endpunkt für den Office 365-Dienst Kontakte-APIs, wobei die Anwendung und die Benutzeranmeldeinformationen wieder stillschweigend übergeben werden, um ein Zugriffstoken für den Outlook-Dienst zu erhalten.

    Nach Erhalt des Zugriffstokens kann der Code ein Outlook-Client-Objekt initialisieren. Der Code verwendet dann die Eigenschaft Me des Outlook-Client-Objekts, um Kontaktinformationen für diesen Benutzer abzurufen.

    Schließlich liest der Controller die Liste der Benutzerkontakte durch und gibt eine Ansicht mit ihren Anzeigenamen zurück.

    
                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);
    

    Die abgeschlossene Index()-Methode sollte nun wie folgt lauten.

        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);
        }
    
Erstellen der Ansicht für die Kontaktdaten

Als nächstes können wir die Ansicht für die Kontaktinformationen des Benutzers erstellen. Sie tun dies, indem wir die Ansicht auf die Klasse MyContact stützen, die Sie zuvor erstellt haben.

  1. Klicken Sie im Solution Explorermit der rechten Maustaste auf den Ordner Kontakte und wählen Sie Hinzufügen > Ansicht.
  2. Definieren Sie im Dialogfenster Ansicht hinzufügen die neue Ansicht:
    • AlsName der Ansicht, geben Sie Index ein.
    • Unter Vorlage wählen Sie Liste.
    • UnterModellklassewählen Sie MyContact aus.
    • Klicken Sie auf Hinzufügen.
  1. Im Projektmappen-Explorer, im Ordner Shared doppelklicken Sie auf die Datei _Layout.cshtml.

  2. Fügen Sie einen Aktionslink für die MyContacts-Seite hinzu und setzen Sie die partielle Klasse für die Benutzeranmeldung ein.

  3. Aktualisieren Sie die HTML der Navigationsleiste aus dem, was automatisch generiert wird.

            <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>
    

    Um einen Aktionslink für die MyContacts-Seite hinzuzufügen und die partielle Klasse für die Benutzeranmeldung einzufügen, gehen Sie wie folgt vor.

            <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>
    


Testen Sie Ihre App

Jetzt können Sie die Lösung ausführen. Drücken Sie F5, um Ihre Webanwendung zu debuggen.

Wenn es sich um eine neue Entwicklungsumgebung handelt, werden Sie möglicherweise von Visual Studio aufgefordert, das IIS-SSL-Zertifikat zu konfigurieren. Wählen Sie Ja zweimal, um fortzufahren.

  1. Visual Studio startet die Webanwendung in dem Browser, den Sie in Visual Studio ausgewählt haben.

  2. Klicken Sie auf Anmeldung in der oberen rechten Ecke der Seite und melden Sie sich bei Ihrem Office 365-Mandanten an, bei dem Sie Ihre Webanwendung registriert haben.

    Da sich nur Benutzer Ihres Unternehmens bei einer Einzelmandantenanwendung anmelden dürfen, ist keine Zustimmung erforderlich. Wenn Ihre Anwendung multi-mandantenfähig wäre, würde Azure AD eine Einwilligungsseite anzeigen, auf der die angeforderten Berechtigungen aufgelistet sind, damit Sie der Anwendung diese Berechtigungen erteilen können.

  3. Sobald Sie angemeldet sind, sollten Sie Ihre E-Mail-Adresse und Abmelden in der Navigationsleiste oben auf der Startseite sehen.

  4. Wählen Sie Meine Kontakte.

    Die Seite Meine Kontakte zeigt die Namen aller Exchange-Kontakte Ihres Mandanten an.

Sie haben jetzt ein Web-Anwendungsprojekt, das Sie anpassen und Office 365-APIs integrieren können.

Nächste Schritte

Entdecken Sie die Office 365-REST-APIs zur Verwendung in Ihren Anwendungen.

Besuchen Sie das Office-Codebeispiel-Repository auf GitHub, um Codebeispiele herunterzuladen oder zu erforschen, die die Office 365-APIs in einer Vielzahl von Projekttypen verwenden, einschließlich:

Zusätzliche Ressourcen

© 2018 Microsoft