"Moet je je Python script verbinden met een Exchange server? We laten je een makkelijke manier zien om dat 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 voorbeeld query doen, maar dit is waar u in moet voeren wat het is dat u zoekt in Exchange. Nadat u op New Query hebt geklikt, opent u de Connection Browser, aan de linkerkant. Zoek de Exchange Connector (MGEXPlugin2010) en open tot de optie Tables zichtbaar is. We kunnen zien dat het schema een "tabel" bevat genaamd Message zodat we onze query kunnen construeren als SELECT * FROM Message WHERE CreationDate >= '2019-01-01 00:00:00' LIMIT 10; om 10 entries te selecteren uit de Exchange's email berichten lijst die zijn aangemaakt na 1 jan 2019. Nogmaals, merk op 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 die moet je 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 die we van de commandoregel krijgen te parsen
- args bevat deze argumenten
- query bevat de query die we willen uitvoeren en dat komt binnen als een argument
- connstr bevat de ODBC connectie string die als argument binnenkomt en die we doorgeven aan de pyodbc module om een ODBC connectie te maken
- conn is de ODBC-verbinding
En hier is wat ons script aan het doen is
- In de regels 70 tot 78 is het de bedoeling om de variabelen connstr en query te halen uit de invoer van de commandoregelargumenten. Omwille van de eenvoud werd pydev's argparse scriptsjabloon gebruikt
- In regel 80, openen we een database cursor met behulp van conn
- In regel 82, voeren we de SQL query uit die we van de commandoregel hebben gekregen
- In de regels 83 tot en met 92 lopen we door de resultaten en lezen we ze rij voor rij uit de cursor.
-Als 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 is gedaan omdat het voldoende is voor demo-doeleinden, maar natuurlijk in een echte-wereld situatie zou je kunnen formatteren als xml, json, csv ... of enige andere vorm van data-uitwisseling formaat. Of je zou ook gewoon het ruwe data rij object 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 u nieuwsgierig bent naar de nieuwste connectoren in deze grote set, kijk dan eens naar de Connect Bridge's Dynamics 365 Financiën en verrichtingen en Dynamics 365 Zakencentrum connectoren, beide gebouwd op het OData Protocol. Of kijk eens naar de OPC UA Connector. Ja, ik weet dat dit een totaal verschillend gebruik lijkt.... Maar de waarheid is dat je OPC UA servers kan benaderen met hetzelfde gereedschap. Om je een idee te geven van wat dit soort integratie kan opleveren, 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:
