"Moet je je Python-script verbinden met een Exchange-server? We tonen je een eenvoudige manier om dit te doen met behulp van een tool genaamd Connect Bridge."
Inleiding
Dit artikel beschrijft hoe u Python verbinding kunt laten maken met Exchange, dat wil zeggen, hoe u mail kunt lezen van een Microsoft Exchange Server (Exchange 2010, 2013, 2016, 2019, Online) met behulp van een Python-taalscript.
De gegevensoverdracht gebeurt via de ODBC-laag, dus vanuit de scripting-kant is het precies hetzelfde als wanneer je python zou gebruiken om toegang te krijgen tot Microsoft SQL Server of om toegang te krijgen tot eender welke databank via ODBC. Je gebruikt gewoon de pyodbc module (we gebruikten python versie 3.7 en pyodbc versie 4.0.26.). De eigenlijke API integratie wordt gedaan door een tool genaamd Connect Bridge en dan lees je in je Python script de gegevens alsof je een database aan het lezen bent.
Let op: Connect Bridge is een commercieel product. U kunt gratis proberen zodat u deze aanpak zelf gratis kunt uitproberen.
Wat is deze “Connect Bridge”?
Connect Bridge is een integratie platform ontwikkeld door Connecting Software. Het staat uw script toe om om het even welke software door ODBC drivers, JDBC drivers, of Web Diensten te verbinden... het vermijden van de behoefte om de API van het programma te bestuderen en te leren waarmee u probeert te verbinden!
In dit specifieke artikel gebruiken we Connect Bridge om verbinding te maken met Microsoft Exchange, maar u kunt ook gegevens ophalen uit Microsoft SharePoint of een CRM zoals Salesforce of Dynamics, naast vele andere. En gegevensoverdracht kan in feite bidirectioneel zijn. Dat wil zeggen, u kunt ook gegevens naar deze systemen sturen, hoewel we ons deze keer richten op het lezen van gegevens.
Waar moet ik beginnen?
Ons doel is om een eenvoudig Python script te maken dat toegang krijgt tot een Exchange server en daar e-mail van leest. We nemen aan dat de Exchange instance al bestaat. Dit zijn eenvoudige stappen die je moet volgen:
1. Zorg ervoor dat u uw Exchange login gegevens bij de hand heeft
2. Vraag een gratis proef aan en installeer Connect Bridge
3. Installeer Python voor Windows ver. 3.7+. U kunt de editor van uw keuze gebruiken voor het schrijven van het script.
4. Installeer pyodbc module 4.0.26+
5. Start Connect Bridge Management Studio en:
5.1. Voeg een account toe voor Exchange (Accounts - Account toevoegen). Voor het toevoegen van de account dient u de connector MGEXPlugin2010 te selecteren en de in punt 1 genoemde credentials te gebruiken.
5.2. Open de optie New Query en vervolgens de Connection Browser. Zoek de Exchange Connector en vouw deze uit tot u de DefaultConnection ziet. Klik met de rechtermuisknop op de DefaultConnection en kies Get Connection string. Kopieer de ODBC verbindingsstring, want die heb je nodig om hem door te geven aan het script.
5.3. Gebruik de optie Nieuwe query om een query uit te testen die toegang geeft tot wat u in Exchange nodig hebt.
We zullen hier een voorbeeldquery uitvoeren, maar hier moet je invoeren wat je zoekt in Exchange. Nadat je op New Query hebt geklikt, open je de Connection Browser aan de linkerkant. Zoek de Exchange Connector (MGEXPlugin2010) en open deze totdat de optie Tables zichtbaar is. We kunnen zien dat het schema een “tabel” bevat met de naam Message, dus we kunnen onze query als volgt construeren SELECT * FROM Message WHERE CreationDate >= '2019-01-01 00:00:00' LIMIT 10; om 10 vermeldingen te selecteren uit de lijst met e-mailberichten van de Exchange die zijn gemaakt na 1 januari 2019. Nogmaals, merk op dat hoewel het lijkt alsof we een database rechtstreeks gebruiken, dat niet het geval is. Connect Bridge is toegang tot de API en vervolgens presenteren alsof het een database. Zodra u uw query hebt, kopieert u deze, omdat u deze moet doorgeven aan het script.
Hands on scripting!
Onze oplossing heeft maar één bestand: CBExchange.py. De volledige broncode staat hieronder. Gelieve u te concentreren op de lijnen 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
'''
CBExchange -- query data from, write data to Exchange
CBExchange is a script that allows to read Exchange mail using SQL queries via Connect Bridge's ODBC driver
@author: Ana Neto
@copyright: 2019
@contact: ana@connecting-software.com
@deffield updated: 22.07.2019
'''
import sys
import os
import pyodbc
from argparse import ArgumentParser
from argparse import RawDescriptionHelpFormatter
__all__ = []
__version__ = 0.2
__date__ = '2019-07-22'
__updated__ = '2019-07-22'
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 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 = 'CBExchange_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 een beetje over de variabelen die we gebruiken:
- parser wordt gebruikt om de argumenten te parsen die we van de opdrachtregel krijgen
- argumenten bevat die argumenten
- query bevat de query die we willen uitvoeren en komt binnen als argument
- connstr bevat de ODBC-verbindingstekenreeks die als argument binnenkomt en die we doorgeven aan de pyodbc-module om een ODBC-verbinding te maken.
- conn is de ODBC-verbinding
En hier is wat ons script aan het doen is
- In regel 70 tot 78 is het de bedoeling om de variabelen connstr en query uit de invoer van de commandoregelargumenten te halen. Omwille van de eenvoud is het scriptsjabloon argparse van pydev gebruikt
- In regel 80 openen we een databasecursor met conn
- In regel 82 voeren we de SQL-query uit die we van de opdrachtregel hebben gekregen
- In regel 83 tot 92 lussen we door de resultaten en lezen we ze rij voor rij uit de cursor.
-Als 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 is gedaan omdat het voldoende is voor demodoeleinden, maar in een echte situatie zou je natuurlijk kunnen formatteren als xml, json, csv... of een ander soort gegevensuitwisselingsformaat. Of je zou ook gewoon het object van de ruwe gegevensrij kunnen gebruiken om aangepaste taken uit te voeren in latere code.
Hoe voer ik het CBExchange.py script uit?
Het CBExchange.py script aanvaardt twee positionele commandoregel argumenten: connstr en query.
Die moeten we kopiëren uit Connect Bridge Management Studio zoals hierboven uitgelegd (punt 5.2). Als je ze bij de hand hebt, open je een commandoregel, cd naar de map waarin je het script hebt opgeslagen en voer uw Python script uit en geef het de 2 parameters door.
Wat kan ik nog meer doen? Verder onderzoeken...
Zoals eerder vermeld, kunnen meer gesofisticeerde query's worden opgesteld zodat je de e-mails krijgt die je wenst. Bijvoorbeeld, als je enkel de e-mails met bijlagen en met een specifieke aanmaakdatum wil verkrijgen, dan zou de query zijn
SELECT * FROM Message
WHERE [HasAttachment] = true and [CreationDate] >= '2019-07-01 00:00:00';
U kunt ook de beschikbare "Opgeslagen Procedures" verkennen. Zoek de Exchange Connector (MGEXPlugin2010) en vouw uit tot u de "Opgeslagen Procedures" optie ziet. Nogmaals, deze Stored Procedures zijn Connect Bridge's API integratie, geen echte database stored procedures. Maar de manier om er mee te werken is dezelfde als wanneer ze dat wel waren.
Enkele van de beschikbare Stored Procedures zijn zichtbaar op deze schermafdruk:
Beperkingen
De Connect Bridge tool is alleen beschikbaar voor Windows besturingssystemen, omdat er geen ODBC Linux client library beschikbaar is. Dus, om dit te laten werken heb je een Windows machine nodig.
Conclusie
We hebben gezien hoe toegang tot Exchange 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... je hoeft alleen maar de connector te kiezen voor de specifieke software die je wilt en daarmee aan de slag te gaan.
Als u de momenteel bij Connect Bridge verkrijgbare connectoren wilt onderzoeken, kunt u terecht bij https://www.connecting-software.com/connectors/
Als je nieuwsgierig bent welke de nieuwste connectoren in deze grote set zijn, kijk dan eens naar Connect Bridge's Dynamics 365 Financiën & bedrijfsvoering en Dynamics 365 Business Central connectors, beide gebaseerd op het OData protocol. Of kijk eens naar de OPC UA Connector. Ja, ik weet dat dit een totaal andere toepassing lijkt.... Maar de waarheid is dat je OPC UA servers kunt benaderen met hetzelfde gereedschap. Om je een idee te geven van wat het resultaat kan zijn van dit type integratie, kijk eens naar Connect Bridge's IIoT showcase.
We hopen dat dit artikel nuttig voor u was!
Hier zijn nog enkele berichten op onze blog over andere integratiemogelijkheden:
Over de auteur
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!"
