def _exchange_create_meeting_function(self, event, *args, **kwargs):
"""Function: Creates a meeting and sends out invitation to required attendees and optional attendees."""
try:
# Get the function parameters:
exchange_email = kwargs.get("exchange_email") # text
exchange_meeting_start_time = kwargs.get(
"exchange_meeting_start_time") # datetimepicker
exchange_meeting_end_time = kwargs.get(
"exchange_meeting_end_time") # datetimepicker
exchange_meeting_subject = kwargs.get(
"exchange_meeting_subject") # text
exchange_meeting_body = kwargs.get("exchange_meeting_body") # text
exchange_required_attendees = kwargs.get(
"exchange_required_attendees") # text
exchange_optional_attendees = kwargs.get(
"exchange_optional_attendees") # text
log = logging.getLogger(__name__)
log.info("exchange_email: %s", exchange_email)
log.info("exchange_meeting_start_time: %s",
exchange_meeting_start_time)
log.info("exchange_meeting_end_time: %s",
exchange_meeting_end_time)
log.info("exchange_meeting_subject: %s", exchange_meeting_subject)
log.info("exchange_meeting_body: %s", exchange_meeting_body)
log.info("exchange_required_attendees: %s",
exchange_required_attendees)
log.info("exchange_optional_attendees: %s",
exchange_optional_attendees)
# Initialize utils
utils = exchange_utils(self.options)
# Create meeting
meeting = utils.create_meeting(
exchange_email, exchange_meeting_start_time,
exchange_meeting_end_time, exchange_meeting_subject,
exchange_meeting_body, exchange_required_attendees,
exchange_optional_attendees)
yield StatusMessage("Successfully connected to %s" %
exchange_email)
# Send out meeting
yield StatusMessage("Sending out meeting")
meeting.save(send_meeting_invitations=SEND_TO_ALL_AND_SAVE_COPY)
results = {
'required_attendees': exchange_required_attendees,
'optional_attendees': exchange_optional_attendees,
'sender': exchange_email,
'subject': exchange_meeting_subject,
'body': exchange_meeting_body,
'start_time': exchange_meeting_start_time,
'end_time': exchange_meeting_end_time
}
# Produce a FunctionResult with the results
yield FunctionResult(results)
except Exception:
yield FunctionError()
def _exchange_move_folder_contents_and_delete_folder_function(self, event, *args, **kwargs):
"""Function: """
try:
# Get the function parameters:
exchange_email = kwargs.get("exchange_email") # text
exchange_delete_if_no_subfolders = kwargs.get("exchange_delete_if_no_subfolders") # boolean
exchange_folder_path = kwargs.get("exchange_folder_path") # text
exchange_destination_folder_path = kwargs.get("exchange_destination_folder_path") # text
log = logging.getLogger(__name__)
# Use default connection email if one was not specified
if exchange_email is None:
exchange_email = self.options.get('email')
log.info('No connection email was specified, using value from config file')
log.info("exchange_delete_emails_if_no_subfolders: %s" % exchange_delete_if_no_subfolders)
log.info("exchange_email: %s" % exchange_email)
log.info("exchange_folder_path: %s" % exchange_folder_path)
log.info("exchange_destination_folder_path: %s" % exchange_destination_folder_path)
# Initialize utils
utils = exchange_utils(self.options)
# Get folders
from_folder = utils.go_to_folder(exchange_email, exchange_folder_path)
to_folder = utils.go_to_folder(exchange_email, exchange_destination_folder_path)
if exchange_delete_if_no_subfolders:
if from_folder.child_folder_count != 0:
raise FunctionError('%s has subfolders' % exchange_folder_path)
else:
queryset = from_folder.all()
else:
queryset = utils.get_emails(exchange_email, folder_path=exchange_folder_path, search_subfolders=True)
# Get items before moving
yield StatusMessage("Getting items")
results = utils.create_email_function_results(queryset)
# Move items
yield StatusMessage("Moving items")
item_count = queryset.count()
for item in queryset:
item.move(to_folder)
# Delete folder
yield StatusMessage("Deleting folder %s" % exchange_folder_path)
from_folder.delete()
yield StatusMessage("%s deleted, %d items moved" % (exchange_folder_path, item_count))
# Produce a FunctionResult with the results
yield FunctionResult(results)
except Exception:
yield FunctionError()
def test_go_to_folder(self, connect_to_account):
"""Testing go_to_folder"""
# Create a mock account and mock root folder with subfolders:
# root - 1
# - 2 - 2_1, 2_2
test_root = MockFolder(
'root', {
'1':
MockFolder('1', {}),
'2':
MockFolder(
'2', {
'2_1':
MockFolder('2_1', {}),
'2_2':
MockFolder('2_2', {'2_2_1': MockFolder('2_2_1', {})})
})
})
connect_to_account.return_value = MockAccount(test_root)
test_utils = exchange_utils(MOCK_OPTS, MOCK_INT_OPTS)
# Check when go to folder that doesn't exist appropriate error is raised
with pytest.raises(FolderError):
test_utils.go_to_folder('mockemail', '3')
# First level navigatino check - root/1
test1 = test_utils.go_to_folder('mockemail', '1')
assert test1 == test_root._subfolders['1']
# Two level navigation check - root/1/1_1
with pytest.raises(FolderError):
test_utils.go_to_folder('mockemail', '1/1_1')
# First level navigation check - root/2
test2 = test_utils.go_to_folder('mockemail', '2')
assert test2 == test_root._subfolders['2']
# Two level navigation check - root/2/2_1
test2_1 = test_utils.go_to_folder('mockemail', '2/2_1')
assert test2_1 == test_root._subfolders['2']._subfolders['2_1']
# Two level navigation check - root/2/2_2
test2_2 = test_utils.go_to_folder('mockemail', '2/2_2')
assert test2_2 == test_root._subfolders['2']._subfolders['2_2']
# Three level navigation check - root/2/2_2/2_2_1
test2_2_1 = test_utils.go_to_folder('mockemail', '2/2_2/2_2_1')
assert test2_2_1 == test_root._subfolders['2']._subfolders[
'2_2']._subfolders['2_2_1']
def _exchange_send_email_function(self, event, *args, **kwargs):
"""Function: """
try:
# Get the function parameters:
exchange_email = kwargs.get("exchange_email") # text
exchange_message_subject = kwargs.get(
"exchange_message_subject") # text
exchange_message_body = kwargs.get("exchange_message_body") # text
exchange_emails = kwargs.get("exchange_emails") # text
log = logging.getLogger(__name__)
if exchange_email is None:
exchange_email = self.options.get('email')
log.info(
'No connection email was specified, using value from config file'
)
log.info("exchange_email: %s" % exchange_email)
log.info("exchange_message_subject: %s" % exchange_message_subject)
log.info("exchange_message_body: %s" % exchange_message_body)
log.info("exchange_emails: %s" % exchange_emails)
# Initialize utils
utils = exchange_utils(self.options)
# Get sender account
email = utils.create_email_message(exchange_email,
exchange_message_subject,
exchange_message_body,
exchange_emails)
yield StatusMessage("Successfully connected to %s" %
exchange_email)
# Send email
yield StatusMessage("Sending email")
email.send_and_save()
yield StatusMessage("Email sent")
results = {
'recipients': exchange_emails,
'sender': exchange_email,
'subject': exchange_message_subject,
'body': exchange_message_body
}
# Produce a FunctionResult with the results
yield FunctionResult(results)
except Exception:
yield FunctionError()
def test_create_meeting(self, connect_to_account):
"""Testing create meeting"""
test_utils = exchange_utils(MOCK_OPTS, MOCK_INT_OPTS)
mock_account = MockAccount(MockFolder('root', {}))
connect_to_account.return_value = mock_account
# Check parameters and that optional_attendees handles None properly
meeting1 = test_utils.create_meeting('mockemail', 1000000, 1100000,
'subject1', 'body1',
'[email protected],[email protected]',
None)
assert meeting1.account == mock_account
assert meeting1.folder == mock_account.calendar
assert meeting1.subject == 'subject1'
assert meeting1.body == 'body1'
assert meeting1.required_attendees == [
'*****@*****.**', '*****@*****.**'
]
assert meeting1.optional_attendees == None
# Check parameters and that required_attendees handles None properly
meeting2 = test_utils.create_meeting('mockemail', 1000000, 1100000,
'qwer', 'tuio', None,
'[email protected],[email protected]')
assert meeting2.account == mock_account
assert meeting2.folder == mock_account.calendar
assert meeting2.subject == 'qwer'
assert meeting2.body == 'tuio'
assert meeting2.required_attendees == None
assert meeting2.optional_attendees == ['*****@*****.**', '*****@*****.**']
# General use test
meeting3 = test_utils.create_meeting('mockemail', 1000000, 1100000,
None, None,
'[email protected],[email protected]',
'[email protected],[email protected]')
assert meeting3.account == mock_account
assert meeting3.folder == mock_account.calendar
assert meeting3.subject == None
assert meeting3.body == None
assert meeting3.required_attendees == [
'*****@*****.**', '*****@*****.**'
]
assert meeting3.optional_attendees == ['*****@*****.**', '*****@*****.**']
def test_create_email_message(self, connect_to_account):
"""Testing create_email_message"""
test_utils = exchange_utils(MOCK_OPTS, MOCK_INT_OPTS)
mock_account = MockAccount(MockFolder('root', {}))
connect_to_account.return_value = mock_account
# Input parameters
test_account1 = mock_account
test_subject1 = 'subject1'
test_body1 = 'body1'
test_to_recipients1 = '*****@*****.**'
# Check returned object has correct parameters
email1 = test_utils.create_email_message(test_account1, test_subject1,
test_body1,
test_to_recipients1)
assert email1.account == mock_account
assert email1.folder == mock_account.sent
assert email1.subject == 'subject1'
assert email1.body == "<html><body>body1</body></html>"
assert email1.to_recipients == ['*****@*****.**']
# More input parameters
test_account2 = mock_account
test_subject2 = None
test_body2 = None
test_to_recipients2 = '[email protected],[email protected]'
# Check input parameters correctly assign None
email2 = test_utils.create_email_message(test_account2, test_subject2,
test_body2,
test_to_recipients2)
assert email2.account == mock_account
assert email2.folder == mock_account.sent
assert email2.subject == None
assert email2.body == "<html><body>None</body></html>"
assert email2.to_recipients == ['*****@*****.**', '*****@*****.**']
def _exchange_get_mailbox_info_function(self, event, *args, **kwargs):
"""Function: Get mailbox info from exchange"""
try:
# Get the function parameters:
log = logging.getLogger(__name__)
get_user = kwargs.get('exchange_get_email')
log.info("exchange_get_email: %s" % get_user)
# Initialize utils
utils = exchange_utils(self.options, self.opts)
# Connect to server
username = self.options.get("email")
yield StatusMessage("Getting mailbox info for %s" % get_user)
account = utils.connect_to_account(username)
# Get mailbox info
info = account.protocol.resolve_names([get_user])
if len(info) == 1:
info = info[0]
results = {
"name": info.name,
"email_address": info.email_address,
"routing_type": info.routing_type,
"mailbox_type": info.mailbox_type,
"success": True
}
else:
results = {"success": False}
yield StatusMessage("No mailbox found for %s" % get_user)
yield StatusMessage("Done getting mailbox info")
# Produce a FunctionResult with the results
yield FunctionResult(results)
except Exception:
yield FunctionError()
def selftest_function(opts):
"""
Simple test to confirm access to Miscrosoft Exchange API connectivity.
"""
options = opts.get("fn_exchange", {})
username = options.get("email")
try:
# Initialize utils
utils = exchange_utils(options)
# Connect to server
account = utils.connect_to_account(username)
# Get mailbox info
info = account.protocol.resolve_names([username])
if isinstance(info, list) and info[0].email_address == username:
return {"state": "success"}
else:
return {"state": "failure"}
except Exception as e:
return {"state": "failure", "status_code": e}
def _exchange_delete_emails_function(self, event, *args, **kwargs):
"""Function: Delete emails with the specified parameters"""
try:
# Get the function parameters:
exchange_email = kwargs.get("exchange_email") # text
exchange_folder_path = kwargs.get("exchange_folder_path") # text
exchange_hard_delete = kwargs.get(
"exchange_hard_delete") # boolean
exchange_email_ids = kwargs.get("exchange_email_ids") # text
exchange_sender = kwargs.get("exchange_sender") # text
exchange_message_subject = kwargs.get(
"exchange_message_subject") # text
exchange_message_body = kwargs.get("exchange_message_body") # text
exchange_start_date = kwargs.get(
"exchange_start_date") # datepicker
exchange_end_date = kwargs.get("exchange_end_date") # datepicker
exchange_has_attachments = kwargs.get(
"exchange_has_attachments") # boolean
exchange_order_by_recency = kwargs.get(
"exchange_order_by_recency") # boolean
exchange_num_emails = kwargs.get("exchange_num_emails") # int
exchange_search_subfolders = kwargs.get(
"exchange_search_subfolders") # boolean
log = logging.getLogger(__name__)
if exchange_folder_path is None:
exchange_folder_path = self.options.get('default_folder_path')
log.info(
'No folder path was specified, using value from config file'
)
log.info("exchange_email: %s" % exchange_email)
log.info("exchange_folder_path: %s" % exchange_folder_path)
log.info("exchange_hard_delete: %s" % exchange_hard_delete)
log.info("exchange_email_ids: %s" % exchange_email_ids)
log.info("exchange_sender: %s" % exchange_sender)
log.info("exchange_message_subject: %s" % exchange_message_subject)
log.info("exchange_message_body: %s" % exchange_message_body)
log.info("exchange_start_date: %s" % exchange_start_date)
log.info("exchange_end_date: %s" % exchange_end_date)
log.info("exchange_has_attachments: %s" % exchange_has_attachments)
log.info("exchange_order_by_recency: %s" %
exchange_order_by_recency)
log.info("exchange_num_emails: %s" % exchange_num_emails)
log.info("exchange_search_subfolders: %s" %
exchange_search_subfolders)
# Initialize utils
utils = exchange_utils(self.options, self.opts)
# Find emails
yield StatusMessage("Finding emails")
emails = utils.get_emails(
exchange_email, exchange_folder_path, exchange_email_ids,
exchange_sender, exchange_message_subject,
exchange_message_body, exchange_start_date, exchange_end_date,
exchange_has_attachments, exchange_order_by_recency,
exchange_num_emails, exchange_search_subfolders)
yield StatusMessage("Done finding emails")
# Get function results
results = utils.create_email_function_results(emails)
num_deleted = emails.count()
# Delete Emails
yield StatusMessage("Deleting emails")
if exchange_hard_delete:
emails.delete()
else:
for item in emails:
item.move_to_trash()
yield StatusMessage("Done deleting emails, %d emails deleted" %
num_deleted)
# Produce a FunctionResult with the results
yield FunctionResult(results)
except Exception:
yield FunctionError()
def test_create_email_function_results(self):
"""Testing create_email_function_results"""
test_utils = exchange_utils(MOCK_OPTS, MOCK_INT_OPTS)
# Test when no results are returned
emails1 = test_utils.create_email_function_results([])
emails1_results = {'email_ids': [], 'emails': {}}
assert emails1 == emails1_results
# Test one email with no attachments
emails2 = [
MockEmail('1', 'Subject 1', 'Body',
MockSender('Sen Der1', '*****@*****.**'), [],
b'abc')
]
emails2_output = test_utils.create_email_function_results(emails2)
emails2_results = {
'email_ids': ['1'],
'emails': {
'1': {
'subject': 'Subject 1',
'body': 'Body',
'sender_name': 'Sen Der1',
'sender_email': '*****@*****.**',
'attachment_ids': [],
'attachments': {},
'mime_content': 'abc'
}
}
}
assert emails2_output == emails2_results
# Test two emails, one with attachments and one without
emails3 = emails2 + [
MockEmail(
'weio', 'nzxcv', 'vds',
MockSender('FIRST LAST', '*****@*****.**'), [
MockAttachment(MockAttachmentId('22'), 'ATTCH',
'spreadsheet', 12, str.encode('encode me'))
], b'def')
]
emails3_output = test_utils.create_email_function_results(emails3)
emails3_results = {
'email_ids': ['1', 'weio'],
'emails': {
'1': {
'subject': 'Subject 1',
'body': 'Body',
'sender_name': 'Sen Der1',
'sender_email': '*****@*****.**',
'attachment_ids': [],
'attachments': {},
'mime_content': 'abc'
},
'weio': {
'subject': 'nzxcv',
'body': 'vds',
'sender_name': 'FIRST LAST',
'sender_email': '*****@*****.**',
'attachment_ids': ['22'],
'attachments': {
'22': {
'attachment_name': 'ATTCH',
'attachment_content_type': 'spreadsheet',
'attachment_size': 12,
'attachment_base64': 'ZW5jb2RlIG1l'
}
},
'mime_content': 'def'
}
}
}
assert emails3_output == emails3_results
# Test that function results only include email items
emails4 = emails3 + [2, 'not an email', True]
emails4_output = test_utils.create_email_function_results(emails4)
assert emails4_output == emails3_results
def test_get_email(self, connect_to_account):
"""Testing get_email"""
# Initialize testing variables with Mock objects
# Mocked account and mocked root with subfolders
opts = MOCK_OPTS
opts_int = MOCK_INT_OPTS
opts['default_folder_path'] = '1'
test_utils = exchange_utils(opts, opts_int)
mock_account = MockAccount(None)
test_root = MockFolder(
'root', {
'1':
MockFolder('1', {}, mock_account),
'2':
MockFolder(
'2', {
'2_1':
MockFolder('2_1', {}, mock_account),
'2_2':
MockFolder(
'2_2',
{'2_2_1': MockFolder('2_2_1', {}, mock_account)},
mock_account)
}, mock_account)
}, mock_account)
rsf = test_root._subfolders
mock_account.set_root(test_root)
connect_to_account.return_value = mock_account
# Sender filter check
emails1 = test_utils.get_emails('mockemail', sender='testsender')
assert emails1.folder_collection == FolderCollection(
account=mock_account, folders=[rsf['1']])
assert emails1.q == Q(sender='testsender')
# Multiple folder check with sender
emails2 = test_utils.get_emails('mockemail',
folder_path='1,2',
sender='another sender')
assert emails2.folder_collection == FolderCollection(
account=mock_account, folders=[rsf['1'], rsf['2']])
assert emails2.q == Q(sender='another sender')
# Subject filter check
emails3 = test_utils.get_emails('mockemail', subject='subject')
assert emails3.folder_collection == FolderCollection(
account=mock_account, folders=[rsf['1']])
assert emails3.q == Q(subject__contains='subject')
# Body filter check
emails4 = test_utils.get_emails('mockemail', body='body')
assert emails4.folder_collection == FolderCollection(
account=mock_account, folders=[rsf['1']])
assert emails4.q == Q(body__contains='body')
# Email id filter check
emails5 = test_utils.get_emails('mockemail', email_ids='id1,id2,idN')
assert emails5.folder_collection == FolderCollection(
account=mock_account, folders=[rsf['1']])
assert emails5.q == Q(message_id='id1') | Q(message_id='id2') | Q(
message_id='idN')
# has_attachments filter check
emails6 = test_utils.get_emails('mockemail', has_attachments=True)
assert emails6.folder_collection == FolderCollection(
account=mock_account, folders=[rsf['1']])
assert emails6.q == Q(has_attachments=True)
# search_subfolders filter check
with patch.object(Folder, 'walk') as walk:
walk.return_value = test_root._subfolders['2']
emails7 = test_utils.get_emails('mockemail',
folder_path='2',
search_subfolders=True)
fc_expected = FolderCollection(folders=[rsf['2']],
account=mock_account)
assert emails7.folder_collection.folders == fc_expected.folders
assert emails7.folder_collection.account == fc_expected.account
assert emails7.q == Q()
emails8 = test_utils.get_emails('mockemail',
folder_path='1',
sender='sender',
subject='subject',
body='body',
has_attachments=False)
assert emails8.folder_collection == FolderCollection(
account=mock_account, folders=[rsf['1']])
print(emails8.q)
print(
Q(sender='sender',
subject__contains='subject',
body__contains='body',
has_attachments=False))
assert emails8.q == Q(sender='sender') & Q(subject__contains='subject') \
& Q(body__contains='body') & Q(has_attachments=False)
def _exchange_move_emails_function(self, event, *args, **kwargs):
"""Function: """
try:
# Get the function parameters:
exchange_email = kwargs.get("exchange_email") # text
exchange_folder_path = kwargs.get("exchange_folder_path") # text
exchange_destination_folder_path = kwargs.get(
"exchange_destination_folder_path") # text
exchange_email_ids = kwargs.get("exchange_email_ids") # text
exchange_sender = kwargs.get("exchange_sender") # text
exchange_message_subject = kwargs.get(
"exchange_message_subject") # text
exchange_message_body = kwargs.get("exchange_message_body") # text
exchange_start_date = kwargs.get(
"exchange_start_date") # datepicker
exchange_end_date = kwargs.get("exchange_end_date") # datepicker
exchange_has_attachments = kwargs.get(
"exchange_has_attachments") # boolean
exchange_order_by_recency = kwargs.get(
"exchange_order_by_recency") # boolean
exchange_num_emails = kwargs.get("exchange_num_emails") # int
exchange_search_subfolders = kwargs.get(
"exchange_search_subfolders") # boolean
log = logging.getLogger(__name__)
# Use default connection email if one was not specified
if exchange_folder_path is None:
exchange_folder_path = self.options.get('default_folder_path')
log.info(
'No from folder path was specified, using value from config file'
)
log.info("exchange_email: %s" % exchange_email)
log.info("exchange_folder_path: %s" % exchange_folder_path)
log.info("exchange_destination_folder_path: %s" %
exchange_destination_folder_path)
log.info("exchange_email_ids: %s" % exchange_email_ids)
log.info("exchange_sender: %s" % exchange_sender)
log.info("exchange_message_subject: %s" % exchange_message_subject)
log.info("exchange_message_body: %s" % exchange_message_body)
log.info("exchange_start_date: %s" % exchange_start_date)
log.info("exchange_end_date: %s" % exchange_end_date)
log.info("exchange_has_attachments: %s" % exchange_has_attachments)
log.info("exchange_order_by_recency: %s" %
exchange_order_by_recency)
log.info("exchange_num_emails: %s" % exchange_num_emails)
log.info("exchange_search_subfolders: %s" %
exchange_search_subfolders)
# Initialize utils
utils = exchange_utils(self.options, self.opts)
# Getting emails
yield StatusMessage("Getting emails")
emails = utils.get_emails(
exchange_email, exchange_folder_path, exchange_email_ids,
exchange_sender, exchange_message_subject,
exchange_message_body, exchange_start_date, exchange_end_date,
exchange_has_attachments, exchange_order_by_recency,
exchange_num_emails, exchange_search_subfolders)
yield StatusMessage("Done getting emails")
# Get function results
results = utils.create_email_function_results(emails)
emails_moved = emails.count()
# Move emails
yield StatusMessage("Moving emails to %s" %
exchange_destination_folder_path)
# get destination folder
move_folder = utils.go_to_folder(exchange_email,
exchange_destination_folder_path)
for email in emails:
email.move(move_folder)
yield StatusMessage("Done moving emails, %d emails moved" %
emails_moved)
# Produce a FunctionResult with the results
yield FunctionResult(results)
except Exception:
yield FunctionError()
def __init__(self, *arg):
self.utils = exchange_utils(MOCK_OPTS, {})
