spamotron/mailing.py

#! /usr/bin/env python3

# (C) Olivier Berger 2001-2002
# (C) François Poulain 2019-2020
#
# 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
import smtplib, time, mimetypes
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(
        "-vv", "--very-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_attachments(args):
    r = []
    for attachement in args.attachement or []:
        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 send_message(templates, data, attachments, args):
    dests = [data["to"]]

    msg = EmailMessage()
    msg["Subject"] = templates[0].render(**data).strip()
    msg["From"] = data["from"]
    msg["To"] = data["to"]
    if "reply-to" in data:
        msg["Reply-To"] = data["reply-to"]
    if "cc" in data:
        msg["Cc"] = data["cc"]
        dests.append(data["cc"])
    if "bcc" in data:
        msg["Bcc"] = data["bcc"]
        dests.append(data["bcc"])

    msg.set_content(templates[1].render(**data))

    if len(templates) > 2:
        alt = templates[2].render(**data)
        msg.add_alternative(alt)

    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"
            % (msg["Subject"], data["from"], 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")
        if args.very_verbose:
            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 templates of the mail
    templates = read_templates(args)

    # optionnaly read the attachment of the mail
    attachments = read_attachments(args)

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

    # send mail to each recipient
    for data in datas:

        # send message
        send_message(templates, data, 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)