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

Tutorial: Erstellen einer OneNote-Anwendung

Gilt für: Privatanwender-Notizbücher auf OneDrive | Enterprise-Notizbücher auf Office 365

Dieses Tutorial zeigt Ihnen, wie Sie eine einfache Anwendung erstellen, die die OneNote-API verwendet, um OneNote-Inhalte zu erhalten und zu erstellen. Die Anwendung, die wir erstellen werden, macht zwei Aufrufe über die OneNote REST API:

Ermittlung von Name und ID der 10 zuletzt geänderten Abschnitte

GET ../notes/sections?select=name,id&top=10&orderby=lastModifiedTime%20desc

Erstellen Sie eine Seite in einem bestimmten Abschnitt

POST ../notes/sections/{id}/pages

Wählen Sie Ihre Plattform aus:

Dieses Tutorial soll zeigen, wie man auf die OneNote-API zugreift, aber es enthält keinen produktionsreifen Code. Wenn Sie Ihre Anwendung erstellen, überprüfen Sie Ihren Code sorgfältig auf mögliche Sicherheits-, Validierungs- und andere Code-Qualitätsprobleme.

Erstellen einer OneNote-Anwendung für iOS

Die App verwendet das OneDrive SDK für iOS, um Authentifizierung und Netzwerkaufrufe zu verarbeiten.

Voraussetzungen

Hier ist, was Sie brauchen, um diesem Tutorial zu folgen:


Erstellen einer OneNote-Anwendung für iOS:

1. Erstellen Sie das Projekt

2. Fügen Sie die OneDrive SDK-Abhängigkeit hinzu

3. Erstellen Sie die Benutzeroberfläche

4. Fügen Sie Auth-Unterstützung hinzu

5. Aufruf der OneNote-API

Vollständiges Code-Beispiel für wichtige Beispieldateien sind am Ende des Tutorials enthalten.

Erstellen Sie das Projekt in Xcode

  1. Erstellen Sie in Xcode ein Projekt Single View Anwendung für iOS mit dem Namen OneNote-iOS-App. Wählen Sie Objektiv C, und wählen Sie iPhone Geräte.
  2. Nachdem das Projekt erstellt wurde, schließen Sie Xcode. Sie öffnen den Arbeitsbereich, nachdem Sie ein Podfile erstellt haben.

Fügen Sie die OneDrive SDK-Abhängigkeit hinzu

Die Anwendung in diesem Tutorial verwendet das OneDrive SDK sowohl für Microsoft-Konten (früher Live Connect) als auch für die Azure Active Directory-Authentifizierung. Die Microsoft-Kontoauthentifizierung wird für den Zugriff auf Consumer-Notebooks auf OneDrive verwendet. Azure AD-Authentifizierung wird für den Zugriff auf Enterprise-Notizbücher in Office 365 verwendet.

  1. Führen Sie diese Befehle in Terminal aus, um ein Podfile zu erstellen und die Datei in Xcode zu öffnen.

    cd {path to the OneNote-iOS-App project directory} 
    touch podfile 
    open -a xcode podfile 
    
  2. Fügen Sie die OneDrive SDK-Abhängigkeit zum Podfile hinzu und speichern Sie die Datei.

    pod 'OneDriveSDK'
    
  3. Führen Sie diese Befehle in Terminal aus, um die Abhängigkeit zu installieren und den Projektarbeitsbereich in Xcode zu öffnen. Sie sollten eine Bestätigung erhalten, wenn die Installation abgeschlossen ist.

    pod install
    open onenote-ios-app.xcworkspace/
    

Xcode 7 Anwendungen, die auf iOS 9.0 abzielen

Wenn Sie iOS 9 mit Xcode 7 anvisieren, müssen Sie PFS-Ausnahmen aktivieren. Siehe den Abschnitt iOS 9 App Transportsicherheit im OneDrive SDK für iOS Infodatei für Anweisungen.

Erstellen Sie die Benutzeroberfläche

Fügen Sie einen Picker hinzu, der die 10 zuletzt geänderten Abschnitte des Benutzers anzeigt, und eine Schaltfläche, die eine OneNote-Seite im ausgewählten Abschnitt erstellt.

  1. Öffnen Sie in Xcode Main.storyboard und ändern Sie die Größenklassenkontrolle (unter dem Canvas) auf wCompact/hAny.

  2. Ziehen Sie eine Picker-Ansicht und eine Schaltfläche aus der Objektbibliothek auf den Canvas. Verwenden Sie Seite erstellen für den Schaltflächentext.

  3. Legen Sie Verbindungen für die Picker-Ansicht an:
    a. Steuerung: Ziehen Sie die Picker-Ansicht auf das Ansicht-Controller-Symbol über dem Canvas. Wählen Sie den Ausgang dataSource.
    b. Wiederholen Sie dies für den Ausgang Delegate.
    c. Wählen Sie Ansicht > Assistenten-Editor > Assistenten-Editor anzeigen und öffnen Sie ViewController.h im zweiten Fenster.
    d. Halten und Ziehen Sie die Picker-Ansicht in dem Canvas in den Codeblock @interface. Fügen Sie eine Ausgang-Verbindung namens sectionPicker ein.

  4. Legen Sie Verbindungen für die Schaltfläche an:
    a. Halten und Ziehen Sie die Schaltfläche in dem Canvas in den Codeblock @interface. Fügen Sie eine Ausgang-Verbindung namens createPageButton ein.
    b. Öffnen Sie ViewController.m im Assistenten-Editor.
    c. Halten und Ziehen Sie die Schaltfläche in dem Canvas in den Codeblock @implementation. Fügen Sie eine Aktion-Verbindung mit dem Namen createPage für das Ereignis Touch Up Inside ein.

  5. Deklarieren Sie die Protokolle UIPickerViewDelegate und UIPickerViewDataSource.

    ViewController.h sollte so aussehen:

     import <UIKit/UIKit.h>
    
     @interface ViewController : UIViewController<UIPickerViewDelegate, UIPickerViewDataSource>
    
     @property (weak, nonatomic) IBOutlet UIPickerView *sectionPicker;
     @property (weak, nonatomic) IBOutlet UIButton *createPageButton;
    
     @end
    
  6. Fügen Sie in ViewController.m die folgenden Delegate-Methoden für die Picker-Ansicht hinzu.

     #pragma mark - Delegate Methods
    -(NSInteger)numberOfComponentsInPickerView:(UIPickerView *)pickerView {
        return 1;
    }
    
    -(NSInteger)pickerView:(UIPickerView *)pickerView numberOfRowsInComponent:(NSInteger)component {
        return sectionNamesForPicker.count;
    }
    
    -(NSString *)pickerView:(UIPickerView*)pickerView titleForRow:(NSInteger)row forComponent:(NSInteger)component {
        return [sectionNamesForPicker objectAtIndex:row];
    }
    

    Sorgen Sie sich nicht um die Fehler für sectionNamesForPicker. Wir fügen die Variable später hinzu.

  7. Fügen Sie in der Methode viewDidLoad folgenden Code ein, um den Picker nach der Zeile [super viewDidLoad]zu verbinden.

     self.sectionPicker.delegate = self;
     self.sectionPicker.dataSource = self;
    

Fügen Sie Auth-Unterstützung hinzu

Das OneDrive SDK übernimmt die Authentifizierung und Autorisierung für Sie. Sie müssen lediglich Identifikatoren für Ihre Anwendung angeben und dann den ODClient verwenden. Das SDK ruft die Anmelde-Benutzeroberfläche beim ersten Start der Anwendung auf und speichert dann die Kontoinformationen. (Erfahren Sie mehr über auth im SDK.)

  1. Importieren Sie in AppDelegate.m das OneDrive SDK.

     #import <OneDriveSDK/OneDriveSDK.h>
    
  2. Ersetzen Sie die Methode didFinishLaunchingWithOptions durch den folgenden Code.

    Ersetzen Sie dann die Platzhalter-Eigenschaftswerte durch die Informationen für Ihre registrierten Anwendungen. Wenn Sie nur mit einer Anwendung testen, können Sie die Eigenschaften, die Sie nicht verwenden, auskommentieren.

     - (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {
    
         // Set the client ID and permission scopes of your app registered on the Microsoft account Developer Center.
         static NSString *const msaClientId = @"000000001A123456";
         static NSString *const msaScopesString = @"wl.signin,wl.offline_access,office.onenote_update";
    
         // Set the client ID and redirect URI of your app registered on the Azure Management Portal.
         static NSString *const aadClientId = @"0b18d05c-386d-4133-b481-az1234567890";
         static NSString *const aadRedirectUri = @"http://localhost/";
    
         // Set properties on the ODClient.
         NSArray *const msaScopes = [msaScopesString componentsSeparatedByString:@","];
         [ODClient setMicrosoftAccountAppId:msaClientId
                                     scopes:msaScopes];
    
         [ODClient setActiveDirectoryAppId:aadClientId
                                capability:@"Notes"
                               redirectURL:aadRedirectUri];
         return YES;
     }
    

    Mit dieser Anwendung können Sie sich mit jeweils einem Konto anmelden (Microsoft-Konto oder Arbeits- oder Schulkonto). Um zu sehen, wie man beide Kontotypen unterstützt und mehrere Konten speichert, siehe das CloudRoll-Beispiel.

  3. Importieren Sie in ViewController.h das OneDrive SDK und deklarieren Sie eine Eigenschaft für das ODClient-Objekt. Alle Aufrufe an das SDK erfolgen über das ODClient-Objekt.

    a. Fügen Sie die Importieren-Anweisung hinzu:

    #import <OneDriveSDK/OneDriveSDK.h>
    

    b. Fügen Sie die Eigenschaft Client zum Codeblock @interface hinzu.

    @property (strong, nonatomic) ODClient *client;
    
  4. Fügen Sie in ViewController.m den folgenden Code an das Ende der Methode viewDidLoad an, um einen authentifizierten ODClient zu erhalten.

    Das SDK ruft die Anmelde-Benutzeroberfläche beim ersten Start der Anwendung auf und speichert dann die Kontoinformationen.

     [ODClient clientWithCompletion:^(ODClient *odClient, NSError *error) {
         if (!error){
             self.client = odClient;
             [self getSections];
         }
         else {
             NSLog(@"Error with auth: %@", [error localizedDescription]);
         }
     }];
    

    Wir werden die getSections Methode im nächsten Abschnitt hinzufügen.

  5. Fügen Sie in ViewController.m die Methode sendRequest zum Codeblock @implementation hinzu.

    Diese Methode fügt die erforderlichen Autorisierung-Header zu den GET-Abschnitten und den POST-Seiten -Anforderungen hinzu und erzeugt die Datenübertragungsaufgabe.

     // Send the request.
     - (void)sendRequest:(NSMutableURLRequest *)request {
    
         // Add the required Authorization header with access token.
         [self.client.authProvider appendAuthHeaders:request completion:^(NSMutableURLRequest *requests, NSError *error) {
    
             // This app also uses the OneDrive SDK to send HTTP requests.
             [[self.client.httpProvider dataTaskWithRequest:(request)
                     completionHandler:^(NSData *data,
                     NSURLResponse *response,
                     NSError *error) {
                         [self handleResponse:data response:response error:error];
             }] resume];
         }];
     }
    

Jetzt können Sie den OneNote-Dienst anrufen.

Aufruf der OneNote-API

Wenn die App geladen wird, erhält sie den Namen und die ID der 10 zuletzt geänderten Abschnitte und füllt den Picker mit den Namen der Abschnitte. Die neue Seite wird im ausgewählten Abschnitt erstellt.

  1. Fügen Sie in ViewController.h Eigenschaften hinzu, die die Antwort speichern.

    // Variables to store the response data.
    @property (strong, nonatomic) NSHTTPURLResponse *returnResponse;
    @property (strong, nonatomic) NSMutableData *returnData;
    

    Fügen Sie den gesamten Code in den folgenden Schritten zum @implementation Codeblock in ViewController.m hinzu. Machen Sie sich keine Sorgen über die Fehler, die Sie während der Erstellung der Anwendung sehen. Sie werden verschwinden, wenn der Code fertig ist.

  2. Fügen Sie in ViewController.m Variablen für die Root-URL des OneNote-Dienstes, das Wörterbuch für die Abschnittsnamen und IDs und ein Array für die Abschnittsnamen hinzu, die den Picker füllen.

    static NSString const *serviceRootUrl = @"https://www.onenote.com/api/v1.0/me/notes/";
    NSMutableDictionary *sectionNamesAndIds;
    NSArray *sectionNamesForPicker;
    
  3. Fügen Sie die Methode getSections hinzu, um die GET sections-Anfrage zu erstellen.

     // Build the "GET sections" request.
     - (void)getSections {
    
         // Construct the request URI and the request.
         NSString *sectionsEndpoint =
                 [serviceRootUrl stringByAppendingString:@"sections?select=name,id&top=10&orderby=lastModifiedTime%20desc"];
         NSMutableURLRequest *request =
                 [[NSMutableURLRequest alloc] initWithURL:[[NSURL alloc] initWithString:sectionsEndpoint]];
         request.HTTPMethod = @"GET";
         if (self.client)
         {
    
             // Send the HTTP request.
             [self sendRequest:request];
         }
         _createPageButton.enabled = false;
     }
    
  4. Fügen Sie die Methode handleResponse hinzu, um die Antwort von den GET-Abschnitten und POST-Seiten Anfragen zu behandeln.

    // Handle the response.
    - (void)handleResponse:(NSData *)data response:(NSURLResponse *)response error:(NSError *) error {
    
        // Log the response.
        NSLog(@"Response %@ with error %@.\n", response, error);
        NSString *stringData = [[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding];
        NSLog(@"Body: %@.\n", stringData);
    
        // Store the response.
        self.returnData = [[NSMutableData alloc] init];
        NSMutableData *convertedData = [data mutableCopy];
        [self.returnData appendData:convertedData];
        self.returnResponse = (NSHTTPURLResponse *)response;
    
        NSInteger status = [self.returnResponse statusCode];
    
        // Check for "GET sections" success.
        if (status == 200) {
            NSLog(@"Sections retrieved!\n");
    
            // Get the section data and populate the picker.
            [self getSectionNamesAndIds];
        }
    
        // Check for "POST pages" success.
        else if (status == 201) {
            NSLog(@"Page created!\n");
    
            // Get the page object and parse out some properties.
            NSDictionary *pageProperties = [self convertData];
            NSString *selfLink = [pageProperties objectForKey:@"self"];
            NSDictionary *links = [pageProperties objectForKey:@"links"];
            NSString *clientUrl = [[links objectForKey:@"oneNoteClientUrl"] objectForKey:@"href"];
            NSString *webUrl = [[links objectForKey:@"oneNoteWebUrl"] objectForKey:@"href"];
            NSLog(@"Link to new page endpoint: %@\n", selfLink);
            NSLog(@"Link open page in the installed client: %@\n", clientUrl);
            NSLog(@"Link to open page in OneNote Online: %@\n", webUrl);
        }
        else {
            NSLog(@"Status code: %ld. Check the logged response for more information.", (long)status);
        }
    }
    
  5. Fügen Sie die Methode convertData hinzu, um die Antwortdaten in JSON zu konvertieren.

    // Get the OneNote entity data from the response.
    - (NSDictionary *)convertData {
    
        // Convert the message body to JSON.
        NSError *parseError;
        NSDictionary *data = [NSJSONSerialization JSONObjectWithData:self.returnData options:kNilOptions error:&parseError];
    
        if (!parseError) {
            return data;
        }
        else {
            NSLog(@"Error parsing response: %@", [parseError localizedDescription]);
            return nil;
        }
    }
    
  6. Fügen Sie die Methode getSectionNamesAndIds hinzu, um die Abschnittsnamen und IDs zu speichern und den Picker zu füllen.

    // Store the section names and IDs, and populate the section picker.
    - (void)getSectionNamesAndIds {
    
        // Get the "value" array that contains the returned sections.
        NSDictionary *results = [self convertData];
    
        // Add the name-id pairs to sectionNamesAndIds, which is used to map section names to IDs.
        if ([results objectForKey:@"value"] != nil) {
            NSDictionary *sections =[results objectForKey:@"value"];
            sectionNamesAndIds = [[NSMutableDictionary alloc] init];
            for (NSMutableDictionary *dict in sections) {
                NSString *sectionName = [dict objectForKey:@"name"];
                NSString *sectionId = [dict objectForKey:@"id"];
                sectionNamesAndIds[sectionName] = sectionId;
            }
        }
    
        // Populate the picker with the section names.
        sectionNamesForPicker = [sectionNamesAndIds allKeys];
        dispatch_async(dispatch_get_main_queue(), ^{[_sectionPicker reloadComponent:0];});
    
        _createPageButton.enabled = true;
    }
    
  7. Bearbeiten Sie die Methode createPage, die für Sie erstellt wurde, als Sie die Schaltflächen-Aktion hinzugefügt haben. Dieser Code erzeugt eine einfache HTML-Seite.

    // Create a simple page.
    - (IBAction)createPage:(id)sender {
    
        // Get the ID of the section that's selected in the picker.
        NSInteger row = [self.sectionPicker selectedRowInComponent:0];
        NSString *selectedSectionName = sectionNamesForPicker[row];
        NSString *selectedSectionId = sectionNamesAndIds[selectedSectionName];
    
        // Construct the request URI and the request.
        NSString *pagesEndpoint = [NSString stringWithFormat:@"sections/%@/pages", selectedSectionId];
        NSString *fullEndpoint = [serviceRootUrl stringByAppendingString:pagesEndpoint];
        NSString *date = [self formatDate];
        NSString *simpleHtml = [NSString stringWithFormat:@"<html>"
                                "<head>"
                                "<title>A page created from simple HTML from iOS</title>"
                                "<meta name=\"created\" content=\"%@\" />"
                                "</head>"
                                "<body>"
                                "<p>This is some <b>simple</b> <i>formatted</i> text.</p>"
                                "</body>"
                                "</html>", date];
    
        NSData *presentation = [simpleHtml dataUsingEncoding:NSUTF8StringEncoding];
        NSMutableURLRequest * request = [[NSMutableURLRequest alloc] initWithURL:[[NSURL alloc] initWithString:fullEndpoint]];
        request.HTTPMethod = @"POST";
        request.HTTPBody = presentation;
        [request addValue:@"text/html" forHTTPHeaderField:@"Content-Type"];
        if (self.client)
        {
    
            // Send the HTTP request.
            [self sendRequest:request];
        }
    }
    
  8. Fügen Sie die Methode formatDate hinzu, um ein ISO 8601-formatiertes Datum für den meta Tag-Zeitstempel zu erhalten.

    // Format the "created" date. OneNote requires the ISO 8601 format.
    - (NSString *)formatDate {
        NSDate *now = [NSDate date];
        NSDateFormatter *dateFormatter = [[NSDateFormatter alloc] init];
        NSLocale *enUSPOSIXLocale = [NSLocale localeWithLocaleIdentifier:@"en_US_POSIX"];
        [dateFormatter setLocale:enUSPOSIXLocale];
        [dateFormatter setDateFormat:@"yyyy-MM-dd'T'HH:mm:ssZZZZZ"];
        return [dateFormatter stringFromDate:now];
    }
    

Nachdem Sie die App erstellt haben, können Sie sie testen, indem Sie sie auf einem iPhone oder iPhone Emulator ausführen. Melden Sie sich mit Ihrem Microsoft-Konto oder Ihrem Arbeits- oder Schulkonto an.

Wenn die Anwendung geöffnet wird, wählen Sie den Bereich, in dem Sie eine Seite erstellen möchten, und wählen Sie dann Seite erstellen. Überprüfen Sie dann das Ausgabefenster in Xcode auf die Logmeldungen. Wenn die Aufrufe funktionieren, zeigt das Ausgabefenster die Ressourcen-URI der neuen Seite und die Links zum Öffnen der Seite in OneNote.

Nächste Schritte:

Hinzufügen von Funktionalität, Eingabevalidierung und Fehlerbehandlung.

Fügen Sie beispielsweise eine Abmelde-Schaltfläche hinzu, die diese Methode aufruft:

- (IBAction)signOut:(UIButton *)sender  {
    [self.client signOutWithCompletion:^(NSError *signOutError) {
        self.client = nil;
        NSLog(@"Logged out.");
    }];
}

In den Artikeln Entwicklung mit der OneNote API erfahren Sie mehr darüber, was Sie mit der OneNote API machen können.

Vollständiges Codebeispiel

AppDelegate.m

#import "AppDelegate.h"
#import <OneDriveSDK/OneDriveSDK.h>

@interface AppDelegate ()

@end

@implementation AppDelegate


- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {

    // Set the client ID and permission scopes of your app registered on the Microsoft account Developer Center.
    static NSString *const msaClientId = @"000000001A123456";
    static NSString *const msaScopesString = @"wl.signin,wl.offline_access,office.onenote_update";

    // Set the client ID and redirect URI of your app registered on the Azure Management Portal.
    static NSString *const aadClientId = @"0b18d05c-386d-4133-b481-az1234567890";
    static NSString *const aadRedirectUri = @"http://localhost/";

    // Set properties on the ODClient.
    NSArray *const msaScopes = [msaScopesString componentsSeparatedByString:@","];
    [ODClient setMicrosoftAccountAppId:msaClientId
                                scopes:msaScopes];

    [ODClient setActiveDirectoryAppId:aadClientId
                           capability:@"Notes"
                          redirectURL:aadRedirectUri];
    return YES;
}

- (void)applicationWillResignActive:(UIApplication *)application {
    // Sent when the application is about to move from active to inactive state. This can occur for certain types of temporary interruptions (such as an incoming phone call or SMS message) or when the user quits the application and it begins the transition to the background state.
    // Use this method to pause ongoing tasks, disable timers, and throttle down OpenGL ES frame rates. Games should use this method to pause the game.
}

- (void)applicationDidEnterBackground:(UIApplication *)application {
    // Use this method to release shared resources, save user data, invalidate timers, and store enough application state information to restore your application to its current state in case it is terminated later.
    // If your application supports background execution, this method is called instead of applicationWillTerminate: when the user quits.
}

- (void)applicationWillEnterForeground:(UIApplication *)application {
    // Called as part of the transition from the background to the inactive state; here you can undo many of the changes made on entering the background.
}

- (void)applicationDidBecomeActive:(UIApplication *)application {
    // Restart any tasks that were paused (or not yet started) while the application was inactive. If the application was previously in the background, optionally refresh the user interface.
}

- (void)applicationWillTerminate:(UIApplication *)application {
    // Called when the application is about to terminate. Save data if appropriate. See also applicationDidEnterBackground:.
}

@end


ViewController.h

#import <UIKit/UIKit.h>
#import <OneDriveSDK/OneDriveSDK.h>

@interface ViewController : UIViewController<UIPickerViewDelegate, UIPickerViewDataSource>

@property (strong, nonatomic) ODClient *client;

// Variables to store the response data.
@property (strong, nonatomic) NSHTTPURLResponse *returnResponse;
@property (strong, nonatomic) NSMutableData *returnData;

// Outlet connections for controls.
@property (weak, nonatomic) IBOutlet UIPickerView *sectionPicker;
@property (weak, nonatomic) IBOutlet UIButton *createPageButton;

@end


ViewController.m

#import "ViewController.h"

@interface ViewController ()

@end

@implementation ViewController

static NSString const *serviceRootUrl = @"https://www.onenote.com/api/v1.0/me/notes/";
NSMutableDictionary *sectionNamesAndIds;
NSArray *sectionNamesForPicker;

- (void)viewDidLoad {
    [super viewDidLoad];

    self.sectionPicker.delegate = self;
    self.sectionPicker.dataSource = self;

    [ODClient clientWithCompletion:^(ODClient *odClient, NSError *error) {
        if (!error){
            self.client = odClient;
            [self getSections];
        }
        else {
            NSLog(@"Error with auth: %@", [error localizedDescription]);
        }
    }];
}

// Build the "GET sections" request.
- (void)getSections {

    // Construct the request URI and the request.
    NSString *sectionsEndpoint =
            [serviceRootUrl stringByAppendingString:@"sections?select=name,id&top=10&orderby=lastModifiedTime%20desc"];
    NSMutableURLRequest *request =
            [[NSMutableURLRequest alloc] initWithURL:[[NSURL alloc] initWithString:sectionsEndpoint]];
    request.HTTPMethod = @"GET";
    if (self.client)
    {

        // Send the HTTP request.
        [self sendRequest:request];
    }
    _createPageButton.enabled = false;
}

// Send the request.
- (void)sendRequest:(NSMutableURLRequest *)request {

    // Add the required Authorization header with access token.
    [self.client.authProvider appendAuthHeaders:request completion:^(NSMutableURLRequest *requests, NSError *error) {

        // This app also uses the OneDrive SDK to send HTTP requests.
        [[self.client.httpProvider dataTaskWithRequest:(request)
                completionHandler:^(NSData *data,
                NSURLResponse *response,
                NSError *error) {
                    [self handleResponse:data response:response error:error];
        }] resume];
    }];
}

// Store the section names and IDs, and populate the section picker.
- (void)getSectionNamesAndIds {

    // Get the "value" array that contains the returned sections.
    NSDictionary *results = [self convertData];

    // Add the name-id pairs to sectionNamesAndIds, which is used to map section names to IDs.
    if ([results objectForKey:@"value"] != nil) {
        NSDictionary *sections =[results objectForKey:@"value"];
        sectionNamesAndIds = [[NSMutableDictionary alloc] init];
        for (NSMutableDictionary *dict in sections) {
            NSString *sectionName = [dict objectForKey:@"name"];
            NSString *sectionId = [dict objectForKey:@"id"];
            sectionNamesAndIds[sectionName] = sectionId;
        }
    }

    // Populate the picker with the section names.
    sectionNamesForPicker = [sectionNamesAndIds allKeys];
    dispatch_async(dispatch_get_main_queue(), ^{[_sectionPicker reloadComponent:0];});

    _createPageButton.enabled = true;
}

// Get the OneNote entity data from the response.
- (NSDictionary *)convertData {

    // Convert the message body to JSON.
    NSError *parseError;
    NSDictionary *data = [NSJSONSerialization JSONObjectWithData:self.returnData options:kNilOptions error:&parseError];

    if (!parseError) {
        return data;
    }
    else {
        NSLog(@"Error parsing response: %@", [parseError localizedDescription]);
        return nil;
    }
}

// Handle the response.
- (void)handleResponse:(NSData *)data response:(NSURLResponse *)response error:(NSError *) error {

    // Log the response.
    NSLog(@"Response %@ with error %@.\n", response, error);
    NSString *stringData = [[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding];
    NSLog(@"Body: %@.\n", stringData);

    // Store the response.
    self.returnData = [[NSMutableData alloc] init];
    NSMutableData *convertedData = [data mutableCopy];
    [self.returnData appendData:convertedData];
    self.returnResponse = (NSHTTPURLResponse *)response;

    NSInteger status = [self.returnResponse statusCode];

    // Check for "GET sections" success.
    if (status == 200) {
        NSLog(@"Sections retrieved!\n");

        // Get the section data and populate the picker.
        [self getSectionNamesAndIds];
    }

    // Check for "POST pages" success.
    else if (status == 201) {
        NSLog(@"Page created!\n");

        // Get the page object and parse out some properties.
        NSDictionary *pageProperties = [self convertData];
        NSString *selfLink = [pageProperties objectForKey:@"self"];
        NSDictionary *links = [pageProperties objectForKey:@"links"];
        NSString *clientUrl = [[links objectForKey:@"oneNoteClientUrl"] objectForKey:@"href"];
        NSString *webUrl = [[links objectForKey:@"oneNoteWebUrl"] objectForKey:@"href"];
        NSLog(@"Link to new page endpoint: %@\n", selfLink);
        NSLog(@"Link open page in the installed client: %@\n", clientUrl);
        NSLog(@"Link to open page in OneNote Online: %@\n", webUrl);
    }
    else {
        NSLog(@"Status code: %ld. Check the logged response for more information.", (long)status);
    }
}

// Create a simple page.
- (IBAction)createPage:(id)sender {

    // Get the ID of the section that's selected in the picker.
    NSInteger row = [self.sectionPicker selectedRowInComponent:0];
    NSString *selectedSectionName = sectionNamesForPicker[row];
    NSString *selectedSectionId = sectionNamesAndIds[selectedSectionName];

    // Construct the request URI and the request.
    NSString *pagesEndpoint = [NSString stringWithFormat:@"sections/%@/pages", selectedSectionId];
    NSString *fullEndpoint = [serviceRootUrl stringByAppendingString:pagesEndpoint];
    NSString *date = [self formatDate];
    NSString *simpleHtml = [NSString stringWithFormat:@"<html>"
                            "<head>"
                            "<title>A page created from simple HTML from iOS</title>"
                            "<meta name=\"created\" content=\"%@\" />"
                            "</head>"
                            "<body>"
                            "<p>This is some <b>simple</b> <i>formatted</i> text.</p>"
                            "</body>"
                            "</html>", date];

    NSData *presentation = [simpleHtml dataUsingEncoding:NSUTF8StringEncoding];
    NSMutableURLRequest * request = [[NSMutableURLRequest alloc] initWithURL:[[NSURL alloc] initWithString:fullEndpoint]];
    request.HTTPMethod = @"POST";
    request.HTTPBody = presentation;
    [request addValue:@"text/html" forHTTPHeaderField:@"Content-Type"];
    if (self.client)
    {

        // Send the HTTP request.
        [self sendRequest:request];
    }
}

// Format the "created" date. OneNote requires the ISO 8601 format.
- (NSString *)formatDate {
    NSDate *now = [NSDate date];
    NSDateFormatter *dateFormatter = [[NSDateFormatter alloc] init];
    NSLocale *enUSPOSIXLocale = [NSLocale localeWithLocaleIdentifier:@"en_US_POSIX"];
    [dateFormatter setLocale:enUSPOSIXLocale];
    [dateFormatter setDateFormat:@"yyyy-MM-dd'T'HH:mm:ssZZZZZ"];
    return [dateFormatter stringFromDate:now];
}

- (void)didReceiveMemoryWarning {
    [super didReceiveMemoryWarning];
    // Dispose of any resources that can be recreated.
}

#pragma mark - Delegate Methods
-(NSInteger)numberOfComponentsInPickerView:(UIPickerView *)pickerView {
    return 1;
}

-(NSInteger)pickerView:(UIPickerView *)pickerView numberOfRowsInComponent:(NSInteger)component {
    return sectionNamesForPicker.count;
}

-(NSString *)pickerView:(UIPickerView*)pickerView titleForRow:(NSInteger)row forComponent:(NSInteger)component {
    return [sectionNamesForPicker objectAtIndex:row];
}
@end

Erstellen einer OneNote-Anwendung für ASP.NET MVC

Diese Webanwendung verwendet Azure Active Directory Authentication Library (ADAL) für .NET zur Authentifizierung von Arbeits- und Schulkonten mehrerer Mandanten.

Voraussetzungen

Hier ist, was Sie brauchen, um diesem Tutorial zu folgen:

  • Visual Studio 2015. Sie können die kostenlose Visual Studio Community Edition verwenden.
  • Eine Web-Anwendung, die auf dem Azure Verwaltungsportalregistriert ist, mit den folgenden delegierten Berechtigungen:

    • Anmelden und Benutzerprofil lesen für Windows Azure Active Directory
    • Ansicht und Änderung von OneNote Notizbüchern für OneNote


    Visual Studio registriert die Webanwendung für Sie während der Erstellung der Anwendung, aber Sie müssen trotzdem Berechtigungen für OneNote hinzufügen und einen Anwendungsschlüssel generieren. (Erfahren Sie mehr über app Registrierung.)


So erstellen Sie eine OneNote-Anwendung mit ASP.NET MVC:

1. Erstellen Sie das Projekt

2. Hinzufügen der ADAL für .NET-Bibliothek

3. Erstellen Sie die Benutzeroberfläche

4. Fügen Sie Auth-Unterstützung hinzu

5. Aufruf der OneNote-API

Vollständiges Code-Beispiel für wichtige Beispieldateien sind am Ende des Tutorials enthalten.

Erstellen des Projekts in Visual Studio

  1. Erstellen Sie in Visual Studio ein ASP.NET Webanwendung-Projekt namens OneNote-WebApp.

  2. Wählen Sie die Vorlage MVC und stellen Sie sicher, dass MVC für die Option Ordner und Kernreferenzen hinzufügen ausgewählt ist.

  3. Wählen Sie Authentifizierung ändern, und wählen Sie dann Arbeits- und Schulkonten.

  4. Wählen Sie Cloud - mehrere Organisationen und geben Sie den Domänennamen Ihres Entwicklermandanten ein (z.B. contoso.onmicrosoft.com).

Sie können die Einstellung Microsoft Azure In der Cloud hosten beibehalten oder löschen. Es wird für dieses Tutorial nicht benötigt. Behalten Sie alle anderen Standardeinstellungen bei.


Visual Studio registriert die Webanwendung bei Azure für Sie, aber Sie müssen sie im Azure Verwaltungsportalkonfigurieren.

  1. Wählen Sie im Portal Ihres Mandantenverzeichnises Anwendungen und klicken Sie dann auf OneNote-Web, um die Konfigurationsseite zu öffnen.

  2. Wählen Sie im Abschnitt Schlüssel eine Dauer für einen neuen Schlüssel.

  3. Fügen Sie im Abschnitt Berechtigungen für andere Anwendungen die OneNote-Anwendung hinzu und fügen Sie dann die delegierte Berechtigung Ansicht und Änderung von OneNote-Notizbüchern hinzu. (Mehr erfahren)

  4. Speichern Sie Ihre Änderungen an der Anwendung und erstellen Sie eine Kopie des neuen Schlüssels, bevor Sie das Portal schließen. Sie werden es bald benutzen.

ADAL für .NET hinzufügen

Die App verwendet die Active Directory Authentifizierung Bibliothek (ADAL) zur Authentifizierung und Autorisierung gegenüber Azure AD. Die App wurde mit der Version 2.19.208020213 erstellt.

  1. In Visual Studio wählen Sie Tools > NuGet-Paket-Manager und führen den folgenden Befehl in der Konsole aus.

    Install-Package Microsoft.IdentityModel.Clients.ActiveDirectory
    

Erstellen Sie die Benutzeroberfläche

Diese Anwendung verwendet zwei Ansichten für HomeController: Index.cshtml und Page.cshtml.

  1. Ersetzen Sie den Inhalt von Views/Home/Index.cshtml durch den folgenden Code. Dies fügt eine Dropdown-Liste zur Auswahl des übergeordneten Abschnitts, ein Textfeld zur Eingabe des Seitennamens und eine Schaltfläche hinzu.

    @model OneNote_WebApp.Models.SectionsViewModel
    
    @{
        ViewBag.Title = "Index";
    }
    
    <h2>OneNote ASP.NET MVC web application</h2>
    
    @Html.Label("Choose a section to create the page in.")
    
    @using (Html.BeginForm("CreatePageAsync", "Home", new AjaxOptions { UpdateTargetId = "create-page" }))
    {
        <div id="create-page">
            @Html.DropDownListFor(
                m => m.SectionId,
                new SelectList(Model.Sections, "Id", "Name", Model.SectionId))
            @Html.ValidationMessageFor(m => m.SectionId)
            <br />
            <br />
            <table>
                <tr>
                    <td>
                        @Html.Label("Enter a name for the new page.")
                        <br />
                        @Html.TextBox("page-name", null, new { @style = "width=80" })
                    </td>
                </tr>
            </table>
            <button>Create page</button>
        </div>
    }
    
  2. Erstellen Sie im Ordner Views/Home eine neue Ansicht mit dem Namen Seite und fügen Sie den folgenden Code hinzu. Diese Ansicht zeigt die Eigenschaften der neu erstellten Seite an.

    @model OneNote_WebApp.Models.PageViewModel
    
    @{
         ViewBag.Title = "Page";
    }
    
    <h2>Page: @Model.Title</h2>
    
    <table>
        <tr>
            <td>@Html.Label("Self link: ")</td>
            <td>@Model.Self</td>
        </tr>
        <tr>
            <td>@Html.Label("Native client link: ")</td>
            <td><a href="@Model.PageLinks.ClientUrl">@Model.PageLinks.ClientUrl</a></td>
        </tr>
        <tr>
            <td>@Html.Label("Web client link: ")</td>
            <td><a href="@Model.PageLinks.WebUrl">@Model.PageLinks.WebUrl</a></td>
        </tr>
    </table>
    

Fügen Sie Auth-Unterstützung hinzu

Die ADAL für .NET-Client-Bibliothek übernimmt den Authentifizierungs- und Autorisierungsprozess. Sie müssen lediglich Identifikatoren für Ihre Anwendung angeben und ein paar Anrufe hinzufügen.

  1. Fügen Sie in der Datei root Web.config die folgenden Schlüssel/Wertpaare zum Knoten appSettings hinzu. Beachten Sie, dass die ClientId und AADInstance bereits von Visual Studio hinzugefügt wurden.

    <add key="ida:AppKey" value="ENTER-your-app-key-here" />
    <add key="ida:OneNoteResourceId" value="https://onenote.com/" />
    
  2. Ersetzen Sie den Platzhalterwert für den App-Schlüssel durch den zuvor generierten Schlüssel.

  3. Fügen Sie in App_Start/Start.Auth.cs die folgende Verwendung-Anweisung ein.

    using Microsoft.IdentityModel.Clients.ActiveDirectory;
    
  4. Ersetzen Sie die globalen Variablen in der Klasse Startup durch folgenden Code. Die Methode GetAuthorizedClient im HomeController verwendet ebenfalls die vier öffentlichen Variablen.

    public static string ClientId = ConfigurationManager.AppSettings["ida:ClientId"];
    public static string AppKey = ConfigurationManager.AppSettings["ida:AppKey"];
    public static string AADInstance = ConfigurationManager.AppSettings["ida:AADInstance"];
    public static string OneNoteResourceId = ConfigurationManager.AppSettings["ida:OneNoteResourceId"];
    private string Authority = AADInstance + "common"; 
    
  5. Ersetzen Sie in der Methode ConfigureAuth die Methode app.UseOpenIdConnectAuthentication durch folgenden Code. ADAL speichert Token und andere Informationen im Token-Cache. (Um zu sehen, was zwischengespeichert ist, fügen Sie diese Zeile hinzu, bevor Sie die Aufgabe zurückgeben: var cache = context.TokenCache.ReadItems();)

    app.UseOpenIdConnectAuthentication(
       new OpenIdConnectAuthenticationOptions
       {
           ClientId = ClientId,
           Authority = Authority,
           TokenValidationParameters = new System.IdentityModel.Tokens.TokenValidationParameters
           {
               ValidateIssuer = false
           },
           Notifications = new OpenIdConnectAuthenticationNotifications()
           {
                AuthorizationCodeReceived = (context) =>
                {
                    var code = context.Code;
                    ClientCredential credential = new ClientCredential(ClientId, AppKey);
                    Microsoft.IdentityModel.Clients.ActiveDirectory.AuthenticationContext authContext =
                       new Microsoft.IdentityModel.Clients.ActiveDirectory.AuthenticationContext(Authority);
                    AuthenticationResult result = authContext.AcquireTokenByAuthorizationCode(
                        code,
                        new Uri(HttpContext.Current.Request.Url.GetLeftPart(UriPartial.Path)),
                        credential,
                        OneNoteResourceId
                    );
                    return Task.FromResult(0);
                },
                AuthenticationFailed = (context) =>
                {
                    context.HandleResponse();
                    if (context.Exception.HResult == -2146233088) //IDX10311: Nonce is null
                    {
                        context.OwinContext.Response.Redirect("Home/Index");
                    }
                    return Task.FromResult(0);
                }
            }
        });
    
  6. Fügen Sie in Controllers/HomeController.cs die folgenden Verwendung -Anweisungen hinzu.

    using Microsoft.IdentityModel.Clients.ActiveDirectory;
    using Microsoft.Owin.Security;
    using Microsoft.Owin.Security.OpenIdConnect;
    using Newtonsoft.Json;
    using System.IO;
    using System.Net.Http;
    using System.Net.Http.Headers;
    using System.Security.Claims;
    using System.Text;
    using System.Threading.Tasks;
    using OneNote_WebApp.Models;
    
  7. Fügen Sie in der Klasse HomeController die Methode GetAuthorizedClient hinzu. Diese Methode erstellt und konfiguriert den HTTP-Client, mit dem die REST-Anfragen an den OneNote-Dienst gestellt werden. Es holt auch das Zugriffstoken und fügt es dem Client hinzu.

    private HttpClient GetAuthorizedClient()
    {
        HttpClient client = new HttpClient();
    
        string userObjectId = ClaimsPrincipal.Current.FindFirst("http://schemas.microsoft.com/identity/claims/objectidentifier").Value;
        string tenantId = ClaimsPrincipal.Current.FindFirst("http://schemas.microsoft.com/identity/claims/tenantid").Value;
        ClientCredential credential = new ClientCredential(Startup.ClientId, Startup.AppKey);
        AuthenticationContext authContext = new AuthenticationContext(Startup.AADInstance + tenantId);
    
        try
        {
            // Call AcquireTokenSilent to get the access token. This first tries to get the token from cache.
            AuthenticationResult authResult = authContext.AcquireTokenSilent(
                Startup.OneNoteResourceId,
                credential,
                new UserIdentifier(userObjectId, UserIdentifierType.UniqueId));
            client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", authResult.AccessToken);
            client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
        }
        catch (AdalSilentTokenAcquisitionException)
        {
            HttpContext.GetOwinContext().Authentication.Challenge(
                new AuthenticationProperties() { RedirectUri = "/" },
                OpenIdConnectAuthenticationDefaults.AuthenticationType);
            return null;
        }
    
        return client;
    }
    

Jetzt können Sie den OneNote-Dienst anrufen und die Antwort analysieren.

Aufruf der OneNote-API

Wenn die App geladen wird, erhält sie den Namen und die ID der 10 zuletzt geänderten Abschnitte und füllt die Dropdown-Liste mit den Namen der Abschnitte. Die neue OneNote Seite wird im ausgewählten Abschnitt erstellt.

  1. Fügen Sie in der Klasse HomeController globale Variablen für die OneNote-Endpunkte und den Pfad zur Bilddatei hinzu, die zur neuen Seite hinzugefügt werden sollen.

    public static string OneNoteRoot = "https://www.onenote.com/api/v1.0/me/notes/";
    public static string SectionsEndpoint = "sections?select=name,id&top=10&orderby=lastModifiedTime%20desc";
    public static string PagesEndpoint = "sections/{0}/pages";
    public static string PathToImageFile = @"C:\<local-path>\logo.png";
    
  2. Ändern Sie den Platzhalterpfad und den Dateinamen in der PathToImageFile Variable, um auf ein lokales PNG-Bild zu zeigen.

  3. Ersetzen Sie die Methode Index durch den folgenden Code. Dieser ruft die Abschnitte ab, bereitet SectionsViewModel für die Index-Ansicht vor und lädt die Ansicht.

    public async Task<ActionResult> Index()
    {
        SectionsViewModel viewModel = new SectionsViewModel();
        try
        {
            viewModel.Sections = await GetSectionsAsync();
        }
        catch (Exception ex)
        {
            return View("Error", new HandleErrorInfo(new Exception(ex.Message), "Home", "GetSectionsAsync"));
        }
        return View(viewModel);
    }
    
  4. Fügen Sie die Methode GetSectionsAsync hinzu, um die GET sections-Anfrage zu erstellen und zu senden und die Antwort zu analysieren.

    [Authorize]
    [HttpGet]   
    public async Task<IEnumerable<Section>> GetSectionsAsync()
    {
        List<Section> sections = new List<Section>();
    
        HttpClient client = GetAuthorizedClient();
        HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, OneNoteRoot + SectionsEndpoint);
        HttpResponseMessage response = await client.SendAsync(request);
        if (response.IsSuccessStatusCode)
        {
    
            // Parse the JSON response.
            string stringResult = await response.Content.ReadAsStringAsync();
            Dictionary<string, dynamic> result = JsonConvert.DeserializeObject<Dictionary<string, dynamic>>(stringResult);
            foreach (var item in result["value"])
            {
                var current = item.ToObject<Dictionary<string, string>>();
                Section section = new Section
                {
                    Name = current["name"],
                    Id = current["id"]
                };
                sections.Add(section);
            }
        }
        else
        {
            throw new Exception("Error getting sections: " + response.StatusCode.ToString());
        }
        return sections;
    }
    
  5. Fügen Sie die Methode CreatePageAsync hinzu, um die POST pages multipart-Anfrage zu erstellen und zu senden und die Antwort zu analysieren. Diese Anfrage erzeugt eine einfache HTML-Seite.

    [Authorize]
    [HttpPost]
    public async Task<ActionResult> CreatePageAsync()
    {
        HttpClient client = GetAuthorizedClient();
    
        // Get user input.
        string selectedSectionId = Request.Form["SectionId"];
        string pageName = Request.Form["page-name"];
        string pagesEndpoint = string.Format("sections/{0}/pages", selectedSectionId);
    
        // Define the page content, which includes an uploaded image.
        const string imagePartName = "imageBlock1";
        string iso8601Date = DateTime.Now.ToString("o");
        string pageHtml = "<html>" +
                          "<head>" +
                          "<title>" + pageName + "</title>" +
                          "<meta name=\"created\" content=\"" + iso8601Date + "\" />" +
                          "</head>" +
                          "<body>" +
                          "<h1>This is a page with an image</h1>" +
                          "<img src=\"name:" + imagePartName +
                          "\" alt=\"No mis monos\" width=\"250\" height=\"200\" />" +
                          "</body>" +
                          "</html>";
    
        HttpResponseMessage response;
    
        // Build the 'POST pages' request.
        var stream = new FileStream(PathToImageFile, FileMode.Open);
        using (var imageContent = new StreamContent(stream))
        {
            try
            {
                imageContent.Headers.ContentType = new MediaTypeHeaderValue("image/png");
                MultipartFormDataContent pageContent = new MultipartFormDataContent
                {
                    {new StringContent(pageHtml, Encoding.UTF8, "text/html"), "Presentation"},
                    {imageContent, imagePartName}
                };
    
                response = await client.PostAsync(OneNoteRoot + pagesEndpoint, pageContent);
                if (!response.IsSuccessStatusCode)
                {
                    throw new Exception(response.StatusCode + ": " + response.ReasonPhrase);
                }
                else
                {
    
                    // Parse the JSON response.
                    string stringResult = await response.Content.ReadAsStringAsync();
                    Dictionary<string, dynamic> pageData = JsonConvert.DeserializeObject<Dictionary<string, dynamic>>(stringResult);
                    Dictionary<string, dynamic> linksData = JsonConvert.DeserializeObject<Dictionary<string, dynamic>>(pageData["links"].ToString());
                    Links pageLinks = new Links
                    {
                        ClientUrl = new Uri(linksData["oneNoteClientUrl"]["href"].ToString()),
                        WebUrl = new Uri(linksData["oneNoteWebUrl"]["href"].ToString())
                    };
                    PageViewModel pageViewModel = new PageViewModel
                    {
                        Title = pageData["title"],
                        Self = new Uri(pageData["self"]),
                        PageLinks = pageLinks
                    };
                    return View("../home/page", pageViewModel);
                }
            }
            catch (Exception ex)
            {
                return View("Error", new HandleErrorInfo(new Exception(ex.Message), "Home", "CreatePageAsync"));
            }
        }
    }
    
  6. Fügen Sie im Ordner Models eine neue Klasse namens Resource.cs hinzu und verwenden Sie den folgenden Code. Dies definiert die Domänenmodelle, die OneNote-Abschnitte und -Seiten darstellen, und die Ansichtsmodelle, die OneNote-Daten in den Ansichten Index und Seite darstellen.

    using System;
    using System.Collections.Generic;
    using System.IO;
    
    namespace OneNote_WebApp.Models
    {
    
        // Common properties of OneNote entities.
        public class Resource
        {
            public string Id { get; set; }
            public string CreatedBy { get; set; }
            public DateTimeOffset CreatedTime { get; set; }
            public string LastModifiedBy { get; set; }
            public DateTimeOffset LastModifiedTime { get; set; }
            public Uri Self { get; set; }
        }
    
        // A OneNote section with some key properties. 
        public class Section : Resource
        {
            public bool IsDefault { get; set; }
            public string Name { get; set; }
            public ICollection<Page> Pages { get; set; }
            public Uri PagesUrl { get; set; }
        }
    
        // A OneNote page with some key properties.
        // This app doesn't use the Page model.
        public class Page : Resource
        {
            public Stream Content { get; set; }
            public Uri ContentUrl { get; set; }
            public Links PageLinks { get; set; }
            public string Title { get; set; }
        }
    
        // The links that open a OneNote page in the installed client or in OneNote Online.
        public class Links
        {
            public Uri ClientUrl { get; set; }
            public Uri WebUrl { get; set; }
        }
    
        // The view model used to populate the section drop-down list.
        public class SectionsViewModel
        {
            public string SectionId { get; set; }
            public IEnumerable<Section> Sections { get; set; }
        }
    
        // The view model used to display properties of the new page.
        public class PageViewModel
        {
            public string Title { get; set; }
            public Uri Self { get; set; }
            public Links PageLinks { get; set; }
        }
    }
    

Nachdem Sie die Anwendung erstellt haben, können Sie sie mit F5-Debuggen ausführen.

Wenn Sie einen Kein Assembly mit einem OwinStartupAttribute gefunden...-Fehler erhalten, fügen Sie das folgende Attribut nach der Verwendung -Anweisungen in der Startup.cs-Klasse im Stammverzeichnis hinzu. (mehr über diesen Fehler erfahren)

[assembly: OwinStartup(typeof(OneNote_WebApp.Startup))]

Melden Sie sich bei der App mit einem Arbeits- oder Schulkonto an, das mindestens ein Notizbuch mit mindestens einem Abschnitt enthält. Wählen Sie in der App den Bereich, in dem Sie eine Seite erstellen möchten, geben Sie einen Namen für die neue Seite ein und wählen Sie dann Seite erstellen. Im Erfolgsfall zeigt die App den Titel und Inhalt und Seitenlinks der neuen Seite an.

Vollständige Code-Beispiele

Startup.Auth.cs

using System;
using System.Configuration;
using System.Threading.Tasks;
using System.Web;
using Microsoft.Owin.Security;
using Microsoft.Owin.Security.Cookies;
using Microsoft.Owin.Security.OpenIdConnect;
using Owin;
using Microsoft.IdentityModel.Clients.ActiveDirectory;

namespace OneNote_WebApp
{
    public partial class Startup
    {

        // Properties used for authorization.
        public static string ClientId = ConfigurationManager.AppSettings["ida:ClientId"];
        public static string AppKey = ConfigurationManager.AppSettings["ida:AppKey"];
        public static string AADInstance = ConfigurationManager.AppSettings["ida:AADInstance"];
        public static string OneNoteResourceId = ConfigurationManager.AppSettings["ida:OneNoteResourceId"];
        private string Authority = AADInstance + "common";

        public void ConfigureAuth(IAppBuilder app)
        {
            app.SetDefaultSignInAsAuthenticationType(CookieAuthenticationDefaults.AuthenticationType);

            app.UseCookieAuthentication(new CookieAuthenticationOptions { });

            app.UseOpenIdConnectAuthentication(
                new OpenIdConnectAuthenticationOptions
                {
                    ClientId = ClientId,
                    Authority = Authority,
                    TokenValidationParameters = new System.IdentityModel.Tokens.TokenValidationParameters
                    {
                        ValidateIssuer = false
                    },
                    Notifications = new OpenIdConnectAuthenticationNotifications()
                    {
                        AuthorizationCodeReceived = (context) =>
                        {
                            var code = context.Code;
                            ClientCredential credential = new ClientCredential(ClientId, AppKey);
                            Microsoft.IdentityModel.Clients.ActiveDirectory.AuthenticationContext authContext =
                                new Microsoft.IdentityModel.Clients.ActiveDirectory.AuthenticationContext(Authority);
                            AuthenticationResult result = authContext.AcquireTokenByAuthorizationCode(
                                code,
                                new Uri(HttpContext.Current.Request.Url.GetLeftPart(UriPartial.Path)),
                                credential,
                                OneNoteResourceId
                            );
                            return Task.FromResult(0);
                        },
                        AuthenticationFailed = (context) =>
                        {
                            context.HandleResponse();
                            if (context.Exception.HResult == -2146233088) //IDX10311: Nonce is null
                            {
                                context.OwinContext.Response.Redirect("Home/Index");
                            }
                            return Task.FromResult(0);
                        }
                    }
                });
        }
    }
}


HomeController

using System;
using System.Collections.Generic;
using System.Web.Mvc;
using Microsoft.IdentityModel.Clients.ActiveDirectory;
using Microsoft.Owin.Security;
using Microsoft.Owin.Security.OpenIdConnect;
using Newtonsoft.Json;
using System.IO;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Security.Claims;
using System.Text;
using System.Threading.Tasks;
using OneNote_WebApp.Models;

namespace OneNote_WebApp.Controllers
{
    [Authorize]
    public class HomeController : Controller
    {

        // Route segments to OneNote resource endpoints.
        public static string OneNoteRoot = "https://www.onenote.com/api/v1.0/me/notes/";
        public static string SectionsEndpoint = "sections?select=name,id&top=10&orderby=lastModifiedTime%20desc";
        public static string PagesEndpoint = "sections/{0}/pages";

        // Path to the image file to add to the page. 
        // Change this to point to a local PNG file before running the app.
        public static string PathToImageFile = @"C:\<local-path>\logo.png";

        // Get sections, add them to SectionsViewModel, and load the view. 
        public async Task<ActionResult> Index()
        {
            SectionsViewModel viewModel = new SectionsViewModel();
            try
            {
                viewModel.Sections = await GetSectionsAsync();
            }
            catch (Exception ex)
            {
                return View("Error", new HandleErrorInfo(new Exception(ex.Message), "Home", "GetSectionsAsync"));
            }
            return View(viewModel);
        }

        // Create and configure the HttpClient used for requests to the OneNote API. 
        private HttpClient GetAuthorizedClient()
        {
            HttpClient client = new HttpClient();

            string userObjectId = ClaimsPrincipal.Current.FindFirst("http://schemas.microsoft.com/identity/claims/objectidentifier").Value;
            string tenantId = ClaimsPrincipal.Current.FindFirst("http://schemas.microsoft.com/identity/claims/tenantid").Value;
            ClientCredential credential = new ClientCredential(Startup.ClientId, Startup.AppKey);
            AuthenticationContext authContext = new AuthenticationContext(Startup.AADInstance + tenantId);

            try
            {
                // Call AcquireTokenSilent to get the access token. This first tries to get the token from cache.
                AuthenticationResult authResult = authContext.AcquireTokenSilent(
                    Startup.OneNoteResourceId,
                    credential,
                    new UserIdentifier(userObjectId, UserIdentifierType.UniqueId));
                client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", authResult.AccessToken);
                client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
            }
            catch (AdalSilentTokenAcquisitionException)
            {
                HttpContext.GetOwinContext().Authentication.Challenge(
                    new AuthenticationProperties() { RedirectUri = "/" },
                    OpenIdConnectAuthenticationDefaults.AuthenticationType);
                return null;
            }
            return client;
        }

        [Authorize]
        [HttpGet]
        // Build the 'GET sections' request and parse the response. The request gets the 10 most recently modified sections.
        public async Task<IEnumerable<Section>> GetSectionsAsync()
        {
            List<Section> sections = new List<Section>();

            HttpClient client = GetAuthorizedClient();
            HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, OneNoteRoot + SectionsEndpoint);
            HttpResponseMessage response = await client.SendAsync(request);
            if (response.IsSuccessStatusCode)
            {

                // Parse the JSON response.
                string stringResult = await response.Content.ReadAsStringAsync();
                Dictionary<string, dynamic> result = JsonConvert.DeserializeObject<Dictionary<string, dynamic>>(stringResult);
                foreach (var item in result["value"])
                {
                    var current = item.ToObject<Dictionary<string, string>>();
                    Section section = new Section
                    {
                        Name = current["name"],
                        Id = current["id"]
                    };
                    sections.Add(section);
                }
            }
            else
            {
                throw new Exception("Error getting sections: " + response.StatusCode.ToString());
            }
            return sections;
        }

        [Authorize]
        [HttpPost]
        // Build the multipart POST request and parse the response. The request creates a page in the selected section.
        public async Task<ActionResult> CreatePageAsync()
        {
            HttpClient client = GetAuthorizedClient();

            // Get user input.
            string selectedSectionId = Request.Form["SectionId"];
            string pageName = Request.Form["page-name"];
            string pagesEndpoint = string.Format("sections/{0}/pages", selectedSectionId);

            // Define the page content, which includes an uploaded image.
            const string imagePartName = "imageBlock1";
            string iso8601Date = DateTime.Now.ToString("o");
            string pageHtml = "<html>" +
                                "<head>" +
                                "<title>" + pageName + "</title>" +
                                "<meta name=\"created\" content=\"" + iso8601Date + "\" />" +
                                "</head>" +
                                "<body>" +
                                "<h1>This is a page with an image</h1>" +
                                "<img src=\"name:" + imagePartName +
                                "\" alt=\"No mis monos\" width=\"250\" height=\"200\" />" +
                                "</body>" +
                                "</html>";

            HttpResponseMessage response;

            // Build the 'POST pages' request.
            var stream = new FileStream(PathToImageFile, FileMode.Open);
            using (var imageContent = new StreamContent(stream))
            {
                try
                {
                    imageContent.Headers.ContentType = new MediaTypeHeaderValue("image/png");
                    MultipartFormDataContent pageContent = new MultipartFormDataContent
                    {
                        {new StringContent(pageHtml, Encoding.UTF8, "text/html"), "Presentation"},
                        {imageContent, imagePartName}
                    };

                    response = await client.PostAsync(OneNoteRoot + pagesEndpoint, pageContent);
                    if (!response.IsSuccessStatusCode)
                    {
                        throw new Exception(response.StatusCode + ": " + response.ReasonPhrase);
                    }
                    else
                    {

                        // Parse the JSON response.
                        string stringResult = await response.Content.ReadAsStringAsync();
                        Dictionary<string, dynamic> pageData = JsonConvert.DeserializeObject<Dictionary<string, dynamic>>(stringResult);
                        Dictionary<string, dynamic> linksData = JsonConvert.DeserializeObject<Dictionary<string, dynamic>>(pageData["links"].ToString());
                        Links pageLinks = new Links
                        {
                            ClientUrl = new Uri(linksData["oneNoteClientUrl"]["href"].ToString()),
                            WebUrl = new Uri(linksData["oneNoteWebUrl"]["href"].ToString())
                        };
                        PageViewModel pageViewModel = new PageViewModel
                        {
                            Title = pageData["title"],
                            Self = new Uri(pageData["self"]),
                            PageLinks = pageLinks
                        };
                        return View("../home/page", pageViewModel);
                    }
                }
                catch (Exception ex)
                {
                    return View("Error", new HandleErrorInfo(new Exception(ex.Message), "Home", "CreatePageAsync"));
                }
            }
        }

        public ActionResult About()
        {
            ViewBag.Message = "Your application description page.";

            return View();
        }

        public ActionResult Contact()
        {
            ViewBag.Message = "Your contact page.";

            return View();
        }
    }
}


Index.cshtml, Page.cshtmlund Resource.cs werden in der Anleitung vollständig angezeigt.

Nächste Schritte: Siehe die Artikel Entwicklung mit der OneNote API, um mehr darüber zu erfahren, was Sie mit der OneNote API machen können.

Zusätzliche Ressourcen

© 2018 Microsoft