Tutorial: Criar um aplicativo do OneNote

Artigo
01/12/2016

Aplica-se ao: Blocos de anotações de consumidor no OneDrive | Blocos de anotações empresariais no Office 365

Este tutorial mostra como criar um aplicativo simples que usa a API do OneNote para obter e criar conteúdo do OneNote. O aplicativo que criaremos fará duas chamadas usando a API REST do OneNote:

Pegue o nome e o id das 10 seções modificadas mais recentemente.

GET ../notes/sections?select=name,id&top=10&orderby=lastModifiedTime%20desc
Crie uma página em uma seção específica.

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

Escolha sua plataforma:

Criar um aplicativo do OneNote para iOS
Criar um aplicativo do OneNote para ASP.NET

Observação

Este tutorial destina-se a demonstrar como acessar a API do OneNote, mas não contém código pronto para produção. Ao criar seu aplicativo, analise cuidadosamente seu código em busca de possíveis problemas de segurança, validação e outros problemas de qualidade de código.

Criar um aplicativo do OneNote para iOS

O aplicativo usa o OneDrive SDK para iOS para lidar com autenticação e chamadas de rede.

Pré-requisitos

Isso é o que você precisa para acompanhar este tutorial:

Xcode 7 da Apple.
O gerenciador de dependências CocoaPods. Se você é novo em usar o CocoaPods, veja Guias CocoaPods.
Um aplicativo cliente nativo registrado no Portal de gerenciamento do Azure ou um aplicativo cliente móvel registrado no Centro de desenvolvedores da conta da Microsoft. (Saiba como registrar um aplicativo.)

Para criar um aplicativo do OneNote para iOS

Crie o projeto
Adicione a dependência do OneDrive SDK
Compile a interface do usuário
Adicione suporte de autenticação
Chame a API do OneNote

Os exemplos de código completo para os principais arquivos de amostra estão incluídos no final do tutorial.

Crie o projeto no Xcode

No Xcode, crie um projeto Aplicativo de visualização única para iOS chamado OneNote-iOS-App. Escolha Objetivo C e escolha os dispositivos do iPhone.
Após o projeto ser criado, feche o Xcode. Você abrirá o espaço de trabalho depois de criar um Podfile.

Adicione a dependência do OneDrive SDK

O aplicativo nesse tutorial usa o OneDrive SDK para a conta da Microsoft (anteriormente, Live Connect) e a autenticação do Active Directory do Azure. A autenticação da conta da Microsoft é usada para acessar os notebooks do consumidor no OneDrive. A autenticação do Azure AD é usada para acessar os notebooks corporativos no Office 365.

Execute estes comandos no Terminal para criar um Podfile e abra o arquivo no Xcode.

cd {path to the OneNote-iOS-App project directory} 
touch podfile 
open -a xcode podfile

Adicione a dependência do OneDrive SDK ao Podfile e salve o arquivo.
```
pod 'OneDriveSDK'
```
Execute esses comandos no Terminal para instalar a dependência e abra o espaço de trabalho do projeto no Xcode. Você deve receber uma confirmação quando a instalação estiver concluída.
```
pod install
open onenote-ios-app.xcworkspace/
```

Aplicativos do Xcode 7 que visam o iOS 9.0

Se você está visando o iOS 9 com Xcode 7, precisa habilitar as exceções do PFS. Veja a seção Segurança de transporte do aplicativo para iOS 9 no leiame do OneDrive SDK para iOS para instruções.

Compile a interface do usuário

Adicione um seletor que exiba as 10 seções modificadas mais recentemente pelo usuário e um botão que crie uma página do OneNote na seção selecionada.

No Xcode, abra Main.storyboard e altere o controle de classe de tamanho (abaixo da tela) para wCompact/hAny.
Arraste uma Exibição do Selecionador e um Botão da Biblioteca de Objetos para a tela. Use Criar página para o texto do botão.
Crie conexões para a exibição do selecionador:
a. Controle e arraste a visualização do selecionador para o ícone Controlador da Exibição acima da tela. Escolha a saída dataSource.
b. Repita para a saída delegar.
c. Escolha Exibir> Editor do Assistente> Mostrar Editor do Assistente e abra ViewController.h na segunda janela.
d. Controle e arraste a exibição do selecionador na tela para o bloco de códigos @interface. Insira uma conexão de Saída chamada sectionPicker.
Crie conexões para o botão:
a. Controle e arraste o botão na tela para o bloco de códigos @interface. Insira uma conexão de Saída chamada createPageButton.
b. Abra ViewController.m no editor assistente.
c. Controle e arraste o botão na tela para o bloco de códigos @implementation. Insira uma conexão de Ação chamada createPage para o evento Retocar o interior.

Declare os protocolos UIPickerViewDelegate e UIPickerViewDataSource.

O ViewController.h deve ficar assim:

 import <UIKit/UIKit.h>

 @interface ViewController : UIViewController<UIPickerViewDelegate, UIPickerViewDataSource>

 @property (weak, nonatomic) IBOutlet UIPickerView *sectionPicker;
 @property (weak, nonatomic) IBOutlet UIButton *createPageButton;

 @end

Em ViewController.m, adicione os seguintes métodos de representação para a exibição do selecionador.

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

Não se preocupe com os erros para sectionNamesForPicker. Adicionaremos a variável depois.

No método viewDidLoad, adicione o seguinte código para conectar o selecionador após a linha [super viewDidLoad].
```
 self.sectionPicker.delegate = self;
 self.sectionPicker.dataSource = self;
```

Adicione suporte de autenticação

O OneDrive SDK lida com a autenticação e a autorização para você. Você só precisa fornecer identificadores para seu aplicativo e, em seguida, usar o ODClient. O SDK invoca a interface de usuário de login na primeira vez que o usuário executa o aplicativo e, em seguida, armazena os dados da conta. (Saiba mais sobre autenticação no SDK.)

Em AppDelegate.m, importe o OneDrive SDK.
```
 #import <OneDriveSDK/OneDriveSDK.h>
```

Substitua o método didFinishLaunchingWithOptions pelo código a seguir.

Em seguida, substitua os valores da propriedade do espaço reservado pelas informações do(s) seu(s) aplicativo(s) registrado(s). Se você está apenas testando com um aplicativo, pode comentar as propriedades que não está usando.

  (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 = @"https://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;
 }

Observação

Este aplicativo permite que você faça login com uma conta por vez (conta da Microsoft ou conta do trabalho ou da escola). Para ver como suportar os dois tipos de conta e armazenar várias contas, veja o exemplo CloudRoll.

Em ViewController.h, importe o OneDrive SDK e declare uma propriedade para o objeto ODClient. Todas as chamadas para o SDK são feitas por meio do objeto ODClient.

a. Adicione o demonstrativo de importação:
```
  #import <OneDriveSDK/OneDriveSDK.h>
```
b. Adicione a propriedade cliente ao bloco de códigos @interface.
```
  @property (strong, nonatomic) ODClient *client;
```
Em ViewController.m, adicione o código a seguir ao final do método viewDidLoad para obter um ODClient autenticado.

O SDK invoca a interface de usuário de login na primeira vez que o usuário executa o aplicativo e, em seguida, armazena os dados da conta.
```
     [ODClient clientWithCompletion:^(ODClient *odClient, NSError *error) {
         if (!error){
             self.client = odClient;
             [self getSections];
         }
         else {
             NSLog(@"Error with auth: %@", [error localizedDescription]);
         }
     }];
```
Iremos adicionar o método getSections na próxima seção.

Em ViewController.m, adicione o método sendRequest ao bloco de códigos @implementation.

Esse método adiciona o cabeçalho Autorização necessário para as solicitações seções GET e páginas POST e cria a tarefa de transferência de dados.

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

Agora você está pronto para fazer chamadas para o serviço do OneNote.

Chame a API do OneNote

Quando o aplicativo é carregado, ele obtém o nome e o ID das 10 seções modificadas mais recentemente e preenche o selecionador com os nomes das seções. A nova página é criada na seção selecionada.

Em ViewController.h, adicione as propriedades que armazenam a resposta.
```
// Variables to store the response data.
@property (strong, nonatomic) NSHTTPURLResponse *returnResponse;
@property (strong, nonatomic) NSMutableData *returnData;
```
Adicione todo o código nas etapas a seguir ao bloco de códigos @implementation em ViewController.m. Não se preocupe com os erros que você vê enquanto cria o aplicativo. Eles somem depois que o código estiver concluído.
Em ViewController.m, inclua as variáveis para a URL raiz do serviço do OneNote, o dicionário para os nomes e IDs das seções, e uma matriz para os nomes das seções que preencherão o selecionador.
```
static NSString const *serviceRootUrl = @"https://www.onenote.com/api/v1.0/me/notes/";
NSMutableDictionary *sectionNamesAndIds;
NSArray *sectionNamesForPicker;
```

Adicione o método getSections para compilar a solicitação seções GET.

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

Adicione o método handleResponse para lidar com a resposta das solicitações das seções GET e páginas POST.

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

Adicione o método convertData para converter os dados de resposta para JSON.

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

Adicione o método getSectionNamesAndIds para armazenar os nomes e IDs das seções e preencher o selecionador.

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

Edite o método createPage que foi criado quando você adicionou a ação do botão. Esse código cria uma página HTML simples.

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

Adicione o método formatDate para obter a data formatada em ISO 8601 para o carimbo de data/hora da marca META.

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

Depois de criar o aplicativo, você pode testá-lo executando-o em um iPhone ou em um emulador de iPhone. Entre usando sua conta da Microsoft ou conta de trabalho ou escola.

Quando o aplicativo abrir, selecione a seção em que você deseja criar uma página e, em seguida, escolha Criar página. Depois, verifique a janela de saída no Xcode para as mensagens de log. Se as chamadas funcionarem, a janela de saída mostrará o URI do recurso da nova página e os links para abrir a página no OneNote.

Próximas etapas

Adicione funcionalidade, validação de entrada e manipulação de erro.

Por exemplo, adicione um botão de saída do serviço que chame esse método:

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

Veja os artigos Desenvolva com a API do OneNote para saber mais sobre o que você pode fazer com a API do OneNote.

Exemplos de código completo para o iOS

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 = @"https://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

Criar um aplicativo do OneNote para ASP.NET

Este aplicativo Web usa a Biblioteca de Autenticação do Active Directory do Azure (ADAL) para .NET para autenticar contas de trabalho e escola de vários locatários.

Pré-requisitos

Isso é o que você precisa para acompanhar este tutorial:

Visual Studio 2015. Você pode usar a edição gratuita do Visual Studio Community.
Um aplicativo Web registrado no Portal de Gerenciamento do Azure, com as seguintes permissões delegadas:
- Faça login e leia o perfil do usuário para o Active Directory do Windows Azure
- Ver e modificar os bloco de anotações do OneNote para OneNote

Observação

O Visual Studio registra o aplicativo Web durante a criação do aplicativo, mas você ainda precisará adicionar permissões para o OneNote e gerar uma chave de aplicativo. (Saiba mais sobre registro de aplicativo.)

Para criar um aplicativo do OneNote usando o ASP.NET MVC

Crie o projeto
Adicione a biblioteca ADAL for .NET
Compile a interface do usuário
Adicione suporte de autenticação
Chame a API do OneNote

Os exemplos de código completo para os principais arquivos de amostra estão incluídos no final do tutorial.

Criar um projeto no Visual Studio

No Visual Studio, crie um projeto aplicativo Web ASP.NET chamado OneNote-WebApp.
Escolha o modelo MVC e certifique-se que MVC está selecionado para a opção Adicione pastas e referências principais.
Escolha Alterar autenticação e, em seguida, escolha Contas de trabalho e escola.
Escolha Nuvem - várias organizações e insira o nome de domínio do seu locatário desenvolvedor (p. ex., contoso.onmicrosoft.com).

Você pode manter ou limpar a configuração Host na nuvem do Microsoft Azure, conforme desejado. Isso não é necessário para esse tutorial. Mantenha todas as outras configurações padrão.

O Visual Studio registra o aplicativo Web com o Azure, mas você precisa terminar de configurá-lo no Portal de gerenciamento do Azure.

No seu diretório de locatários no portal, escolha Aplicativos e depois clique no aplicativo OneNote-Web para abrir sua página de configuração.
Na seção Chaves, escolha uma duração para uma nova chave.
Na seção Permissões para outros aplicativos, adicione o aplicativo OneNote e depois adicione a permissão delegada Ver e modificar os blocos de anotações do OneNote. (saiba mais)
Salve suas alterações no aplicativo e faça uma cópia da nova chave antes de fechar o portal. Você vai usá-la em breve.

Adicionar ADAL para .NET

O aplicativo usa a Biblioteca de Autenticação do Active Directory (ADAL) para autenticar e autorizar no Azure AD. O aplicativo foi criado usando a versão 2.19.208020213.

No Visual Studio, escolha Ferramentas> Gerenciador de Pacotes NuGet> Console do Gerenciador de Pacotes e execute o seguinte comando no console.
```
Install-Package Microsoft.IdentityModel.Clients.ActiveDirectory
```

Compile a interface do usuário

Este aplicativo usa dois modos de exibição para HomeController: Index.cshtml e Page.cshtml.

Substitua o conteúdo de Views/Home/Index.cshtml pelo seguinte código. Isso adiciona uma lista suspensa para selecionar a seção pai, uma caixa de texto para inserir o nome da página e um botão.

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

Na pasta Exibições/Página inicial, crie uma nova exibição denominada Página e adicione o seguinte código. Esta exibição apresenta propriedades para a página recém-criada.

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

Adicione suporte de autenticação

A biblioteca de clientes do ADAL for .NET manipula o processo de autenticação e autorização. Você só precisa fornecer identificadores para seu aplicativo e adicionar algumas chamadas.

No arquivo raiz Web.config, adicione os seguintes pares de chave/valor ao nó appSettings. Observe que ClientId e AADInstance já foram adicionados pelo Visual Studio.
```
<add key="ida:AppKey" value="ENTER-your-app-key-here" />
<add key="ida:OneNoteResourceId" value="https://onenote.com/" />
```
Substitua o valor do espaço reservado para a chave do aplicativo pela chave que você gerou anteriormente.
Em App_Start/Start.Auth.cs, adicione a seguinte instrução using.
```
using Microsoft.IdentityModel.Clients.ActiveDirectory;
```

Substitua as variáveis globais na classe Inicialização com o código a seguir. O método GetAuthorizedClient em HomeController também usa as quatro variáveis públicas.

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

No método ConfigureAuth, substitua o método app.UseOpenIdConnectAuthentication pelo código a seguir. O ADAL armazena tokens e outras informações no cache de token. (Para ver o que está em cache, adicione esta linha antes de retornar à tarefa: 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);
            }
        }
    });

Em Controllers/HomeController.cs, adicione as seguintes instruções using.

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;

Na classe HomeController, adicione o método GetAuthorizedClient . Esse método cria e configura o HttpClient usado para fazer as solicitações REST para o serviço do OneNote. Ele também obtém o token de acesso e o adiciona ao cliente.

private HttpClient GetAuthorizedClient()
{
    HttpClient client = new HttpClient();

    string userObjectId = ClaimsPrincipal.Current.FindFirst("https://schemas.microsoft.com/identity/claims/objectidentifier").Value;
    string tenantId = ClaimsPrincipal.Current.FindFirst("https://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;
}

Agora você está pronto para fazer chamadas para o serviço do OneNote e analisar a resposta.

Chame a API do OneNote

Quando o aplicativo é carregado, ele obtém o nome e o ID das 10 seções modificadas mais recentemente e preenche a lista suspensa com os nomes das seções. A nova página do OneNote é criada na seção selecionada.

Na classe HomeController, adicione as variáveis globais para os pontos de extremidade do OneNote e o caminho para o arquivo de imagem para adicionar à nova página.

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

Altere o caminho do espaço reservado e o nome do arquivo na variável PathToImageFile para apontar para uma imagem PNG local.

Substitua o método Índice pelo código a seguir. Isso pega as seções, prepara o SectionsViewModel para a exibição do Índice e carrega a exibição.

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

Adicione o método GetSectionsAsync para compilar e enviar a solicitação OBTER seções e analisar a resposta.

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

Adicione o método CreatePageAsync para compilar e enviar a solicitação com diversas partes páginas POST e para analisar a resposta. Essa solicitação cria uma página HTML simples.

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

Na pasta Modelos, adicione uma nova classe chamada Resource.cs e use o código a seguir. Isso define os modelos de domínio que representam as seções e páginas do OneNote, e os modelos de exibição que representam os dados do OneNote nas exibições Índice e Página.

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

Depois de criar o aplicativo, você pode executá-lo com a depuração F5.

Se você receber um erro Nenhum conjunto de módulos (assembly) encontrado contendo um OwinStartupAttribute..., adicione o seguinte atributo depois das instruções using na classe Startup.cs no diretório raiz. (Saiba mais sobre este error.)

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

Faça login no aplicativo usando uma conta de trabalho ou escola que tenha pelo menos um bloco de anotações que contenha pelo menos uma seção. No aplicativo, selecione a seção em que você deseja criar uma página, insira um nome para a nova página e escolha Criar página. Se for bem-sucedido, o aplicativo exibirá o título e os links de página próprios da nova página.

Exemplos de código completo para o ASP.NET MVC

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("https://schemas.microsoft.com/identity/claims/objectidentifier").Value;
            string tenantId = ClaimsPrincipal.Current.FindFirst("https://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.cshtmle Resource.cs são mostrados na íntegra nas instruções.

Tutorial: Criar um aplicativo do OneNote

Criar um aplicativo do OneNote para iOS

Pré-requisitos

Para criar um aplicativo do OneNote para iOS

Crie o projeto no Xcode

Adicione a dependência do OneDrive SDK

Aplicativos do Xcode 7 que visam o iOS 9.0

Compile a interface do usuário

Adicione suporte de autenticação

Chame a API do OneNote

Próximas etapas

Exemplos de código completo para o iOS

AppDelegate.m

ViewController.h

ViewController.m

Criar um aplicativo do OneNote para ASP.NET

Pré-requisitos

Para criar um aplicativo do OneNote usando o ASP.NET MVC

Criar um projeto no Visual Studio

Adicionar ADAL para .NET

Compile a interface do usuário

Adicione suporte de autenticação

Chame a API do OneNote

Exemplos de código completo para o ASP.NET MVC

Startup.Auth.cs

HomeController

Confira também

Recursos adicionais