VirtualMailManager/cli/subcommands.py
author martin f. krafft <madduck@madduck.net>
Sat, 07 Apr 2012 00:45:57 +0200
branchv0.6.x
changeset 492 e5c2b3647971
parent 487 fb0af82ab4af
child 506 fb0ffde628d6
permissions -rw-r--r--
Modify address check query to obtain well-defined result The way in which UNION does not yield the desired result, because (a) UNION merges results and (b) the result order is undefined. This patch changes the query to select the counts as columns and hence provides a well-defined order.

# -*- coding: UTF-8 -*-
# Copyright 2007 - 2011, Pascal Volk
# See COPYING for distribution information.
"""
    VirtualMailManager.cli.subcommands
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    VirtualMailManager's cli subcommands.
"""

import locale
import os

from textwrap import TextWrapper
from time import strftime, strptime

from VirtualMailManager import ENCODING
from VirtualMailManager.cli import get_winsize, prog, w_err, w_std
from VirtualMailManager.common import human_size, size_in_bytes, version_str
from VirtualMailManager.constants import __copyright__, __date__, \
     __version__, ACCOUNT_EXISTS, ALIAS_EXISTS, ALIASDOMAIN_ISDOMAIN, \
     DOMAIN_ALIAS_EXISTS, INVALID_ARGUMENT, EX_MISSING_ARGS, RELOCATED_EXISTS
from VirtualMailManager.errors import VMMError
from VirtualMailManager.password import list_schemes
from VirtualMailManager.serviceset import SERVICES

__all__ = (
    'Command', 'RunContext', 'cmd_map', 'usage', 'alias_add', 'alias_delete',
    'alias_info', 'aliasdomain_add', 'aliasdomain_delete', 'aliasdomain_info',
    'aliasdomain_switch', 'config_get', 'config_set', 'configure',
    'domain_add', 'domain_delete',  'domain_info', 'domain_quota',
    'domain_services', 'domain_transport', 'get_user', 'help_', 'list_domains',
    'list_pwschemes', 'relocated_add', 'relocated_delete', 'relocated_info',
    'user_add', 'user_delete', 'user_info', 'user_name', 'user_password',
    'user_quota', 'user_services', 'user_transport', 'version',
)

_ = lambda msg: msg
txt_wrpr = TextWrapper(width=get_winsize()[1] - 1)
cmd_map = {}


class Command(object):
    """Container class for command information."""
    __slots__ = ('name', 'alias', 'func', 'args', 'descr')

    def __init__(self, name, alias, func, args, descr):
        """Create a new Command instance.

        Arguments:

        `name` : str
          the command name, e.g. ``addalias``
        `alias` : str
          the command's short alias, e.g. ``aa``
        `func` : callable
          the function to handle the command
        `args` : str
          argument placeholders, e.g. ``aliasaddress``
        `descr` : str
          short description of the command
        """
        self.name = name
        self.alias = alias
        self.func = func
        self.args = args
        self.descr = descr

    @property
    def usage(self):
        """the command's usage info."""
        return u'%s %s %s' % (prog, self.name, self.args)


class RunContext(object):
    """Contains all information necessary to run a subcommand."""
    __slots__ = ('argc', 'args', 'cget', 'hdlr', 'scmd')
    plan_a_b = _(u'Plan A failed ... trying Plan B: %(subcommand)s %(object)s')

    def __init__(self, argv, handler, command):
        """Create a new RunContext"""
        self.argc = len(argv)
        self.args = [unicode(arg, ENCODING) for arg in argv]
        self.cget = handler.cfg_dget
        self.hdlr = handler
        self.scmd = command


def alias_add(ctx):
    """create a new alias e-mail address"""
    if ctx.argc < 3:
        usage(EX_MISSING_ARGS, _(u'Missing alias address and destination.'),
              ctx.scmd)
    elif ctx.argc < 4:
        usage(EX_MISSING_ARGS, _(u'Missing destination address.'), ctx.scmd)
    ctx.hdlr.alias_add(ctx.args[2].lower(), *ctx.args[3:])


def alias_delete(ctx):
    """delete the specified alias e-mail address or one of its destinations"""
    if ctx.argc < 3:
        usage(EX_MISSING_ARGS, _(u'Missing alias address.'), ctx.scmd)
    elif ctx.argc < 4:
        ctx.hdlr.alias_delete(ctx.args[2].lower())
    else:
        ctx.hdlr.alias_delete(ctx.args[2].lower(), ctx.args[3])


def alias_info(ctx):
    """show the destination(s) of the specified alias"""
    if ctx.argc < 3:
        usage(EX_MISSING_ARGS, _(u'Missing alias address.'), ctx.scmd)
    address = ctx.args[2].lower()
    try:
        _print_aliase_info(address, ctx.hdlr.alias_info(address))
    except VMMError, err:
        if err.code is ACCOUNT_EXISTS:
            w_err(0, ctx.plan_a_b % {'subcommand': u'userinfo',
                  'object': address})
            ctx.scmd = ctx.args[1] = 'userinfo'
            user_info(ctx)
        elif err.code is RELOCATED_EXISTS:
            w_err(0, ctx.plan_a_b % {'subcommand': u'relocatedinfo',
                  'object': address})
            ctx.scmd = ctx.args[1] = 'relocatedinfo'
            relocated_info(ctx)
        else:
            raise


def aliasdomain_add(ctx):
    """create a new alias for an existing domain"""
    if ctx.argc < 3:
        usage(EX_MISSING_ARGS, _(u'Missing alias domain name and destination '
                                 u'domain name.'), ctx.scmd)
    elif ctx.argc < 4:
        usage(EX_MISSING_ARGS, _(u'Missing destination domain name.'),
              ctx.scmd)
    ctx.hdlr.aliasdomain_add(ctx.args[2].lower(), ctx.args[3].lower())


def aliasdomain_delete(ctx):
    """delete the specified alias domain"""
    if ctx.argc < 3:
        usage(EX_MISSING_ARGS, _(u'Missing alias domain name.'), ctx.scmd)
    ctx.hdlr.aliasdomain_delete(ctx.args[2].lower())


def aliasdomain_info(ctx):
    """show the destination of the given alias domain"""
    if ctx.argc < 3:
        usage(EX_MISSING_ARGS, _(u'Missing alias domain name.'), ctx.scmd)
    try:
        _print_aliasdomain_info(ctx.hdlr.aliasdomain_info(ctx.args[2].lower()))
    except VMMError, err:
        if err.code is ALIASDOMAIN_ISDOMAIN:
            w_err(0, ctx.plan_a_b % {'subcommand': u'domaininfo',
                  'object': ctx.args[2].lower()})
            ctx.scmd = ctx.args[1] = 'domaininfo'
            domain_info(ctx)
        else:
            raise


def aliasdomain_switch(ctx):
    """assign the given alias domain to an other domain"""
    if ctx.argc < 3:
        usage(EX_MISSING_ARGS, _(u'Missing alias domain name and destination '
                                 u'domain name.'), ctx.scmd)
    elif ctx.argc < 4:
        usage(EX_MISSING_ARGS, _(u'Missing destination domain name.'),
              ctx.scmd)
    ctx.hdlr.aliasdomain_switch(ctx.args[2].lower(), ctx.args[3].lower())


def config_get(ctx):
    """show the actual value of the configuration option"""
    if ctx.argc < 3:
        usage(EX_MISSING_ARGS, _(u"Missing option name."), ctx.scmd)

    noop = lambda option: option
    opt_formater = {
        'misc.dovecot_version': version_str,
        'domain.quota_bytes': human_size,
    }

    option = ctx.args[2].lower()
    w_std('%s = %s' % (option, opt_formater.get(option,
                       noop)(ctx.cget(option))))


def config_set(ctx):
    """set a new value for the configuration option"""
    if ctx.argc < 3:
        usage(EX_MISSING_ARGS, _(u'Missing option and new value.'), ctx.scmd)
    if ctx.argc < 4:
        usage(EX_MISSING_ARGS, _(u'Missing new configuration value.'),
              ctx.scmd)
    ctx.hdlr.cfg_set(ctx.args[2].lower(), ctx.args[3])


def configure(ctx):
    """start interactive configuration modus"""
    if ctx.argc < 3:
        ctx.hdlr.configure()
    else:
        ctx.hdlr.configure(ctx.args[2].lower())


def domain_add(ctx):
    """create a new domain"""
    if ctx.argc < 3:
        usage(EX_MISSING_ARGS, _(u'Missing domain name.'), ctx.scmd)
    elif ctx.argc < 4:
        ctx.hdlr.domain_add(ctx.args[2].lower())
    else:
        ctx.hdlr.domain_add(ctx.args[2].lower(), ctx.args[3])
    if ctx.cget('domain.auto_postmaster'):
        w_std(_(u'Creating account for postmaster@%s') % ctx.args[2].lower())
        ctx.scmd = 'useradd'
        ctx.args = [prog, ctx.scmd, u'postmaster@' + ctx.args[2].lower()]
        ctx.argc = 3
        user_add(ctx)


def domain_delete(ctx):
    """delete the given domain and all its alias domains"""
    if ctx.argc < 3:
        usage(EX_MISSING_ARGS, _(u'Missing domain name.'), ctx.scmd)
    elif ctx.argc < 4:
        ctx.hdlr.domain_delete(ctx.args[2].lower())
    elif ctx.args[3].lower() == 'force':
        ctx.hdlr.domain_delete(ctx.args[2].lower(), True)
    else:
        usage(INVALID_ARGUMENT, _(u"Invalid argument: '%s'") % ctx.args[3],
              ctx.scmd)


def domain_info(ctx):
    """display information about the given domain"""
    if ctx.argc < 3:
        usage(EX_MISSING_ARGS, _(u'Missing domain name.'), ctx.scmd)
    if ctx.argc < 4:
        details = None
    else:
        details = ctx.args[3].lower()
        if details not in ('accounts', 'aliasdomains', 'aliases', 'full',
                           'relocated'):
            usage(INVALID_ARGUMENT, _(u"Invalid argument: '%s'") % details,
                  ctx.scmd)
    try:
        info = ctx.hdlr.domain_info(ctx.args[2].lower(), details)
    except VMMError, err:
        if err.code is DOMAIN_ALIAS_EXISTS:
            w_err(0, ctx.plan_a_b % {'subcommand': u'aliasdomaininfo',
                  'object': ctx.args[2].lower()})
            ctx.scmd = ctx.args[1] = 'aliasdomaininfo'
            aliasdomain_info(ctx)
        else:
            raise
    else:
        q_limit = u'Storage: %(bytes)s; Messages: %(messages)s'
        if not details:
            info['bytes'] = human_size(info['bytes'])
            info['messages'] = locale.format('%d', info['messages'], True)
            info['quota limit/user'] = q_limit % info
            _print_info(ctx, info, _(u'Domain'))
        else:
            info[0]['bytes'] = human_size(info[0]['bytes'])
            info[0]['messages'] = locale.format('%d', info[0]['messages'],
                                                True)
            info[0]['quota limit/user'] = q_limit % info[0]
            _print_info(ctx, info[0], _(u'Domain'))
            if details == u'accounts':
                _print_list(info[1], _(u'accounts'))
            elif details == u'aliasdomains':
                _print_list(info[1], _(u'alias domains'))
            elif details == u'aliases':
                _print_list(info[1], _(u'aliases'))
            elif details == u'relocated':
                _print_list(info[1], _(u'relocated users'))
            else:
                _print_list(info[1], _(u'alias domains'))
                _print_list(info[2], _(u'accounts'))
                _print_list(info[3], _(u'aliases'))
                _print_list(info[4], _(u'relocated users'))


def domain_quota(ctx):
    """update the quota limit of the specified domain"""
    if ctx.argc < 3:
        usage(EX_MISSING_ARGS, _(u'Missing domain name and storage value.'),
              ctx.scmd)
    if ctx.argc < 4:
        usage(EX_MISSING_ARGS, _(u'Missing storage value.'), ctx.scmd)
    messages = 0
    force = None
    try:
        bytes_ = size_in_bytes(ctx.args[3])
    except (ValueError, TypeError):
        usage(INVALID_ARGUMENT, _(u"Invalid storage value: '%s'") %
              ctx.args[3], ctx.scmd)
    if ctx.argc < 5:
        pass
    elif ctx.argc < 6:
        try:
            messages = int(ctx.args[4])
        except ValueError:
            if ctx.args[4].lower() != 'force':
                usage(INVALID_ARGUMENT,
                      _(u"Neither a valid number of messages nor the keyword "
                        u"'force': '%s'") % ctx.args[4], ctx.scmd)
            force = 'force'
    else:
        try:
            messages = int(ctx.args[4])
        except ValueError:
            usage(INVALID_ARGUMENT,
                  _(u"Not a valid number of messages: '%s'") % ctx.args[4],
                  ctx.scmd)
        if ctx.args[5].lower() != 'force':
            usage(INVALID_ARGUMENT, _(u"Invalid argument: '%s'") % ctx.args[5],
                  ctx.scmd)
        force = 'force'
    ctx.hdlr.domain_quotalimit(ctx.args[2].lower(), bytes_, messages, force)


def domain_services(ctx):
    """allow all named service and block the uncredited."""
    if ctx.argc < 3:
        usage(EX_MISSING_ARGS, _(u'Missing domain name.'), ctx.scmd)
    services = []
    force = False
    if ctx.argc is 3:
        pass
    elif ctx.argc is 4:
        arg = ctx.args[3].lower()
        if arg in SERVICES:
            services.append(arg)
        elif arg == 'force':
            force = True
        else:
            usage(INVALID_ARGUMENT, _(u"Invalid argument: '%s'") % arg,
                  ctx.scmd)
    else:
        services.extend([service.lower() for service in ctx.args[3:-1]])
        arg = ctx.args[-1].lower()
        if arg == 'force':
            force = True
        else:
            services.append(arg)
        unknown = [service for service in services if service not in SERVICES]
        if unknown:
            usage(INVALID_ARGUMENT, _(u'Invalid service arguments: %s') %
                  ' '.join(unknown), ctx.scmd)
    ctx.hdlr.domain_services(ctx.args[2].lower(), (None, 'force')[force],
                             *services)


def domain_transport(ctx):
    """update the transport of the specified domain"""
    if ctx.argc < 3:
        usage(EX_MISSING_ARGS, _(u'Missing domain name and new transport.'),
              ctx.scmd)
    if ctx.argc < 4:
        usage(EX_MISSING_ARGS, _(u'Missing new transport.'), ctx.scmd)
    if ctx.argc < 5:
        ctx.hdlr.domain_transport(ctx.args[2].lower(), ctx.args[3])
    else:
        force = ctx.args[4].lower()
        if force != 'force':
            usage(INVALID_ARGUMENT, _(u"Invalid argument: '%s'") % force,
                  ctx.scmd)
        ctx.hdlr.domain_transport(ctx.args[2].lower(), ctx.args[3], force)


def get_user(ctx):
    """get the address of the user with the given UID"""
    if ctx.argc < 3:
        usage(EX_MISSING_ARGS, _(u'Missing UID.'), ctx.scmd)
    _print_info(ctx, ctx.hdlr.user_by_uid(ctx.args[2]), _(u'Account'))


def help_(ctx):
    """print help messages."""
    if ctx.argc > 2:
        hlptpc = ctx.args[2].lower()
        if hlptpc in cmd_map:
            topic = hlptpc
        else:
            for scmd in cmd_map.itervalues():
                if scmd.alias == hlptpc:
                    topic = scmd.name
                    break
            else:
                usage(INVALID_ARGUMENT, _(u"Unknown help topic: '%s'") %
                      ctx.args[2], ctx.scmd)
        # FIXME
        w_err(1, "'help %s' not yet implemented." % topic, 'see also: vmm(1)')

    old_ii = txt_wrpr.initial_indent
    old_si = txt_wrpr.subsequent_indent
    txt_wrpr.initial_indent = ' '
    # len(max(_overview.iterkeys(), key=len)) #Py25
    txt_wrpr.subsequent_indent = 20 * ' '
    order = cmd_map.keys()
    order.sort()

    w_std(_(u'List of available subcommands:') + '\n')
    for key in order:
        w_std('\n'.join(txt_wrpr.wrap('%-18s %s' % (key, cmd_map[key].descr))))

    txt_wrpr.initial_indent = old_ii
    txt_wrpr.subsequent_indent = old_si
    txt_wrpr.initial_indent = ''


def list_domains(ctx):
    """list all domains / search domains by pattern"""
    matching = ctx.argc > 2
    if matching:
        gids, domains = ctx.hdlr.domain_list(ctx.args[2].lower())
    else:
        gids, domains = ctx.hdlr.domain_list()
    _print_domain_list(gids, domains, matching)


def list_pwschemes(ctx_unused):
    """Prints all usable password schemes and password encoding suffixes."""
    # TODO: Remove trailing colons from keys.
    # For now it is to late, the translators has stared their work
    keys = (_(u'Usable password schemes:'), _(u'Usable encoding suffixes:'))
    old_ii, old_si = txt_wrpr.initial_indent, txt_wrpr.subsequent_indent
    txt_wrpr.initial_indent = txt_wrpr.subsequent_indent = '\t'
    txt_wrpr.width = txt_wrpr.width - 8

    for key, value in zip(keys, list_schemes()):
        if key.endswith(':'):  # who knows … (see TODO above)
            #key = key.rpartition(':')[0]
            key = key[:-1]  # This one is for Py24
        w_std(key, len(key) * '-')
        w_std('\n'.join(txt_wrpr.wrap(' '.join(value))), '')

    txt_wrpr.initial_indent, txt_wrpr.subsequent_indent = old_ii, old_si
    txt_wrpr.width = txt_wrpr.width + 8


def relocated_add(ctx):
    """create a new record for a relocated user"""
    if ctx.argc < 3:
        usage(EX_MISSING_ARGS,
              _(u'Missing relocated address and destination.'), ctx.scmd)
    elif ctx.argc < 4:
        usage(EX_MISSING_ARGS, _(u'Missing destination address.'), ctx.scmd)
    ctx.hdlr.relocated_add(ctx.args[2].lower(), ctx.args[3])


def relocated_delete(ctx):
    """delete the record of the relocated user"""
    if ctx.argc < 3:
        usage(EX_MISSING_ARGS, _(u'Missing relocated address.'), ctx.scmd)
    ctx.hdlr.relocated_delete(ctx.args[2].lower())


def relocated_info(ctx):
    """print information about a relocated user"""
    if ctx.argc < 3:
        usage(EX_MISSING_ARGS, _(u'Missing relocated address.'), ctx.scmd)
    relocated = ctx.args[2].lower()
    try:
        _print_relocated_info(addr=relocated,
                              dest=ctx.hdlr.relocated_info(relocated))
    except VMMError, err:
        if err.code is ACCOUNT_EXISTS:
            w_err(0, ctx.plan_a_b % {'subcommand': u'userinfo',
                  'object': relocated})
            ctx.scmd = ctx.args[1] = 'userinfoi'
            user_info(ctx)
        elif err.code is ALIAS_EXISTS:
            w_err(0, ctx.plan_a_b % {'subcommand': u'aliasinfo',
                  'object': relocated})
            ctx.scmd = ctx.args[1] = 'aliasinfo'
            alias_info(ctx)
        else:
            raise


def user_add(ctx):
    """create a new e-mail user with the given address"""
    if ctx.argc < 3:
        usage(EX_MISSING_ARGS, _(u'Missing e-mail address.'), ctx.scmd)
    elif ctx.argc < 4:
        password = None
    else:
        password = ctx.args[3]
    gen_pass = ctx.hdlr.user_add(ctx.args[2].lower(), password)
    if ctx.argc < 4 and gen_pass:
        w_std(_(u"Generated password: %s") % gen_pass)


def user_delete(ctx):
    """delete the specified user"""
    if ctx.argc < 3:
        usage(EX_MISSING_ARGS, _(u'Missing e-mail address.'), ctx.scmd)
    elif ctx.argc < 4:
        ctx.hdlr.user_delete(ctx.args[2].lower())
    elif ctx.args[3].lower() == 'force':
        ctx.hdlr.user_delete(ctx.args[2].lower(), True)
    else:
        usage(INVALID_ARGUMENT, _(u"Invalid argument: '%s'") % ctx.args[3],
              ctx.scmd)


def user_info(ctx):
    """display information about the given address"""
    if ctx.argc < 3:
        usage(EX_MISSING_ARGS, _(u'Missing e-mail address.'), ctx.scmd)
    if ctx.argc < 4:
        details = None
    else:
        details = ctx.args[3].lower()
        if details not in ('aliases', 'du', 'full'):
            usage(INVALID_ARGUMENT, _(u"Invalid argument: '%s'") % details,
                  ctx.scmd)
    try:
        info = ctx.hdlr.user_info(ctx.args[2].lower(), details)
    except VMMError, err:
        if err.code is ALIAS_EXISTS:
            w_err(0, ctx.plan_a_b % {'subcommand': u'aliasinfo',
                  'object': ctx.args[2].lower()})
            ctx.scmd = ctx.args[1] = 'aliasinfo'
            alias_info(ctx)
        elif err.code is RELOCATED_EXISTS:
            w_err(0, ctx.plan_a_b % {'subcommand': u'relocatedinfo',
                  'object': ctx.args[2].lower()})
            ctx.scmd = ctx.args[1] = 'relocatedinfo'
            relocated_info(ctx)
        else:
            raise
    else:
        if details in (None, 'du'):
            info['quota storage'] = _format_quota_usage(info['ql_bytes'],
                    info['uq_bytes'], True)
            info['quota messages'] = _format_quota_usage(info['ql_messages'],
                    info['uq_messages'])
            _print_info(ctx, info, _(u'Account'))
        else:
            info[0]['quota storage'] = _format_quota_usage(info[0]['ql_bytes'],
                    info[0]['uq_bytes'], True)
            info[0]['quota messages'] = _format_quota_usage(
                    info[0]['ql_messages'], info[0]['uq_messages'])
            _print_info(ctx, info[0], _(u'Account'))
            _print_list(info[1], _(u'alias addresses'))


def user_name(ctx):
    """set or update the real name for an address"""
    if ctx.argc < 3:
        usage(EX_MISSING_ARGS, _(u"Missing e-mail address and user's name."),
              ctx.scmd)
    if ctx.argc < 4:
        usage(EX_MISSING_ARGS, _(u"Missing user's name."), ctx.scmd)
    ctx.hdlr.user_name(ctx.args[2].lower(), ctx.args[3])


def user_password(ctx):
    """update the password for the given address"""
    if ctx.argc < 3:
        usage(EX_MISSING_ARGS, _(u'Missing e-mail address.'), ctx.scmd)
    elif ctx.argc < 4:
        password = None
    else:
        password = ctx.args[3]
    ctx.hdlr.user_password(ctx.args[2].lower(), password)


def user_quota(ctx):
    """update the quota limit for the given address"""
    if ctx.argc < 3:
        usage(EX_MISSING_ARGS, _(u'Missing e-mail address and storage value.'),
              ctx.scmd)
    elif ctx.argc < 4:
        usage(EX_MISSING_ARGS, _(u'Missing storage value.'), ctx.scmd)
    try:
        bytes_ = size_in_bytes(ctx.args[3])
    except (ValueError, TypeError):
        usage(INVALID_ARGUMENT, _(u"Invalid storage value: '%s'") %
              ctx.args[3], ctx.scmd)
    if ctx.argc < 5:
        messages = 0
    else:
        try:
            messages = int(ctx.args[4])
        except ValueError:
            usage(INVALID_ARGUMENT,
                  _(u"Not a valid number of messages: '%s'") % ctx.args[4],
                  ctx.scmd)
    ctx.hdlr.user_quotalimit(ctx.args[2].lower(), bytes_, messages)


def user_services(ctx):
    """allow all named service and block the uncredited."""
    if ctx.argc < 3:
        usage(EX_MISSING_ARGS, _(u'Missing e-mail address.'), ctx.scmd)
    services = []
    if ctx.argc >= 4:
        services.extend([service.lower() for service in ctx.args[3:]])
        unknown = [service for service in services if service not in SERVICES]
        if unknown:
            usage(INVALID_ARGUMENT, _(u'Invalid service arguments: %s') %
                  ' '.join(unknown), ctx.scmd)
    ctx.hdlr.user_services(ctx.args[2].lower(), *services)


def user_transport(ctx):
    """update the transport of the given address"""
    if ctx.argc < 3:
        usage(EX_MISSING_ARGS, _(u'Missing e-mail address and transport.'),
              ctx.scmd)
    if ctx.argc < 4:
        usage(EX_MISSING_ARGS, _(u'Missing transport.'), ctx.scmd)
    ctx.hdlr.user_transport(ctx.args[2].lower(), ctx.args[3])


def usage(errno, errmsg, subcommand=None):
    """print usage message for the given command or all commands.
    When errno > 0, sys,exit(errno) will interrupt the program.
    """
    if subcommand and subcommand in cmd_map:
        w_err(errno, _(u"Error: %s") % errmsg,
              _(u"usage: ") + cmd_map[subcommand].usage)

    # TP: Please adjust translated words like the original text.
    # (It's a table header.) Extract from usage text:
    # usage: vmm subcommand arguments
    #   short long
    #   subcommand                arguments
    #
    #   da    domainadd           fqdn [transport]
    #   dd    domaindelete        fqdn [force]
    u_head = _(u"""usage: %s subcommand arguments
  short long
  subcommand                arguments\n""") % prog
    order = cmd_map.keys()
    order.sort()
    w_err(0, u_head)
    for key in order:
        scmd = cmd_map[key]
        w_err(0, '  %-5s %-19s %s' % (scmd.alias, scmd.name, scmd.args))
    w_err(errno, '', _(u"Error: %s") % errmsg)


def version(ctx_unused):
    """Write version and copyright information to stdout."""
    w_std('%s, %s %s (%s %s)\nPython %s %s %s\n\n%s\n%s %s' % (prog,
    # TP: The words 'from', 'version' and 'on' are used in
    # the version information, e.g.:
    # vmm, version 0.5.2 (from 09/09/09)
    # Python 2.5.4 on FreeBSD
        _(u'version'), __version__, _(u'from'),
        strftime(locale.nl_langinfo(locale.D_FMT),
            strptime(__date__, '%Y-%m-%d')).decode(ENCODING, 'replace'),
        os.sys.version.split()[0], _(u'on'), os.uname()[0],
        __copyright__, prog,
        _(u'is free software and comes with ABSOLUTELY NO WARRANTY.')))


def update_cmd_map():
    """Update the cmd_map, after gettext's _ was installed."""
    cmd = Command
    cmd_map.update({
    # Account commands
    'getuser': cmd('getuser', 'gu', get_user, 'uid',
                   _(u'get the address of the user with the given UID')),
    'useradd': cmd('useradd', 'ua', user_add, 'address [password]',
                   _(u'create a new e-mail user with the given address')),
    'userdelete': cmd('userdelete', 'ud', user_delete, 'address [force]',
                      _(u'delete the specified user')),
    'userinfo': cmd('userinfo', 'ui', user_info, 'address [details]',
                    _(u'display information about the given address')),
    'username': cmd('username', 'un', user_name, 'address name',
                    _(u'set or update the real name for an address')),
    'userpassword': cmd('userpassword', 'up', user_password,
                        'address [password]',
                        _(u'update the password for the given address')),
    'userquota': cmd('userquota', 'uq', user_quota,
                     'address storage [messages]',
                     _(u'update the quota limit for the given address')),
    'userservices': cmd('userservices', 'us', user_services,
                        'address [service ...]',
                        _(u'enables the specified services and disables all '
                          u'not specified services')),
    'usertransport': cmd('usertransport', 'ut', user_transport,
                         'address transport',
                         _(u'update the transport of the given address')),
    # Alias commands
    'aliasadd': cmd('aliasadd', 'aa', alias_add, 'address destination ...',
                    _(u'create a new alias e-mail address with one or more '
                      u'destinations')),
    'aliasdelete': cmd('aliasdelete', 'ad', alias_delete,
                       'address [destination]',
                       _(u'delete the specified alias e-mail address or one '
                         u'of its destinations')),
    'aliasinfo': cmd('aliasinfo', 'ai', alias_info, 'address',
                     _(u'show the destination(s) of the specified alias')),
    # AliasDomain commands
    'aliasdomainadd': cmd('aliasdomainadd', 'ada', aliasdomain_add,
                          'fqdn destination',
                          _(u'create a new alias for an existing domain')),
    'aliasdomaindelete': cmd('aliasdomaindelete', 'add', aliasdomain_delete,
                             'fqdn', _(u'delete the specified alias domain')),
    'aliasdomaininfo': cmd('aliasdomaininfo', 'adi', aliasdomain_info, 'fqdn',
                         _(u'show the destination of the given alias domain')),
    'aliasdomainswitch': cmd('aliasdomainswitch', 'ads', aliasdomain_switch,
                             'fqdn destination', _(u'assign the given alias '
                             'domain to an other domain')),
    # Domain commands
    'domainadd': cmd('domainadd', 'da', domain_add, 'fqdn [transport]',
                     _(u'create a new domain')),
    'domaindelete': cmd('domaindelete', 'dd', domain_delete, 'fqdn [force]',
                      _(u'delete the given domain and all its alias domains')),
    'domaininfo': cmd('domaininfo', 'di', domain_info, 'fqdn [details]',
                      _(u'display information about the given domain')),
    'domainquota': cmd('domainquota', 'dq', domain_quota,
                       'fqdn storage [messages] [force]',
                       _(u'update the quota limit of the specified domain')),
    'domainservices': cmd('domainservices', 'ds', domain_services,
                          'fqdn [service ...] [force]',
                          _(u'enables the specified services and disables all '
                            u'not specified services of the given domain')),
    'domaintransport': cmd('domaintransport', 'dt', domain_transport,
                           'fqdn transport [force]',
                           _(u'update the transport of the specified domain')),
    'listdomains': cmd('listdomains', 'ld', list_domains, '[pattern]',
                      _(u'list all domains or search for domains by pattern')),
    # Relocated commands
    'relocatedadd': cmd('relocatedadd', 'ra', relocated_add,
                        'address newaddress',
                        _(u'create a new record for a relocated user')),
    'relocateddelete': cmd('relocateddelete', 'rd', relocated_delete,
                           'address',
                           _(u'delete the record of the relocated user')),
    'relocatedinfo': cmd('relocatedinfo', 'ri', relocated_info, 'address',
                         _(u'print information about a relocated user')),
    # cli commands
    'configget': cmd('configget', 'cg', config_get, 'option',
                     _('show the actual value of the configuration option')),
    'configset': cmd('configset', 'cs', config_set, 'option value',
                      _('set a new value for the configuration option')),
    'configure': cmd('configure', 'cf', configure, '[section]',
                     _(u'start interactive configuration modus')),
    'listpwschemes': cmd('listpwschemes', 'lp', list_pwschemes, '',
                         _(u'lists all usable password schemes and password '
                           u'encoding suffixes')),
    'help': cmd('help', 'h', help_, '[subcommand]',
                _(u'show a help overview or help for the given subcommand')),
    'version': cmd('version', 'v', version, '',
                   _(u'show version and copyright information')),
    })


def _get_order(ctx):
    """returns a tuple with (key, 1||0) tuples. Used by functions, which
    get a dict from the handler."""
    order = ()
    if ctx.scmd == 'domaininfo':
        order = ((u'domain name', 0), (u'gid', 1), (u'domain directory', 0),
                 (u'quota limit/user', 0), (u'active services', 0),
                 (u'transport', 0), (u'alias domains', 0), (u'accounts', 0),
                 (u'aliases', 0), (u'relocated', 0))
    elif ctx.scmd == 'userinfo':
        if ctx.argc == 4 and ctx.args[3] != u'aliases' or \
           ctx.cget('account.disk_usage'):
            order = ((u'address', 0), (u'name', 0), (u'uid', 1), (u'gid', 1),
                     (u'home', 0), (u'mail_location', 0),
                     (u'quota storage', 0), (u'quota messages', 0),
                     (u'disk usage', 0), (u'transport', 0), (u'smtp', 1),
                     (u'pop3', 1), (u'imap', 1), (u'sieve', 1))
        else:
            order = ((u'address', 0), (u'name', 0), (u'uid', 1), (u'gid', 1),
                     (u'home', 0), (u'mail_location', 0),
                     (u'quota storage', 0), (u'quota messages', 0),
                     (u'transport', 0), (u'smtp', 1), (u'pop3', 1),
                     (u'imap', 1), (u'sieve', 1))
    elif ctx.scmd == 'getuser':
        order = ((u'uid', 1), (u'gid', 1), (u'address', 0))
    return order


def _format_quota_usage(limit, used, human=False):
    """Put quota's limit / usage / percentage in a formatted string."""
    if human:
        q_usage = {
            'used': human_size(used),
            'limit': human_size(limit),
        }
    else:
        q_usage = {
            'used': locale.format('%d', used, True),
            'limit': locale.format('%d', limit, True),
        }
    if limit:
        q_usage['percent'] = locale.format('%6.2f', 100. / limit * used, True)
    else:
        q_usage['percent'] = locale.format('%6.2f', 0, True)
    return _(u'[%(percent)s%%] %(used)s/%(limit)s') % q_usage


def _print_info(ctx, info, title):
    """Print info dicts."""
    # TP: used in e.g. 'Domain information' or 'Account information'
    msg = u'%s %s' % (title, _(u'information'))
    w_std(msg, u'-' * len(msg))
    for key, upper in _get_order(ctx):
        if upper:
            w_std(u'\t%s: %s' % (key.upper().ljust(17, u'.'), info[key]))
        else:
            w_std(u'\t%s: %s' % (key.title().ljust(17, u'.'), info[key]))
    print


def _print_list(alist, title):
    """Print a list."""
    # TP: used in e.g. 'Existing alias addresses' or 'Existing accounts'
    msg = u'%s %s' % (_(u'Existing'), title)
    w_std(msg, u'-' * len(msg))
    if alist:
        if title != _(u'alias domains'):
            w_std(*(u'\t%s' % item for item in alist))
        else:
            for domain in alist:
                if not domain.startswith('xn--'):
                    w_std(u'\t%s' % domain)
                else:
                    w_std(u'\t%s (%s)' % (domain, domain.decode('idna')))
        print
    else:
        w_std(_(u'\tNone'), '')


def _print_aliase_info(alias, destinations):
    """Print the alias address and all its destinations"""
    title = _(u'Alias information')
    w_std(title, u'-' * len(title))
    w_std(_(u'\tMail for %s will be redirected to:') % alias)
    w_std(*(u'\t     * %s' % dest for dest in destinations))
    print


def _print_relocated_info(**kwargs):
    """Print the old and new addresses of a relocated user."""
    title = _(u'Relocated information')
    w_std(title, u'-' * len(title))
    w_std(_(u"\tUser '%(addr)s' has moved to '%(dest)s'") % kwargs, '')


def _format_domain(domain, main=True):
    """format (prefix/convert) the domain name."""
    if domain.startswith('xn--'):
        domain = u'%s (%s)' % (domain, domain.decode('idna'))
    if main:
        return u'\t[+] %s' % domain
    return u'\t[-]     %s' % domain


def _print_domain_list(dids, domains, matching):
    """Print a list of (matching) domains/alias domains."""
    if matching:
        title = _(u'Matching domains')
    else:
        title = _(u'Existing domains')
    w_std(title, '-' * len(title))
    if domains:
        for did in dids:
            if domains[did][0] is not None:
                w_std(_format_domain(domains[did][0]))
            if len(domains[did]) > 1:
                w_std(*(_format_domain(a, False) for a in domains[did][1:]))
    else:
        w_std(_('\tNone'))
    print


def _print_aliasdomain_info(info):
    """Print alias domain information."""
    title = _(u'Alias domain information')
    for key in ('alias', 'domain'):
        if info[key].startswith('xn--'):
            info[key] = u'%s (%s)' % (info[key], info[key].decode('idna'))
    w_std(title, '-' * len(title),
          _('\tThe alias domain %(alias)s belongs to:\n\t    * %(domain)s') %
          info, '')

del _