# -*- coding: UTF-8 -*-

# Copyright (c) 2007 - 2010, Pascal Volk

# See COPYING for distribution information.

"""Virtual Mail Manager's Domain class to manage e-mail domains."""

from random import choice

from VirtualMailManager import check_domainname

from VirtualMailManager.constants.ERROR import \

     ACCOUNT_AND_ALIAS_PRESENT, ACCOUNT_PRESENT, ALIAS_PRESENT, \

     DOMAIN_ALIAS_EXISTS, DOMAIN_EXISTS, NO_SUCH_DOMAIN

from VirtualMailManager.errors import DomainError as DomErr

from VirtualMailManager.Transport import Transport

MAILDIR_CHARS = '0123456789abcdefghijklmnopqrstuvwxyz'

class Domain(object):

    """Class to manage e-mail domains."""

    __slots__ = ('_basedir','_domaindir','_id','_name','_transport','_dbh')

    def __init__(self, dbh, domainname, basedir=None, transport=None):

        """Creates a new Domain instance.

        Keyword arguments:

        dbh -- a pyPgSQL.PgSQL.connection

        domainname -- name of the domain (str)

        transport -- default vmm.cfg/misc/transport  (str)

        """

        self._dbh = dbh

        self._name = check_domainname(domainname)

        self._basedir = basedir

        if transport is not None:

            self._transport = Transport(self._dbh, transport=transport)

        else:

            self._transport = transport

        self._id = 0

        self._domaindir = None

        if not self._exists() and self._isAlias():

            raise DomErr(_(u"The domain “%s” is an alias domain.") %

                         self._name, DOMAIN_ALIAS_EXISTS)

    def _exists(self):

        """Checks if the domain already exists.

        If the domain exists _id will be set and returns True, otherwise False

        will be returned.

        """

        dbc = self._dbh.cursor()

        dbc.execute("SELECT gid, tid, domaindir FROM domain_data WHERE gid =\

 (SELECT gid FROM domain_name WHERE domainname = %s AND is_primary)",

                self._name)

        result = dbc.fetchone()

        dbc.close()

        if result is not None:

            self._id, self._domaindir = result[0], result[2]

            self._transport = Transport(self._dbh, tid=result[1])

            return True

        else:

            return False

    def _isAlias(self):

        """Checks if self._name is known for an alias domain."""

        dbc = self._dbh.cursor()

        dbc.execute('SELECT is_primary FROM domain_name WHERE domainname = %s',

                self._name)

        result = dbc.fetchone()

        dbc.close()

        if result is not None and not result[0]:

            return True

        else:

            return False

    def _setID(self):

        """Sets the ID of the domain."""

        dbc = self._dbh.cursor()

        dbc.execute("SELECT nextval('domain_gid')")

        self._id = dbc.fetchone()[0]

        dbc.close()

    def _prepare(self):

        self._setID()

        self._domaindir = "%s/%s/%i" % (self._basedir, choice(MAILDIR_CHARS),

                self._id)

    def _has(self, what):

        """Checks if aliases or accounts are assigned to the domain.

        If there are assigned accounts or aliases True will be returned,

        otherwise False will be returned.

        Keyword arguments:

        what -- 'alias' or 'users' (strings)

        """

        if what not in ['alias', 'users']:

            return False

        dbc = self._dbh.cursor()

        if what == 'users':

            dbc.execute("SELECT count(gid) FROM users WHERE gid=%s", self._id)

        else:

            dbc.execute("SELECT count(gid) FROM alias WHERE gid=%s", self._id)

        count = dbc.fetchone()

        dbc.close()

        if count[0] > 0:

            return True

        else:

            return False

    def _chkDelete(self, delUser, delAlias):

        """Checks dependencies for deletion.

        Keyword arguments:

        delUser -- ignore available accounts (bool)

        delAlias -- ignore available aliases (bool)

        """

        if not delUser:

            hasUser = self._has('users')

        else:

            hasUser = False

        if not delAlias:

            hasAlias = self._has('alias')

        else:

            hasAlias = False

        if hasUser and hasAlias:

            raise DomErr(_(u'There are accounts and aliases.'),

                         ACCOUNT_AND_ALIAS_PRESENT)

        elif hasUser:

            raise DomErr(_(u'There are accounts.'), ACCOUNT_PRESENT)

        elif hasAlias:

            raise DomErr(_(u'There are aliases.'), ALIAS_PRESENT)

    def save(self):

        """Stores the new domain in the database."""

        if self._id < 1:

            self._prepare()

            dbc = self._dbh.cursor()

            dbc.execute("INSERT INTO domain_data (gid, tid, domaindir)\

 VALUES (%s, %s, %s)", self._id, self._transport.getID(), self._domaindir)

            dbc.execute("INSERT INTO domain_name (domainname, gid, is_primary)\

 VALUES (%s, %s, %s)", self._name, self._id, True)

            self._dbh.commit()

            dbc.close()

        else:

            raise DomErr(_(u'The domain “%s” already exists.') % self._name,

                         DOMAIN_EXISTS)

    def delete(self, delUser=False, delAlias=False):

        """Deletes the domain.

        Keyword arguments:

        delUser -- force deletion of available accounts (bool)

        delAlias -- force deletion of available aliases (bool)

        """

        if self._id > 0:

            self._chkDelete(delUser, delAlias)

            dbc = self._dbh.cursor()

            for t in ('alias','users','relocated','domain_name','domain_data'):

                dbc.execute("DELETE FROM %s WHERE gid = %d" % (t, self._id))

            self._dbh.commit()

            dbc.close()

        else:

            raise DomErr(_(u"The domain “%s” doesn't exist.") % self._name,

                         NO_SUCH_DOMAIN)

    def updateTransport(self, transport, force=False):

        """Sets a new transport for the domain.

        Keyword arguments:

        transport -- the new transport (str)

        force -- True/False force new transport for all accounts (bool)

        """

        if self._id > 0:

            if transport == self._transport.getTransport():

                return

            trsp = Transport(self._dbh, transport=transport)

            dbc = self._dbh.cursor()

            dbc.execute("UPDATE domain_data SET tid = %s WHERE gid = %s",

                    trsp.getID(), self._id)

            if dbc.rowcount > 0:

                self._dbh.commit()

            if force:

                dbc.execute("UPDATE users SET tid = %s WHERE gid = %s",

                        trsp.getID(), self._id)

                if dbc.rowcount > 0:

                    self._dbh.commit()

            dbc.close()

        else:

            raise DomErr(_(u"The domain “%s” doesn't exist.") % self._name,

                         NO_SUCH_DOMAIN)

    def getID(self):

        """Returns the ID of the domain."""

        return self._id

    def getDir(self):

        """Returns the directory of the domain."""

        return self._domaindir

    def getTransport(self):

        """Returns domain's transport."""

        return self._transport.getTransport()

    def getTransportID(self):

        """Returns the ID from the domain's transport."""

        return self._transport.getID()

    def getInfo(self):

        """Returns a dictionary with information about the domain."""

        sql = """\

SELECT gid, domainname, transport, domaindir, aliasdomains, accounts,

       aliases, relocated

  FROM vmm_domain_info

 WHERE gid = %i""" % self._id

        dbc = self._dbh.cursor()

        dbc.execute(sql)

        info = dbc.fetchone()

        dbc.close()

        if info is None:

            raise DomErr(_(u"The domain “%s” doesn't exist.") % self._name,

                         NO_SUCH_DOMAIN)

        else:

            keys = ['gid', 'domainname', 'transport', 'domaindir',

                    'aliasdomains', 'accounts', 'aliases', 'relocated']

            return dict(zip(keys, info))

    def getAccounts(self):

        """Returns a list with all accounts from the domain."""

        dbc = self._dbh.cursor()

        dbc.execute("SELECT local_part from users where gid = %s ORDER BY\

 local_part", self._id)

        users = dbc.fetchall()

        dbc.close()

        accounts = []

        if len(users) > 0:

            addr = u'@'.join

            _dom = self._name

            accounts = [addr((account[0], _dom)) for account in users]

        return accounts

    def getAliases(self):

        """Returns a list with all aliases from the domain."""

        dbc = self._dbh.cursor()

        dbc.execute("SELECT DISTINCT address FROM alias WHERE gid = %s\

 ORDER BY address",  self._id)

        addresses = dbc.fetchall()

        dbc.close()

        aliases = []

        if len(addresses) > 0:

            addr = u'@'.join

            _dom = self._name

            aliases = [addr((alias[0], _dom)) for alias in addresses]

        return aliases

    def getRelocated(self):

        """Returns a list with all addresses from relocated users."""

        dbc = self._dbh.cursor()

        dbc.execute("SELECT address FROM relocated WHERE gid = %s\

 ORDER BY address", self._id)

        addresses = dbc.fetchall()

        dbc.close()

        relocated = []

        if len(addresses) > 0:

            addr = u'@'.join

            _dom = self._name

            relocated = [addr((address[0], _dom)) for address in addresses]

        return relocated

    def getAliaseNames(self):

        """Returns a list with all alias names from the domain."""

        dbc = self._dbh.cursor()

        dbc.execute("SELECT domainname FROM domain_name WHERE gid = %s\

 AND NOT is_primary ORDER BY domainname", self._id)

        anames = dbc.fetchall()

        dbc.close()

        aliasdomains = []

        if len(anames) > 0:

            aliasdomains = [aname[0] for aname in anames]

        return aliasdomains

def search(dbh, pattern=None, like=False):

    if pattern is not None and like is False:

        pattern = check_domainname(pattern)

    sql = 'SELECT gid, domainname, is_primary FROM domain_name'

    if pattern is None:

        pass

    elif like:

        sql += " WHERE domainname LIKE '%s'" % pattern

    else:

        sql += " WHERE domainname = '%s'" % pattern

    sql += ' ORDER BY is_primary DESC, domainname'

    dbc = dbh.cursor()

    dbc.execute(sql)

    doms = dbc.fetchall()

    dbc.close()

    domdict = {}

    order = [dom[0] for dom in doms if dom[2]]

    if len(order) == 0:

        for dom in doms:

            if dom[0] not in order:

                order.append(dom[0])

    for gid, dom, is_primary in doms:

        if is_primary:

            domdict[gid] = [dom]

        else:

            try:

                domdict[gid].append(dom)

            except KeyError:

                domdict[gid] = [None, dom]

    del doms

    return order, domdict

def get_gid(dbh, domainname):

    """Returns the *GID* of the domain *domainname*.

    Raises an `DomainError` if the domain does not exist.

    """

    domainname = check_domainname(domainname)

    dbc = dbh.cursor()

    dbc.execute('SELECT gid FROM domain_name WHERE domainname=%s', domainname)

    gid = dbc.fetchone()

    dbc.close()

    if gid:

        return gid[0]

    else:

        raise DomErr(_(u"The domain “%s” doesn't exist.") % domainname,

                     NO_SUCH_DOMAIN)