vmm: comparison VirtualMailManager/Account.py

equal deleted inserted replaced

-:45ec5c3cfef4
+:524f7ed5ad5b
 """
 from VirtualMailManager.Domain import Domain
 from VirtualMailManager.EmailAddress import EmailAddress
 from VirtualMailManager.Transport import Transport
+from VirtualMailManager.common import version_str
 from VirtualMailManager.constants.ERROR import \
 ACCOUNT_EXISTS, ACCOUNT_MISSING_PASSWORD, ALIAS_PRESENT, \
-INVALID_AGUMENT, NO_SUCH_ACCOUNT, NO_SUCH_DOMAIN, \
+INVALID_AGUMENT, INVALID_MAIL_LOCATION, NO_SUCH_ACCOUNT, NO_SUCH_DOMAIN, \
-UNKNOWN_MAILLOCATION_NAME, UNKNOWN_SERVICE
+UNKNOWN_SERVICE
 from VirtualMailManager.errors import AccountError as AErr
-from VirtualMailManager.maillocation import MailLocation, known_format
+from VirtualMailManager.maillocation import MailLocation
-from VirtualMailManager.pycompat import all
+from VirtualMailManager.password import pwhash
 _ = lambda msg: msg
+cfg_dget = lambda option: None
 class Account(object):
 """Class to manage e-mail accounts."""
-__slots__ = ('_addr', '_domain', '_mid', '_new', '_passwd', '_tid', '_uid',
+__slots__ = ('_addr', '_dbh', '_domain', '_mid', '_new', '_passwd',
-'_dbh')
+'_transport', '_uid')
 def __init__(self, dbh, address):
 """Creates a new Account instance.
 When an account with the given *address* could be found in the
 Arguments:
 `dbh` : pyPgSQL.PgSQL.Connection
 A database connection for the database access.
-`address` : basestring
+`address` : VirtualMailManager.EmailAddress.EmailAddress
 The e-mail address of the (new) Account.
 """
 if not isinstance(address, EmailAddress):
 raise TypeError("Argument 'address' is not an EmailAddress")
 self._addr = address
 if not self._domain.gid:
 raise AErr(_(u"The domain '%s' doesn't exist.") %
 self._addr.domainname, NO_SUCH_DOMAIN)
 self._uid = 0
 self._mid = 0
-self._tid = 0
+self._transport = self._domain.transport
 self._passwd = None
 self._new = True
 self._load()
+def __nonzero__(self):
+"""Returns `True` if the Account is known, `False` if it's new."""
+return not self._new
 def _load(self):
 """Load 'uid', 'mid' and 'tid' from the database and set _new to
 `False` - if the user could be found. """
 dbc = self._dbh.cursor()
 "SELECT uid, mid, tid FROM users WHERE gid=%s AND local_part=%s",
 self._domain.gid, self._addr.localpart)
 result = dbc.fetchone()
 dbc.close()
 if result:
-self._uid, self._mid, self._tid = result
+self._uid, self._mid, _tid = result
+if _tid != self._transport.tid:
+self._transport = Transport(self._dbh, tid=_tid)
 self._new = False
 def _set_uid(self):
 """Set the unique ID for the new Account."""
 assert self._uid == 0
 self._uid = dbc.fetchone()[0]
 dbc.close()
 def _prepare(self, maillocation):
 """Check and set different attributes - before we store the
-information in the database."""
+information in the database.
-if not known_format(maillocation):
+"""
-raise AErr(_(u'Unknown mail_location mailbox format: %r') %
+if maillocation.dovecot_version > cfg_dget('misc.dovecot_version'):
-maillocation, UNKNOWN_MAILLOCATION_NAME)
+raise AErr(_("The mail_location prefix '%(prefix)s' requires \
-self._mid = MailLocation(format=maillocation).mid
+Dovecot >= v%(version)s") % {'prefix': maillocation.prefix,
-if not self._tid:
+'version': version_str(maillocation.dovecot_version)},
-self._tid = self._domain.transport.tid
+INVALID_MAIL_LOCATION)
+if not maillocation.postfix and \
+self._transport.transport.lower() in ('virtual:', 'virtual'):
+raise AErr(_(u"Invalid transport '%(transport)s' for mail_location\
+prefix '%(prefix)s'") % {'transport': self._transport,
+'prefix': maillocation.prefix},
+INVALID_MAIL_LOCATION)
+self._mid = maillocation.mid
 self._set_uid()
-def _switch_state(self, state, dcvers, service):
+def _switch_state(self, state, service):
 """Switch the state of the Account's services on or off. See
 Account.enable()/Account.disable() for more information."""
 self._chk_state()
 if service not in (None, 'all', 'imap', 'pop3', 'sieve', 'smtp'):
 raise AErr(_(u"Unknown service: '%s'.") % service, UNKNOWN_SERVICE)
-if dcvers >= 0x10200b02:
+if cfg_dget('misc.dovecot_version') >= 0x10200b02:
 sieve_col = 'sieve'
 else:
 sieve_col = 'managesieve'
 if service in ('smtp', 'pop3', 'imap'):
 sql = 'UPDATE users SET %s = %s WHERE uid = %d' % (service, state,
 return self._addr
 @property
 def domain_directory(self):
 """The directory of the domain the Account belongs to."""
-return self._domain.directory
+if self._domain:
+return self._domain.directory
+return None
 @property
 def gid(self):
 """The Account's group ID."""
-return self._domain.gid
+if self._domain:
+return self._domain.gid
+return None
 @property
 def home(self):
 """The Account's home directory."""
-return '%s/%s' % (self._domain.directory, self._uid)
+if not self._new:
+return '%s/%s' % (self._domain.directory, self._uid)
+return None
 @property
 def uid(self):
 """The Account's unique ID."""
 return self._uid
 Account.modify().
 Argument:
 `password` : basestring
-The hashed password for the new Account."""
+The password for the new Account.
+"""
+if not isinstance(password, basestring) or not password:
+raise AErr(_(u"Couldn't accept password: '%s'") % password,
+ACCOUNT_MISSING_PASSWORD)
 self._passwd = password
 def set_transport(self, transport):
 """Set the transport for the new Account.
 Argument:
 `transport` : basestring
 The string representation of the transport, e.g.: 'dovecot:'
 """
-self._tid = Transport(self._dbh, transport=transport).tid
+self._transport = Transport(self._dbh, transport=transport)
-def enable(self, dcvers, service=None):
+def enable(self, service=None):
 """Enable a/all service/s for the Account.
 Possible values for the *service* are: 'imap', 'pop3', 'sieve' and
 'smtp'. When all services should be enabled, use 'all' or the
 default value `None`.
 Arguments:
-`dcvers` : int
-The concatenated major and minor version number from
-`dovecot --version`.
 `service` : basestring
 The name of a service ('imap', 'pop3', 'smtp', 'sieve'), 'all'
 or `None`.
 """
-self._switch_state(True, dcvers, service)
+self._switch_state(True, service)
-def disable(self, dcvers, service=None):
+def disable(self, service=None):
 """Disable a/all service/s for the Account.
 For more information see: Account.enable()."""
-self._switch_state(False, dcvers, service)
+self._switch_state(False, service)
-def save(self, maillocation, dcvers, smtp, pop3, imap, sieve):
+def save(self):
-"""Save the new Account in the database.
+"""Save the new Account in the database."""
-Arguments:
-`maillocation` : basestring
-The mailbox format of the mail_location: 'maildir', 'mbox',
-'dbox' or 'mdbox'.
-`dcvers` : int
-The concatenated major and minor version number from
-`dovecot --version`.
-`smtp, pop3, imap, sieve` : bool
-Indicates if the user of the Account should be able to use this
-services.
-"""
 if not self._new:
 raise AErr(_(u"The account '%s' already exists.") % self._addr,
 ACCOUNT_EXISTS)
 if not self._passwd:
 raise AErr(_(u"No password set for '%s'.") % self._addr,
 ACCOUNT_MISSING_PASSWORD)
-assert all(isinstance(service, bool) for service in (smtp, pop3, imap,
+if cfg_dget('misc.dovecot_version') >= 0x10200b02:
-sieve))
-if dcvers >= 0x10200b02:
 sieve_col = 'sieve'
 else:
 sieve_col = 'managesieve'
-self._prepare(maillocation)
+self._prepare(MailLocation(format=cfg_dget('mailbox.format')))
 sql = "INSERT INTO users (local_part, passwd, uid, gid, mid, tid,\
 smtp, pop3, imap, %s) VALUES ('%s', '%s', %d, %d, %d, %d, %s, %s, %s, %s)" % (
-sieve_col, self._addr.localpart, self._passwd, self._uid,
+sieve_col, self._addr.localpart, pwhash(self._passwd), self._uid,
-self._domain.gid, self._mid, self._tid, smtp, pop3, imap, sieve)
+self._domain.gid, self._mid, self._transport.tid,
+cfg_dget('account.smtp'), cfg_dget('account.pop3'),
+cfg_dget('account.imap'), cfg_dget('account.sieve'))
 dbc = self._dbh.cursor()
 dbc.execute(sql)
 self._dbh.commit()
 dbc.close()
 self._new = False
 def modify(self, field, value):
 """Update the Account's *field* to the new *value*.
-Possible values for *filed* are: 'name', 'password' and
+Possible values for *field* are: 'name', 'password' and
 'transport'.  *value* is the *field*'s new value.
 Arguments:
 `field` : basestring
 The attribute name: 'name', 'password' or 'transport'
 `value` : basestring
-The new value of the attribute. The password is expected as a
+The new value of the attribute.
-hashed password string.
 """
 if field not in ('name', 'password', 'transport'):
 raise AErr(_(u"Unknown field: '%s'") % field, INVALID_AGUMENT)
 self._chk_state()
 dbc = self._dbh.cursor()
 if field == 'password':
 dbc.execute('UPDATE users SET passwd = %s WHERE uid = %s',
-value, self._uid)
+pwhash(value), self._uid)
 elif field == 'transport':
-self._tid = Transport(self._dbh, transport=value).tid
+if value != self._transport.transport:
-dbc.execute('UPDATE users SET tid = %s WHERE uid = %s',
+self._transport = Transport(self._dbh, transport=value)
-self._tid, self._uid)
+dbc.execute('UPDATE users SET tid = %s WHERE uid = %s',
+self._transport.tid, self._uid)
 else:
 dbc.execute('UPDATE users SET name = %s WHERE uid = %s',
 value, self._uid)
 if dbc.rowcount > 0:
 self._dbh.commit()
 dbc.close()
-def get_info(self, dcvers):
+def get_info(self):
 """Returns a dict with some information about the Account.
 The keys of the dict are: 'address', 'gid', 'home', 'imap'
 'mail_location', 'name', 'pop3', 'sieve', 'smtp', transport' and
 'uid'.
-Argument:
-`dcvers` : int
-The concatenated major and minor version number from
-`dovecot --version`.
 """
 self._chk_state()
-if dcvers >= 0x10200b02:
+if cfg_dget('misc.dovecot_version') >= 0x10200b02:
 sieve_col = 'sieve'
 else:
 sieve_col = 'managesieve'
-sql = 'SELECT name, uid, gid, mid, tid, smtp, pop3, imap, %s\
+sql = 'SELECT name, smtp, pop3, imap, %s FROM users WHERE uid = %d' % \
-FROM users WHERE uid = %d' % (sieve_col, self._uid)
+(sieve_col, self._uid)
 dbc = self._dbh.cursor()
 dbc.execute(sql)
 info = dbc.fetchone()
 dbc.close()
 if info:
-keys = ('name', 'uid', 'gid', 'mid', 'transport', 'smtp',
+keys = ('name', 'smtp', 'pop3', 'imap', sieve_col)
-'pop3', 'imap', sieve_col)
 info = dict(zip(keys, info))
-for service in ('smtp', 'pop3', 'imap', sieve_col):
+for service in keys[1:]:
 if info[service]:
 # TP: A service (pop3/imap) is enabled/usable for a user
 info[service] = _('enabled')
 else:
 # TP: A service (pop3/imap) isn't enabled/usable for a user
 info[service] = _('disabled')
 info['address'] = self._addr
-info['home'] = '%s/%s' % (self._domain.directory, info['uid'])
+info['gid'] = self._domain.gid
-info['mail_location'] = MailLocation(mid=info['mid']).mail_location
+info['home'] = '%s/%s' % (self._domain.directory, self._uid)
-if info['transport'] == self._domain.transport.tid:
+info['mail_location'] = MailLocation(mid=self._mid).mail_location
-info['transport'] = self._domain.transport.transport
+info['transport'] = self._transport.transport
-else:
+info['uid'] = self._uid
-info['transport'] = Transport(self._dbh,
-tid=info['transport']).transport
-del info['mid']
 return info
 # nearly impossible‽
 raise AErr(_(u"Couldn't fetch information for account: '%s'") \
 % self._addr, NO_SUCH_ACCOUNT)
 aliases = []
 if addresses:
 aliases = [alias[0] for alias in addresses]
 return aliases
-def delete(self, delalias):
+def delete(self, delalias=False):
 """Delete the Account from the database.
 Argument:
-`delalias` : basestring
+`delalias` : bool
-if the values of delalias is 'delalias', all aliases, which
+if *delalias* is `True`, all aliases, which points to the Account,
-points to the Account, will be also deleted."""
+will be also deleted.  If there are aliases and *delalias* is
+`False`, an AccountError will be raised.
+"""
+assert isinstance(delalias, bool)
 self._chk_state()
 dbc = self._dbh.cursor()
-if delalias == 'delalias':
+if delalias:
-dbc.execute('DELETE FROM users WHERE uid= %s', self._uid)
+dbc.execute('DELETE FROM users WHERE uid = %s', self._uid)
 # delete also all aliases where the destination address is the same
 # as for this account.
 dbc.execute("DELETE FROM alias WHERE destination = %s",
 str(self._addr))
 self._dbh.commit()
 else:  # check first for aliases
 a_count = self._count_aliases()
-if a_count == 0:
+if a_count > 0:
-dbc.execute('DELETE FROM users WHERE uid = %s', self._uid)
-self._dbh.commit()
-else:
 dbc.close()
 raise AErr(_(u"There are %(count)d aliases with the \
 destination address '%(address)s'.") % \
 {'count': a_count, 'address': self._addr},
 ALIAS_PRESENT)
-dbc.close()
+dbc.execute('DELETE FROM users WHERE uid = %s', self._uid)
+self._dbh.commit()
+dbc.close()
+self._new = True
+self._uid = self._mid = 0
+self._addr = self._dbh = self._domain = self._passwd = None
+self._transport = None
 def get_account_by_uid(uid, dbh):
 """Search an Account by its UID.
 raise AErr(_(u"There is no account with the UID '%d'.") % uid,
 NO_SUCH_ACCOUNT)
 info = dict(zip(('address', 'uid', 'gid'), info))
 return info
+del _, cfg_dget
-del _

branch	v0.6.x
changeset 275	524f7ed5ad5b
parent 266	e14c345b44a1
child 276	f2ecfe0a0e09