def login(self, server):
'''Login to server, return account instance'''
credentials = exchangelib.ServiceAccount(username=self.username,
password=self._password)
if self.ews_url and self.ews_auth_type and self.smtp_host:
config = exchangelib.Configuration(service_endpoint=self.ews_url,
credentials=credentials,
auth_type=self.ews_auth_type)
account = exchangelib.Account(primary_smtp_address=server,
config=config,
autodiscover=False,
access_type=exchangelib.DELEGATE)
else:
account = exchangelib.Account(primary_smtp_address=server,
credentials=credentials,
autodiscover=True,
access_type=exchangelib.DELEGATE)
self.ews_url = account.protocol.service_endpoint
self.ews_auth_type = account.protocol.auth_type
self.smtp_host = account.primary_smtp_address
return account
def ensure_connection(self):
try:
if not self.account:
credentials = exchangelib.ServiceAccount(
username=self.username, password=self.password)
if self.host:
config = exchangelib.Configuration(server=self.host,
credentials=credentials)
self.account = exchangelib.Account(
primary_smtp_address=self.email_address,
config=config,
autodiscover=False,
access_type=exchangelib.DELEGATE)
else:
self.account = exchangelib.Account(
primary_smtp_address=self.email_address,
credentials=credentials,
autodiscover=True,
access_type=exchangelib.DELEGATE)
yield
except Exception as e:
# NOTE(sileht): retry just once if the connection have been
# broken to ensure this is not a sporadic connection lost.
# Like wifi reconnect, sleep wake up
# Wait a bit when disconnection occurs to not hog the cpu
self.logger.warn(e)
time.sleep(1)
self.connection = None
def open(self, address, password, host = None): """ Opens a connection to an email for reading Use: https://resources.hacware.com/connecting-to-the-ews-with-python-using-exchangelib-2/ """ credentials = exchangelib.Credentials(address, password) if (host): config = exchangelib.Configuration(server = host, credentials = credentials) yield exchangelib.Account(address, config = config, autodiscover = False, access_type = exchangelib.DELEGATE) else: yield exchangelib.Account(address, credentials = credentials, autodiscover = True)
def getEvents(VALUES):
"""get events from exchange and write them to file"""
url = VALUES['owa']
username = VALUES['username']
password = VALUES['password']
BEFORE = int(VALUES['before'])
FUTURE = int(VALUES['future'])
try:
credentials = exchangelib.Credentials(username=username,
password=password)
config = exchangelib.Configuration(server=url, credentials=credentials)
account = exchangelib.Account(primary_smtp_address=username,
credentials=credentials,
config=config)
total_number = str(account.calendar.total_count)
tz = exchangelib.EWSTimeZone.localzone()
right_now = tz.localize(exchangelib.EWSDateTime.now())
start = right_now - datetime.timedelta(days=BEFORE)
end = right_now + datetime.timedelta(days=FUTURE)
allEvents = account.calendar.view(start=start, end=end)
return allEvents
except Exception as inst:
print(inst)
quit()
def initData(self, email, username, password, trelloEmail):
self.credentials = exchangelib.Credentials(username=username,
password=password)
self.account = exchangelib.Account(email,
credentials=self.credentials,
autodiscover=True)
self.ticketingEmail = trelloEmail
self.recentEmail = self.account.inbox.all().order_by(
'-datetime_received')[0].id
def connect_to_exchange(server: str, domain: str, email: str, username: str) -> exchangelib.Account:
"""
Get Exchange account connection with server
"""
credentials = exchangelib.Credentials(username= f'{domain}\\{username}',
password=getpass.getpass("Exchange pass:"))
config = exchangelib.Configuration(server=server, credentials=credentials)
return exchangelib.Account(primary_smtp_address=email, autodiscover=False,
config = config, access_type='delegate')
def main():
boot_time = time.time()
config = load_config()
metrics.init(config, 'iris-owa-sync', default_metrics)
owaconfig = config.get('owa')
if not owaconfig:
logger.critical('Missing OWA configs')
sys.exit(1)
api_host = owaconfig.get('api_host', 'http://localhost:16649')
iris_client = IrisClient(api_host, 0, owaconfig['iris_app'],
owaconfig['iris_app_key'])
proxies = owaconfig.get('proxies')
# only way to configure a proxy is to monkey-patch (http adapter) a monkey-patch (baseprotocol) :/
if proxies:
UseProxyHttpAdapter._my_proxies = proxies
exchangelib.protocol.BaseProtocol.HTTP_ADAPTER_CLS = UseProxyHttpAdapter
creds = exchangelib.Credentials(**owaconfig['credentials'])
try:
nap_time = int(owaconfig.get('sleep_interval', 60))
except ValueError:
nap_time = 60
while True:
start_time = time.time()
message_count = 0
try:
config = exchangelib.Configuration(credentials=creds,
**owaconfig['config'])
account = exchangelib.Account(config=config,
access_type=exchangelib.DELEGATE,
**owaconfig['account'])
except (exchangelib.errors.EWSError,
requests.exceptions.RequestException):
logger.exception('Failed authenticating to OWA365')
metrics.incr('owa_api_failure_count')
else:
logger.info('Receiving mail on behalf of %s',
owaconfig['account'].get('primary_smtp_address'))
message_count = poll(account, iris_client)
now = time.time()
run_time = now - start_time
logger.info(
'Last run took %2.f seconds and processed %s messages. Waiting %s seconds until next poll..',
run_time, message_count, nap_time)
metrics.set('uptime', now - boot_time)
metrics.emit()
sleep(nap_time)
def exchange_test_connect(address, password):
"""Tests Exchange connection with supplied credentials"""
logger.debug("Attempting Exchange login with user: %s" % (address))
try:
credentials = exchangelib.Credentials(address, password)
account = exchangelib.Account(address,
credentials=credentials,
autodiscover=True)
logger.debug("Connection successful")
return True, "Connection successful"
except Exception as e:
logger.debug("Connection unsuccessful: %s" % str(e))
return False, str(e)
def send_alert_email(public_ip, service_id, location, email_isp):
email_body = "Buna ziua, \n Nu ne mai raspunde routerul cu IP-ul: " + public_ip + "\n ServiceID: " + service_id + "\n Locatie: " + location + "\n Ne puteti ajuta va rugam cu o verificare ? \n P.S.: Va rugam sa raspundeti cu toti colegii din CC.\n O zi buna, \n NOC Team \n"
creds = E.Credentials(username=exchange_username, password=exchange_password)
config = E.Configuration(server=exchange_server, credentials=creds)
a = E.Account(primary_smtp_address=exchange_smtp_address, config=config, autodiscover=False, access_type=E.DELEGATE)
m = E.Message(
account=a,
subject='Router Down',
body=email_body,
to_recipients=email_isp,
cc_recipients=exchange_cc_recipients, # Simple strings work, too
)
m.send_and_save()
def __init__(self, username, password):
if isinstance(username, bytes):
username = username.decode()
if isinstance(password, bytes):
password = password.decode()
self.credentials = ex.Credentials(username, password)
self.config = ex.Configuration(server='outlook.office365.com',
credentials=self.credentials)
self.account = ex.Account(primary_smtp_address=username,
config=self.config,
autodiscover=False,
access_type=ex.DELEGATE)
self._inbox_all = []
def check_email():
creds = E.Credentials(username=exchange_username, password=exchange_password)
config = E.Configuration(server=exchange_server, credentials=creds)
account = E.Account(primary_smtp_address=exchange_smtp_address, config=config, autodiscover=False, access_type=E.DELEGATE) # logging onto Exchange
email_filtered = account.inbox.filter(subject__icontains="Devices up/down")
re_ip = re.compile("\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}")
if email_filtered.exists(): # if there are any e-mails for this filter
for i in email_filtered: # for each e-mail
#print(i.body)
ip = re.findall(re_ip,i.body)
for j in ip:
if not None:
email_filtered.delete()
return j
def send_zipped_file_exchange(zipped_file, recipients, sender, connect_params):
for param in ['host', 'sender', 'user', 'pass']:
assert param in connect_params, 'must specify mandatory parameter %s' % param
credentials = exchangelib.ServiceAccount(
username=connect_params['user'],
password=connect_params['pass']
)
print("creds are:\n%s" % credentials)
config = exchangelib.Configuration(
server=connect_params['host'],
credentials=credentials,
# version=version,
# auth_type=NTLM
)
print("config is:\n%s" % config)
account = exchangelib.Account(
primary_smtp_address=connect_params['sender'],
credentials=credentials,
autodiscover=False,
config=config,
access_type=exchangelib.DELEGATE
)
message = exchangelib.Message(
account=account,
subject='TEST: File %s' % zipped_file,
body='',
to_recipients=recipients
)
with open(zipped_file, 'w+') as zf:
attachment = exchangelib.FileAttachment(name=zipped_file, content=zf.read())
message.attach(attachment)
message.send_and_save()
def connect_ews(config):
domain = config.get('domain', None)
username = config.get('username', None)
email = config.get('email', None)
if username is not None and domain is not None:
username = f'{domain}\\{username}'
else:
username = f'{email}'
password = config.get('password', None)
if password is None:
password = keyring.get_password('ewsorgsync', username)
if password is None:
logging.error(
'Can\'t find password (neither in config nor in keychain)')
sys.exit(-1)
if domain is not None:
username = f'{domain}\\{username}'
else:
username = f'{email}'
cred = exlib.Credentials(username, password)
endpoint = config.get('endpoint', None)
server = config.get('server', None)
if endpoint is not None and server is not None:
logging.error(
'The server and endpoint options are mutually exclusive!')
sys.exit(-1)
elif endpoint is None and server is None:
logging.error('You must give either the server or endpoint option!')
sys.exit(-1)
conf = {'server': server, 'service_endpoint': endpoint}
ewsconf = exlib.Configuration(credentials=cred, **conf)
logging.debug('Connecting to endpoint')
acc = exlib.Account(primary_smtp_address=config['email'],
config=ewsconf,
default_timezone=exlib.EWSTimeZone.localzone(),
access_type=exlib.DELEGATE)
logging.debug('Refreshing folders')
acc.root.refresh()
return acc
def getEvents(VALUES):
"""get months events from exchange and write them to file"""
url = VALUES['owa']
# print(url)
username = VALUES['username']
password = VALUES['password']
BEFORE = VALUES['before']
FUTURE = VALUES['future']
try:
credentials = exchangelib.Credentials(username=username,
password=password)
config = exchangelib.Configuration(server=url, credentials=credentials)
account = exchangelib.Account(primary_smtp_address=username,
credentials=credentials,
config=config)
tz = exchangelib.EWSTimeZone.localzone()
right_now = tz.localize(exchangelib.EWSDateTime.now())
start = right_now - datetime.timedelta(days=7)
# print(start)
end = right_now + datetime.timedelta(days=7)
# print(end)
allEvents = account.calendar.view(start=start, end=end)
# for item in allEvents:
# local_start = item.start.astimezone(tz=tz)
# local_end = item.end.astimezone(tz=tz)
# print("{} start={} end={}".format(item.subject, local_start, local_end))
return allEvents
except:
print("username or password incorrect")
print("remember username should be in form of ")
print("-u <domain>\\\<username> or")
print("in config file user=<domain>\\<username>")
quit()
#!/usr/bin/env python3
import exchangelib
from string import Template
from os.path import basename
from modules import get_profile
import sys
email_config = get_profile.getProfile(items=['nhs'])
# set up connection to EWS
try:
c = exchangelib.Credentials(email_config['user'], email_config['password'])
a = exchangelib.Account('*****@*****.**',
credentials=c,
autodiscover=True)
except Exception as e:
print(e)
sys.exit(1)
def read_template(filename):
"""
Returns a Template object comprising the contents of the
file specified by filename.
"""
with open(filename, 'r', encoding='utf-8') as template_file:
template_file_content = template_file.read()
return Template(template_file_content)
def send_email(to,
# Created on 2018/2/
# from exchangelib import DELEGATE, Account, Credentials, Configuration, NTLM, Message, Mailbox, HTMLBody
# from exchangelib.protocol import BaseProtocol, NoVerifyHTTPAdapter
import exchangelib
# 此句用来消除ssl证书错误，exchange使用自签证书需加上
BaseProtocol.HTTP_ADAPTER_CLS = NoVerifyHTTPAdapter
# 输入你的域账号如example\leo
cred = exchangelib.Credentials(r'hywingroup\gjxx', 'hywin666')
config = exchangelib.Configuration(server='https://mail.hywingroup.com',
credentials=cred,
auth_type=exchangelib.NTLM)
a = exchangelib.Account(primary_smtp_address='*****@*****.**',
config=config,
autodiscover=False,
access_type=exchangelib.DELEGATE)
# 此处为用来发送html格式邮件的文件路径
# with open(r'D:\1.html') as f:
# msg = f.read().decode('utf-8')
m = exchangelib.Message(
account=a,
folder=a.sent,
subject=u'测试邮件',
body='ceshiyoujian',
to_recipients=[Mailbox(email_address='*****@*****.**')])
m.send_and_save()
logging.error("parameter " + parameter + " is not defined.")
sys.exit(1)
if not config["ssl_verify"]:
urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
exchangelib.BaseProtocol.HTTP_ADAPTER_CLS = exchangelib.NoVerifyHTTPAdapter
exchange_credentials = exchangelib.Credentials(username=config["username"],
password=config["password"])
exchange_config = exchangelib.Configuration(
server=config["server"], credentials=exchange_credentials)
exchange_account = exchangelib.Account(
primary_smtp_address=config["primary_smtp_address"],
config=exchange_config,
autodiscover=False,
access_type=exchangelib.DELEGATE)
exchange_account.public_folders_root.refresh()
public_folders_root = exchange_account.public_folders_root
target_folder = get_folder(config["target_path"], public_folders_root)
item = exchangelib.PostItem(account=exchange_account,
folder=target_folder,
subject=config["subject"])
item.author = config["author"]
item.save()
logging.info("Success")
sys.exit(0)
def authenticate(self, request, username, password):
"""
Check for the format of the username (``dom\\user`` vs ``user@dom``),
then authenticate, and if successful, get or create the user object and
return it.
"""
username = username.lower()
allowed_formats = get_setting('AUTH_EXCHANGE_ALLOWED_FORMATS')
if '\\' in username:
# assume dom\user
if 'netbios' not in allowed_formats: return None
netbios, user = username.rsplit('\\', 1)
try:
dom = get_setting(
'AUTH_EXCHANGE_NETBIOS_TO_DOMAIN_MAP')[netbios]
except KeyError:
dom = netbios
smtp = '{0}@{1}'.format(user, dom)
c_username = username
elif '@' in username:
# assume user@dom
if 'email' not in allowed_formats: return None
user, dom = username.rsplit('@', 1)
smtp = username
c_username = username
else:
# assume username only
if 'username' not in allowed_formats: return None
dom = get_setting('AUTH_EXCHANGE_DEFAULT_DOMAIN')
user = username
smtp = "{0}@{1}".format(user, dom)
if not '.' in dom:
c_username = "******".format(dom, user)
else:
c_username = "******".format(user, dom)
# check if domain is allowed
domains = get_setting('AUTH_EXCHANGE_DOMAIN_SERVERS')
if dom not in domains: return None
# authenticate against Exchange server
domain_server = domains.get(dom, 'autodiscover') or 'autodiscover'
cred = el.Credentials(username=c_username, password=password)
if domain_server == 'autodiscover':
acc_opts = {
'primary_smtp_address': smtp,
'credentials': cred,
'autodiscover': True,
'access_type': el.DELEGATE
}
try:
acc = el.Account(**acc_opts)
except (el.errors.UnauthorizedError, el.errors.AutoDiscoverFailed):
return None
else:
cfg_opts = {
'credentials': cred,
'server': domain_server,
}
try:
cfg = el.Configuration(**cfg_opts)
except (el.errors.UnauthorizedError, el.errors.AutoDiscoverFailed):
return None
acc_opts = {
'config': cfg,
'primary_smtp_address': smtp,
'credentials': cred,
'autodiscover': False,
'access_type': el.DELEGATE
}
try:
acc = el.Account(**acc_opts)
except (el.errors.UnauthorizedError, el.errors.AutoDiscoverFailed):
return None
if not acc: return None
# auth successful, get or create local user
try:
u = user_model.objects.get(**{username_field: c_username})
except user_model.DoesNotExist:
if self.create_unknown_user:
u = user_model.objects.create(**{username_field: c_username})
if DomainOrganization:
DomainOrganization.associate_new_user(u, dom)
else:
return None
# enforce domain user properties, if they exist, and save
user_properties = get_setting(
'AUTH_EXCHANGE_DOMAIN_USER_PROPERTIES').get(dom, {})
if user_properties:
for k, v in user_properties.items():
setattr(u, k, v)
if '.' in dom: setattr(u, u.get_email_field_name(), c_username)
u.save()
return u
