307 lines
12 KiB
Python
307 lines
12 KiB
Python
import logging
|
||
|
||
import aiosmtplib
|
||
from channels.layers import get_channel_layer
|
||
from channels.db import database_sync_to_async
|
||
from django.core.files.base import ContentFile
|
||
from mail.models import Email, EventAddress, EmailAttachment
|
||
from notify_sessions.models import SystemEvent
|
||
from tickets.models import IssueThread
|
||
|
||
|
||
def find_quoted_printable(s, marker):
|
||
positions = [i for i in range(len(s)) if s.lower().startswith('=?utf-8?' + marker + '?', i)]
|
||
for pos in positions:
|
||
end = s.find('?=', pos + 10)
|
||
if end == -1:
|
||
continue
|
||
yield pos, end + 3
|
||
|
||
|
||
def unescape_and_decode_quoted_printable(s):
|
||
import quopri
|
||
decoded = ''
|
||
last_end = 0
|
||
for start, end in find_quoted_printable(s, 'q'):
|
||
decoded += s[last_end:start]
|
||
decoded += quopri.decodestring(s[start + 10:end - 3]).decode('utf-8')
|
||
last_end = end
|
||
decoded += s[last_end:]
|
||
return decoded
|
||
|
||
|
||
def unescape_and_decode_base64(s):
|
||
import base64
|
||
decoded = ''
|
||
last_end = 0
|
||
for start, end in find_quoted_printable(s, 'b'):
|
||
decoded += s[last_end:start]
|
||
decoded += base64.b64decode(s[start + 10:end - 3]).decode('utf-8')
|
||
last_end = end
|
||
decoded += s[last_end:]
|
||
return decoded
|
||
|
||
|
||
def unescape_simplified_quoted_printable(s):
|
||
import quopri
|
||
return quopri.decodestring(s).decode('utf-8')
|
||
|
||
|
||
def collect_references(issue_thread):
|
||
mails = issue_thread.emails.order_by('timestamp')
|
||
references = []
|
||
for mail in mails:
|
||
if mail.reference:
|
||
references.append(mail.reference)
|
||
return references
|
||
|
||
|
||
def make_reply(reply_email, references=None, event=None):
|
||
from email.message import EmailMessage
|
||
from core.settings import MAIL_DOMAIN
|
||
event = event or "mail"
|
||
reply = EmailMessage()
|
||
reply["From"] = reply_email.sender
|
||
reply["To"] = reply_email.recipient
|
||
reply["Subject"] = reply_email.subject
|
||
reply["Reply-To"] = f"{event}@{MAIL_DOMAIN}"
|
||
if reply_email.in_reply_to:
|
||
reply["In-Reply-To"] = reply_email.in_reply_to
|
||
if reply_email.reference:
|
||
reply["Message-ID"] = reply_email.reference
|
||
else:
|
||
reply["Message-ID"] = reply_email.id + "@" + MAIL_DOMAIN
|
||
reply_email.reference = reply["Message-ID"]
|
||
reply_email.save()
|
||
if references:
|
||
reply["References"] = " ".join(references)
|
||
|
||
reply.set_content(reply_email.body)
|
||
|
||
return reply
|
||
|
||
|
||
def make_notification(message, to, event=None): # TODO where should replies to this go
|
||
from email.message import EmailMessage
|
||
from core.settings import MAIL_DOMAIN
|
||
event = event or "mail"
|
||
notification = EmailMessage()
|
||
notification["From"] = "notifications@%s" % MAIL_DOMAIN
|
||
notification["To"] = to
|
||
notification["Subject"] = f"System3 Notification"
|
||
# notification["Reply-To"] = f"{event}@{MAIL_DOMAIN}"
|
||
# notification["In-Reply-To"] = email.reference
|
||
# notification["Message-ID"] = email.id + "@" + MAIL_DOMAIN
|
||
|
||
notification.set_content(message)
|
||
|
||
return notification
|
||
|
||
|
||
async def send_smtp(message):
|
||
await aiosmtplib.send(message, hostname="127.0.0.1", port=25, use_tls=False, start_tls=False)
|
||
|
||
|
||
def find_active_issue_thread(in_reply_to, address, subject):
|
||
from re import match
|
||
uuid_match = match(r'^ticket\+([a-f0-9-]{36})@', address)
|
||
if uuid_match:
|
||
issue = IssueThread.objects.filter(uuid=uuid_match.group(1))
|
||
if issue.exists():
|
||
return issue.first(), False
|
||
reply_to = Email.objects.filter(reference=in_reply_to)
|
||
if reply_to.exists():
|
||
return reply_to.first().issue_thread, False
|
||
else:
|
||
issue = IssueThread.objects.create(name=subject)
|
||
return issue, True
|
||
|
||
|
||
def find_target_event(address):
|
||
try:
|
||
address_map = EventAddress.objects.get(address=address)
|
||
if address_map.event:
|
||
return address_map.event
|
||
except EventAddress.DoesNotExist:
|
||
pass
|
||
return None
|
||
|
||
|
||
def parse_email_body(raw, log=None):
|
||
import email
|
||
from hashlib import sha256
|
||
|
||
attachments = []
|
||
|
||
parsed = email.message_from_bytes(raw)
|
||
body = ""
|
||
if parsed.is_multipart():
|
||
for part in parsed.walk():
|
||
ctype = part.get_content_type()
|
||
cdispo = str(part.get('Content-Disposition'))
|
||
|
||
# skip any text/plain (txt) attachments
|
||
if ctype == 'text/plain' and 'attachment' not in cdispo:
|
||
segment = part.get_payload()
|
||
if not segment:
|
||
continue
|
||
segment = unescape_and_decode_quoted_printable(segment)
|
||
segment = unescape_and_decode_base64(segment)
|
||
if part.get('Content-Transfer-Encoding') == 'quoted-printable':
|
||
segment = unescape_simplified_quoted_printable(segment)
|
||
log.debug(segment)
|
||
body = body + segment
|
||
elif 'attachment' in cdispo or 'inline' in cdispo:
|
||
file = ContentFile(part.get_payload(decode=True))
|
||
chash = sha256(file.read()).hexdigest()
|
||
name = part.get_filename()
|
||
if name is None:
|
||
name = "unnamed"
|
||
attachment, _ = EmailAttachment.objects.get_or_create(
|
||
name=name, mime_type=ctype, file=file, hash=chash)
|
||
attachment.save()
|
||
attachments.append(attachment)
|
||
if 'inline' in cdispo:
|
||
body = body + f'<img src="cid:{attachment.id}">'
|
||
log.info("Image %s %s", ctype, attachment.id)
|
||
else:
|
||
log.info("Attachment %s %s", ctype, cdispo)
|
||
else:
|
||
if parsed.get_content_type() == 'text/plain':
|
||
body = parsed.get_payload()
|
||
elif parsed.get_content_type() == 'text/html':
|
||
from bs4 import BeautifulSoup
|
||
import re
|
||
body = parsed.get_payload()
|
||
soup = BeautifulSoup(body, 'html.parser')
|
||
body = re.sub(r'([\r\n]+.?)*[\r\n]', r'\n', soup.get_text()).strip('\n')
|
||
else:
|
||
log.warning("Unknown content type %s", parsed.get_content_type())
|
||
body = "Unknown content type"
|
||
body = unescape_and_decode_quoted_printable(body)
|
||
body = unescape_and_decode_base64(body)
|
||
if parsed.get('Content-Transfer-Encoding') == 'quoted-printable':
|
||
body = unescape_simplified_quoted_printable(body)
|
||
log.debug(body)
|
||
|
||
return parsed, body, attachments
|
||
|
||
|
||
@database_sync_to_async
|
||
def receive_email(envelope, log=None):
|
||
parsed, body, attachments = parse_email_body(envelope.content, log)
|
||
|
||
header_from = parsed.get('From')
|
||
header_to = parsed.get('To')
|
||
header_in_reply_to = parsed.get('In-Reply-To')
|
||
header_message_id = parsed.get('Message-ID')
|
||
|
||
if header_from != envelope.mail_from:
|
||
log.warning("Header from does not match envelope from")
|
||
log.info(f"Header from: {header_from}, envelope from: {envelope.mail_from}")
|
||
|
||
if header_to != envelope.rcpt_tos[0]:
|
||
log.warning("Header to does not match envelope to")
|
||
log.info(f"Header to: {header_to}, envelope to: {envelope.rcpt_tos[0]}")
|
||
|
||
recipient = envelope.rcpt_tos[0].lower() if envelope.rcpt_tos else header_to.lower()
|
||
sender = envelope.mail_from if envelope.mail_from else header_from
|
||
subject = parsed.get('Subject')
|
||
if not subject:
|
||
subject = "No subject"
|
||
subject = unescape_and_decode_quoted_printable(subject)
|
||
subject = unescape_and_decode_base64(subject)
|
||
target_event = find_target_event(recipient)
|
||
|
||
active_issue_thread, new = find_active_issue_thread(header_in_reply_to, recipient, subject)
|
||
|
||
email = Email.objects.create(
|
||
sender=sender, recipient=recipient, body=body, subject=subject, reference=header_message_id,
|
||
in_reply_to=header_in_reply_to, raw=envelope.content, event=target_event,
|
||
issue_thread=active_issue_thread)
|
||
for attachment in attachments:
|
||
email.attachments.add(attachment)
|
||
email.save()
|
||
|
||
reply = None
|
||
if new:
|
||
# auto reply if new issue
|
||
references = collect_references(active_issue_thread)
|
||
if not sender.startswith('noreply'):
|
||
subject = f"Re: {subject} [#{active_issue_thread.short_uuid()}]"
|
||
body = '''Your request (#{}) has been received and will be reviewed by our lost&found angels.
|
||
|
||
We are reviewing incoming requests during the event and teardown. Immediately after the event, expect a delay as the \
|
||
workload is high. We will not forget about your request and get back in touch once we have updated information on your \
|
||
request. Requests for devices, wallets, credit cards or similar items will be handled with priority.
|
||
|
||
If you happen to find your lost item or just want to add additional information, please reply to this email. Please \
|
||
do not create a new request.
|
||
|
||
Your c3lf (Cloakroom + Lost&Found) Team'''.format(active_issue_thread.short_uuid())
|
||
reply_email = Email.objects.create(
|
||
sender=recipient, recipient=sender, body=body, subject=subject,
|
||
in_reply_to=header_message_id, event=target_event, issue_thread=active_issue_thread)
|
||
reply = make_reply(reply_email, references, event=target_event.slug if target_event else None)
|
||
else:
|
||
# change state if not new
|
||
if active_issue_thread.state != 'pending_new':
|
||
active_issue_thread.state = 'pending_open'
|
||
active_issue_thread.save()
|
||
|
||
notification = None
|
||
if new:
|
||
notification = f"New issue {active_issue_thread.short_uuid()} created by {sender}"
|
||
else:
|
||
notification = f"Reply to issue {active_issue_thread.short_uuid()} by {sender}"
|
||
|
||
return email, new, reply, notification
|
||
|
||
|
||
class LMTPHandler:
|
||
async def handle_RCPT(self, server, session, envelope, address, rcpt_options):
|
||
from core.settings import MAIL_DOMAIN
|
||
address = address.lower()
|
||
if not address.endswith('@' + MAIL_DOMAIN):
|
||
return '550 not relaying to that domain'
|
||
envelope.rcpt_tos.append(address)
|
||
return '250 OK'
|
||
|
||
async def handle_DATA(self, server, session, envelope):
|
||
log = logging.getLogger('mail.log')
|
||
log.setLevel(logging.DEBUG)
|
||
log.info('Message from %s' % envelope.mail_from)
|
||
log.info('Message for %s' % envelope.rcpt_tos)
|
||
log.info('Message data:\n')
|
||
|
||
content = None
|
||
try:
|
||
content = envelope.content
|
||
email, new, reply, notification = await database_sync_to_async(receive_email)(envelope, log)
|
||
log.info(f"Created email {email.id}")
|
||
systemevent = await database_sync_to_async(SystemEvent.objects.create)(type='email received',
|
||
reference=email.id)
|
||
log.info(f"Created system event {systemevent.id}")
|
||
channel_layer = get_channel_layer()
|
||
await channel_layer.group_send(
|
||
'general', {"type": "generic.event", "name": "send_message_to_frontend", "event_id": systemevent.id,
|
||
"message": "email received"})
|
||
log.info(f"Sent message to frontend")
|
||
if notification:
|
||
log.info(f"Sending notification {notification}")
|
||
await channel_layer.group_send(
|
||
'general', {"type": "generic.event", "name": "user_notification", "event_id": systemevent.id,
|
||
"message": notification})
|
||
if new and reply:
|
||
log.info('Sending message to %s' % reply['To'])
|
||
await send_smtp(reply)
|
||
log.info("Sent auto reply")
|
||
|
||
return '250 Message accepted for delivery'
|
||
except Exception as e:
|
||
from hashlib import sha256
|
||
random_filename = 'mail-' + sha256(content).hexdigest()
|
||
with open(random_filename, 'wb') as f:
|
||
f.write(content)
|
||
log.error(f"Saved email to {random_filename} because of error %s (%s)", e, type(e))
|
||
return '451 Internal server error'
|