manage_members.py

#!/bin/env python
from mailmanclient import Client

# This program dumps all the user deails
# from a given email list into json output.
# The output json can then be taken as input to suscribe users from a source
# into a target.

# Example usages:

# dumping a email list to a file
# python manage_members.py -l=dtest@lists.med.stanford.edu -d > dtest.json
# restoring an older email list to sync with a modern one.
# python manage_members.py -l=dtest@lists.med.stanford.edu -r=dtest.json
# replacing an entire source email list to the new one
# python manage_members.py -l=dtest@lists.med.stanford.edu -restore=dtest.json  -scrub

import os
import sys
import time
import argparse

try:
    import json
except ImportError:
    import simplejson as json

def get_ml_fqdns(client):
    ml_fqdns = []
    for mlist in client.lists:
        ml_fqdns.append(mlist.fqdn_listname)
    return ml_fqdns

def dump_fqdn_members(client,ml_fqdn ):

    """Prints the members of a email list"""
    # Get members from email list
    member_list = client.get_list(ml_fqdn)
    members_hash = {}
    members_hash['members'] = []
    preferences = {}

    # Get json data from each member
    for member in member_list.members:

        members_hash['members'].append({
            'list_fqdn': args.list_fqdn,
            'email': member.email,
            'display_name': member.user.display_name,
            #'password': member.user.password,
            'preferences': dict(member.preferences)
        })
        #print json.dumps(member.user.rest_data, indent=2)
    print json.dumps(members_hash, indent=2)
# end dump_fqdn_memberss

def restore_members( members_file, ml_fqdn, scrub ):

    """Creates Code to Restore Members of a source/target email list."""
    """The scrub option determines if the current target scriptions are wiped."""

    tgt_list = None # Used for assigning the
    if members_file == '-':
        json_file = sys.stdin
    else:
        with open(members_file) as json_file:
            data = json.load(json_file)
            # subscribe members from source into target
            for src_member in data['members']:
                # get target the email list
                if (ml_fqdn == src_member['list_fqdn']):
                    #deletes all members in the list
                    if ( scrub and tgt_list is None):
                        scrub_members( ml_fqdn )
                    tgt_list = client.get_list(ml_fqdn)
                    # Get members from the current email list
                    tgt_members = [str(tgt_member.email) for tgt_member in tgt_list.members]

                    #Add member if not already in list
                    if src_member['email'] not in tgt_members:
                        # check on display_name is null or not
                        if( src_member['display_name'] is not None):
                            display_name = src_member['display_name']
                        else:
                            display_name = 'display_name=None'

                        # subscribe member to list
                        tgt_list.subscribe(src_member['email'],
                                           display_name,
                                           pre_verified=True,
                                           pre_confirmed=True,
                                           pre_approved=True)

                    # set the preferences
                    set_preferences(src_member['preferences'],
                                    tgt_list.get_member(src_member['email']).preferences)
                else:
                    print("Error: Email List "+ml_fqdn+" does not match with data file"+src_member['list_fqdn'])

    if members_file != '-':
        json_file.close()
#end restore_members
def scrub_members( list_fqdn ):
    """Removes all target members from email list to be replace with source list."""
    scrub_list = client.get_list(list_fqdn)
    scrub_members = [str(scrub_member.email) for scrub_member in scrub_list.members]
    for scrub_email in scrub_members:
        scrub_list.unsubscribe(scrub_email)

#end scrub_members

def set_preferences(src_prefs, tgt_prefs):
    """Sets preferences on user."""
    tgt_pref = None

    for src_pref in src_prefs:
      if (src_prefs[src_pref] is not None):
        tgt_pref = str(src_prefs[src_pref])
        #print ('preference: '+src_pref+'='+str(src_prefs[src_pref]))
      else:
        tgt_pref = src_pref+'=None'
      tgt_prefs[src_pref] = tgt_pref
      #tgt_prefs['delivery_mode'] =  src_member['preferences']['delivery_mode']
    tgt_prefs.save()
#end set_preferences



if __name__ == '__main__':
    parser = argparse.ArgumentParser(description="Manage Users in Mailman Email Lists.")

    CORE_URI = os.environ.get('MAILMAN_CORE_URI',
                              'http://mailman-core:8001/3.1')
    CORE_USER = os.environ.get('MAILMAN_REST_USER', 'restadmin')
    CORE_PASS = os.environ.get('MAILMAN_REST_PASSWORD', 'restpass')

    # user invoked variables
    parser.add_argument('-l','--list-fqdn', required=True, help='Required Mailing List')
    parser.add_argument('-d','--dump',action='store_true',
    help='Dumps a mailing list to stout in json format.')
    parser.add_argument('-r','--restore',
    help='Subscribes users from a source email list into a tareget email list if not already added.')
    parser.add_argument('-s','--scrub',action='store_true',
    help='Removes all users from a target email list and suscribes the current.')
    # Add arguments for env variables
    parser.add_argument('--core-uri', dest='core_uri', default=CORE_URI)
    parser.add_argument('--rest-user', dest='core_user', default=CORE_USER)
    parser.add_argument('--rest-password', dest='core_password', default=CORE_PASS)


    # Parse out the command line arguments
    args = parser.parse_args()

    # Set the mailman client
    client = Client(args.core_uri, args.core_user, args.core_password)

    # append the mail lists to an array from client
    ml_fqdns = get_ml_fqdns(client)

    # store mailing list
    if args.list_fqdn:
        ml_fqdn = args.list_fqdn
    else:
        ml_fqdn = 'NA'

    # lists members of a list
    if args.dump:
        # get members from list
        if ml_fqdn in ml_fqdns:
            dump_fqdn_members(client,ml_fqdn)
        else:
            sys.exit('Error: Email list"'+ml_fqdn+'" does not exist in domain '+args.core_uri +
                     "\nSee List\n"+str(ml_fqdns))
    #end if
    elif args.restore:
        if args.scrub:
            restore_members( args.restore, ml_fqdn,True)
        else:
            restore_members( args.restore, ml_fqdn,False)
    else:
        print("Error: Need to perform a dump (-d) or restore (-r) of the email list "
              +ml_fqdn)