CreateCustomVerificationTemplate.py

#!/usr/bin/env python

""" Create AWS SES custom verification email template

This script is used to mimic the following aws ses custom verification
email template creation function:

aws ses create-custom-verification-email-template
    --template-name <template-name>
    --from-email-address <from-email-address>
    --template-subject <template-subject>
    --template-content <template-content>
    --success-redirection-url <success-redirection-url>
    --failure-redirection-url <failure-redirection-url>


Default AWS_REGION is `us-west-2` but the tempalte can be created in other
regions by setting up AWS_REGION env variable (check aws docuementation
for restrictions in certain regions.)

As os 2018-10-02, Update and Deletion of existing templates need to be
performed using the aws account with sufficient permissions to perform those
operations. If the local dev user is decided to grant such permissions in
the future, this script can be extended for deletion and update of the
existing custom verification email templates.

As of 2018-10-02, you can only run 4
`create-custom-verification-email-template` aws ses requests in a day in each
region.
"""

import sys
import boto3
import os
import json
import argparse
from botocore.exceptions import ClientError

# Use `us-west-2` as default region
# This should work for local development, alpha stack(us-east-2) and prod
AWS_REGION = os.getenv('AWS_REGION', 'us-west-2')


# Path to default verification email contents
VERIFICATION_TEMPLATE = os.getenv('DEFAULT_VERIFICATION_TEMPLATE_PATH',
                                  ('/home/homecu/tmp/aws/ses/'
                                   'default_verification_email_template'))

USAGE = ("USAGE: CreateCustomVerificationTemplate.py [-h] -tn TEMPLATE_NAME "
         "[-fe FROM_EMAIL_ADDRESS] [-su SUBJECT] [-c CONTENT]"
         "[-s SUCCESS] [-f FAILURE]")


def get_email_defaults():
    '''return custom email verification template defaults'''
    contents = None
    with open(VERIFICATION_TEMPLATE, 'r') as fh:
        contents = ''.join(fh.readlines())

    return {
        "sender": "support@homecu.com",
        "subject": "Please confirm your email address",
        "content": contents,
        "success": ("https://my.homecu.net/admbin/static/html/"
                    "AdmEmailSuccess.html"),
        "failure": ("https://my.homecu.net/admbin/static/html/"
                    "AdmEmailFailure.html"),
    }


class CustomArgumentParser(argparse.ArgumentParser):
    """Custom ArgumentParser class

    Extends:
        argparse.ArgumentParser
    """

    def error(self, message):
        """Suppressing default error method

        Return custom error message on ArgumentParser.error.

        Arguments:
            message -- error message

        Raises:
            SystemExit
        """
        custom_error = {
            'status': '999',
            'error': USAGE,
            'response': {}
        }
        print(json.dumps("{}: {}".format(__file__, custom_error)))
        raise SystemExit(2)


def get_parser():
    """Prepare argument parser.

    Returns:
        parser -- ArgumentParser object
    """
    defaults = get_email_defaults()
    parser = CustomArgumentParser(
        description="AWS SES Create New Custom Email Verification Template."
    )

    parser.add_argument("-tn", "--template-name",
                        help=('Name of the custom verification email template'
                              '(required)'),
                        required=True
                        )

    parser.add_argument("-fe", "--from-email-address",
                        help="Sender's email address (from email address)",
                        default=defaults["sender"]
                        )

    parser.add_argument("-su", "--subject",
                        help="Email subject",
                        default=defaults["subject"]
                        )

    parser.add_argument("-c", "--content",
                        help=('Email content (single lined json text with no '
                              'breaks)'),
                        default=defaults["content"]
                        )

    parser.add_argument("-s", "--success",
                        help="Success redirection url",
                        default=defaults["success"]
                        )

    parser.add_argument("-f", "--failure",
                        help="Failure redirection url",
                        default=defaults["failure"]
                        )
    return parser


def main(argv):
    """Main method to create custom verification template

    Arguments:
        argv {list} -- list of script arguments

    Raises:
        SystemExit -- [description]
    """
    main_return = {
        'status': '000',
        'error': '',
        'response': {}
    }

    # get argument parser
    parser = get_parser()
    try:
        args = parser.parse_args(argv)
    except (argparse.ArgumentError, Exception) as e:
        main_return = {
            'status': '999',
            'error': e,
            'response': {}
        }
        print(json.dumps(main_return))
        raise SystemExit(2)

    response = None
    excption = False
    try:

        # Create boto3 client object
        client = boto3.client('ses', region_name=AWS_REGION)

        # Create custom verification email template on a specified region
        response = client.create_custom_verification_email_template(
            TemplateName=args.template_name,
            FromEmailAddress=args.from_email_address,
            TemplateSubject=args.subject,
            TemplateContent=args.content,
            SuccessRedirectionURL=args.success,
            FailureRedirectionURL=args.failure
        )

    except ClientError as e:
        main_return['status'] = '999'
        main_return['error'] = e.response["Error"]["Message"]
        excption = True
    except BaseException as e:
        main_return['status'] = '999'
        main_return['error'] = str(e)
        excption = True
    except Exception as e:
        main_return['status'] = '999'
        main_return['error'] = e
        excption = True

    main_return["response"] = response
    print(json.dumps(main_return))

    if excption:
        raise SystemExit(2)


def run():
    """Script entrypoint"""
    main(sys.argv[1:])


if __name__ == "__main__":
    run()