Esempio: Gestione delle credenziali tramite librerie personalizzate costruite localmente

Per dimostrare come funziona lo scripting in Workiva, abbiamo costruito in precedenza uno script che aggiorna una cella in un foglio di calcolo. Questo articolo si basa su quell'esempio e mostra come eseguire la stessa operazione utilizzando l'autenticazione basata su token.

Nota: Lo scripting è attualmente disponibile solo tramite la funzione Personalizza Workiva. Per saperne di più.

Requisiti

Workiva Scripting deve essere abilitato per il tuo workspace. Scopri di più su Workiva Scripting.
Il ruolo Script Editor è necessario per creare o modificare gli script.

Passo 1: Creare un file di script

Questo script è una variante di quello utilizzato nel nostro esempio : Script per aggiornare i fogli di calcolo. Questa versione protegge l'ID e il segreto del cliente e ottiene invece un token che consente al codice di autenticarsi in Workiva.

Per creare lo script nel tuo spazio di lavoro, segui i seguenti passaggi:

Dalla Home, clicca su + Crea => Script.
A destra, inserisci un nome e una breve descrizione per lo script.

Vai all'editor di script al centro dello schermo e cancella il codice esistente. Copia e incolla quanto segue:

# Ti diamo il benvenuto in Workiva Scripting importa richieste importa json importa os da WorkivaAuth importa WorkivaAuth OUTPUT_SS_ID = os.getenv('OUTPUT_SS_ID') OUTPUT_SHEET_ID = os.getenv('OUTPUT_SHEET_ID') SS_API_URL = 'https://api.app.wdesk.com/platform/v1/spreadsheets/' class SSApi: def __init__(self, accessToken, ssId, sheetId): self._accessToken = 'Bearer ' + accessToken self._headers = {'Authorization': self._accessToken} self._ssId = ssId self._sheetId = sheetId def updateRange(self, range, values): url = SS_API_URL + self._ssId + "/sheets/" + \ self._sheetId + "/values/" + range requests.put(url, headers=self._headers, data=json.dumps(values)) def updateSS(outputSSApi: SSApi): values = [] values.append(["Hello World"]) outputSSApi.updateRange('A1', {"values": values}) def main(): authToken = WorkivaAuth.getWorkivaAuthToken() outputSSApi = SSApi(authToken, OUTPUT_SS_ID, OUTPUT_SHEET_ID) updateSS(outputSSApi) print("SS updated!!!") main()

Clicca su Salva.

Passo 2: Generare le dipendenze sul tuo computer locale

Mentre lavori a questa sezione, noterai che questa variante non include alcun codice per generare un token basato sull'ID e sul segreto del cliente. Piuttosto, il codice è astratto in una libreria creata localmente chiamata WorkivaAuth e poi inserita nel bundle dependencies.zip insieme alla libreria di richiesta.

Per seguirci, apri il terminale del tuo computer locale e completa i seguenti passaggi:

Crea una cartella denominata Creds.
```
mkdir Creds
```
Entra nella cartella Creds.
```
cd Creds
```

Crea un file requirements.txt con il seguente contenuto:

./WorkivaAuth/dist/WorkivaAuth-1.0.tar.gz requests==2.29.0

Crea una cartella denominata WorkivaAuth.
```
mkdir WorkivaAuth
```
Entra nella cartella WorkivaAuth.
```
cd WorkivaAuth
```

Nella cartella WorkivaAuth, crea un file setup.py con il seguente contenuto:

from setuptools import setup, find_packages setup( name='WorkivaAuth', version='1.0', packages=find_packages(), install_requires=[ 'requests' ] )

Nella cartella WorkivaAuth, crea un'altra cartella denominata WorkivaAuth.
```
mkdir WorkivaAuth
```
Nota: Non è un errore di battitura. Il percorso corretto è ./WorkivaAuth/WorkivaAuth.
Entra nella cartella WorkivaAuth appena creata.
```
cd WorkivaAuth
```

Crea un file __init__.py vuoto e un file WorkivaAuth.py nella cartella WorkivaAuth/WorkivaAuth con il seguente contenuto:

# WorkivaAuth import requests import json # Replace with the actual URL AUTH_URL = "https://api.app.wdesk.com/iam/v1/oauth2/token" # Define the missing variable CLIENT_ID CLIENT_ID = "your_client_id" # Define the missing variable CLIENT_SECRET CLIENT_SECRET = "your_client_secret" def getWorkivaAuthToken(): data = { 'client_id': CLIENT_ID, 'client_secret': CLIENT_SECRET, 'grant_type': 'client_credentials' } # Replace with the appropriate headers headers = { 'Content-Type': 'application/x-www-form-urlencoded', } tokenRes = requests.post( AUTH_URL, data=data, headers=headers ) tokenResponse = json.loads(tokenRes.text) return tokenResponse['access_token']

Ora dovresti avere la seguente struttura di cartelle:

 Creds/ |-- WorkivaAuth/ | |-- WorkivaAuth/ | |-- __init__.py | |-- WorkivaAuth.py | |-- setup.py |-- requirements.txt

Torna alla cartella Creds.
```
cd ..
```
```
cd ...
```
Esegui i seguenti comandi per generare il tuo pacchetto di distribuzione WorkivaAuth.
```
cd WorkivaAuth
```
```
python3 setup.py sdist
```
```
cd ..
```

Installa la dipendenza in una nuova directory Dependencies.

pip3 install --target ./dependencies --requirement requirements.txt

Crea un file dependencies.zip.

cd dependencies

zip -r ../dependencies.zip .

cd ..

Nella parte finale di questo articolo ti mostreremo come caricare questo file nello script creato in Passo 1.

Passo 3: caricare le dipendenze su Workiva

Ora che hai creato il file delle dipendenze, torna su Workiva e caricalo come sorgente.

Vai su Workiva Scripting e apri il file di script creato in precedenza in questo articolo.
Vai al pannello Sources sul lato sinistro; clicca con il tasto destro del mouse nello spazio vuoto appena sotto il file corrente e seleziona Upload Source Files.
Seleziona Sfoglia e individua il file dependencies.zip creato nel passaggio precedente.
Carica il file dependencies.zip per concludere.

Dovresti vedere una fonte non selezionabile chiamata dependencies.zip, che indica che ora sei pronto ad autenticarti in Workiva senza esporre alcuna credenziale!

Centro assistenza di Workiva