def __init__(self, credentials, user, export_path, mail_ending,
start_date=None, amqp_info=None):
logger.info('Start New MailboxScan: {}'.format(user))
exchange_credentials = ServiceAccount(username=credentials[0],
password=credentials[1])
username = user + mail_ending
self.start_date = start_date
if self.start_date is None:
self.export_path = Path(export_path + username)
else:
self.export_path = Path(export_path + username + '_' +
str(self.start_date))
self.current_path = None
self.actual_exported_mails = 0
self.amqp_info = amqp_info
self.amqp_data = amqp_info[2]
self.amqp_data['start_time'] = time.time()
self.update_amqp()
try:
self.account = Account(primary_smtp_address=username,
credentials=exchange_credentials,
autodiscover=True,
access_type=IMPERSONATION)
self.account.root.refresh()
logger.info('{}: Init complete'.format(username))
except ErrorNonExistentMailbox:
logger.error('No such user: {}'.format(username))
self.account = None
def get_account():
credentials = ServiceAccount(username=USERNAME, password=PASSWORD)
config = Configuration(server=SERVER, credentials=credentials)
return Account(primary_smtp_address=EMAIL,
config=config,
autodiscover=False,
access_type=DELEGATE)
def connect_test(password,
email,
access_type,
user=None,
win=None,
server=None,
*args,
**kwargs):
if user and win:
credentials = ServiceAccount(username="******".format(user, win),
password=password,
max_wait=__max_timeout__)
elif user and win is None:
credentials = ServiceAccount(username=user,
password=password,
max_wait=__max_timeout__)
else:
credentials = ServiceAccount(username=email,
password=password,
max_wait=__max_timeout__)
access_type = DELEGATE if "DELEGATE" in access_type else IMPERSONATION
if server:
config = Configuration(server=server, credentials=credentials)
user_account = Account(primary_smtp_address=email,
credentials=credentials,
autodiscover=False,
access_type=access_type,
config=config)
else:
user_account = Account(primary_smtp_address=email,
credentials=credentials,
autodiscover=True,
access_type=access_type)
ewl_url = user_account.protocol.service_endpoint
ews_auth_type = user_account.protocol.auth_type
primary_smtp_address = user_account.primary_smtp_address
return ewl_url, ews_auth_type, primary_smtp_address, user_account
def connect_to_server():
credentials = ServiceAccount(username='******',
password='******')
config = Configuration(server='win9595.tcsmfdm.com',
credentials=credentials)
account = Account(primary_smtp_address="*****@*****.**",
config=config,
autodiscover=False,
access_type=DELEGATE)
return account
def beforefetch(self):
self.usercreds = ServiceAccount(
username=self.userinfo[
'ServiceAccountEmail'], # Or [email protected] for O365
password=self.userinfo['ServiceAccountPassword'])
self.config = Configuration(server='outlook.office365.com',
credentials=self.usercreds)
emaillist = requests.get(config.API_ENDPOINT +
'api/metadata/emaillist?UserId=' +
str(self.userid))
emaillist = json.loads(emaillist.text)
self.__fetchmails(emaillist)
def __init__(self, username, password, smtp_address, server):
self.username = username
self.password = password
self.credentials = ServiceAccount(
username=self.username,
password=self.password)
self.config = Configuration(
server=server,
credentials=self.credentials)
self.account = Account(
primary_smtp_address=smtp_address,
config=self.config,
autodiscover=False,
access_type=DELEGATE)
def ews_smailer_error(subject, body):
def send_email(account, subject, body, recipients, attachments=None):
to_recipients = []
for recipient in recipients:
to_recipients.append(Mailbox(email_address=recipient))
#####Create message#####
m = Message(account=account,
folder=account.sent,
subject=subject,
body=body,
to_recipients=to_recipients)
#####attach files#####
for attachment_name, attachment_content in attachments or []:
file = FileAttachment(name=attachment_name,
content=attachment_content)
m.attach(file)
m.send_and_save()
logger.info("Email sent successfully")
##### Create and configure logger #####
logging.basicConfig(filename="newfile.log",
format='%(asctime)s %(message)s',
filemode='w')
##### Creating an object #####
logger = logging.getLogger()
##### Setting the threshold of logger to DEBUG #####
logger.setLevel(logging.DEBUG)
logger.info("Function for sending email for error reporting is called")
cfg = ConfigParser()
cfg.read("config.ini")
key = cfg['mail']['key']
key = bytes(key, 'utf-8')
passw = bytes(cfg['mail']['password'], 'utf-8')
print(type(key))
f = Fernet(key)
credentials = ServiceAccount(username=cfg['mail']['id'],
password=f.decrypt(passw).decode("utf-8"))
config = Configuration(server="outlook.office365.com",
credentials=credentials)
account = Account(primary_smtp_address=cfg['mail']['id'],
config=config,
autodiscover=False,
access_type=DELEGATE)
send_email(account, subject, body, [cfg['internal']['id']], attachments=[])
def connect(email,
password,
service_endpoint=None,
auth_type=None,
access_type=None,
user=None,
win_domain=None,
*args,
**kwargs):
access_type = DELEGATE if "DELEGATE" in access_type else IMPERSONATION
if user and win_domain:
creds = ServiceAccount(username="******".format(win_domain, user),
password=password,
max_wait=__max_timeout__)
elif user and win_domain is None:
creds = ServiceAccount(username=user,
password=password,
max_wait=__max_timeout__)
else:
creds = ServiceAccount(username=email,
password=password,
max_wait=__max_timeout__)
if access_type is not None and auth_type is not None and service_endpoint is not None:
conf = Configuration(service_endpoint=service_endpoint,
credentials=creds,
auth_type=auth_type)
account = Account(primary_smtp_address=email,
config=conf,
autodiscover=False,
access_type=access_type)
else:
account = Account(primary_smtp_address=email,
autodiscover=True,
credentials=creds)
return account
def initAccount():
global account
info = None
try:
info = getCouchDoc()
except Exception as e:
raise Exception("unable to get couch doc: {}".format(e))
uname = os.getenv("EXCHANGE_PROXY_USERNAME")
pw = os.getenv("EXCHANGE_PROXY_PASSWORD")
print("creating service account with uname: {}, password: {}".format(uname, pw))
credentials = ServiceAccount(username=uname, password=pw)
try:
resource = info["resource"]
if not resource:
raise Exception("resource not set in config doc")
autodiscover = info["autodiscover-url"]
if not autodiscover:
raise Exception("autodiscover-url not set in config doc")
access = info["access-type"]
if not access:
raise Exception("access-type not set in config doc")
except KeyError as e:
raise Exception("missing key {} in config doc".format(e))
except Exception as e:
raise Exception(e)
# split domain and resource id
split = resource.rsplit("@", 1)
if len(split) != 2 or not split[1]:
raise Exception("badly formatted resource (got: {}, expected: <resource_id>@<domain>)".format(resource))
accesstype = IMPERSONATION if access == 'impersonation' else DELEGATE
# populate autodiscover cache with correct server, because Office365 TLS cert is broken
# https://github.com/ecederstrand/exchangelib/issues/337
protocol = exchangelib.autodiscover.AutodiscoverProtocol(
service_endpoint=autodiscover,
credentials=credentials, auth_type='basic')
exchangelib.autodiscover._autodiscover_cache[(split[1], credentials)] = protocol
account = Account(primary_smtp_address=resource, credentials=credentials, autodiscover=True, access_type=accesstype)
print("Exchange account successfully set up")
def __init__(self, sensor_service, config):
super(ItemSensor, self).__init__(sensor_service=sensor_service, config=config)
self._logger = self.sensor_service.get_logger(name=self.__class__.__name__)
self._stop = False
self._store_key = 'exchange.item_sensor_date_str'
self._timezone = EWSTimeZone.timezone(config['timezone'])
self._credentials = ServiceAccount(
username=config['username'],
password=config['password'])
self.primary_smtp_address = config['primary_smtp_address']
self.sensor_folder = config['sensor_folder']
try:
self.server = config['server']
self.autodiscover = False
except KeyError:
self.autodiscover = True
def __init__(self, config):
super(BaseExchangeAction, self).__init__(config)
api_url = os.environ.get('ST2_ACTION_API_URL', None)
token = os.environ.get('ST2_ACTION_AUTH_TOKEN', None)
self.client = Client(api_url=api_url, token=token)
self._credentials = ServiceAccount(
username=config['username'],
password=config['password'])
self.timezone = EWSTimeZone.timezone(config['timezone'])
try:
server = config['server']
autodiscover = False
except KeyError:
autodiscover = True
cache = self._get_cache()
if cache:
config = Configuration(
service_endpoint=cache.ews_url,
credentials=self._credentials,
auth_type=cache.ews_auth_type)
self.account = Account(
primary_smtp_address=cache.primary_smtp_address,
config=config,
autodiscover=False,
access_type=DELEGATE
)
else:
if autodiscover:
self.account = Account(
primary_smtp_address=config['primary_smtp_address'],
credentials=self._credentials,
autodiscover=autodiscover,
access_type=DELEGATE)
else:
config = Configuration(
server=server,
credentials=self._credentials)
self.account = Account(
primary_smtp_address=config['primary_smtp_address'],
config=config,
autodiscover=False,
access_type=DELEGATE)
self._store_cache_configuration()
def __init__(self, email, server, username, password, forward_email=None, enableFaultTolerance=False):
if enableFaultTolerance:
credentials = ServiceAccount(
username=username,
password=password
)
else:
credentials = Credentials(
username=username,
password=password
)
self.account = Account(
primary_smtp_address=email,
config=Configuration(
server=server,
credentials=credentials,
),
autodiscover=False,
access_type=DELEGATE,
)
self.forward_email = forward_email
images_Directory = "/home/pi/Pictures"
replacements_Directory = "/home/pi/Pictures/Replacements"
# pulls all image files and dates to the images dict from the data.py file
images = catalog
# variables
failed_body = "There was an error fulfilling your request. be sure to check the formatting of your " \
"subject line and that the date is not passed or improperly formatted. Format should be date in XX/XX/XXXX" \
"\nExample: 02/12/2099" \
"\n\nFor list of files and their names, send a message or reply to this message with the subject line 'files'\n" \
"If the file youre attempting to update is not in that list of files it cannot be added or updated at this time."
update_success = "The requested changes have been made"
noAttachment_body = "There was an error fulfilling your request. There was no attached image to update."
# exchangelib login's
credentials = ServiceAccount(username='******',
password='******')
account = Account(primary_smtp_address='*****@*****.**',
credentials=credentials,
autodiscover=True,
access_type=DELEGATE)
# send messages...
def sendMessage(recipient, subject, body):
try:
m = Message(account=account,
folder=account.sent,
subject=subject,
body=body,
to_recipients=[Mailbox(email_address=recipient)])
except Exception as e:
def getEmailObject(email_username,email_password,email_server,email_smtp):
credentials = ServiceAccount(username=email_username, password=email_password)
config = Configuration(server=email_server, credentials=credentials)
account = Account(primary_smtp_address=email_smtp, config=config, autodiscover=False, access_type=DELEGATE)
return account
password = os.environ.get("EXCHANGE_PASSWORD")
username = os.environ.get("EXCHANGE_USERNAME")
outgoing_email_address = os.environ.get("EXCHANGE_OUTGOING_ADDRESS")
soundfile = os.environ.get("NOTIFICATION_SOUND")
exchange_server = os.environ.get("EXCHANGE_SERVER")
if soundfile != "":
# load a sound file
pygame.mixer.pre_init()
else:
print("Skipping loading of soundfile")
print("Initiating connection to exchange...")
# If you want to enable the fault tolerance, create credentials as a service account instead:
credentials = ServiceAccount(username=username, password=password)
# Set up a target account and do an autodiscover lookup to find the target EWS endpoint:
account = Account(primary_smtp_address=outgoing_email_address, credentials=credentials,
autodiscover=True, access_type=DELEGATE)
config = Configuration(server=exchange_server, credentials=credentials, auth_type=NTLM)
last_number_of_emails = account.inbox.unread_count
print("Waiting for emails... Press CTRL+C to stop")
try:
while True:
# Update the counters
account.inbox.refresh()
def get_accounts(logger=None, **config):
"""
get a list of working Exchange accounts
This function expects that each Exchange account is described by the
``config`` argument as shown in the ``JSON`` snippet below.
A full representation of the structure of the ``config`` argument as
used in the :ref:`Mail Borg Client Application` is available in the
:ref:`borg_client_config` section.
.. code-block:: json
{
"smtp_address":"*****@*****.**",
"domain_account":
{
"domain":"PHSABC",
"username":"******",
"password":"******"
},
"exchange_autodiscover":true,
"autodiscover_server":null
}
:arg dict config:
a :class:`dictionary <dict>` that matches the structure described in
:ref:`borg_client_config` (or the relevant portions thereof)
As used in the :ref:`Mail Borg Client Application`, the ``config``
argument is provided via an :attr:`WitnessMessages.config` instance
attribute
:arg logger:
logging facility; Usually provided by the caller the logger
data is provided by the calling function but this function is capable
of creating a :class:`_Logger` instance if needed
:type logger: :class:`_Logger`
:returns:
:class:`list` of :class:`exchangelib.Account` objects
An :class:`exchangelib.Account` object is only created if this
module was able to connect to the EWS end point using the provided
credentials.
If an Exchange account entry in the ``config`` argument cannot be used
to create a valid :class:`exchangelib.Account` instance, an error
will be logged and there will be no matching entry in the return.
If none of the Exchange account entries in the ``config`` argument can
be used to create a valid :class:`exchangelib.Account` instance,
an error will be logged and the function will return ``None``
"""
if not config:
config = load_config()
if logger is None:
logger = _Logger()
accounts = []
exchange_accounts = config.get('exchange_client_config').\
get('exchange_accounts')
for exchange_account in exchange_accounts:
if not validate_email_to_ascii(
exchange_account.get('smtp_address'), logger=logger, **config):
continue
credentials = ServiceAccount(
username='******'.format(
exchange_account.get('domain_account').get('domain'),
exchange_account.get('domain_account').get('username')),
password=exchange_account.get('domain_account').get('password'))
exc_config = None
if not exchange_account.get('exchange_autodiscover', True):
exc_config = Configuration(
server=exchange_account.get('autodiscover_server'),
credentials=credentials)
try:
if exchange_account.get('exchange_autodiscover', True):
accounts.append(
Account(primary_smtp_address=exchange_account.get(
'smtp_address'),
credentials=credentials,
autodiscover=True,
access_type=DELEGATE))
else:
accounts.append(
Account(primary_smtp_address=exchange_account.get(
'smtp_address'),
config=exc_config,
autodiscover=False,
access_type=DELEGATE))
logger.info(
dict(
type='connection',
status='PASS',
wm_id=config.get('wm_id'),
message='connected to exchange',
account='{}\\{}, {}'.format(
exchange_account.get('domain_account').get('domain'),
exchange_account.get('domain_account').get('username'),
exchange_account.get('smtp_address'))))
except Exception as err: # pylint: disable=broad-except
logger.err(
dict(
type='connection',
status='FAIL',
wm_id=config.get('wm_id'),
message='cannot connect to exchange',
account='{}\\{}, {}'.format(
exchange_account.get('domain_account').get('domain'),
exchange_account.get('domain_account').get('username'),
exchange_account.get('smtp_address')),
exeption=str(err)))
if not accounts:
logger.err(
dict(type='configuration',
status='FAIL',
wm_id=config.get('wm_id'),
account=None,
message=(
'no valid exchange account found in config for bot %s' %
config.get('host_name'))))
return None
return accounts
from exchangelib import Account, DELEGATE, Configuration, ServiceAccount
from exchangelib.protocol import BaseProtocol, NoVerifyHTTPAdapter
import urllib3
from bs4 import BeautifulSoup
from slack import slack_integration
import schedule
import time
import re
from bean import mail_bean
import methods
urllib3.disable_warnings()
BaseProtocol.HTTP_ADAPTER_CLS = NoVerifyHTTPAdapter
credentials = ServiceAccount(username='******',
password='******')
config = Configuration(server='win9595.tcsmfdm.com', credentials=credentials)
account = Account(primary_smtp_address="*****@*****.**",
config=config,
autodiscover=False,
access_type=DELEGATE)
def extract_new_structured_email():
for new_structured_email in account.inbox.filter(
is_read=False, subject__istartswith='[EXTERNAL] ALARM:'):
subject_email = new_structured_email.subject
from_email = new_structured_email.sender.email_address
date_email = new_structured_email.datetime_received
from exchangelib import DELEGATE, Account, ServiceAccount, EWSDateTime, EWSTimeZone, CalendarItem, Configuration
import datetime
import time
from twilio.rest import Client
import html
# Twilio Credentials
account_sid = "#########"
auth_token = "#########"
client = Client(account_sid, auth_token)
# Exchange Credentials
credentials = ServiceAccount(username='******', password='******')
account = Account(primary_smtp_address='#########"',
credentials=credentials,
autodiscover=True,
access_type=DELEGATE)
# Cache Exchange Credentials. This prevents server timeout
ews_url = account.protocol.service_endpoint
ews_auth_type = account.protocol.auth_type
primary_smtp_address = account.primary_smtp_address
config = Configuration(service_endpoint=ews_url,
credentials=credentials,
auth_type=ews_auth_type)
# Create account
myaccount = Account(primary_smtp_address=primary_smtp_address,
config=config,
autodiscover=False,
to_recipients.append(Mailbox(email_address=recipient))
# Create message
m = Message(account=account,
folder=account.sent,
subject=subject,
body=body,
to_recipients=to_recipients)
# attach files
for attachment_name, attachment_content in attachments or []:
file = FileAttachment(name=attachment_name, content=attachment_content)
m.attach(file)
m.send_and_save()
credentials = ServiceAccount(username=cfg['user'], password=cfg['password'])
config = Configuration(server=cfg['server'], credentials=credentials)
account = Account(primary_smtp_address=cfg['smtp_address'],
config=config,
autodiscover=False,
access_type=DELEGATE)
# Read attachment
attachments = []
with open('filestorage/numbers-test-document.pdf', 'rb') as f:
content = f.read()
attachments.append(('whatever.pdf', content))
# Send email
send_email(account,
except FileNotFoundError:
print(
'Copy settings.yml.sample to settings.yml and enter values for your test server'
)
raise
categories = ['perftest']
tz = EWSTimeZone.timezone('America/New_York')
verify_ssl = settings.get('verify_ssl', True)
if not verify_ssl:
from exchangelib.protocol import BaseProtocol, NoVerifyHTTPAdapter
BaseProtocol.HTTP_ADAPTER_CLS = NoVerifyHTTPAdapter
config = Configuration(server=settings['server'],
credentials=ServiceAccount(settings['username'],
settings['password']))
print('Exchange server: %s' % config.protocol.server)
account = Account(config=config,
primary_smtp_address=settings['account'],
access_type=DELEGATE)
# Remove leftovers from earlier tests
account.calendar.filter(categories__contains=categories).delete()
# Calendar item generator
def generate_items(count):
start = tz.localize(EWSDateTime(2000, 3, 1, 8, 30, 0))
end = tz.localize(EWSDateTime(2000, 3, 1, 9, 15, 0))
tpl_item = CalendarItem(
def ews_smailer(email, filename, list):
def send_email(account, subject, body, recipients, attachments=None):
to_recipients = []
for recipient in recipients:
to_recipients.append(Mailbox(email_address=recipient))
#####Create message#####
m = Message(account=account,
folder=account.sent,
subject=subject,
body=body,
to_recipients=to_recipients)
#####attach files#####
for attachment_name, attachment_content in attachments or []:
file = FileAttachment(name=attachment_name,
content=attachment_content)
m.attach(file)
m.send_and_save()
logger.info("Email sent successfully")
##### Create and configure logger #####
logging.basicConfig(filename="newfile.log",
format='%(asctime)s %(message)s',
filemode='w')
##### Creating an object #####
logger = logging.getLogger()
##### Setting the threshold of logger to DEBUG #####
logger.setLevel(logging.DEBUG)
logger.info("Function for sending email is called")
cfg = ConfigParser()
cfg.read("config.ini")
key = cfg['mail']['key']
key = bytes(key, 'utf-8')
print(type(key))
passw = bytes(cfg['mail']['password'], 'utf-8')
f = Fernet(key)
print(f.decrypt(cfg['mail']['password']).decode("utf-8"))
credentials = ServiceAccount(username=cfg['mail']['id'],
password=f.decrypt(passw).decode("utf-8"))
config = Configuration(server="outlook.office365.com",
credentials=credentials)
account = Account(primary_smtp_address=cfg['mail']['id'],
config=config,
autodiscover=False,
access_type=DELEGATE)
#####Read attachment#####
attachments = []
filename = filename + ".xlsx"
with open(filename, 'rb') as f:
content = f.read()
attachments.append((filename, content))
#####Send email#####
body = '''
Hello,
Please find attached the utilization report of RBA script of\n
PU : ''' + list[0] + '''
DU : ''' + list[1] + '''
Account : ''' + list[2] + '''
Script name. : ''' + filename + '''
Thank You.
Regards
RBA Utilization Reporter Team
Incase of any quesries contact us at [email protected]
'''
subject = "RBA Utilization Report - " + list[0] + "-" + list[
1] + "-" + list[2] + "-" + filename
send_email(account, subject, body, [email], attachments=attachments)
