"Vi siete mai chiesti come accedere a Microsoft SharePoint nei vostri script Python?
Questo tutorial si occupa proprio di questo:
sarete in grado di farlo in modo semplice utilizzando uno strumento chiamato Connect Bridge".
Introduzione
Questo articolo descrive come fare Python si collega a SharePointcioè come accedere ai dati dei sistemi Microsoft SharePoint (2010, 2013 o 2019) da script in linguaggio Python (utilizzando la versione 3.7). Il trasferimento dei dati avviene tramite il livello ODBC. Abbiamo ottenuto questo risultato in Python utilizzando il file modulo pyodbc ver. 4.0.26.
E' importante notare che in questo articolo utilizziamo un prodotto commerciale chiamato Connect Bridge. Questo è, infatti, ciò che rende possibile l'integrazione Python / SharePoint, permettendo la comunicazione dei dati in modo che siate sicuri di non rovinare il lato SharePoint (e, credetemi, questo è MOLTO importante). È possibile ottenere una prova gratuita per Connect Bridge, in modo da poter provare tutto questo da soli.
Cos'è questo "Connect Bridge"?
Sono contento che tu l'abbia chiesto! Connect Bridge è una piattaforma di integrazione sviluppata da Connecting Software che permette di collegare qualsiasi software attraverso driver ODBC, driver JDBC o servizi web. La panoramica generale dell'architettura dello strumento è su questo diagramma di scenario client-server.
Connect Bridge architettura della piattaforma di integrazione
Come si può vedere nel diagramma dell'architettura, lo strumento può essere utilizzato per accedere non solo ai dati di Microsoft SharePoint all'interno del vostro script Python, ma si possono anche afferrare/immettere dati da/verso Microsoft Exchange e Microsoft Dynamics CRM tra molti altri.
Lo scopo - ottenere dati SharePoint usando Python
Lo scopo del nostro lavoro era di creare uno script Python che ci permettesse di parlare con SharePoint tramite Connect Bridge.
Noi usiamo SharePoint, ma è possibile usare una logica simile per connettersi a Microsoft Exchange o a un CRM come Salesforce o Dynamics.
Iniziare...
Ora iniziamo questo tutorial! Il nostro obiettivo è quello di creare un semplice script Python che accede a un'istanza SharePoint. Assumiamo che l'istanza SharePoint esista già (assicurati di avere le tue credenziali di accesso a portata di mano). Questi sono semplici passi da seguire:
1. Richiedi un prova gratuita e installare Connect Bridge
2. Installare Pitone per finestre ver. 3.7+. Si prega di notare che per rendere più facile la scrittura, l'esecuzione e il debug del mio script abbiamo usato Liclipse 5.2.4 con il plugin pydev, ma questo è, ovviamente, opzionale. È possibile utilizzare l'editor di vostra scelta.
3. Installare modulo pyodbc 4.0.26+
4. Eseguire Connect Bridge Management Studio e
4.1. Aggiungi un account per SharePoint (Accounts - Add account). Qui è dove avrai bisogno di quelle credenziali che abbiamo menzionato prima.
4.2. Aprire il Nuova query e poi l'opzione Browser di connessione. Trova il Connettore SharePoint e aprirlo fino a che non vedi il DefaultConnection. Cliccate con il tasto destro su di esso e scegliete Ottenere la stringa di connessione. Poi copiate la stringa di connessione ODBC. Vi servirà per passarla allo script.
4.3. Usa l'opzione Nuova query per provare una query che acceda a ciò che ti serve in SharePoint. Faremo una query di esempio qui, ma qui è dove dovreste inserire ciò che state cercando in SharePoint. Una volta cliccato su Nuova query, aprire il Browser di connessione. Trova il Connettore SharePoint e aprirlo fino a che non vedi il Tabelle opzione. Vedrete che lo schema contiene una "tabella" chiamata Site_Pages quindi possiamo costruire la nostra query come
SELECT UniqueId, ContentType, Created, Modified, ContentVersion FROM Site_Pages LIMIT 10;
per selezionare le prime 10 voci del SharePoint Pagine del sito elenco. È importante notare che anche se sembra che stiamo usando direttamente un database, non è così.
Connect Bridge accede all'API e la presenta come se fosse un database. Una volta che avete la vostra query, copiatela, perché vi servirà anche per passarla allo script.
Mani sullo scripting!
Il nucleo e, allo stesso tempo, l'unico file della nostra soluzione è CBQuery.py. Il codice sorgente completo è qui sotto. Concentratevi sulle linee 70-92 che rappresentano la soluzione di base. Una descrizione completa di come funziona questo script è qui sotto.
#!/usr/local/bin/python3.7
# encoding: utf-8
'''
CBQuery -- query data from, write data to SharePoint
CBQuery is a script that allows to run SQL queries via Connect Bridge ODBC driver
@author: Ana Neto and Michal Hainc
@copyright: 2019
@contact: ana@connecting-soiftware.com
@deffield updated: 04.07.2019
'''
import sys
import os
import pyodbc
from argparse import ArgumentParser
from argparse import RawDescriptionHelpFormatter
__all__ = []
__version__ = 0.2
__date__ = '2019-07-04'
__updated__ = '2019-07-04'
DEBUG = 1
TESTRUN = 0
PROFILE = 0
class CLIError(Exception):
'''Generic exception to raise and log different fatal errors.'''
def __init__(self, msg):
super(CLIError).__init__(type(self))
self.msg = "E: %s" % msg
def __str__(self):
return self.msg
def __unicode__(self):
return self.msg
def main(argv=None): # IGNORE:C0111
'''Command line options.'''
if argv is None:
argv = sys.argv
else:
sys.argv.extend(argv)
program_name = os.path.basename(sys.argv[0])
program_version = "v%s" % __version__
program_build_date = str(__updated__)
program_version_message = '%%(prog)s %s (%s)' % (program_version, program_build_date)
program_shortdesc = __import__('__main__').__doc__.split("n")[1]
program_license = '''%s
Created by Ana Neto and Michal Hainc on %s.
Licensed under the Apache License 2.0
http://www.apache.org/licenses/LICENSE-2.0
Distributed on an "AS IS" basis without warranties
or conditions of any kind, either express or implied.
USAGE
''' % (program_shortdesc, str(__date__))
try:
# Setup argument parser
parser = ArgumentParser(description=program_license, formatter_class=RawDescriptionHelpFormatter)
parser.add_argument('connstr')
parser.add_argument('query')
# Process arguments
args = parser.parse_args()
query = args.query
connstr = args.connstr
conn = pyodbc.connect(connstr)
cursor = conn.cursor()
cursor.execute(query)
while 1:
row = None
try:
row = cursor.fetchone()
except:
print(sys.exc_info()[1])
break
if not row:
break
print(row)
except KeyboardInterrupt:
### handle keyboard interrupt ###
return 0
except:
print(sys.exc_info()[1])
#indent = len(program_name) * " "
#sys.stderr.write(program_name + ": " + repr(e) + "n")
#sys.stderr.write(indent + " for help use --help")
return 2
if __name__ == "__main__":
if TESTRUN:
import doctest
doctest.testmod()
if PROFILE:
import cProfile
import pstats
profile_filename = 'CBQuery_profile.txt'
cProfile.run('main()', profile_filename)
statsfile = open("profile_stats.txt", "wb")
p = pstats.Stats(profile_filename, stream=statsfile)
stats = p.strip_dirs().sort_stats('cumulative')
stats.print_stats()
statsfile.close()
sys.exit(0)
sys.exit(main())
Ecco cosa sta facendo il nostro copione:
- Le linee 71-80 si concentrano sull'ottenere le variabili connstr e query dall'input degli argomenti della riga di comando. Per questo abbiamo usato il modello di script argparse di pydev per rendere la mia vita più facile
- La variabile connstr contiene la stringa di connessione ODBC che passiamo nel modulo pyodbc per creare una connessione ODBC (memorizzata nella variabile conn)
- come passo successivo apriamo un cursore di database utilizzando la connessione memorizzata in conn
- Avendo la connessione memorizzata in conn apriamo un cursore di database utilizzando conn
- Eseguiamo la query SQL (è la query che è stata passata attraverso il parametro della riga di comando denominato query)
- Infine, utilizziamo un while loop per leggere i risultati del cursore riga per riga. Quando il cursore.fetchone restituisce Nessuno, interrompiamo il ciclo
- Se si verifica un'eccezione durante il fetch ODBC, rompiamo anche il loop e stampiamo il problema in uscita
- Se il metodo fetchone ha successo e restituisce una riga di dati, stampiamo la riga di dati grezzi così com'è all'uscita. Questa è stata la nostra scelta per questa demo, ma si prega di notare che questo potrebbe essere qualsiasi tipo di output... potremmo formattare come xml o json, csv... o qualsiasi altro tipo di formato di scambio di dati. Potremmo anche semplicemente usare l'oggetto raw data row per essere in ulteriore codice per eseguire compiti personalizzati.
Esecuzione dello script CBQuery.py
Sappiamo che il nostro CBQuery.py accetta due argomenti a riga di comando posizionale: connstr e query.
Dobbiamo copiarli da Connect Bridge Management Studio come spiegato sopra (punto 4).
Possiamo creare una lista di contatti SharePoint e scrivere una voce?
Supponiamo ora di voler creare una lista di contatti in SharePoint e creare un contatto su quella lista. Fondamentalmente dobbiamo seguire lo stesso processo ma cambiare la query per usare una "Stored Procedure". Ancora una volta questa "Stored Procedure" accederà di fatto a SharePoint tramite l'API, ma otterrà i dati nel SharePoint che avete specificato. Ecco la query che dobbiamo eseguire:
EXEC SP_CREATE_TABLE 'MyContacts', 'This table was created using Connect Bridge', true, 'Contacts';
La query crea una nuova lista SharePoint (MyContacts), con una descrizione che apparirà nella barra di lancio rapido della pagina SharePoint.
Ora dobbiamo chiamare la seguente query per aggiornare la riflessione dello schema Connect Bridge ODBC dello schema SharePoint. Così, la nostra nuova "tabella" diventa visibile al client ODBC.
EXEC SP_UPDATE_SCHEMA;
A questo punto possiamo inserire un contatto nella nostra lista di contatti.
INSERT INTO MyContacts (FirstName, LastName) VALUES ('Ana', 'Neto');
Ora dovreste essere in grado di vedere la nostra voce e la nostra nuova lista SharePoint nell'interfaccia utente SharePoint.
Possiamo selezionare la voce che abbiamo appena creato eseguendo la seguente query.
SELECT FirstName,LastName FROM MyContacts
Caricamento e download di documenti condivisi
Per caricare un documento condiviso, useremo la lista SharePoint esistente "Documents" e la "Stored Procedure" SP_INSERT_SHAREDDOCUMENT. I parametri che prende sono:
- Nome della tabella dei documenti condivisi
- Nome del file
- Cartella (percorso relativo, sul server)
- Tipo MIME
- Dati per il file
Possiamo inserire il documento eseguendo la seguente dichiarazione:
EXEC SP_INSERT_SHAREDDOCUMENT
'Documents',
'hello2.txt',
'/Shared Documents/NewFolder',
'text/plain',
'SGVsbG8gV29ybGQ=';
Se volete controllare la presenza della cartella in anticipo, potete eseguire l'istruzione:
EXEC SP_ENSURE_FOLDER_PATH
'Documents',
'/NewFolder';
Dopo aver eseguito SP_INSERT_SHAREDDOCUMENT possiamo controllare la presenza del documento nella tabella "Documents" eseguendo la dichiarazione:
SELECT Id,Name FROM Documents;Possiamo anche scaricare il contenuto binario di un particolare documento da una particolare biblioteca di documenti eseguendo la dichiarazione:
EXEC SP_SAVE_SHAREDDOCUMENT_BY_ID 'Documents', 2; A questo punto è possibile verificare l'esistenza del documento condiviso nell'interfaccia utente SharePoint
Vincoli
Finora, siamo stati in grado di utilizzare lo strumento Connect Bridge solo da sistemi operativi Windows, perché non è disponibile una libreria client ODBC Linux (e non siamo sicuri che sia possibile). Quindi assicuratevi di giocare con i vostri script Python su una macchina Windows.
Conclusione
Abbiamo visto come l'accesso ai dati SharePoint in Python può essere fatto facilmente utilizzando la piattaforma di integrazione Connect Bridge. Ora immaginate che quello che avete visto in questo articolo sia possibile anche con Microsoft Dynamics CRM e Microsoft Exchange! Sì, con Connect Bridge questo è possibile e il modo di farlo è simile.
A chi posso rivolgermi per domande?
"Mi chiamo Ana Neto, e sono un consulente tecnico per Connecting Software. Sono un ingegnere del software dal 1997, e mi piace il mondo delle possibilità che connettono Bridge apre..
Se avete domande a riguardo, lasciate una risposta qui sotto!".
Comments 1
Grazie per la chiara spiegazione!