spamotron/mailing.py

#! /usr/bin/env python3

# (C) Olivier Berger 2001-2002
# (C) François Poulain 2019
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful, but
# WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
# General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
# 02111-1307, USA.
#

# This program is used to mail a message to several recipients, thus
# providing customization for each recipient.

import argparse, csv, sys, re
import smtplib, time, mimetypes
from email.header import Header
from email.message import EmailMessage
from jinja2 import Environment, FileSystemLoader, select_autoescape


def parse_args():
    parser = argparse.ArgumentParser(description="Simple mailing script.")
    ma = parser.add_argument_group(title="mandatory arguments", description=None)
    ma.add_argument(
        "-t",
        "--tofile",
        type=str,
        required=True,
        help="CSV file containing recipients data.",
    )
    ma.add_argument(
        "-b",
        "--basename",
        type=str,
        required=True,
        help="Templates basename to be used. The known extensions are: "
        ".subject for subject, .txt for plain body "
        "and optionally .html for html alternative.",
    )
    parser.add_argument(
        "-d",
        "--dry-run",
        action="store_true",
        help="Load data but don't send anything.",
    )
    parser.add_argument(
        "-v", "--verbose", action="store_true",
    )
    parser.add_argument(
        "-a", "--attachement", type=str, nargs="+", help="Optionnal attachments.",
    )
    return parser.parse_args()


def read_recipients_datas(args):
    with open(args.tofile) as csv_file:
        csv_soup = csv.reader(csv_file)
        first = [(s.split(":", 1)) for s in csv_soup.__next__()]
        header = [
            (h[0].strip().lower(), h[1].strip() if len(h) == 2 else None) for h in first
        ]
        datas = [[s.strip() for s in d] for d in csv_soup]
        full_datas = []
        for data in datas:
            try:
                full_data = {
                    h[0]: data[i] if i < len(data) or not h[1] else h[1]
                    for i, h in enumerate(header)
                }
                full_datas.append(full_data)
            except Exception:
                print("Ligne mal renseignée:", data, file=sys.stderr)
        return full_datas


def read_templates(args):
    env = Environment(
        loader=FileSystemLoader("."), autoescape=select_autoescape(["html"])
    )
    templates = [
        env.get_template("{}.subject".format(args.basename)),
        env.get_template("{}.txt".format(args.basename)),
    ]
    try:
        templates.append(env.get_template("{}.html".format(args.basename)))
    except Exception:
        pass
    return templates


def read_join(args):
    r = []
    for attachement in args.attachement:
        try:
            with open(attachement, "rb") as fp:
                ctype, encoding = mimetypes.guess_type(attachement)
                if ctype is None or encoding is not None:
                    ctype = "application/octet-stream"
                maintype, subtype = ctype.split("/", 1)
                metadata = {
                    "filename": attachement,
                    "maintype": maintype,
                    "subtype": subtype,
                }
                r.append((fp.read(), metadata))
        except Exception as e:
            print("read error: %s" % e)
            exit(1)
    return r


def replace_values(bodytemplate, values):
    body = bodytemplate

    for i in range(len(values)):
        i = i + 1
        pattern = "${{%02d}}" % i

        body = body.replace(pattern, values[i - 1])

    return body


# patterns for header of the mail
FROMPATTERN = re.compile(r"^From: *(.*)")
SUBJECTPATTERN = re.compile(r"^Subject: *(.*)")
CCPATTERN = re.compile(r"^Cc: *(.*)")
BCCPATTERN = re.compile(r"^Bcc: *(.*)")
REPLYTOPATTERN = re.compile(r"^Reply-To: *(.*)")


def qencode_subject(message):
    subjectmatches = re.search(r"^Subject: *(.*)$", message, re.MULTILINE)
    if subjectmatches == None:
        return message
    subjectstr = subjectmatches.group(1)
    h = Header(subjectstr, "utf-8")
    qsubjectstr = h.encode()
    return message.replace(subjectstr, qsubjectstr, 1)


def send_message(message, to, attachments, args):

    lines = message.split("\n")

    # identify headers in the template
    fromvalue = None
    subjectvalue = None
    ccvalue = None
    bccvalue = None
    replytovalue = None

    for index, line in enumerate(lines):
        if not line:
            body = "\n".join(lines[index + 1 :])
            break

        frommatches = FROMPATTERN.match(line)
        subjectmatches = SUBJECTPATTERN.match(line)
        ccmatches = CCPATTERN.match(line)
        bccmatches = BCCPATTERN.match(line)
        replytomatches = REPLYTOPATTERN.match(line)

        if frommatches:
            fromvalue = frommatches.group(1)
        if subjectmatches:
            subjectvalue = subjectmatches.group(1)
        if ccmatches:
            ccvalue = ccmatches.group(1)
        if bccmatches:
            bccvalue = bccmatches.group(1)
        if replytomatches:
            replytovalue = replytomatches.group(1)

    # lists all addresses to which the mail will be sent
    dests = [to]

    if ccvalue:
        dests.append(ccvalue)
    if bccvalue:
        dests.append(bccvalue)

    msg = EmailMessage()
    msg["Subject"] = subjectvalue
    msg["From"] = fromvalue
    msg["To"] = to
    if replytovalue:
        msg["Reply-To"] = replytovalue
    if ccvalue:
        msg["Cc"] = ccvalue
    msg.set_content(body)
    if attachments:
        for attachment in attachments:
            msg.add_attachment(attachment[0], **attachment[1])

    if args.verbose:
        print(msg)
        print("-" * 80)
    else:
        print(
            "Sending : %s, from %s to %s, dests : %s"
            % (subjectvalue, fromvalue, dests[0], repr(dests))
        )

    if not args.dry_run:
        # sending the mail to its recipients using the local mailer via SMTP
        server = smtplib.SMTP("localhost", "25")
        server.set_debuglevel(1)
        server.send_message(msg)
        server.quit()


if __name__ == "__main__":

    args = parse_args()

    # read the recipients file
    datas = read_recipients_datas(args)

    # read the template of the mail
    templates = read_templates(args)
    print(templates)
    exit(0)

    # optionnaly read the attachment of the mail
    attachment = None
    if args.attachement:
        attachments = read_join(args)

    # counter to be able to pause each 10 mails send
    counter = 0

    # send mail to each recipient
    for set in sets:

        values = set

        # the recipient is always in first column
        recipient = values[0]

        # replace substitution variables in the template for each recipient
        body = replace_values(bodytemplate, values)

        # send message
        send_message(body, recipient, attachments, args)

        # pause every 10 mails for 5 secs so that the MTA doesn't explode
        counter = counter + 1
        if counter >= 10:
            counter = 0
            print("suspending execution for 5 secs")
            time.sleep(5)