"Heb je je ooit afgevraagd hoe je toegang krijgt tot Microsoft SharePoint in je Python scripts?
Deze handleiding gaat daarover:
kunt u dat op een eenvoudige manier doen met behulp van een instrument dat Connect Bridge heet."
Inleiding
Dit artikel beschrijft hoe je Python aansluiten op SharePoint, dat wil zeggen, hoe toegang te krijgen tot gegevens van Microsoft SharePoint systemen (2010, 2013 of 2019) vanuit Python taal scripts (met behulp van versie 3.7). De gegevensoverdracht gebeurt via de ODBC-laag. We hebben dit in Python bereikt met behulp van de pyodbc module ver. 4.0.26.
Het is belangrijk op te merken dat we in dit artikel gebruik maken van een commercieel product genaamd Connect Bridge. Dit is in feite wat de Python / SharePoint integratie mogelijk maakt, door de datacommunicatie mogelijk te maken op een manier dat u er zeker van bent dat u de SharePoint kant niet verknoeit (en, geloof me, dit is ZEER belangrijk). U kunt gratis proberen voor Connect Bridge, zodat je dit allemaal zelf kunt uitproberen.
Wat is deze "Connect Bridge"?
Ik ben blij dat je het vraagt! Connect Bridge is een door Connecting Software ontwikkeld integratieplatform dat het mogelijk maakt om software te verbinden via ODBC drivers, JDBC drivers of Web Services. Het algemene overzicht van de architectuur van de tool is op deze client-server scenario diagram.
Connect Bridge architectuur van het integratieplatform
Zoals u kunt zien op het architectuurdiagram, kan de tool niet alleen worden gebruikt om toegang te krijgen tot Microsoft SharePoint gegevens vanuit uw Python script, maar u kunt ook gegevens ophalen uit/zetten in Microsoft Exchange en Microsoft Dynamics CRM, naast vele andere.
Het doel - het verkrijgen van SharePoint gegevens met behulp van Python
Het doel van ons werk was een Python-script te maken waarmee we via Connect Bridge met SharePoint kunnen praten.
Wij gebruiken SharePoint, maar het is mogelijk om soortgelijke logica te gebruiken om aan te sluiten op Microsoft Exchange of naar een CRM zoals Salesforce of Dynamics.
Aan de slag...
Laten we nu beginnen met deze tutorial! Ons doel is om een eenvoudig Python script te maken dat toegang krijgt tot een SharePoint instantie. We nemen aan dat de SharePoint instance al bestaat (zorg ervoor dat je je login gegevens bij de hand hebt). Dit zijn eenvoudige stappen die je moet volgen:
1. Vraag een gratis proefversie en installeer Connect Bridge
2. Installeer Python voor Windows ver. 3.7+. Om het schrijven, uitvoeren en debuggen van mijn script te vergemakkelijken, hebben we gebruik gemaakt van Liclipse 5.2.4 met de pydev plugin, maar dit is, uiteraard, optioneel. U kunt de editor van uw keuze gebruiken.
3. Installeer pyodbc module 4.0.26+
4. Start Connect Bridge Management Studio en
4.1. Voeg een account toe voor SharePoint (Accounts - Account toevoegen). Hier heb je de referenties nodig die we eerder noemden.
4.2. Open de Nieuwe vraag optie en dan de Verbinding Browser. Zoek de SharePoint Aansluiting en open het tot je de DefaultConnection. Klik er met de rechtermuisknop op en kies Verbindingsteken ophalen. Kopieer dan de ODBC verbindings string. Je zal het nodig hebben om het door te geven aan het script.
4.3. Gebruik de New Query optie om een query uit te testen die toegang geeft tot wat u nodig heeft in SharePoint. We zullen hier een voorbeeld query geven, maar dit is de plaats waar je moet invullen wat je zoekt in SharePoint. Als je eenmaal hebt geklikt op Nieuwe vraag, open de Verbinding Browser. Zoek de SharePoint Aansluiting en open het tot je de Tabellen optie. Je zult zien dat het schema een “tabel” genaamd Site_Pages bevat, dus we kunnen onze query als volgt samenstellen
SELECT UniqueId, ContentType, Created, Modified, ContentVersion FROM Site_Pages LIMIT 10;
om de eerste 10 regels van SharePoint's Pagina's lijst. Het is belangrijk op te merken dat, hoewel het lijkt alsof we rechtstreeks een database gebruiken, dat niet het geval is.
Connect Bridge benadert de API en presenteert die alsof het een database is. Als je je query hebt, kopieer die dan, want je zult hem ook nodig hebben om aan het script door te geven.
Hands on scripting!
Het kernbestand en tegelijkertijd het enige bestand in onze oplossing is CBQuery.py. De volledige broncode staat hieronder. Concentreer je op de regels 70-92 die de kern van de oplossing weergeven. Een volledige beschrijving van hoe dit script werkt staat hieronder.
#!/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())
Hier is wat ons script aan het doen is:
- Regels 71-80 richten zich op het verkrijgen van de variabelen connstr en query uit de invoer van de commandoregelargumenten. Hiervoor hebben we de pydevs argparse scriptsjabloon gebruikt om mijn leven gemakkelijker te maken
- De variabele connstr bevat de ODBC-verbindingstekenreeks die we doorgeven aan de pyodbc-module om een ODBC-verbinding te maken (opgeslagen in de variabele conn).
- Als volgende stap openen we een databasecursor met behulp van de verbinding die is opgeslagen in conn
- Met de verbinding opgeslagen in conn openen we een databasecursor met conn
- We voeren de SQL-query uit (dit is de query die is doorgegeven via de opdrachtregelparameter met de naam query)
- Tenslotte gebruiken we een while-lus om rij voor rij resultaten uit de cursor te lezen. Wanneer cursor.fetchone geen resultaat geeft, breken we de lus af
- Als er een uitzondering optreedt tijdens het ophalen van ODBC, breken we de lus ook af en drukken we het probleem af op de uitvoer
- Als de methode fetchone slaagt en een gegevensrij retourneert, printen we de ruwe gegevensrij zoals hij is naar de uitvoer. Dit was onze keuze voor deze demo, maar merk op dat dit elk soort uitvoer kan zijn... we kunnen het opmaken als xml of json, csv... of elk ander soort gegevensuitwisselingsformaat. We kunnen ook gewoon het object van de ruwe gegevensrij gebruiken in verdere code om aangepaste taken uit te voeren.
Het CBQuery.py script uitvoeren
We weten dat onze CBQuery.py twee positionele commandoregel argumenten accepteert: connstr en query.
Die moeten we kopiëren uit Connect Bridge Management Studio, zoals hierboven uitgelegd (punt 4).
Kunnen we een SharePoint contactlijst maken en een bericht schrijven?
Stel nu dat we een contactpersonenlijst willen maken in SharePoint en een contactpersoon willen maken op die lijst. We moeten in principe hetzelfde proces volgen, maar de query wijzigen in een "Stored Procedure". Nogmaals deze "Stored Procedure" zal, in feite, toegang krijgen tot SharePoint via de API, maar het krijgt de gegevens in de SharePoint die je hebt opgegeven. Hier is de query die we moeten uitvoeren:
EXEC SP_CREATE_TABLE 'MyContacts', 'This table was created using Connect Bridge', true, 'Contacts';
De query maakt een nieuwe SharePoint lijst aan (MyContacts), met een beschrijving die zal verschijnen in de snelstartbalk van de SharePoint pagina.
Nu moeten we de volgende query oproepen om het Connect Bridge ODBC schema reflectie van het SharePoint schema bij te werken. Zo wordt onze nieuwe “tabel” zichtbaar voor de ODBC-client.
EXEC SP_UPDATE_SCHEMA;
Op dit punt kunnen we een contact in onze contactlijst invoegen.
INSERT INTO MyContacts (FirstName, LastName) VALUES ('Ana', 'Neto');
U zou nu ons item en onze nieuwe SharePoint lijst moeten kunnen zien in de SharePoint UI.
We kunnen het item dat we net hebben aangemaakt selecteren door de volgende query uit te voeren.
SELECT FirstName,LastName FROM MyContacts
Uploaden en downloaden van gedeelde documenten
Voor het uploaden van een gedeeld document gebruiken we de bestaande SharePoint-lijst “Documenten” en de "Opgeslagen procedure" SP_INSERT_SHAREDDOCUMENT. De parameters die hiervoor nodig zijn, zijn:
- Naam tabel met gedeelde documenten
- Bestandsnaam
- Map (relatief pad, op de server)
- MIME-type
- Gegevens voor het bestand
We kunnen het document invoegen door het volgende statement uit te voeren:
EXEC SP_INSERT_SHAREDDOCUMENT
'Documents',
'hello2.txt',
'/Shared Documents/NewFolder',
'text/plain',
'SGVsbG8gV29ybGQ=';
Als u de aanwezigheid van de map vooraf wilt controleren, kunt u het statement uitvoeren:
EXEC SP_ENSURE_FOLDER_PATH
'Documents',
'/NewFolder';
Na het uitvoeren van SP_INSERT_SHAREDDOCUMENT kunnen we de aanwezigheid van het document in de tabel “Documents” controleren door de verklaring uit te voeren:
SELECT Id,Name FROM Documents;We kunnen ook de binaire inhoud van een bepaald document uit een bepaalde documentbibliotheek downloaden door het statement uit te voeren:
EXEC SP_SAVE_SHAREDDOCUMENT_BY_ID 'Documents', 2; Op dit punt kunt u het bestaan van het gedeelde document controleren in de SharePoint UI
Beperkingen
Tot nu toe hebben we de Connect Bridge tool alleen kunnen gebruiken vanuit Windows besturingssystemen, omdat er geen ODBC Linux client library beschikbaar is (en we weten niet eens zeker of dat wel mogelijk is). Speel dus zeker met je Python scripts op een Windows machine.
Conclusie
We hebben gezien hoe toegang tot SharePoint data in Python gemakkelijk kan worden gedaan met behulp van het Connect Bridge integratie platform. Stel je nu eens voor dat wat je in dit artikel hebt gezien ook mogelijk is met Microsoft Dynamics CRM en Microsoft Exchange! Ja, met Connect Bridge is dit mogelijk en de manier om het te doen is vergelijkbaar.
Bij wie kan ik terecht met vragen?
Door Ana Neto, technisch adviseur op Connecting Software.
"Ik ben software engineer sinds 1997, met een recentere liefde voor schrijven en spreken in het openbaar. Heb je vragen of opmerkingen over dit artikel? Ik zou graag je feedback horen, laat hieronder een reactie achter!"
Comments 1
Dank u voor de duidelijke uitleg!