Lavora con un documento archiviato in un SharePoint online

Microsoft SharePoint Online è una raccolta di tecnologie basate sul Web che semplificano l’archiviazione, la condivisione e la gestione delle informazioni digitali da parte delle organizzazioni. Puoi lavorare con i documenti archiviati nella cartella “Documenti condivisi” in SharePoint utilizzando il nostro potente Aspose.Words per .NET.

In questo articolo, tratteremo uno scenario comune per convertire un documento caricato nella cartella “Documenti condivisi” in formato PDF e caricare nuovamente il documento risultante nella cartella.

Preimpostato

Unisciti al Programma per sviluppatori Microsoft 365
Configura un secondo il videotutorial sandbox istantaneo
Crea credenziali basate sull’app per SharePoint Online come dettagliato in Configurazione di un’entità solo app con autorizzazioni tenant
Carica il documento con il nome “TestDoc.docx” sul sito di comunicazione principale nella cartella “Documenti condivisi”
Acquista la licenza Aspose.Words o utilizza un Licenza e abbonamento

Tieni presente che se disponi già di un sito di comunicazione root SharePoint Online, salta i passaggi 1-2.

Crea applicazione console

Per valutare come funziona Aspose.Words for .NET con i documenti SharePoint, è necessario creare un’applicazione console con le impostazioni appropriate e implementare la logica per scaricare un documento dalla cartella “Documenti condivisi”, elaborarlo e quindi caricare questo file nella stessa cartella. Per fare ciò, seguire le istruzioni descritte in questa sezione.

Per eseguire le istruzioni è necessario trovare e fissare i valori dei seguenti parametri, che saranno disponibili dopo aver completato i passaggi nella parte “Preset”:

Identificativo del locatario – vedere come trovare l’ID del tuo inquilino
Nome dell’inquilino
Identificativo del cliente
Segreto del cliente

Tieni presente che il segreto client e l'identificatore client dovrebbero essere generati nel passaggio 3 della parte “Preset”.

Crea un nuovo progetto di applicazione console

Per creare un nuovo progetto di applicazione console, attenersi alla seguente procedura:

In Visual Studio, creare un nuovo progetto di applicazione console denominato “SPOnlineExample” per il linguaggio C# e il framework di destinazione .NET 6
Aggiungi i seguenti pacchetti:
- Microsoft.Extensions.Configuration.Json
- Aspose.Words

Aggiungi file di configurazione

Per aggiungere il file di configurazione, attenersi alla seguente procedura:

Aggiungi un file “appsettings.json” al progetto;

Aggiungi il seguente contenuto al file: JSON

{
  "TenantId": "Your tenant id.",
  "TenantName": "Your tenant name.",

  "ClientSecret": "App client secret.",
  "ClientId": "App client id.",

  "AsposeWordsLicensePath": "Path to your Aspose.Words license."
}

Completa i campi con i tuoi valori personalizzati.

Aggiungi il client REST API online SharePoint

Crea un file “SPOClient.cs” nel progetto e compilalo con il seguente contenuto:

.NET

using System.Net.Http.Json;
using System.Net.Http.Headers;
using System.Security.Authentication;
using System.Text.Json.Serialization;
using Microsoft.Extensions.Configuration;

namespace SPOnlineExample
{
    /// <summary>
    /// Sharepoint online REST API client.
    /// </summary>
    internal class SPOClient
    {
        private readonly string authUrl;
        private readonly string clientId;
        private readonly string resource;
        private readonly string tenantId;
        private readonly HttpClient client;
        private readonly string tenantName;
        private readonly string clientSecret;

        private const string grandType = "client_credentials";
        private const string resourceId = "00000003-0000-0ff1-ce00-000000000000";
    
        // URL templates.
        private static readonly string authUrlTemplate = "https://accounts.accesscontrol.windows.net/{0}/tokens/OAuth/2";
        private static readonly string downloadfileTemplate = "https://{0}.sharepoint.com/_api/web/GetFileByServerRelativeUrl('{1}')/$value";
        private static readonly string uploadfileTemplate =
            "https://{0}.sharepoint.com/_api/web/GetFolderByServerRelativeUrl('{1}')/Files/add(url='{2}',overwrite=true)";
    
        // Access token.
        private string token = string.Empty;
    
        public SPOClient(IConfigurationRoot appConfig)
        {
            tenantId = appConfig[nameof(tenantId)];
            clientSecret = appConfig[nameof(clientSecret)];
            tenantName = appConfig[nameof(tenantName)];
    
            authUrl = string.Format(authUrlTemplate, tenantId);
            clientId = $"{appConfig[nameof(clientId)]}@{tenantId}";
            resource = $"{resourceId}/{tenantName}.sharepoint.com@{tenantId}";
    
            client = new HttpClient();
        }
    
        public async Task Authorize()
        {
            var formContent = new FormUrlEncodedContent(new[]
            {
                new KeyValuePair<string, string>("grant_type", grandType),
                new KeyValuePair<string, string>("client_id", clientId),
                new KeyValuePair<string, string>("client_secret", clientSecret),
                new KeyValuePair<string, string>("resource", resource)
            });
    
            var response = await client.PostAsync(authUrl, formContent);
            var responseData = await response.Content.ReadFromJsonAsync<AuthRespose>();
    
            if (!response.IsSuccessStatusCode |  | responseData == null)
                throw new AuthenticationException(responseData?.Description);
    
            token = responseData.Token;
        }
    
        public async Task<Stream> DownloadFile(string relativeFilePath)
        {
            var url = string.Format(downloadfileTemplate, tenantName, relativeFilePath);
            using var request = CreateRequest(url, HttpMethod.Get);
    
            var response = await client.SendAsync(request);
    
            if (!response.IsSuccessStatusCode)
            {
                var errorData = await response.Content.ReadAsStringAsync();
                throw new Exception(errorData);
            }
    
            var fileStream = await response.Content.ReadAsStreamAsync();
            return fileStream;
        }
    
        public async Task UploadFile(string relativeFolderPath, string fileName, Stream fileData)
        {
            var url = string.Format(uploadfileTemplate, tenantName, relativeFolderPath, fileName);
            using var request = CreateRequest(url, HttpMethod.Post);
    
            request.Headers.Add("IF-MATCH", "*"); // Overwrite any changes.
            request.Content = new StreamContent(fileData);
    
            var response = await client.SendAsync(request);
    
            if (!response.IsSuccessStatusCode)
            {
                var errorData = await response.Content.ReadAsStringAsync();
                throw new Exception(errorData);
            }
        }
    
        private HttpRequestMessage CreateRequest(string url, HttpMethod httpMethod)
        {
            var request = new HttpRequestMessage(httpMethod, url);
            request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", token);
    
            return request;
        }
    
        private class AuthRespose
        {
            public string Error { get; set; } = string.Empty;
    
            [JsonPropertyName("error_description")]
            public string Description { get; set; } = string.Empty;
    
            [JsonPropertyName("access_token")]
            public string Token { get; set; } = string.Empty;
        }
    }
}

Aggiungi la logica dello scenario al programma

Spostare il seguente contenuto nel file “Program.cs”:

.NET

using Aspose.Words;
using Aspose.Words.Saving;
using Microsoft.Extensions.Configuration;

namespace SPOnlineExample
{
    public static class Program
    {
        static async Task Main(string[] args)
        {
            // The example below downloads the file "testdoc.docx" from the shared documents folder.
            // Converts it to PDF and uploads conversion result to the same folder.

            var appConfig = GetAppConfig();
            var client = new SPOClient(appConfig);
    
            await client.Authorize();
            var fileStream = await client.DownloadFile("/Shared%20Documents/TestDoc.docx");
    
            var lic = new License();
            lic.SetLicense(appConfig["AsposeWordsLicensePath"]);
            var doc = new Document(fileStream);
    
            using var outputStream = new MemoryStream();
            var saveOptions = new PdfSaveOptions();
            doc.Save(outputStream, saveOptions);
    
            await client.UploadFile("/Shared%20Documents", "TestDoc.pdf", outputStream);
    
            Console.WriteLine("Done. Press any key to complete.");
            Console.ReadKey();
        }
    
        private static IConfigurationRoot GetAppConfig()
        {
            // Build configuration
            return JsonConfigurationExtensions.AddJsonFile(
                    new ConfigurationBuilder().SetBasePath(Directory.GetCurrentDirectory()),
                    "appsettings.json")
                .Build();
        }
    }
}

Esegui l’esempio creato e controlla il risultato

Infine, esegui l’esempio creato e controlla il risultato ottenuto:

Compilare il progetto
Eseguire l’applicazione della console

Di conseguenza, il file “TestDoc.pdf” dovrebbe essere inserito nella cartella “Documenti condivisi” del sito di comunicazione principale.

Guarda anche

L’articolo Rendering per maggiori informazioni sui formati a pagina fissa e con layout a flusso
L’articolo Conversione nel formato a pagina fissa per maggiori informazioni sull’impaginazione
L’articolo Specifica le opzioni di rendering durante la conversione in PDF per maggiori informazioni sull’utilizzo della classe PdfSaveOptions

Serializza il documento in un database Lavorare con un documento contrassegnato da un'etichetta di riservatezza