def authorize(
self,
username: str,
password: str,
autodiscover: bool = True,
access_type: str = "DELEGATE",
server: str = None,
primary_smtp_address: str = None,
) -> None:
"""Connect to Exchange account
:param username: account username
:param password: account password
:param autodiscover: use autodiscover or set it off
:param accesstype: default "DELEGATE", other option "IMPERSONATION"
:param server: required for configuration options
:param primary_smtp_address: by default set to username, but can be
set to be different than username
"""
kwargs = {}
kwargs["autodiscover"] = autodiscover
kwargs["access_type"] = (DELEGATE if access_type.upper() == "DELEGATE"
else IMPERSONATION)
kwargs["primary_smtp_address"] = (primary_smtp_address if
primary_smtp_address else username)
self.credentials = Credentials(username, password)
if server:
self.config = Configuration(server=server,
credentials=self.credentials)
kwargs["config"] = self.config
else:
kwargs["credentials"] = self.credentials
self.account = Account(**kwargs)
def acctSetup(params):
server = params.get('server')
email = params.get('email')
password = params.get('password')
shared = params.get('delegated')
try:
config = Configuration(server=server,
credentials=Credentials(email, password))
if params.get('delegated'):
account = Account(primary_smtp_address=shared,
autodiscover=False,
config=config,
access_type=DELEGATE)
else:
account = Account(primary_smtp_address=email,
autodiscover=False,
config=config,
access_type=DELEGATE)
return account
except Exception as e:
print(e)
def folders(search, delegate):
"""
Print exchange file structure.
"""
credentials = Credentials(tbestate.username, tbestate.password)
if delegate:
username = delegate
else:
username = tbestate.username
if tbestate.exch_host:
config = Configuration(server=tbestate.exch_host,
credentials=credentials)
account = Account(username,
config=config,
autodiscover=False,
access_type=DELEGATE)
else:
account = Account(username,
credentials=credentials,
autodiscover=True,
access_type=DELEGATE)
# pylint: disable=maybe-no-member
account.root.refresh()
if search:
for branches in account.root.glob(search):
click.secho(f'{branches.tree()}')
click.secho(f'-------------------------------------\n', dim=True)
else:
click.secho(f'{account.root.tree()}')
click.secho(f'-------------------------------------\n', dim=True)
def EmailAccountAuthByNtlmHash(username, ntlmhash, email, server=None, flag=True):
try:
if flag:
hash = ntlmhash if ntlmhash.find(":") > 0 else "00000000000000000000000000000000:%s"%str(ntlmhash)
print("[+] 账号:%s 认证口令NTLM-Hash:%s"%(str(username), str(hash)))
else:
hash = ntlmhash
except Exception as hashexception:
print("[-] NTLM-Hash值输入错误!")
raise hashexception
try:
credentials = Credentials(username, hash)
except Exception as credexception:
print("[-] 凭据生成错误!")
raise credexception
try:
if server == None:
email = Account(email, credentials=credentials, autodiscover=True)
print("[+] 邮箱账号认证登录成功")
return email
else:
config = Configuration(server, credentials)
email = Account(primary_smtp_address=email, config=config, autodiscover=False)
return email
except Exception as error:
print("[+] 账号连接或认证失败")
return None
def test_autodiscover_from_account(self):
from exchangelib.autodiscover import _autodiscover_cache
_autodiscover_cache.clear()
account = Account(
primary_smtp_address=self.account.primary_smtp_address,
credentials=self.account.protocol.credentials,
autodiscover=True,
locale='da_DK')
self.assertEqual(account.primary_smtp_address,
self.account.primary_smtp_address)
self.assertEqual(account.protocol.service_endpoint.lower(),
self.account.protocol.service_endpoint.lower())
self.assertEqual(account.protocol.version.build,
self.account.protocol.version.build)
# Make sure cache is full
self.assertTrue((account.domain, self.account.protocol.credentials,
True) in _autodiscover_cache)
# Test that autodiscover works with a full cache
account = Account(
primary_smtp_address=self.account.primary_smtp_address,
credentials=self.account.protocol.credentials,
autodiscover=True,
locale='da_DK')
self.assertEqual(account.primary_smtp_address,
self.account.primary_smtp_address)
# Test cache manipulation
key = (account.domain, self.account.protocol.credentials, True)
self.assertTrue(key in _autodiscover_cache)
del _autodiscover_cache[key]
self.assertFalse(key in _autodiscover_cache)
del _autodiscover_cache
def connect(self, url, email): ews_url = url# "http://*****:*****@serverchoice.com" credentials = Credentials(primary_smtp_address, 'topsecret') config = Configuration(service_endpoint=ews_url, credentials=credentials, auth_type=ews_auth_type) self.account = Account( primary_smtp_address=primary_smtp_address, config=config, autodiscover=False, access_type=DELEGATE )
def connect_account(self,email,config=None):
"""
param email: str, like [email protected]
param config: Configuration
return: Account object
"""
if config==None:
return Account(primary_smtp_address=email, config=self.config,autodiscover=False, access_type=DELEGATE)
return Account(primary_smtp_address=email, config=config,autodiscover=False, access_type=DELEGATE)
def main():
config_file_path = os.path.join(
os.path.dirname(os.path.realpath(__file__)),
'exchange-calendar-to-org.cfg')
config = configparser.ConfigParser()
config.read(config_file_path)
email = config.get('Settings', 'email')
try:
server_url = config.get('Settings', 'server_url')
except configparser.NoOptionError:
server_url = None
password = config.get('Settings', 'password')
sync_days = int(config.get('Settings', 'sync_days'))
org_file_path = config.get('Settings', 'org_file')
tz_string = config.get('Settings', 'timezone_string')
sslverify = config.getboolean('Settings', 'verify_ssl')
tz = EWSTimeZone.timezone(tz_string)
credentials = Credentials(username=email, password=password)
if server_url is None:
account = Account(
primary_smtp_address=email,
credentials=credentials,
autodiscover=True,
access_type=DELEGATE)
else:
server = Configuration(server=server_url, credentials=credentials, verify_ssl=sslverify)
account = Account(
primary_smtp_address=email,
config=server,
autodiscover=False,
access_type=DELEGATE)
now = datetime.datetime.now()
end = now + datetime.timedelta(days=sync_days)
items = account.calendar.filter(
start__lt=tz.localize(EWSDateTime(end.year, end.month, end.day)),
end__gt=tz.localize(EWSDateTime(now.year, now.month, now.day)), )
text = []
text.append('* Calendar')
text.append('\n')
for item in items:
text.append(get_item_text(item, tz))
text.append('\n')
f = open(org_file_path, 'w')
f.write(''.join(text))
def fetch_free_busy(date, uid):
acc = current_app.config['EXCHANGE_PROVIDER_ACCOUNT']
creds = current_app.config['EXCHANGE_PROVIDER_CREDENTIALS']
server = current_app.config['EXCHANGE_PROVIDER_SERVER']
domain = current_app.config['EXCHANGE_DOMAIN']
if not creds or not server or not domain:
raise RuntimeError('Exchange provider not configured!')
credentials = Credentials(*creds)
configuration = Configuration(server=server,
auth_type=NTLM,
credentials=credentials)
uid_account = Account(acc, config=configuration, autodiscover=False)
accounts = [
(uid_account, 'Organizer', False),
(
Account(f'{uid}@{domain}',
autodiscover=False,
config=configuration),
'Optional',
False,
),
]
tz = uid_account.default_timezone
start = utc.localize(datetime.combine(date, time.min)).astimezone(tz)
end = start + timedelta(hours=24)
results = []
try:
info = uid_account.protocol.get_free_busy_info(accounts=accounts,
start=start,
end=end)
for busy_info in info:
if busy_info.view_type == 'FreeBusyMerged':
for event in busy_info.calendar_events or []:
overlap = find_overlap(date, event.start, event.end)
if event.busy_type in {'Busy', 'Tentative', 'OOF'
} and overlap:
results.append(overlap)
except (ErrorProxyRequestProcessingFailed, ErrorMailRecipientNotFound):
# mailbox (probably) doesn't exist
return []
return [((start.hour, start.minute), (end.hour, end.minute))
for start, end in results]
def setup(self):
if self.autodiscover:
self.account = Account(
primary_smtp_address=self.primary_smtp_address,
credentials=self._credentials,
autodiscover=True,
access_type=DELEGATE)
else:
config = Configuration(server=self.server,
credentials=self._credentials)
self.account = Account(
primary_smtp_address=self.primary_smtp_address,
config=config,
autodiscover=False,
access_type=DELEGATE)
def send_email(content, exchange_host, mailbox, mail_user, mail_password,
dest_address):
"""
Sends an email to dest_address containing the list of potential malicious new domains.
"""
from exchangelib import DELEGATE, Account, Configuration, Credentials, Message, Mailbox
message = "Found the following potential malicious new domains: {}".format(
content)
creds = Credentials(username=mail_user, password=mail_password)
serverconfig = Configuration(server=exchange_host, credentials=creds)
account = Account(primary_smtp_address=mailbox,
credentials=creds,
autodiscover=False,
config=serverconfig,
access_type=DELEGATE)
if account:
print("Authenticated as {} to O365 succeeded.".format(mail_user))
else:
print("Authentication to O365 mailbox as {} has failed.".format(
mail_user))
sys.exit(-1)
m = Message(account=account,
subject='New domain alert',
body=message,
to_recipients=[
Mailbox(email_address=dest_address),
])
m.send()
print("Email has been sent to {}.".format(dest_address))
def get_account(account_email):
return Account(
primary_smtp_address=account_email,
autodiscover=False,
config=config,
access_type=ACCESS_TYPE,
)
def searchDelegates(params, fparser):
server = params.get('server')
email = params.get('email')
password = params.get('password')
if isinstance(fparser.get("galList"), (str)):
fname = ''.join(fparser.get("galList"))
fname = fname.split(' ')
else:
fname = fparser.get("galList")
print('[+] Checking Where Compromised User Has Access' + '\n')
for shared in fname:
try:
config = Configuration(server=server,
credentials=Credentials(email, password))
account = Account(primary_smtp_address=shared,
autodiscover=False,
config=config,
access_type=DELEGATE)
folderInbox = account.inbox
#print(folderInbox.permission_set)
for s in folderInbox.permission_set.permissions:
if s.permission_level != 'None':
print('User: {} has {} permissions on {}\'s Inbox'.format(
email, s.permission_level, shared))
except Exception as e:
if 'The specified object was not found in the store., The process failed to get the correct properties' not in str(
e):
print(e)
def email(self, to, subject, body):
"""
发送邮件
:param to: 接收人
:param subject: 邮件主题
:param body: 邮件内容
:return:
"""
creds = Credentials(
username=self.email_name,
password=self.email_password
)
account = Account(
primary_smtp_address=self.email_name + '@taoche.com',
credentials=creds,
autodiscover=True,
access_type=DELEGATE
)
m = Message(
account=account,
subject=subject,
body=HTMLBody(body),
to_recipients=[Mailbox(email_address=i) for i in to]
)
m.send()
def getAccount(self):
self.logger.debug('%s. getAccount starts', __name__)
try:
username = self.cfg.get('EWS', 'username')
password = self.cfg.get('EWS', 'password')
authType = self.cfg.get('EWS', 'auth_type')
credentials = Credentials(username=username, password=password)
ews_server = self.cfg.get('EWS', 'server')
smtp_address = self.cfg.get('EWS', 'smtp_address')
if authType == 'NTLM':
config = Configuration(server=ews_server,
credentials=credentials,
auth_type=NTLM)
elif authType == 'None':
#O365 does not use NTLM auth
config = Configuration(server=ews_server,
credentials=credentials,
auth_type=None)
else:
raise ValueError(authType)
account = Account(primary_smtp_address=smtp_address,
config=config,
autodiscover=False,
access_type=DELEGATE)
return account
except ValueError:
self.logger.error('authType not supported: %s', authType)
raise
except Exception as e:
self.logger.error('Failed to get account', exc_info=True)
raise
def send_email(title='报警邮件',
recervers='*****@*****.**',
msg='content',
file_name=''):
try:
credentials = Credentials(username, password)
config = Configuration(server=r_server, credentials=credentials)
account = Account(username,
autodiscover=False,
config=config,
access_type=DELEGATE)
except Exception as e:
print('错误: {0}'.format(e))
sys.exit(1)
m = Message(
account=account,
subject=title,
body=HTMLBody(msg),
to_recipients=[Mailbox(email_address=x) for x in recervers.split(',')])
if file_name:
with open(os.path.abspath(r"../work_flow/sre.xls"), "rb") as f:
cont = f.read()
attchF = FileAttachment(name='值班表.xls', content=cont)
m.attach(attchF)
m.send_and_save()
else:
m.send()
def ews_account():
# TODO: get from a keychain
#ews_password = None
# ews_password = input( "Password: "******"master" )
if ews_password is None:
ews_password = input( "Password: "******"master", ews_password )
credentials = Credentials(
os.environ.get( "EWS_ACCOUNT" ),
ews_password
)
config = Configuration(
server=os.environ.get( "EWS_SERVER" ),
has_ssl=True,
credentials=credentials
)
a = Account(
primary_smtp_address=os.environ.get( "EWS_SMTP_ADDRESS" ),
credentials=credentials,
config=config
)
return a
def send_with_exchange(username, password, server, address, content,
subject='', to_recipients=[], attachements=[]):
credentials = Credentials(username=username, password=password)
config = Configuration(server=server, credentials=credentials)
account = Account(
primary_smtp_address=address,
autodiscover=False,
config=config,
credentials=credentials,
access_type=DELEGATE)
_to_recipients = []
for item in to_recipients:
_to_recipients.append(Mailbox(email_address=item['email']))
m = Message(
account=account,
subject=subject,
body=HTMLBody(content),
to_recipients=_to_recipients)
if attachements:
for item in attachements:
with open(item['src'], 'rb') as f:
img_attach = FileAttachment(name=item['name'], content=f.read())
m.attach(img_attach)
m.send()
def notifyOfChange(self):
# format message body into something useful
messageGreeting = ''
today = str(date.today())
# check to see if the application was a pass or a fail
if self.passFail == True:
messageGreeting = "Below are the stations that have received new check-ins: \n"
formattedMessage = ''
for ind in self.updateMessage:
formattedMessage += str(ind + '\n')
else:
messageGreeting = "Station: The following station was unable to scrape. Please check the URL " \
"for any discrepencies: \n"
formattedMessage = "Station {0},\n URL https://www.plugshare.com/location/{1}".format(
self.stationNames, self.urlID)
# set exchange credentials
credentials = Credentials('<UserName>', '<Password>')
account = Account("<Outlook Email Address>",
credentials=credentials,
autodiscover=True,
access_type=DELEGATE)
recipients = ['<Email Addresses>']
#create message
testMessage = Message(
account=account,
folder=account.sent,
subject='{0} Plugshare Report (auto-generated)'.format(today),
body="{0}{1}".format(messageGreeting, formattedMessage),
to_recipients=recipients)
testMessage.send_and_save()
def ews_config_setup(cls, user, domain, password):
"""Authenticates with Outlook EWS and returns the account objected created with the passed credentials.
(From: "https://github.com/mikesiegel/ews-crack")
:param user: (String) the user you wish to authenticate, (for the email '*****@*****.**', just pass 'test' as the user)
:param domain: (String) the domain of the user to authenticate
:param password: (String) the password of the user to authenticate
:return: (Account,Config) returns the account object returned from EWS and the config details
"""
try:
config = Configuration(
server='outlook.office365.com/EWS/Exchange.asmx',
credentials=Credentials(username="******".format(user, domain),
password=password))
account = Account(primary_smtp_address="{}@{}".format(
user, domain),
autodiscover=False,
config=config,
access_type=DELEGATE)
except UnauthorizedError:
print("Bad password")
return None, None
except CASError:
print("CAS Error: User {} does not exist.".format(user))
return None, None
return account, config
def miniprogram_booking_roomCode_get(roomCode, monthToLoad): # noqa: E501
# 按房间信息和月份（query中）获取所有的预约信息
db_session = None
if "DEVMODE" in os.environ:
if os.environ["DEVMODE"] == "True":
db_session = orm.init_db(os.environ["DEV_DATABASEURI"])
else:
db_session = orm.init_db(os.environ["DATABASEURI"])
else:
db_session = orm.init_db(os.environ["DATABASEURI"])
responseList = []
learner = weapp.getLearner()
if not learner:
db_session.remove()
return {'code': -1001, 'message': '没有找到对应的Learner'}, 200
try:
room_account = Account(
primary_smtp_address=('*****@*****.**' % roomCode),
credentials=credentials,
config=config
)
except Exception as e:
db_session.remove()
return {'code': -2002, 'message': '代理用的Office Account初始化失败', "log": str(e)}, 200
monthToLoad_year = int(monthToLoad.split("-")[0])
monthToLoad_month = int(monthToLoad.split("-")[1])
if monthToLoad_month == 1:
start = room_account.default_timezone.localize(EWSDateTime(monthToLoad_year - 1, 12, 1))
else:
start = room_account.default_timezone.localize(EWSDateTime(monthToLoad_year, monthToLoad_month - 1, 1))
if monthToLoad_month == 11:
end = room_account.default_timezone.localize(EWSDateTime(monthToLoad_year + 1, 1, 1))
elif monthToLoad_month == 12:
end = room_account.default_timezone.localize(EWSDateTime(monthToLoad_year + 1, 2, 1))
else:
end = room_account.default_timezone.localize(EWSDateTime(monthToLoad_year, monthToLoad_month + 2, 1))
try:
for item in room_account.calendar.view(start=start, end=end).all().order_by('start'):
notes = db_session.query(orm.BookingNotes_db).filter(orm.BookingNotes_db.changekey == item.changekey).one_or_none()
localizedStart = item.start.astimezone(get_localzone())
localizedEnd = item.end.astimezone(get_localzone())
bookedByID = getattr(notes, "bookedByID", 0)
bookedByName = getattr(notes, "bookedByName", "")
responseList.append({
'startDate': ("%d-%0*d-%0*d" % (localizedStart.year, 2, localizedStart.month, 2, localizedStart.day)),
'endDate': ("%d-%0*d-%0*d" % (localizedEnd.year, 2, localizedEnd.month, 2, localizedEnd.day)),
'startTime': ("%0*d:%0*d" % (2, localizedStart.hour, 2, localizedStart.minute)),
'endTime': ("%0*d:%0*d" % (2, localizedEnd.hour, 2, localizedEnd.minute)),
'subject': item.subject,
'changekey': item.changekey,
'bookedByID': bookedByID,
'bookedByName': bookedByName,
'description': '' if not getattr(item, 'text_body') else getattr(item, 'text_body'),
'type': 'appointment'
})
except Exception as e:
db_session.remove()
return {'code': -2003, 'message': '获取房间事件列表失败', 'log': str(e)}, 200
db_session.remove()
return {'code': 0, 'data': responseList, 'message': '成功'}, 200
def initialize_exchange_client(self, password=None):
acc_credentials = Credentials(username=self.email_address, password=password)
version = Version(build=Build(config.EXCHANGE_VERSION['major'], config.EXCHANGE_VERSION['minor']))
acc_config = Configuration(service_endpoint=config.EXCHANGE_URL, credentials=acc_credentials,
auth_type='basic', version=version, retry_policy=FaultTolerance(max_wait=300))
self.exchange_client = Account(primary_smtp_address=self.email_address, config=acc_config,
autodiscover=True, access_type='delegate')
def make_a_reservation(preferences, timeslot):
logger.info("Trying to make a reservation for {0} minutes.".format(timeslot))
now = tz.localize(EWSDateTime.now())
now = now.replace(minute=(now.minute - (now.minute % 5))) # round down to nearest 5
start_time = now.replace(second=0, microsecond=0)
end_time = now.replace(second=0, microsecond=0) + timedelta(minutes=timeslot)
logger.debug("Reserving for " + str(start_time) + " - " + str(end_time))
try:
credentials = Credentials(username=preferences["username"], password=preferences["password"])
config = Configuration(service_endpoint=preferences["server"], credentials=credentials, auth_type=NTLM)
account = Account(primary_smtp_address=preferences["email"], config=config, autodiscover=False, access_type=DELEGATE)
item = CalendarItem(folder=account.calendar, subject='Pikavaraus', body='Made with Naurunappula at ' + str(now), start=start_time, end=end_time)
except requests.exceptions.RequestException as e: # failure in data communication
logger.exception("Exception while contacting the server.")
return False
if not check_availability(preferences, timeslot):
return False
try:
item.save()
return True
except Exception as e:
return False
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 send_mail_exchange(config, recipients, subject, body, attachments):
"""Sends the supplied message through an Exchange connection to the list of recipients"""
# Gathering email account details
user = config["Email"]
password = encryption.get_password()
# Connecting to Exchange account
account = None
try:
credentials = Credentials(user, password)
account = Account(user, credentials=credentials, autodiscover=True)
logger.debug("Exchange connection successful")
except Exception as e:
logger.error("Could not connect to Exchange Email: " + str(e))
return
# Constructing message
message = Message(account=account,
subject=subject,
body=body,
to_recipients=recipients.replace(", ", ",").split(","))
# Attaching files
for image_path in attachments:
with open(image_path, 'rb') as f:
repImage = FileAttachment(name=os.path.basename(image_path),
content=f.read())
message.attach(repImage)
# Sending
message.send_and_save()
def Email(self,to, subject, body,email_type, attachments=None):
creds = Credentials(username=self.localVariable["__EMAILEX__"],
password=self.localVariable["__EMAILEX_PASSWORD__"])
config = Configuration(server='outlook.office365.com',credentials=creds)
account = Account(
primary_smtp_address=self.localVariable["__EMAILEX__"],
config=config,
# credentials=creds,
autodiscover=False,
access_type=DELEGATE
)
m = Message(
account=account,
subject=subject,
body=HTMLBody(body),
to_recipients = [Mailbox(email_address=to)]
)
if attachments:
m.attach(attachments)
if email_type==1 and to in list(self.localStore.keys()):
print("清除 %s" % to)
self.localStore.pop(to)
try:
m.send()
if email_type == 0:
message = u"验证码已发送邮箱!"
else:
message = u"证书已发送邮箱!"
return message
except:
message = u"发送失败!"
return message
def authenticate_by_email():
global user_ip
if not request.json or not 'email' in request.json:
abort(400)
data = request.json
email = data['email']
password = data['password']
username = data['username']
try:
credentials = Credentials(email, password)
config = Configuration(server='email.msb.com.vn', credentials=credentials)
account = Account(email, config=config, autodiscover=False)
logger.info(str(security_rule.query_rules('(?i)Allow SEVPN for %s'% username)))
logger.info(user_ip)
security_rule.update_rule_by_description(
description = '(?i)Allow SEVPN for %s'% username,
ipRanges = '%s/32'%user_ip
)
return 'Rule updated', 200
except UnauthorizedError:
return 'Unauthorized', 403
except TransportError:
return 'Server Not Found', 404
except Exception as e:
logger.info(type(e))
logger.info(e)
return 'Unknown Errors', 500
def login(self):
"""
This function logs the user into the MS Exchange mailbox
:return: The mailbox account object
"""
credentials = Credentials(self.username, self.password)
return Account(self.account, credentials=credentials, autodiscover=True)
def connect_to_account(self, primary_smtp_address, impersonation=False):
"""Connect to specified account and return it"""
# Don't check certificates
if not self.verify_cert:
BaseProtocol.HTTP_ADAPTER_CLS = NoVerifyHTTPAdapter
# Decide whether or not to use impersonation access
access_type = IMPERSONATION if impersonation else DELEGATE
# Use credentials to get account
try:
credentials = Credentials(username=self.username,
password=self.password)
config = Configuration(server=self.server, credentials=credentials)
account = Account(primary_smtp_address=primary_smtp_address,
config=config,
autodiscover=self.verify_cert,
access_type=access_type)
except ErrorNonExistentMailbox:
raise NoMailboxError(primary_smtp_address)
except ConnectionError:
raise ServerConnectionError(self.server)
except UnauthorizedError:
raise CredentialsError()
except ErrorImpersonateUserDenied:
raise ImpersonationError(self.username, primary_smtp_address)
return account
def Email_Attachment(username,password,Folder_name, File_path):
#连接邮箱所需信息
creds = Credentials(
username=username,
password=password
)
account = Account(
primary_smtp_address=username,
credentials=creds,
autodiscover=True,
access_type=DELEGATE
)
#迭代收件箱下的文件夹中的附件，并保存到本地
for item in account.inbox.children:
if item.name==Folder_name:#只保存Folder_name参数文件夹下的附件
index=0
totalcount=0
page=0
while True:
for model in item.all()[page:page+50]:
index=index+1
for attachment in model.attachments:
if isinstance(attachment,type(attachment)):
with open(File_path + attachment.name, 'wb') as f:
f.write(attachment.content)
if totalcount==index:
break
page=page+50
totalcount=index
