def profile(domain, conn=None):
domain = str(domain).lower()
if not iredutils.is_domain(domain):
return (False, 'INVALID_DOMAIN_NAME')
if not conn:
_wrap = SQLWrap()
conn = _wrap.conn
try:
# Get domain profile first.
_qr = simple_profile(domain=domain, conn=conn)
if _qr[0]:
_profile = _qr[1]
else:
return _qr
# num_existing_users
_profile[
'num_existing_users'] = sql_lib_general.num_users_under_domain(
domain=domain, conn=conn)
return (True, _profile)
except Exception as e:
return (False, repr(e))
def revoke_admin_privilege_if_no_managed_domains(admin=None, conn=None):
"""If given admin doesn't manage any domain, revoke the admin privilege.
@admin -- email address of domain admin
@conn -- sql connection cursor
"""
if not admin:
return (True, )
if not conn:
_wrap = SQLWrap()
conn = _wrap.conn
# Return immediately if it's a global admin
if sql_lib_general.is_global_admin(admin=admin, conn=conn):
return (True, )
if not num_managed_domains(admin=admin, conn=conn):
try:
conn.update('mailbox',
vars={'admin': admin},
isadmin=0,
where='username=$admin')
except Exception as e:
log_traceback()
return (False, repr(e))
return (True, )
def simple_profile(mail, columns=None, conn=None):
"""Return value of sql column `mailbox.settings`.
@columns -- a list or tuple which contains SQL column names
"""
if not conn:
_wrap = SQLWrap()
conn = _wrap.conn
sql_what = '*'
if columns:
sql_what = ','.join(columns)
try:
qr = conn.select('mailbox',
vars={'username': mail},
what=sql_what,
where='username=$username',
limit=1)
if qr:
return (True, list(qr)[0])
else:
return (False, 'NO_SUCH_ACCOUNT')
except Exception as e:
return (False, repr(e))
def is_email_exists(mail, conn=None) -> bool:
# Return True if account is invalid or exist.
if not iredutils.is_email(mail):
return True
mail = iredutils.strip_mail_ext_address(mail)
if not conn:
_wrap = SQLWrap()
conn = _wrap.conn
try:
# `forwardings` table has email addr of mail user account and alias account.
qr = conn.select('forwardings',
vars={'mail': mail},
what='address',
where='address=$mail',
limit=1)
if qr:
return True
# Check `alias` for alias account which doesn't have any member.
qr = conn.select('alias',
vars={'mail': mail},
what='address',
where='address=$mail',
limit=1)
if qr:
return True
return False
except Exception:
return True
def delete_admins(mails, revoke_admin_privilege_from_user=True, conn=None):
mails = [str(v) for v in mails if iredutils.is_email(v)]
if not mails:
return (True, )
sql_vars = {'mails': mails}
try:
if not conn:
_wrap = SQLWrap()
conn = _wrap.conn
# Standalone mail admins
conn.delete('admin', vars=sql_vars, where='username IN $mails')
conn.delete('domain_admins', vars=sql_vars, where='username IN $mails')
# Unmark globa/domain admin which is mail user
if revoke_admin_privilege_from_user:
conn.update(
'mailbox',
vars=sql_vars,
where='username IN $mails AND (isadmin=1 OR isglobaladmin=1)',
isadmin=0,
isglobaladmin=0)
log_activity(event='delete',
msg="Delete admin(s): %s." % ', '.join(mails))
return (True, )
except Exception as e:
log_traceback()
return (False, repr(e))
def __num_accounts_under_domain(domain, account_type, conn=None) -> int:
num = 0
if not iredutils.is_domain(domain):
return num
if not conn:
_wrap = SQLWrap()
conn = _wrap.conn
# mapping of account types and sql table names
mapping = {'user': '******', 'alias': 'alias', 'maillist': 'maillists'}
sql_table = mapping[account_type]
try:
qr = conn.select(sql_table,
vars={'domain': domain},
what='COUNT(domain) AS total',
where='domain=$domain')
if qr:
num = qr[0].total
except Exception as e:
logger.error(e)
return num
def profile(mail, with_used_quota=True, conn=None):
"""Get full user profile.
@with_alias -- get per-user alias addresses.
@with_forwardings -- get mail forwarding addresses
"""
mail = str(mail).lower()
try:
if not conn:
_wrap = SQLWrap()
conn = _wrap.conn
qr = conn.select("mailbox",
vars={'mail': mail},
where="username=$mail",
limit=1)
if qr:
p = qr[0]
p['stored_bytes'] = 0
p['stored_messages'] = 0
if with_used_quota:
_used_quota = sql_lib_general.get_account_used_quota(
accounts=[mail], conn=conn)
if mail in _used_quota:
p['stored_bytes'] = _used_quota[mail]['bytes']
p['stored_messages'] = _used_quota[mail]['messages']
return (True, p)
else:
return (False, 'NO_SUCH_ACCOUNT')
except Exception as e:
return (False, repr(e))
def GET(self, cur_page=1, disabled_only=False):
"""List paged mail domains."""
form = web.input(_unicode=False)
cur_page = int(cur_page) or 1
all_domain_profiles = []
domain_used_quota = {}
all_first_chars = []
first_char = None
if 'starts_with' in form:
first_char = form.get('starts_with')[:1].upper()
if not iredutils.is_valid_account_first_char(first_char):
first_char = None
_wrap = SQLWrap()
conn = _wrap.conn
# Get first characters of all domains
_qr = sql_lib_domain.get_first_char_of_all_domains(conn=conn)
if _qr[0]:
all_first_chars = _qr[1]
total = sql_lib_admin.num_managed_domains(conn=conn,
disabled_only=disabled_only,
first_char=first_char)
if total:
qr = sql_lib_domain.get_paged_domains(cur_page=cur_page,
first_char=first_char,
disabled_only=disabled_only,
conn=conn)
if qr[0]:
all_domain_profiles = qr[1]
if settings.SHOW_USED_QUOTA:
domains = []
for i in all_domain_profiles:
domains.append(str(i.domain))
domain_used_quota = sql_lib_domain.get_domain_used_quota(
conn=conn, domains=domains)
if session.get('is_global_admin'):
days_to_keep_removed_mailbox = settings.DAYS_TO_KEEP_REMOVED_MAILBOX_FOR_GLOBAL_ADMIN
else:
days_to_keep_removed_mailbox = settings.DAYS_TO_KEEP_REMOVED_MAILBOX
return web.render(
'sql/domain/list.html',
cur_page=cur_page,
total=total,
all_domain_profiles=all_domain_profiles,
domain_used_quota=domain_used_quota,
local_transports=settings.LOCAL_TRANSPORTS,
first_char=first_char,
all_first_chars=all_first_chars,
disabled_only=disabled_only,
days_to_keep_removed_mailbox=days_to_keep_removed_mailbox,
msg=form.get('msg', None))
def get_profile(mail, columns=None, conn=None):
if not iredutils.is_email(mail):
return (False, 'INVALID_MAIL')
if isinstance(columns, (list, tuple, set)):
columns = ','.join(columns)
else:
columns = '*'
if not conn:
_wrap = SQLWrap()
conn = _wrap.conn
try:
qr = conn.select('admin',
vars={'username': mail},
what=columns,
where='username=$username',
limit=1)
if qr:
return (True, list(qr)[0])
else:
return (False, 'NO_SUCH_ACCOUNT')
except Exception as e:
log_traceback()
return (False, repr(e))
def is_global_admin(admin, conn=None) -> bool:
if not admin:
return False
if admin == session.get('username'):
if session.get('is_global_admin'):
return True
else:
return False
# Not logged admin.
try:
if not conn:
_wrap = SQLWrap()
conn = _wrap.conn
qr = conn.select('domain_admins',
vars={
'username': admin,
'domain': 'ALL'
},
what='username',
where='username=$username AND domain=$domain',
limit=1)
if qr:
return True
else:
return False
except:
return False
def POST(self):
form = web.input(_unicode=False, mail=[])
accounts = form.get('mail', [])
action = form.get('action', None)
msg = form.get('msg', None)
_wrap = SQLWrap()
conn = _wrap.conn
if action == 'delete':
result = sql_lib_admin.delete_admins(
mails=accounts,
revoke_admin_privilege_from_user=True,
conn=conn)
msg = 'DELETED'
elif action == 'disable':
result = sql_lib_utils.set_account_status(conn=conn,
accounts=accounts,
account_type='admin',
enable_account=False)
msg = 'DISABLED'
elif action == 'enable':
result = sql_lib_utils.set_account_status(conn=conn,
accounts=accounts,
account_type='admin',
enable_account=True)
msg = 'ENABLED'
else:
result = (False, 'INVALID_ACTION')
if result[0] is True:
raise web.seeother('/admins?msg=%s' % msg)
else:
raise web.seeother('/admins?msg=' + web.urlquote(result[1]))
def POST(self, profile_type, mail):
mail = str(mail).lower()
form = web.input(domainName=[], managed_domains=[])
if not (session.get('is_global_admin')
or session.get('username') == mail):
# Don't allow to view/update others' profile.
raise web.seeother(
'/profile/admin/general/%s?msg=PERMISSION_DENIED' %
session.get('username'))
_wrap = SQLWrap()
conn = _wrap.conn
result = sql_lib_admin.update(mail=mail,
profile_type=profile_type,
form=form,
conn=conn)
if result[0]:
raise web.seeother('/profile/admin/{}/{}?msg=UPDATED'.format(
profile_type, mail))
else:
raise web.seeother('/profile/admin/{}/{}?msg={}'.format(
profile_type, mail, web.urlquote(result[1])))
def GET(self, cur_page=1):
form = web.input()
cur_page = int(cur_page)
if cur_page == 0:
cur_page = 1
_wrap = SQLWrap()
conn = _wrap.conn
result = sql_lib_admin.get_paged_admins(conn=conn, cur_page=cur_page)
if result[0] is True:
(total, records) = (result[1]['total'], result[1]['records'])
# Get list of global admins.
all_global_admins = []
qr = sql_lib_admin.get_all_global_admins(conn=conn)
if qr[0]:
all_global_admins = qr[1]
return web.render(
'sql/admin/list.html',
cur_page=cur_page,
total=total,
admins=records,
allGlobalAdmins=all_global_admins,
msg=form.get('msg', None),
)
else:
raise web.seeother('/domains?msg=%s' % web.urlquote(result[1]))
def assign_admins_to_domain(domain, admins, conn=None):
"""Assign list of NEW admins to specified mail domain.
It doesn't remove existing admins."""
if not iredutils.is_domain(domain):
return (False, 'INVALID_DOMAIN_NAME')
if not isinstance(admins, (list, tuple, set)):
return (False, 'NO_ADMINS')
else:
admins = [str(i).lower() for i in admins if iredutils.is_email(i)]
if not admins:
return (False, 'NO_ADMINS')
if not conn:
_wrap = SQLWrap()
conn = _wrap.conn
for adm in admins:
try:
conn.insert('domain_admins', domain=domain, username=adm)
except Exception as e:
if e.__class__.__name__ == 'IntegrityError':
pass
else:
return (False, repr(e))
return (True, )
def get_first_char_of_all_domains(conn=None):
"""Get first character of all domains."""
if not conn:
_wrap = SQLWrap()
conn = _wrap.conn
admin = session.get('username')
chars = []
try:
if sql_lib_general.is_global_admin(admin=admin, conn=conn):
qr = conn.select(
'domain',
what='SUBSTRING(domain FROM 1 FOR 1) AS first_char',
group='first_char')
else:
qr = conn.query(
"""SELECT SUBSTRING(domain.domain FROM 1 FOR 1) AS first_char
FROM domain
LEFT JOIN domain_admins ON (domain.domain=domain_admins.domain)
WHERE domain_admins.username=$admin
GROUP BY first_char""",
vars={'admin': admin})
if qr:
chars = [i.first_char.upper() for i in qr]
chars.sort()
return (True, chars)
except Exception as e:
logger.error(e)
return (False, repr(e))
def is_domain_admin(domain, admin=None, conn=None) -> bool:
if (not iredutils.is_domain(domain)) or (not iredutils.is_email(admin)):
return False
if not admin:
admin = session.get('username')
if admin == session.get('username') and session.get('is_global_admin'):
return True
try:
if not conn:
_wrap = SQLWrap()
conn = _wrap.conn
qr = conn.select(
'domain_admins',
vars={
'domain': domain,
'username': admin
},
what='username',
where='domain=$domain AND username=$username AND active=1',
limit=1,
)
if qr:
return True
else:
return False
except:
return False
def get_domain_admin_addresses(domain, conn=None):
"""List email addresses of all domain admins (exclude global admins).
>>> get_domain_admin_addresses(domain='abc.com')
(True, ['user1@<domain>.com', 'user2@<domain>.com', ...])
>>> get_domain_admin_addresses(domain='xyz.com')
(False, '<reason>')
"""
all_admins = set()
sql_vars = {'domain': domain}
try:
if not conn:
_wrap = SQLWrap()
conn = _wrap.conn
qr = conn.select('domain_admins',
vars=sql_vars,
what='username',
where='domain=$domain')
for i in qr:
all_admins.add(str(i.username).lower())
return (True, list(all_admins))
except Exception as e:
return (False, repr(e))
def simple_profile(domain, columns=None, conn=None):
if not iredutils.is_domain(domain):
return (False, 'INVALID_DOMAIN_NAME')
sql_what = '*'
if columns:
sql_what = ','.join(columns)
try:
if not conn:
_wrap = SQLWrap()
conn = _wrap.conn
qr = conn.select('domain',
vars={'domain': domain},
what=sql_what,
where='domain=$domain',
limit=1)
if qr:
p = list(qr)[0]
return (True, p)
else:
return (False, 'INVALID_DOMAIN_NAME')
except Exception as e:
return (False, repr(e))
def get_domain_settings(domain, domain_profile=None, conn=None):
domain = str(domain).lower()
try:
if not domain_profile:
if not conn:
_wrap = SQLWrap()
conn = _wrap.conn
qr = conn.select('domain',
vars={'domain': domain},
what='settings',
where='domain=$domain',
limit=1)
if qr:
domain_profile = list(qr)[0]
else:
return (False, 'INVALID_DOMAIN_NAME')
ps = domain_profile.get('settings', '')
ds = sqlutils.account_settings_string_to_dict(ps)
return (True, ds)
except Exception as e:
return (False, repr(e))
def delete_accounts(accounts,
account_type,
keep_mailbox_days=0,
conn=None):
# accounts must be a list/tuple.
# account_type in ['domain', 'user', 'admin', 'alias']
if not accounts:
return (True, )
if not conn:
_wrap = SQLWrap()
conn = _wrap.conn
if account_type == 'domain':
qr = sql_lib_domain.delete_domains(domains=accounts,
keep_mailbox_days=keep_mailbox_days,
conn=conn)
return qr
elif account_type == 'user':
sql_lib_user.delete_users(accounts=accounts,
keep_mailbox_days=keep_mailbox_days,
conn=conn)
elif account_type == 'admin':
sql_lib_admin.delete_admins(mails=accounts, conn=conn)
return (True, )
def GET(self, domain):
domain = str(domain).lower()
form = web.input()
# Get all managed domains.
_wrap = SQLWrap()
conn = _wrap.conn
if session.get('is_global_admin'):
qr = sql_lib_domain.get_all_domains(conn=conn, name_only=True)
else:
qr = sql_lib_admin.get_managed_domains(
conn=conn,
admin=session.get('username'),
domain_name_only=True)
if qr[0] is True:
all_domains = qr[1]
else:
raise web.seeother('/api?msg=' + web.urlquote(qr[1]))
# Get domain profile.
qr_profile = sql_lib_domain.simple_profile(domain=domain, conn=conn)
if qr_profile[0] is True:
domain_profile = qr_profile[1]
domain_settings = sqlutils.account_settings_string_to_dict(
domain_profile['settings'])
else:
raise web.seeother('/api?msg=%s' % web.urlquote(qr_profile[1]))
# Cet total number and allocated quota size of existing users under domain.
num_users_under_domain = sql_lib_general.num_users_under_domain(
domain=domain, conn=conn)
min_passwd_length = domain_settings.get('min_passwd_length',
settings.min_passwd_length)
max_passwd_length = domain_settings.get('max_passwd_length',
settings.max_passwd_length)
return web.render(
'api/msg/msg.html',
content_type="application/json",
msg={
#"cur_domain":domain,
#"allDomains":all_domains,
#"profile":domain_profile,
#"domain_settings":domain_settings,
#"min_passwd_length":min_passwd_length,
#"max_passwd_length":max_passwd_length,
#"store_password_in_plain_text":settings.STORE_PASSWORD_IN_PLAIN_TEXT,
#"num_existing_users":num_users_under_domain,
#"languagemaps":iredutils.get_language_maps(),
#"password_policies":iredutils.get_password_policies(),
#"msg":form.get('msg')
"msg": "Create User API's GET method!"
})
def num_managed_users(admin=None, domains=None, conn=None, listed_only=False):
"""Count users of all managed domains."""
num = 0
if not admin:
admin = session.get('username')
if not conn:
_wrap = SQLWrap()
conn = _wrap.conn
if domains:
domains = [str(d).lower() for d in domains if iredutils.is_domain(d)]
else:
qr = get_managed_domains(conn=conn,
admin=admin,
domain_name_only=True,
listed_only=listed_only)
if qr[0]:
domains = qr[1]
if not domains:
return num
sql_vars = {'admin': admin, 'domains': domains}
try:
if sql_lib_general.is_global_admin(admin=admin, conn=conn):
if domains:
qr = conn.select('mailbox',
vars=sql_vars,
what='COUNT(username) AS total',
where='domain IN $domains')
else:
qr = conn.select('mailbox', what='COUNT(username) AS total')
else:
sql_append_where = ''
if domains:
sql_append_where = 'AND mailbox.domain IN %s' % web.sqlquote(
domains)
qr = conn.query(
"""
SELECT COUNT(mailbox.username) AS total
FROM mailbox
LEFT JOIN domain_admins ON (mailbox.domain = domain_admins.domain)
WHERE domain_admins.username=$admin %s
""" % (sql_append_where),
vars=sql_vars,
)
num = qr[0].total or 0
except:
log_traceback()
return num
def GET(self, domain):
domain = str(domain).lower()
form = web.input()
# Get all managed domains.
_wrap = SQLWrap()
conn = _wrap.conn
if session.get('is_global_admin'):
qr = sql_lib_domain.get_all_domains(conn=conn, name_only=True)
else:
qr = sql_lib_admin.get_managed_domains(
conn=conn,
admin=session.get('username'),
domain_name_only=True)
if qr[0] is True:
all_domains = qr[1]
else:
raise web.seeother('/domains?msg=' + web.urlquote(qr[1]))
# Get domain profile.
qr_profile = sql_lib_domain.simple_profile(domain=domain, conn=conn)
if qr_profile[0] is True:
domain_profile = qr_profile[1]
domain_settings = sqlutils.account_settings_string_to_dict(
domain_profile['settings'])
else:
raise web.seeother('/domains?msg=%s' % web.urlquote(qr_profile[1]))
# Cet total number and allocated quota size of existing users under domain.
num_users_under_domain = sql_lib_general.num_users_under_domain(
domain=domain, conn=conn)
min_passwd_length = domain_settings.get('min_passwd_length',
settings.min_passwd_length)
max_passwd_length = domain_settings.get('max_passwd_length',
settings.max_passwd_length)
return web.render(
'sql/user/create.html',
cur_domain=domain,
allDomains=all_domains,
profile=domain_profile,
domain_settings=domain_settings,
min_passwd_length=min_passwd_length,
max_passwd_length=max_passwd_length,
store_password_in_plain_text=settings.STORE_PASSWORD_IN_PLAIN_TEXT,
num_existing_users=num_users_under_domain,
languagemaps=iredutils.get_language_maps(),
password_policies=iredutils.get_password_policies(),
msg=form.get('msg'),
)
def get_managed_domains(admin,
domain_name_only=False,
listed_only=False,
conn=None):
admin = str(admin).lower()
if not iredutils.is_email(admin):
return (False, 'INCORRECT_USERNAME')
if not conn:
_wrap = SQLWrap()
conn = _wrap.conn
try:
if sql_lib_general.is_global_admin(admin=admin, conn=conn):
if listed_only:
result = conn.query("""
SELECT domain.domain
FROM domain
LEFT JOIN domain_admins ON (domain.domain=domain_admins.domain)
WHERE domain_admins.username=$admin
ORDER BY domain_admins.domain
""",
vars={'admin': admin})
else:
result = conn.select('domain', what='domain', order='domain')
else:
sql_left_join = ''
if not listed_only:
sql_left_join = """OR domain_admins.domain='ALL'"""
result = conn.query("""
SELECT domain.domain
FROM domain
LEFT JOIN domain_admins ON (domain.domain=domain_admins.domain %s)
WHERE domain_admins.username=$admin
ORDER BY domain_admins.domain
""" % (sql_left_join),
vars={'admin': admin})
if domain_name_only:
domains = []
for i in result:
_domain = str(i['domain']).lower()
if iredutils.is_domain(_domain):
domains.append(_domain)
return (True, domains)
else:
return (True, list(result))
except Exception as e:
log_traceback()
return (False, repr(e))
def GET(self):
form = web.input(_unicode=False)
_check_new_version = ('checknew' in form)
# Check new version.
if session.get('is_global_admin') and _check_new_version:
(_status, _info) = sysinfo.check_new_version()
session['new_version_available'] = _status
if _status:
session['new_version'] = _info
else:
session['new_version_check_error'] = _info
# Get numbers of domains, users, aliases.
num_existing_domains = 0
num_existing_users = 0
_wrap = SQLWrap()
conn = _wrap.conn
try:
num_existing_domains = sql_lib_admin.num_managed_domains(conn=conn)
num_existing_users = sql_lib_admin.num_managed_users(conn=conn)
except:
pass
# Get numbers of existing messages and quota bytes.
# Set None as default, so that it's easy to detect them in Jinja2 template.
total_messages = None
total_bytes = None
if session.get('is_global_admin'):
if settings.SHOW_USED_QUOTA:
try:
qr = sql_lib_admin.sum_all_used_quota(conn=conn)
total_messages = qr['messages']
total_bytes = qr['bytes']
except:
pass
return web.render(
'dashboard.html',
version=__version__,
iredmail_version=sysinfo.get_iredmail_version(),
hostname=sysinfo.get_hostname(),
uptime=sysinfo.get_server_uptime(),
loadavg=sysinfo.get_system_load_average(),
netif_data=sysinfo.get_nic_info(),
# number of existing accounts
num_existing_domains=num_existing_domains,
num_existing_users=num_existing_users,
total_messages=total_messages,
total_bytes=total_bytes,
)
def get_all_managed_domains(conn=None,
columns=None,
name_only=False,
disabled_only=False):
"""Get all managed domains.
Returned values:
- (True, [records])
- (True, [<domain_name>, <domain_name>, ...])
- (False, <error>)
"""
if columns:
sql_what = ','.join(columns)
else:
if name_only:
sql_what = 'domain.domain'
else:
sql_what = 'domain.*'
sql_where = None
if disabled_only:
sql_where = 'domain.active=0'
try:
if not conn:
_wrap = SQLWrap()
conn = _wrap.conn
if session.get('is_global_admin'):
qr = conn.select('domain',
what=sql_what,
where=sql_where,
order='domain ASC')
else:
if sql_where:
sql_where = ' AND ' + sql_where
qr = conn.select(
['domain', 'domain_admins'],
vars={'admin': session.username},
what=sql_what,
where=
'domain_admins.username=$admin AND domain_admins.domain=domain.domain %s'
% sql_where,
order='domain.domain ASC')
if name_only:
domain_names = [str(r.domain).lower() for r in qr]
return (True, domain_names)
else:
return (True, list(qr))
except Exception as e:
return (False, repr(e))
def update(mail, profile_type, form, conn=None):
mail = str(mail).lower()
# Don't allow to view/update other admins' profile.
if mail != session.get('username') and not session.get('is_global_admin'):
return (False, 'PERMISSION_DENIED')
sql_vars = {'username': mail}
if not conn:
_wrap = SQLWrap()
conn = _wrap.conn
params = {}
if profile_type == 'general':
# Name, preferred language
params['name'] = form.get('cn', '')
params['language'] = form_utils.get_language(form)
# Update account status
params['active'] = 0
if 'accountStatus' in form:
params['active'] = 1
elif profile_type == 'password':
newpw = web.safestr(form.get('newpw', ''))
confirmpw = web.safestr(form.get('confirmpw', ''))
# Verify new passwords.
qr = iredpwd.verify_new_password(newpw=newpw, confirmpw=confirmpw)
if qr[0] is True:
passwd = iredpwd.generate_password_hash(qr[1])
params['password'] = passwd
params['passwordlastchange'] = iredutils.get_gmttime()
else:
return qr
if params:
try:
conn.update('admin',
vars=sql_vars,
where='username=$username',
**params)
except Exception as e:
log_traceback()
if 'password' in params:
raise web.seeother('/profile/admin/password/{}?msg={}'.format(
mail, web.urlquote(e)))
else:
raise web.seeother('/profile/admin/general/{}?msg={}'.format(
mail, web.urlquote(e)))
return (True, )
def get_admin_settings(admin=None, existing_settings=None, conn=None) -> Tuple:
"""Return a dict of per-admin settings.
:param admin: mail address of domain admin
:param existing_settings: original value of sql column `settings`
:param conn: SQL connection cursor
"""
if not admin:
admin = session.get('username')
if not iredutils.is_email(admin):
return (False, 'INVALID_ADMIN')
if not conn:
_wrap = SQLWrap()
conn = _wrap.conn
account_settings = {}
# Get settings stored in sql column `mailbox.settings`
if existing_settings:
orig_settings = existing_settings
else:
try:
qr = conn.select(
'mailbox',
vars={'username': admin},
what='settings',
where='username=$username AND (isadmin=1 OR isglobaladmin=1)',
limit=1)
if not qr:
# Not a mail user
qr = conn.select('admin',
vars={'username': admin},
what='settings',
where='username=$username',
limit=1)
if not qr:
return (False, 'INVALID_ADMIN')
orig_settings = qr[0]['settings']
except Exception as e:
return (False, repr(e))
if orig_settings:
account_settings = sqlutils.account_settings_string_to_dict(
orig_settings)
return (True, account_settings)
def get_first_char_of_all_accounts(domain, account_type, conn=None):
"""Get first character of accounts under given domain.
@domain - must be a valid domain name.
@account_type - could be one of: user, ml, alias.
@conn - SQL connection cursor
"""
if not conn:
_wrap = SQLWrap()
conn = _wrap.conn
type_map = {
'user': {
'table': 'mailbox',
'column': 'username'
},
'alias': {
'table': 'alias',
'column': 'address'
},
'ml': {
'table': 'maillists',
'column': 'address'
}
}
_table = type_map[account_type]['table']
_column = type_map[account_type]['column']
chars = []
try:
qr = conn.select(
_table,
vars={
'domain': domain,
'column': _column
},
what="SUBSTRING({} FROM 1 FOR 1) AS first_char".format(_column),
where='domain=$domain',
group='first_char')
if qr:
chars = [str(i.first_char).upper() for i in qr]
chars.sort()
return (True, chars)
except Exception as e:
log_traceback()
return (False, repr(e))
def num_managed_domains(admin=None,
disabled_only=False,
first_char=None,
conn=None):
num = 0
if not admin:
admin = session.get('username')
if not conn:
_wrap = SQLWrap()
conn = _wrap.conn
sql_where = ''
if disabled_only is True:
sql_where += 'domain.active=0'
if first_char:
first_char = first_char[0].lower()
if sql_where:
sql_where += ' AND domain.domain LIKE %s' % web.sqlquote(
first_char + '%')
else:
sql_where += 'domain.domain LIKE %s' % web.sqlquote(first_char +
'%')
try:
if sql_lib_general.is_global_admin(admin=admin, conn=conn):
qr = conn.select('domain',
what='COUNT(domain) AS total',
where=sql_where or None)
else:
if sql_where:
sql_where = 'AND ' + sql_where
qr = conn.query("""
SELECT COUNT(domain.domain) AS total
FROM domain
LEFT JOIN domain_admins ON (domain.domain=domain_admins.domain)
WHERE domain_admins.username=$admin %s
""" % (sql_where),
vars={'admin': admin})
num = qr[0].total or 0
except:
log_traceback()
return num