mirror of
https://github.com/paperless-ngx/paperless-ngx.git
synced 2025-04-02 13:45:10 -05:00
279 lines
9.0 KiB
Python
279 lines
9.0 KiB
Python
import os
|
|
import tempfile
|
|
from datetime import timedelta, date
|
|
|
|
from django.conf import settings
|
|
from django.utils.text import slugify
|
|
from django_q.tasks import async_task
|
|
from imap_tools import MailBox, MailBoxUnencrypted, AND, MailMessageFlags, \
|
|
MailboxFolderSelectError
|
|
|
|
from documents.loggers import LoggingMixin
|
|
from documents.models import Correspondent
|
|
from paperless_mail.models import MailAccount, MailRule
|
|
|
|
|
|
class MailError(Exception):
|
|
pass
|
|
|
|
|
|
class BaseMailAction:
|
|
|
|
def get_criteria(self):
|
|
return {}
|
|
|
|
def post_consume(self, M, message_uids, parameter):
|
|
pass
|
|
|
|
|
|
class DeleteMailAction(BaseMailAction):
|
|
|
|
def post_consume(self, M, message_uids, parameter):
|
|
M.delete(message_uids)
|
|
|
|
|
|
class MarkReadMailAction(BaseMailAction):
|
|
|
|
def get_criteria(self):
|
|
return {'seen': False}
|
|
|
|
def post_consume(self, M, message_uids, parameter):
|
|
M.seen(message_uids, True)
|
|
|
|
|
|
class MoveMailAction(BaseMailAction):
|
|
|
|
def post_consume(self, M, message_uids, parameter):
|
|
M.move(message_uids, parameter)
|
|
|
|
|
|
class FlagMailAction(BaseMailAction):
|
|
|
|
def get_criteria(self):
|
|
return {'flagged': False}
|
|
|
|
def post_consume(self, M, message_uids, parameter):
|
|
M.flag(message_uids, [MailMessageFlags.FLAGGED], True)
|
|
|
|
|
|
def get_rule_action(rule):
|
|
if rule.action == MailRule.ACTION_FLAG:
|
|
return FlagMailAction()
|
|
elif rule.action == MailRule.ACTION_DELETE:
|
|
return DeleteMailAction()
|
|
elif rule.action == MailRule.ACTION_MOVE:
|
|
return MoveMailAction()
|
|
elif rule.action == MailRule.ACTION_MARK_READ:
|
|
return MarkReadMailAction()
|
|
else:
|
|
raise ValueError("Unknown action.")
|
|
|
|
|
|
def make_criterias(rule):
|
|
maximum_age = date.today() - timedelta(days=rule.maximum_age)
|
|
criterias = {
|
|
"date_gte": maximum_age
|
|
}
|
|
if rule.filter_from:
|
|
criterias["from_"] = rule.filter_from
|
|
if rule.filter_subject:
|
|
criterias["subject"] = rule.filter_subject
|
|
if rule.filter_body:
|
|
criterias["body"] = rule.filter_body
|
|
|
|
return {**criterias, **get_rule_action(rule).get_criteria()}
|
|
|
|
|
|
def get_title(message, att, rule):
|
|
if rule.assign_title_from == MailRule.TITLE_FROM_SUBJECT:
|
|
title = message.subject
|
|
elif rule.assign_title_from == MailRule.TITLE_FROM_FILENAME:
|
|
title = os.path.splitext(os.path.basename(att.filename))[0]
|
|
else:
|
|
raise ValueError("Unknown title selector.")
|
|
|
|
return title
|
|
|
|
|
|
def get_correspondent(message, rule):
|
|
if rule.assign_correspondent_from == MailRule.CORRESPONDENT_FROM_NOTHING:
|
|
correspondent = None
|
|
elif rule.assign_correspondent_from == MailRule.CORRESPONDENT_FROM_EMAIL:
|
|
correspondent_name = message.from_
|
|
correspondent = Correspondent.objects.get_or_create(
|
|
name=correspondent_name, defaults={
|
|
"slug": slugify(correspondent_name)
|
|
})[0]
|
|
elif rule.assign_correspondent_from == MailRule.CORRESPONDENT_FROM_NAME:
|
|
if message.from_values and \
|
|
'name' in message.from_values \
|
|
and message.from_values['name']:
|
|
correspondent_name = message.from_values['name']
|
|
else:
|
|
correspondent_name = message.from_
|
|
|
|
correspondent = Correspondent.objects.get_or_create(
|
|
name=correspondent_name, defaults={
|
|
"slug": slugify(correspondent_name)
|
|
})[0]
|
|
elif rule.assign_correspondent_from == MailRule.CORRESPONDENT_FROM_CUSTOM:
|
|
correspondent = rule.assign_correspondent
|
|
else:
|
|
raise ValueError("Unknwown correspondent selector")
|
|
|
|
return correspondent
|
|
|
|
|
|
def get_mailbox(server, port, security):
|
|
if security == MailAccount.IMAP_SECURITY_NONE:
|
|
mailbox = MailBoxUnencrypted(server, port)
|
|
elif security == MailAccount.IMAP_SECURITY_STARTTLS:
|
|
mailbox = MailBox(server, port, starttls=True)
|
|
elif security == MailAccount.IMAP_SECURITY_SSL:
|
|
mailbox = MailBox(server, port)
|
|
else:
|
|
raise ValueError("Unknown IMAP security")
|
|
return mailbox
|
|
|
|
class MailAccountHandler(LoggingMixin):
|
|
|
|
def handle_mail_account(self, account):
|
|
|
|
self.renew_logging_group()
|
|
|
|
self.log('debug', f"Processing mail account {account}")
|
|
|
|
total_processed_files = 0
|
|
|
|
with get_mailbox(account.imap_server,
|
|
account.imap_port,
|
|
account.imap_security) as M:
|
|
|
|
try:
|
|
M.login(account.username, account.password)
|
|
except Exception:
|
|
raise MailError(
|
|
f"Error while authenticating account {account.name}")
|
|
|
|
self.log('debug', f"Account {account}: Processing "
|
|
f"{account.rules.count()} rule(s)")
|
|
|
|
for rule in account.rules.all():
|
|
self.log(
|
|
'debug',
|
|
f"Account {account}: Processing rule {rule.name}")
|
|
|
|
self.log(
|
|
'debug',
|
|
f"Rule {account}.{rule}: Selecting folder {rule.folder}")
|
|
|
|
try:
|
|
M.folder.set(rule.folder)
|
|
except MailboxFolderSelectError:
|
|
raise MailError(
|
|
f"Rule {rule.name}: Folder {rule.folder} does not exist "
|
|
f"in account {account.name}")
|
|
|
|
criterias = make_criterias(rule)
|
|
|
|
self.log(
|
|
'debug',
|
|
f"Rule {account}.{rule}: Searching folder with criteria "
|
|
f"{str(AND(**criterias))}")
|
|
|
|
try:
|
|
messages = M.fetch(criteria=AND(**criterias), mark_seen=False)
|
|
except Exception:
|
|
raise MailError(
|
|
f"Rule {rule.name}: Error while fetching folder "
|
|
f"{rule.folder} of account {account.name}")
|
|
|
|
post_consume_messages = []
|
|
|
|
mails_processed = 0
|
|
|
|
for message in messages:
|
|
try:
|
|
processed_files = self.handle_message(message, rule)
|
|
except Exception:
|
|
raise MailError(
|
|
f"Rule {rule.name}: Error while processing mail "
|
|
f"{message.uid} of account {account.name}")
|
|
if processed_files > 0:
|
|
post_consume_messages.append(message.uid)
|
|
|
|
total_processed_files += processed_files
|
|
mails_processed += 1
|
|
|
|
self.log(
|
|
'debug',
|
|
f"Rule {account}.{rule}: Processed {mails_processed} "
|
|
f"matching mail(s)")
|
|
|
|
self.log(
|
|
'debug',
|
|
f"Rule {account}.{rule}: Running mail actions on "
|
|
f"{len(post_consume_messages)} mails")
|
|
|
|
try:
|
|
get_rule_action(rule).post_consume(
|
|
M,
|
|
post_consume_messages,
|
|
rule.action_parameter)
|
|
|
|
except Exception:
|
|
raise MailError(
|
|
f"Rule {rule.name}: Error while processing post-consume "
|
|
f"actions for account {account.name}")
|
|
|
|
return total_processed_files
|
|
|
|
def handle_message(self, message, rule):
|
|
if not message.attachments:
|
|
return 0
|
|
|
|
self.log(
|
|
'debug',
|
|
f"Rule {rule.account}.{rule}: "
|
|
f"Processing mail {message.subject} from {message.from_} with "
|
|
f"{len(message.attachments)} attachment(s)")
|
|
|
|
correspondent = get_correspondent(message, rule)
|
|
tag = rule.assign_tag
|
|
doc_type = rule.assign_document_type
|
|
|
|
processed_attachments = 0
|
|
|
|
for att in message.attachments:
|
|
|
|
title = get_title(message, att, rule)
|
|
|
|
# TODO: check with parsers what files types are supported
|
|
if att.content_type == 'application/pdf':
|
|
|
|
os.makedirs(settings.SCRATCH_DIR, exist_ok=True)
|
|
_, temp_filename = tempfile.mkstemp(prefix="paperless-mail-", dir=settings.SCRATCH_DIR)
|
|
with open(temp_filename, 'wb') as f:
|
|
f.write(att.payload)
|
|
|
|
self.log(
|
|
'info',
|
|
f"Rule {rule.account}.{rule}: "
|
|
f"Consuming attachment {att.filename} from mail "
|
|
f"{message.subject} from {message.from_}")
|
|
|
|
async_task(
|
|
"documents.tasks.consume_file",
|
|
path=temp_filename,
|
|
override_filename=att.filename,
|
|
override_title=title,
|
|
override_correspondent_id=correspondent.id if correspondent else None,
|
|
override_document_type_id=doc_type.id if doc_type else None,
|
|
override_tag_ids=[tag.id] if tag else None,
|
|
task_name=f"Mail: {att.filename}"
|
|
)
|
|
|
|
processed_attachments += 1
|
|
|
|
return processed_attachments
|