~mailman-coders/mailman/2.1

#! @PYTHON@

#

# Copyright (C) 1998-2018 by the Free Software Foundation, Inc.

#

# 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.

"""List all the members of a mailing list.

Usage: %(PROGRAM)s [options] listname

Where:

    --output file

    -o file

        Write output to specified file instead of standard out.

    --regular / -r

        Print just the regular (non-digest) members.

    --digest[=kind] / -d [kind]

        Print just the digest members.  Optional argument can be "mime" or

        "plain" which prints just the digest members receiving that kind of

        digest.

    --nomail[=why] / -n [why]

        Print the members that have delivery disabled.  Optional argument can

        be "byadmin", "byuser", "bybounce", or "unknown" which prints just the

        users who have delivery disabled for that reason.  It can also be

        "enabled" which prints just those member for whom delivery is

        enabled.

    --fullnames / -f

        Include the full names in the output.

    --preserve / -p

        Output member addresses case preserved the way they were added to the

        list.  Otherwise, addresses are printed in all lowercase.

    --moderated / -m

        Print just the moderated members.  Ignores -r, -d, -n.

    --non-moderated / -M

        Print just the non-moderated members.  Ignores -r, -d, -n.

    --invalid / -i

        Print only the addresses in the membership list that are invalid.

        Ignores -r, -d, -n.

    --unicode / -u

        Print addresses which are stored as Unicode objects instead of normal

        string objects.  Ignores -r, -d, -n.

    --help

    -h

        Print this help message and exit.

    listname is the name of the mailing list to use.

Note that if neither -r or -d is supplied, regular members are printed first,

followed by digest members, but no indication is given as to address status.

"""

import sys

from types import UnicodeType

import paths

from Mailman import mm_cfg

from Mailman import Utils

from Mailman import MailList

from Mailman import Errors

from Mailman import MemberAdaptor

from Mailman.i18n import C_

from email.Utils import formataddr

PROGRAM = sys.argv[0]

ENC = sys.getdefaultencoding()

COMMASPACE = ', '

try:

    True, False

except NameError:

    True = 1

    False = 0

WHYCHOICES = {'enabled' : MemberAdaptor.ENABLED,

              'unknown' : MemberAdaptor.UNKNOWN,

              'byuser'  : MemberAdaptor.BYUSER,

              'byadmin' : MemberAdaptor.BYADMIN,

              'bybounce': MemberAdaptor.BYBOUNCE,

              }

def usage(code, msg=''):

    if code:

        fd = sys.stderr

    else:

        fd = sys.stdout

    print >> fd, C_(__doc__)

    if msg:

        print >> fd, msg

    sys.exit(code)

def safe(s):

    if not s:

        return ''

    if isinstance(s, UnicodeType):

        return s.encode(ENC, 'replace')

    return unicode(s, ENC, 'replace').encode(ENC, 'replace')

def isinvalid(addr):

    try:

        Utils.ValidateEmail(addr)

        return False

    except Errors.EmailAddressError:

        return True

def isunicode(addr):

    return isinstance(addr, UnicodeType)

def whymatches(mlist, addr, why):

    # Return true if the `why' matches the reason the address is enabled, or

    # in the case of why is None, that they are disabled for any reason

    # (i.e. not enabled).

    status = mlist.getDeliveryStatus(addr)

    if why is None:

        return status <> MemberAdaptor.ENABLED

    return status == WHYCHOICES[why]

def main():

    # Because of the optional arguments, we can't use getopt. :(

    outfile = None

    regular = None

    digest = None

    preserve = None

    nomail = None

    why = None

    kind = None

    fullnames = False

    invalidonly = False

    unicodeonly = False

    moderatedonly = False

    nonmoderatedonly = False

    # Throw away the first (program) argument

    args = sys.argv[1:]

    if not args:

        usage(0)

    while True:

        try:

            opt = args.pop(0)

        except IndexError:

            usage(1)

        if opt in ('-h', '--help'):

            usage(0)

        elif opt in ('-f', '--fullnames'):

            fullnames = True

        elif opt in ('-p', '--preserve'):

            preserve = True

        elif opt in ('-r', '--regular'):

            regular = True

        elif opt in ('-o', '--output'):

            try:

                outfile = args.pop(0)

            except IndexError:

                usage(1)

        elif opt == '-n':

            nomail = True

            if args and args[0] in WHYCHOICES.keys():

                why = args.pop(0)

        elif opt.startswith('--nomail'):

            nomail = True

            i = opt.find('=')

            if i >= 0:

                why = opt[i+1:]

                if why not in WHYCHOICES.keys():

                    usage(1, C_('Bad --nomail option: %(why)s'))

        elif opt == '-d':

            digest = True

            if args and args[0] in ('mime', 'plain'):

                kind = args.pop(0)

        elif opt.startswith('--digest'):

            digest = True

            i = opt.find('=')

            if i >= 0:

                kind = opt[i+1:]

                if kind not in ('mime', 'plain'):

                    usage(1, C_('Bad --digest option: %(kind)s'))

        elif opt in ('-m', '--moderated'):

            moderatedonly = True

            if nonmoderatedonly or invalidonly or unicodeonly:

                usage(1, C_('Only one of -m, -M, -i or -u may be specified.'))

        elif opt in ('-M', '--non-moderated'):

            nonmoderatedonly = True

            if moderatedonly or invalidonly or unicodeonly:

                usage(1, C_('Only one of -m, -M, -i or -u may be specified.'))

        elif opt in ('-i', '--invalid'):

            invalidonly = True

            if moderatedonly or nonmoderatedonly or unicodeonly:

                usage(1, C_('Only one of -m, -M, -i or -u may be specified.'))

        elif opt in ('-u', '--unicode'):

            unicodeonly = True

            if moderatedonly or nonmoderatedonly or invalidonly:

                usage(1, C_('Only one of -m, -M, -i or -u may be specified.'))

        else:

            # No more options left, push the last one back on the list

            args.insert(0, opt)

            break

    if len(args) <> 1:

        usage(1)

    listname = args[0].lower().strip()

    if regular is None and digest is None:

        regular = digest = True

    if outfile:

        try:

            fp = open(outfile, 'w')

        except IOError:

            print >> sys.stderr, C_(

                                 'Could not open file for writing:'), outfile

            sys.exit(1)

    else:

        fp = sys.stdout

    try:

        mlist = MailList.MailList(listname, lock=False)

    except Errors.MMListError, e:

        print >> sys.stderr, C_('No such list: %(listname)s')

        sys.exit(1)

    # Get the lowercased member addresses

    rmembers = mlist.getRegularMemberKeys()

    dmembers = mlist.getDigestMemberKeys()

    if preserve:

        # Convert to the case preserved addresses

        rmembers = mlist.getMemberCPAddresses(rmembers)

        dmembers = mlist.getMemberCPAddresses(dmembers)

    if invalidonly or unicodeonly or moderatedonly or nonmoderatedonly:

        all = rmembers + dmembers

        all.sort()

        for addr in all:

            name = fullnames and mlist.getMemberName(addr) or ''

            showit = False

            if invalidonly and isinvalid(addr):

                showit = True

            if unicodeonly and isunicode(addr):

                showit = True

            if moderatedonly and mlist.getMemberOption(addr, mm_cfg.Moderate):

                showit = True

            if nonmoderatedonly and not mlist.getMemberOption(addr,

                                                             mm_cfg.Moderate):

                showit = True

            if showit:

                print >> fp, formataddr((safe(name), addr))

        return

    if regular:

        rmembers.sort()

        for addr in rmembers:

            name = fullnames and mlist.getMemberName(addr) or ''

            # Filter out nomails

            if nomail and not whymatches(mlist, addr, why):

                continue

            print >> fp, formataddr((safe(name), addr))

    if digest:

        dmembers.sort()

        for addr in dmembers:

            name = fullnames and mlist.getMemberName(addr) or ''

            # Filter out nomails

            if nomail and not whymatches(mlist, addr, why):

                continue

            # Filter out digest kinds

            if mlist.getMemberOption(addr, mm_cfg.DisableMime):

                # They're getting plain text digests

                if kind == 'mime':

                    continue

            else:

                # They're getting MIME digests

                if kind == 'plain':

                    continue

            print >> fp, formataddr((safe(name), addr))

if __name__ == '__main__':

    main()