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

# Copyright (c) 2007 - 2010, Pascal Volk

# See COPYING for distribution information.

"""

    VirtualMailManager.Alias

    Virtual Mail Manager's Alias class to manage e-mail aliases.

"""

from VirtualMailManager.Domain import Domain

from VirtualMailManager.EmailAddress import EmailAddress

from VirtualMailManager.Exceptions import VMMAliasException as VMMAE

from VirtualMailManager.constants.ERROR import ALIAS_ADDR_DEST_IDENTICAL, \

     ALIAS_EXCEEDS_EXPANSION_LIMIT, ALIAS_EXISTS, NO_SUCH_ALIAS, NO_SUCH_DOMAIN

_ = lambda msg: msg

class Alias(object):

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

    __slots__ = ('_addr', '_dests', '_gid', '_dbh')

    def __init__(self, dbh, address):

        if isinstance(address, EmailAddress):

            self._addr = address

        else:

            raise TypeError("Argument 'address' is not an EmailAddress")

        self._dbh = dbh

        self._gid = 0

        self._dests = []

        self.__set_gid()

        self.__load_dests()

    def __set_gid(self):

        """Sets the alias' _gid based on its _addr.domainname."""

        dom = Domain(self._dbh, self._addr.domainname)

        self._gid = dom.getID()

        if self._gid == 0:

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

                        self._addr.domainname, NO_SUCH_DOMAIN)

    def __load_dests(self):

        """Loads all known destination addresses into the _dests list."""

        dbc = self._dbh.cursor()

        dbc.execute(

                'SELECT destination FROM alias WHERE gid=%s AND address=%s',

                    self._gid, self._addr.localpart)

        dests = iter(dbc.fetchall())

        if dbc.rowcount > 0:

            dest_add = self._dests.append

            for dest in dests:

                dest_add(EmailAddress(dest[0]))

        dbc.close()

    def __check_expansion(self, limit):

        """Checks the current expansion limit of the alias."""

        dcount = len(self._dests)

        failed = False

        if dcount == limit:

            failed = True

            errmsg = _(

u"""Can't add new destination to alias “%(address)s”.

Currently this alias expands into %(count)i/%(limit)i recipients.

One more destination will render this alias unusable.

Hint: Increase Postfix' virtual_alias_expansion_limit""")

        elif dcount > limit:

            failed = True

            errmsg = _(

u"""Can't add new destination to alias “%(address)s”.

This alias already exceeds it's expansion limit (%(count)i/%(limit)i).

So its unusable, all messages addressed to this alias will be bounced.

Hint: Delete some destination addresses.""")

        if failed:

            raise VMMAE(errmsg % {'address': self._addr, 'count': dcount,

                                  'limit': limit},

                        ALIAS_EXCEEDS_EXPANSION_LIMIT)

    def __delete(self, destination=None):

        """Deletes a destination from the alias, if ``destination`` is not

        ``None``. If ``destination`` is None, the alias with all it's

        destination addresses will be deleted."""

        dbc = self._dbh.cursor()

        if destination is None:

            dbc.execute("DELETE FROM alias WHERE gid=%s AND address=%s",

                        self._gid, self._addr.localpart)

        else:

            dbc.execute("DELETE FROM alias WHERE gid=%s AND address=%s AND \

 destination=%s",

                        self._gid, self._addr.localpart, str(destination))

        if dbc.rowcount > 0:

            self._dbh.commit()

        dbc.close()

    def __len__(self):

        """Returns the number of destinations of the alias."""

        return len(self._dests)

    def addDestination(self, destination, expansion_limit):

        """Adds the ``destination`` `EmailAddress` to the alias."""

        if not isinstance(destination, EmailAddress):

            raise TypeError("Argument 'destination' is not an EmailAddress")

        if self._addr == destination:

            raise VMMAE(_(u"Address and destination are identical."),

                        ALIAS_ADDR_DEST_IDENTICAL)

        if not destination in self._dests:

            self.__check_expansion(expansion_limit)

            dbc = self._dbh.cursor()

            dbc.execute('INSERT INTO alias (gid, address, destination) \

VALUES (%s, %s, %s)',

                        self._gid, self._addr.localpart, str(destination))

            self._dbh.commit()

            dbc.close()

            self._dests.append(destination)

        else:

            raise VMMAE(_(

                u'The alias “%(a)s” has already the destination “%(d)s”.') %

                        {'a': self._addr, 'd': destination}, ALIAS_EXISTS)

    def delDestination(self, destination):

        """Deletes the specified ``destination`` address from the alias."""

        if not isinstance(destination, EmailAddress):

            raise TypeError("Argument 'destination' is not an EmailAddress")

        if not self._dests:

            raise VMMAE(_(u"The alias “%s” doesn't exist.") % self._addr,

                        NO_SUCH_ALIAS)

        if not destination in self._dests:

            raise VMMAE(_(u"The address “%(d)s” isn't a destination of \

the alias “%(a)s”.") %

                        {'a': self._addr, 'd': destination}, NO_SUCH_ALIAS)

        self.__delete(destination)

        self._dests.remove(destination)

    def getDestinations(self):

        """Returns an iterator for all destinations of the alias."""

        if self._dests:

            return iter(self._dests)

        else:

            raise VMMAE(_(u"The alias “%s” doesn't exist.") % self._addr,

                        NO_SUCH_ALIAS)

    def delete(self):

        """Deletes the alias with all it's destinations."""

        if self._dests:

            self.__delete()

            del self._dests[:]

        else:

            raise VMMAE(_(u"The alias “%s” doesn't exist.") % self._addr,

                        NO_SUCH_ALIAS)

del _