You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
255 lines
8.3 KiB
Python
255 lines
8.3 KiB
Python
from mailu import manager, db
|
|
from mailu.admin import models
|
|
|
|
|
|
@manager.command
|
|
def flushdb():
|
|
""" Flush the database
|
|
"""
|
|
db.drop_all()
|
|
|
|
|
|
@manager.command
|
|
def initdb():
|
|
""" Initialize the database
|
|
"""
|
|
db.create_all()
|
|
|
|
|
|
@manager.command
|
|
def admin(localpart, domain_name, password):
|
|
""" Create an admin user
|
|
"""
|
|
domain = models.Domain.query.get(domain_name)
|
|
if not domain:
|
|
domain = models.Domain(name=domain_name)
|
|
db.session.add(domain)
|
|
user = models.User(
|
|
localpart=localpart,
|
|
domain=domain,
|
|
global_admin=True
|
|
)
|
|
user.set_password(password)
|
|
db.session.add(user)
|
|
db.session.commit()
|
|
|
|
@manager.command
|
|
def user(localpart, domain_name, password, hash_scheme='SHA512-CRYPT'):
|
|
""" Create a user
|
|
"""
|
|
domain = models.Domain.query.get(domain_name)
|
|
if not domain:
|
|
domain = models.Domain(name=domain_name)
|
|
db.session.add(domain)
|
|
user = models.User(
|
|
localpart=localpart,
|
|
domain=domain,
|
|
global_admin=False
|
|
)
|
|
user.set_password(password, hash_scheme=hash_scheme)
|
|
db.session.add(user)
|
|
db.session.commit()
|
|
|
|
@manager.option('-n','--domain_name',dest='domain_name')
|
|
@manager.option('-u','--max_users',dest='max_users')
|
|
@manager.option('-a','--max_aliases',dest='max_aliases')
|
|
@manager.option('-q','--max_quota_bytes',dest='max_quota_bytes')
|
|
def domain(domain_name, max_users=0, max_aliases=0, max_quota_bytes=0):
|
|
domain = models.Domain.query.get(domain_name)
|
|
if not domain:
|
|
domain = models.Domain(name=domain_name)
|
|
db.session.add(domain)
|
|
db.session.commit()
|
|
|
|
@manager.command
|
|
def user_import(localpart, domain_name, password_hash, hash_scheme='SHA512-CRYPT'):
|
|
""" Import a user along with password hash. Available hashes:
|
|
'SHA512-CRYPT'
|
|
'SHA256-CRYPT'
|
|
'MD5-CRYPT'
|
|
'CRYPT'
|
|
"""
|
|
domain = models.Domain.query.get(domain_name)
|
|
if not domain:
|
|
domain = models.Domain(name=domain_name)
|
|
db.session.add(domain)
|
|
user = models.User(
|
|
localpart=localpart,
|
|
domain=domain,
|
|
global_admin=False
|
|
)
|
|
user.set_password(password_hash, hash_scheme=hash_scheme, raw=True)
|
|
db.session.add(user)
|
|
db.session.commit()
|
|
|
|
@manager.command
|
|
def config_update(verbose=False, delete_objects=False):
|
|
"""sync configuration with data from YAML-formatted stdin"""
|
|
import yaml, sys
|
|
new_config=yaml.load(sys.stdin)
|
|
# print new_config
|
|
domains=new_config.get('domains',[])
|
|
tracked_domains=set()
|
|
for domain_config in domains:
|
|
if verbose:
|
|
domain_name = domain_config['name']
|
|
max_users=domain_config.get('max_users',0)
|
|
max_aliases=domain_config.get('max_aliases',0)
|
|
max_quota_bytes=domain_config.get('max_quota_bytes',0)
|
|
tracked_domains.add(domain_name)
|
|
domain = models.Domain.query.get(domain_name)
|
|
if not domain:
|
|
domain = models.Domain(name=domain_name,
|
|
max_users=max_users,
|
|
max_aliases=max_aliases,
|
|
max_quota_bytes=max_quota_bytes)
|
|
db.session.add(domain)
|
|
print("Added "+str(domain_config))
|
|
else:
|
|
domain.max_users = max_users
|
|
domain.max_aliases = max_aliases
|
|
domain.max_quota_bytes = max_quota_bytes
|
|
db.session.add(domain)
|
|
print("Updated "+str(domain_config))
|
|
|
|
users=new_config.get('users',[])
|
|
tracked_users=set()
|
|
user_optional_params=('comment','quota_bytes','global_admin',
|
|
'enable_imap','enable_pop','forward_enabled','forward_destination',
|
|
'reply_enabled','reply_subject','reply_body','displayed_name','spam_enabled',
|
|
'email','spam_threshold')
|
|
for user_config in users:
|
|
if verbose:
|
|
print(str(user_config))
|
|
localpart=user_config['localpart']
|
|
domain_name=user_config['domain']
|
|
global_admin=user_config.get('global_admin',False)
|
|
password_hash=user_config.get('password_hash',None)
|
|
hash_scheme=user_config.get('hash_scheme',None)
|
|
domain = models.Domain.query.get(domain_name)
|
|
email='{0}@{1}'.format(localpart,domain_name)
|
|
optional_params={}
|
|
for k in user_optional_params:
|
|
if user_config.has_key(k):
|
|
optional_params[k]=user_config[k]
|
|
if not domain:
|
|
domain = models.Domain(name=domain_name)
|
|
db.session.add(domain)
|
|
user = models.User.query.get(email)
|
|
tracked_users.add(email)
|
|
tracked_domains.add(domain_name)
|
|
if not user:
|
|
user = models.User(
|
|
localpart=localpart,
|
|
domain=domain,
|
|
**optional_params
|
|
)
|
|
user.set_password(password_hash, hash_scheme=hash_scheme, raw=True)
|
|
db.session.add(user)
|
|
|
|
aliases=new_config.get('aliases',[])
|
|
tracked_aliases=set()
|
|
for alias_config in aliases:
|
|
if verbose:
|
|
print(str(alias_config))
|
|
localpart=alias_config['localpart']
|
|
domain_name=alias_config['domain']
|
|
destination=alias_config['destination']
|
|
if type(alias_config['destination']) == str:
|
|
destination = alias_config['destination'].split(',')
|
|
else:
|
|
destination = alias_config['destination']
|
|
wildcard=alias_config.get('wildcard',False)
|
|
domain = models.Domain.query.get(domain_name)
|
|
email='{0}@{1}'.format(localpart,domain_name)
|
|
if not domain:
|
|
domain = models.Domain(name=domain_name)
|
|
db.session.add(domain)
|
|
alias = models.Alias.query.get(email)
|
|
tracked_aliases.add(email)
|
|
tracked_domains.add(domain_name)
|
|
if not alias:
|
|
alias = models.Alias(
|
|
localpart=localpart,
|
|
domain=domain,
|
|
wildcard=wildcard,
|
|
destination=destination,
|
|
email=email
|
|
)
|
|
else:
|
|
alias.destination = destination
|
|
alias.wildcard=wildcard
|
|
db.session.add(alias)
|
|
|
|
db.session.commit()
|
|
|
|
managers=new_config.get('managers',[])
|
|
# tracked_managers=set()
|
|
for manager_config in managers:
|
|
if verbose:
|
|
print(str(manager_config))
|
|
domain_name = manager_config['domain']
|
|
user_name = manager_config['user']
|
|
domain = models.Domain.query.get(domain_name)
|
|
manageruser = models.User.query.get(user_name + '@' + domain_name)
|
|
if not manageruser in domain.managers:
|
|
domain.managers.append(manageruser)
|
|
db.session.add(domain)
|
|
|
|
db.session.commit()
|
|
|
|
if delete_objects:
|
|
for user in db.session.query(models.User).all():
|
|
if not ( user.email in tracked_users ):
|
|
if verbose:
|
|
print("Deleting user: "+str(user.email))
|
|
db.session.delete(user)
|
|
for alias in db.session.query(models.Alias).all():
|
|
if not ( alias.email in tracked_aliases ):
|
|
if verbose:
|
|
print("Deleting alias: "+str(alias.email))
|
|
db.session.delete(alias)
|
|
for domain in db.session.query(models.Domain).all():
|
|
if not ( domain.name in tracked_domains ):
|
|
if verbose:
|
|
print("Deleting domain: "+str(domain.name))
|
|
db.session.delete(domain)
|
|
db.session.commit()
|
|
|
|
@manager.command
|
|
def user_delete(email):
|
|
"""delete user"""
|
|
user = models.User.query.get(email)
|
|
if user:
|
|
db.session.delete(user)
|
|
db.session.commit()
|
|
|
|
@manager.command
|
|
def alias_delete(email):
|
|
"""delete alias"""
|
|
alias = models.Alias.query.get(email)
|
|
if alias:
|
|
db.session.delete(alias)
|
|
db.session.commit()
|
|
|
|
@manager.command
|
|
def alias(localpart, domain_name, destination):
|
|
""" Create an alias
|
|
"""
|
|
domain = models.Domain.query.get(domain_name)
|
|
if not domain:
|
|
domain = models.Domain(name=domain_name)
|
|
db.session.add(domain)
|
|
alias = models.Alias(
|
|
localpart=localpart,
|
|
domain=domain,
|
|
destination=destination.split(','),
|
|
email="%s@%s" % (localpart, domain_name)
|
|
)
|
|
db.session.add(alias)
|
|
db.session.commit()
|
|
|
|
|
|
if __name__ == "__main__":
|
|
manager.run()
|