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, {})