"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" bevat met de naam Site_Pages, zodat we onze query kunnen construeren als
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:
- Lijnen 71-80 richten zich op het verkrijgen van de variabelen connstr en query van de commandoregel argumenten input. Hiervoor gebruikten we het pydev's argparse script sjabloon om mijn leven gemakkelijker te maken
- De variabele connstr bevat de ODBC verbindings string die we doorgeven aan de pyodbc module om een ODBC verbinding te maken (opgeslagen in de variabele conn)
- Als volgende stap openen we een database cursor met de connectie opgeslagen in conn
- Met de verbinding opgeslagen in conn openen we een database cursor met conn
- We voeren de SQL-query uit (dit is de query die werd doorgegeven via de opdrachtregelparameter met de naam query)
- Tenslotte gebruiken we een while-lus om de resultaten van de cursor rij per rij te lezen. Wanneer cursor.fetchone None teruggeeft, breken we de lus
- Als er een uitzondering optreedt tijdens het ophalen van ODBC, breken we ook de lus en drukken we het probleem af naar de uitvoer
- Als de fetchone methode slaagt en een gegevensrij teruggeeft, drukken we de onbewerkte gegevensrij af zoals ze is naar de uitvoer. Dit was onze keuze voor deze demo, maar merk op dat dit elke soort output zou kunnen zijn... we zouden het kunnen formatteren als xml of json, csv... of een ander soort data-interchange formaat. We kunnen ook gewoon gebruik maken van de ruwe gegevens rij object om 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 contactlijst willen maken in SharePoint en op die lijst een contact willen aanmaken. We moeten in principe hetzelfde proces volgen, maar de query veranderen om een "Stored Procedure" te gebruiken. Opnieuw zal deze "Stored Procedure" in feite toegang hebben tot SharePoint via de API, maar het krijgt de data in de SharePoint die u hebt gespecificeerd. 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 aanroepen om de Connect Bridge ODBC schema reflectie van het SharePoint schema bij te werken. Zodat onze nieuwe "tabel" zichtbaar wordt 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 zullen we gebruik maken van de bestaande SharePoint lijst "Documenten" en de "Stored Procedure" SP_INSERT_SHAREDDOCUMENT. De parameters die daarvoor nodig zijn, zijn:
- Naam tabel 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 de SP_INSERT_SHAREDDOCUMENT kunnen we de aanwezigheid van het document in de tabel "Documenten" controleren door het statement 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?
"Mijn naam is Ana Neto, en ik ben technisch adviseur voor Connecting Software. Ik ben sinds 1997 software-ingenieur, en ik hou van de wereld van mogelijkheden die connect Bridge opent.
Als je er vragen over hebt, laat dan hieronder een reactie achter!"
Comments 1
Dank u voor de duidelijke uitleg!