YunoHost/moulinette
1
0
Fork 0
mirror of https://github.com/YunoHost/moulinette.git synced 2024-09-03 20:06:31 +02:00
Code Issues Projects Releases Packages Wiki Activity

broken

Browse source
This commit is contained in:
root 2012-11-08 19:20:13 +01:00
parent 0e17445ff0
commit d54ebd86eb
4 changed files with 295 additions and 268 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

10
action_map.yml
View file

@ -58,7 +58,6 @@ user:
-f: -f:
full: --filter full: --filter
help: LDAP filter used to search help: LDAP filter used to search
pattern: 'yayaya'
-l: -l:
full: --limit full: --limit
help: Maximum number of user fetched help: Maximum number of user fetched
@ -75,15 +74,24 @@ user:
-u: -u:
full: --username full: --username
help: Must be unique help: Must be unique
ask: "Username"
#pattern: '^[a-z0-9_]+$'
pattern: 'aza'
-f: -f:
full: --firstname full: --firstname
ask: "Firstname"
-l: -l:
full: --lastname full: --lastname
ask: "Lastname"
-m: -m:
full: --mail full: --mail
help: Main mail address must be unique help: Main mail address must be unique
ask: "Mail address"
pattern: '^[\w.-]+@[\w.-]+\.[a-zA-Z]{2,6}$'
-p: -p:
full: --password full: --password
ask: "User password"
password: yes
### user_delete() ### user_delete()
delete: delete:

80
parse_args
View file

@ -24,6 +24,7 @@ import os
import sys import sys
import argparse import argparse
import gettext import gettext
import getpass
try: try:
import yaml import yaml
except ImportError: except ImportError:
@ -38,7 +39,7 @@ if not __debug__:
gettext.install('YunoHost') gettext.install('YunoHost')
try: try:
from yunohost import YunoHostError, YunoHostLDAP, str_to_func, colorize, pretty_print_dict, display_error, connect_services, disconnect_services, validate from yunohost import YunoHostError, YunoHostLDAP, str_to_func, colorize, pretty_print_dict, display_error, validate
except ImportError: except ImportError:
sys.stderr.write('Error: Yunohost CLI Require YunoHost lib\n') sys.stderr.write('Error: Yunohost CLI Require YunoHost lib\n')
sys.exit(1) sys.exit(1)
@ -59,6 +60,8 @@ def parse_dict(action_map):
parsers = subparsers_category = subparsers_action = {} parsers = subparsers_category = subparsers_action = {}
parsers['general'] = argparse.ArgumentParser() parsers['general'] = argparse.ArgumentParser()
subparsers = parsers['general'].add_subparsers() subparsers = parsers['general'].add_subparsers()
new_args = []
patterns = {}
# Add general arguments # Add general arguments
for arg_name, arg_params in action_map['general_arguments'].items(): for arg_name, arg_params in action_map['general_arguments'].items():
@ -88,28 +91,59 @@ def parse_dict(action_map):
# Add arguments # Add arguments
if 'arguments' in action_params: if 'arguments' in action_params:
for arg_name, arg_params in action_params['arguments'].items(): for arg_name, arg_params in action_params['arguments'].items():
if 'password' in arg_params:
if arg_params['password']: is_password = True
del arg_params['password']
else: is_password = False
if 'full' in arg_params: if 'full' in arg_params:
arg_fullname = arg_params['full'] arg_names = [arg_name, arg_params['full']]
del arg_params['full'] del arg_params['full']
else: else: arg_names = [arg_name]
arg_fullname = False
if 'ask' in arg_params:
require_input = True
if (category != sys.argv[1]) or (action != sys.argv[2]):
require_input = False
for name in arg_names:
if name in sys.argv: require_input = False
if require_input:
if is_password:
if os.isatty(1):
pwd1 = getpass.getpass(colorize(arg_params['ask'] + ': ', 'cyan'))
pwd2 = getpass.getpass(colorize('Retype ' + arg_params['ask'][0].lower() + arg_params['ask'][1:] + ': ', 'cyan'))
if pwd1 != pwd2:
raise YunoHostError(22, _("Passwords don't match"))
sys.exit(1)
else:
raise YunoHostError(22, _("Missing arguments") + ': ' + arg_name)
new_args.extend([arg_name, pwd1])
else:
if os.isatty(1):
arg_value = raw_input(colorize(arg_params['ask'] + ': ', 'cyan'))
else:
raise YunoHostError(22, _("Missing arguments") + ': ' + arg_name)
new_args.extend([arg_name, arg_value])
del arg_params['ask']
if 'pattern' in arg_params: if 'pattern' in arg_params:
pattern = arg_params['pattern'] if (category == sys.argv[1]) and (action == sys.argv[2]):
del arg_params['pattern'] if 'dest' in arg_params: name = arg_params['dest']
def pmatch(string): elif arg_fullname: name = arg_fullname
validate({ string : pattern }) else: name = arg_name
if arg_fullname: patterns[name] = arg_params['pattern']
parsers[category + '_' + action].add_argument(arg_name, arg_fullname, type=pmatch, **arg_params) del arg_params['pattern']
else:
parsers[category + '_' + action].add_argument(arg_name, type=pmatch, **arg_params)
else:
if arg_fullname:
parsers[category + '_' + action].add_argument(arg_name, arg_fullname, **arg_params)
else:
parsers[category + '_' + action].add_argument(arg_name, **arg_params)
return parsers['general'].parse_args() parsers[category + '_' + action].add_argument(*arg_names, **arg_params)
args = parsers['general'].parse_args(sys.argv.extend(new_args))
args_dict = vars(args)
print patterns
for key, value in patterns.items():
validate({ args_dict[key] : value })
return args
def main(): def main():
@ -126,13 +160,9 @@ def main():
with open('action_map.yml') as f: with open('action_map.yml') as f:
action_map = yaml.load(f) action_map = yaml.load(f)
args = parse_dict(action_map)
connections = connect_services(action_map)
try: try:
if connections: args = parse_dict(action_map)
result = args.func(vars(args), connections) result = args.func(vars(args))
else:
result = args.func(vars(args))
except TypeError, error: except TypeError, error:
if not __debug__ : if not __debug__ :
traceback.print_exc() traceback.print_exc()
@ -148,8 +178,6 @@ def main():
pretty_print_dict(result) pretty_print_dict(result)
else: else:
print(json.dumps(result)) print(json.dumps(result))
finally:
disconnect_services(connections)
return 0 return 0

33
yunohost.py
View file

@ -99,6 +99,7 @@ def validate(regex_dict):
Boolean | YunoHostError Boolean | YunoHostError
""" """
print regex_dict
for attr, pattern in regex_dict.items(): for attr, pattern in regex_dict.items():
if re.match(pattern, attr): if re.match(pattern, attr):
continue continue
@ -242,27 +243,35 @@ class YunoHostError(Exception):
self.desc = code self.desc = code
class YunoHostLDAP: class YunoHostLDAP(object):
""" Specific LDAP functions for YunoHost """ """ Specific LDAP functions for YunoHost """
conn = None
def __init__(self, password=False): def __enter__(self, password=False):
""" """
Connect to LDAP base Connect to LDAP base
Initialize to localhost, base yunohost.org, prompt for password Initialize to localhost, base yunohost.org, prompt for password
""" """
self.conn = ldap.initialize('ldap://localhost:389') if self.conn is None:
self.base = 'dc=yunohost,dc=org' self.conn = ldap.initialize('ldap://localhost:389')
if password: self.base = 'dc=yunohost,dc=org'
self.pwd = password if password:
else: self.pwd = password
self.pwd = getpass.getpass(colorize(_('Admin Password: '), 'yellow')) else:
try: try:
self.conn.simple_bind_s('cn=admin,' + self.base, self.pwd) self.pwd = getpass.getpass(colorize(_('Admin Password: '), 'yellow'))
except ldap.INVALID_CREDENTIALS: except KeyboardInterrupt, EOFError:
raise YunoHostError(13, _('Invalid credentials')) raise YunoHostError(125, _("Interrupted"))
try:
self.conn.simple_bind_s('cn=admin,' + self.base, self.pwd)
except ldap.INVALID_CREDENTIALS:
raise YunoHostError(13, _('Invalid credentials'))
return self
def __exit__(self, type, value, traceback):
self.disconnect()
def disconnect(self): def disconnect(self):
""" """

436
yunohost_user.py
View file

@ -7,318 +7,300 @@ import crypt
import random import random
import string import string
import getpass import getpass
from yunohost import YunoHostError, win_msg, colorize, validate, get_required_args from yunohost import YunoHostError, YunoHostLDAP, win_msg, colorize, validate, get_required_args
def user_list(args, connections): def user_list(args):
""" """
List YunoHost users from LDAP List YunoHost users from LDAP
Keyword argument: Keyword argument:
args -- Dictionnary of values (can be empty) args -- Dictionnary of values (can be empty)
connections -- LDAP connection
Returns: Returns:
Dict Dict
""" """
yldap = connections['ldap'] with YunoHostLDAP() as yldap:
user_attrs = ['uid', 'mail', 'cn', 'mailalias'] user_attrs = ['uid', 'mail', 'cn', 'mailalias']
attrs = [] attrs = []
result_dict = {} result_dict = {}
if args['offset']: offset = int(args['offset']) if args['offset']: offset = int(args['offset'])
else: offset = 0 else: offset = 0
if args['limit']: limit = int(args['limit']) if args['limit']: limit = int(args['limit'])
else: limit = 1000 else: limit = 1000
if args['filter']: filter = args['filter'] if args['filter']: filter = args['filter']
else: filter = 'uid=*' else: filter = 'uid=*'
if args['fields']: if args['fields']:
for attr in args['fields']: for attr in args['fields']:
if attr in user_attrs: if attr in user_attrs:
attrs.append(attr) attrs.append(attr)
continue continue
else: else:
raise YunoHostError(22, _("Invalid field : ") + attr) raise YunoHostError(22, _("Invalid field : ") + attr)
else: else:
attrs = user_attrs attrs = user_attrs
result = yldap.search('ou=users,dc=yunohost,dc=org', filter, attrs) result = yldap.search('ou=users,dc=yunohost,dc=org', filter, attrs)
if result and len(result) > (0 + offset) and limit > 0: if result and len(result) > (0 + offset) and limit > 0:
i = 0 + offset i = 0 + offset
for user in result[i:]: for user in result[i:]:
if i < limit: if i < limit:
entry = { entry = {
'Username': user['uid'], 'Username': user['uid'],
'Fullname': user['cn'], 'Fullname': user['cn'],
'Mail': user['mail'][0] 'Mail': user['mail'][0]
} }
if len(user['mail']) > 1: if len(user['mail']) > 1:
entry['Mail Forward'] = user['mail'][1:] entry['Mail Forward'] = user['mail'][1:]
if 'mailalias' in user: if 'mailalias' in user:
entry['Mail Aliases'] = user['mailalias'] entry['Mail Aliases'] = user['mailalias']
result_dict[str(i)] = entry result_dict[str(i)] = entry
i += 1 i += 1
else: else:
raise YunoHostError(167, _("No user found")) raise YunoHostError(167, _("No user found"))
return result_dict return result_dict
def user_create(args, connections): def user_create(args):
""" """
Add user to LDAP Add user to LDAP
Keyword argument: Keyword argument:
args -- Dictionnary of values (can be empty) args -- Dictionnary of values (can be empty)
connections -- LDAP connections
Returns: Returns:
Dict Dict
""" """
yldap = connections['ldap'] print args
args = get_required_args(args, { with YunoHostLDAP() as yldap:
'username': _('Username'), # Validate password length
'mail': _('Mail address'), if len(args['password']) < 4:
'firstname': _('Firstname'), raise YunoHostError(22, _("Password is too short"))
'lastname': _('Lastname'),
'password': _('Password')
}, True)
# Validate password length yldap.validate_uniqueness({
if len(args['password']) < 4: 'uid' : args['username'],
raise YunoHostError(22, _("Password is too short")) 'mail' : args['mail'],
'mailalias' : args['mail']
})
# Validate other values TODO: validate all values # Check if unix user already exists (doesn't work)
validate({ #if not os.system("getent passwd " + args['username']):
args['username'] : r'^[a-z0-9_]+$', # raise YunoHostError(17, _("Username not available"))
args['mail'] : r'^[\w.-]+@[\w.-]+\.[a-zA-Z]{2,6}$',
})
yldap.validate_uniqueness({ #TODO: check if mail belongs to a domain
'uid' : args['username'],
'mail' : args['mail'],
'mailalias' : args['mail']
})
# Check if unix user already exists (doesn't work) # Get random UID/GID
#if not os.system("getent passwd " + args['username']): uid_check = gid_check = 0
# raise YunoHostError(17, _("Username not available")) while uid_check == 0 and gid_check == 0:
uid = str(random.randint(200, 99999))
uid_check = os.system("getent passwd " + uid)
gid_check = os.system("getent group " + uid)
#TODO: check if mail belongs to a domain # Adapt values for LDAP
fullname = args['firstname'] + ' ' + args['lastname']
rdn = 'uid=' + args['username'] + ',ou=users'
char_set = string.ascii_uppercase + string.digits
salt = ''.join(random.sample(char_set,8))
salt = '$1$' + salt + '$'
pwd = '{CRYPT}' + crypt.crypt(str(args['password']), salt)
attr_dict = {
'objectClass' : ['mailAccount', 'inetOrgPerson', 'posixAccount'],
'givenName' : args['firstname'],
'sn' : args['lastname'],
'displayName' : fullname,
'cn' : fullname,
'uid' : args['username'],
'mail' : args['mail'],
'userPassword' : pwd,
'gidNumber' : uid,
'uidNumber' : uid,
'homeDirectory' : '/home/' + args['username'],
'loginShell' : '/bin/false'
}
# Get random UID/GID if yldap.add(rdn, attr_dict):
uid_check = gid_check = 0 # Create user /home directory by switching user
while uid_check == 0 and gid_check == 0: os.system("su - " + args['username'] + " -c ''")
uid = str(random.randint(200, 99999)) #TODO: Send a welcome mail to user
uid_check = os.system("getent passwd " + uid) win_msg(_("User successfully created"))
gid_check = os.system("getent group " + uid) return { _("Fullname") : fullname, _("Username") : args['username'], _("Mail") : args['mail'] }
else:
# Adapt values for LDAP raise YunoHostError(169, _("An error occured during user creation"))
fullname = args['firstname'] + ' ' + args['lastname']
rdn = 'uid=' + args['username'] + ',ou=users'
char_set = string.ascii_uppercase + string.digits
salt = ''.join(random.sample(char_set,8))
salt = '$1$' + salt + '$'
pwd = '{CRYPT}' + crypt.crypt(str(args['password']), salt)
attr_dict = {
'objectClass' : ['mailAccount', 'inetOrgPerson', 'posixAccount'],
'givenName' : args['firstname'],
'sn' : args['lastname'],
'displayName' : fullname,
'cn' : fullname,
'uid' : args['username'],
'mail' : args['mail'],
'userPassword' : pwd,
'gidNumber' : uid,
'uidNumber' : uid,
'homeDirectory' : '/home/' + args['username'],
'loginShell' : '/bin/false'
}
if yldap.add(rdn, attr_dict):
# Create user /home directory by switching user
os.system("su - " + args['username'] + " -c ''")
#TODO: Send a welcome mail to user
win_msg(_("User successfully created"))
return { _("Fullname") : fullname, _("Username") : args['username'], _("Mail") : args['mail'] }
else:
raise YunoHostError(169, _("An error occured during user creation"))
def user_delete(args, connections): def user_delete(args):
""" """
Remove user from LDAP Remove user from LDAP
Keyword argument: Keyword argument:
args -- Dictionnary of values (can be empty) args -- Dictionnary of values (can be empty)
connections -- LDAP connection
Returns: Returns:
Dict Dict
""" """
yldap = connections['ldap'] with YunoHostLDAP() as yldap:
result = { 'Users' : [] } result = { 'Users' : [] }
args = get_required_args(args, { 'users' : _('User to delete') }) args = get_required_args(args, { 'users' : _('User to delete') })
if not isinstance(args['users'], list): if not isinstance(args['users'], list):
args['users'] = [ args['users'] ] args['users'] = [ args['users'] ]
for user in args['users']: for user in args['users']:
validate({ user : r'^[a-z0-9_]+$' }) validate({ user : r'^[a-z0-9_]+$' })
if yldap.remove('uid=' + user+ ',ou=users'): if yldap.remove('uid=' + user+ ',ou=users'):
if args['purge']: if args['purge']:
os.system('rm -rf /home/' + user) os.system('rm -rf /home/' + user)
result['Users'].append(user) result['Users'].append(user)
continue continue
else: else:
raise YunoHostError(169, _("An error occured during user deletion")) raise YunoHostError(169, _("An error occured during user deletion"))
win_msg(_("User(s) successfully deleted")) win_msg(_("User(s) successfully deleted"))
return result return result
def user_update(args, connections): def user_update(args):
""" """
Update user informations Update user informations
Keyword argument: Keyword argument:
args -- Dictionnary of values args -- Dictionnary of values
connections -- LDAP connection
Returns: Returns:
Dict Dict
""" """
yldap = connections['ldap'] with YunoHostLDAP() as yldap:
validate({ args['user'] : r'^[a-z0-9_]+$' }) validate({ args['user'] : r'^[a-z0-9_]+$' })
attrs_to_fetch = ['givenName', 'sn', 'mail', 'mailAlias'] attrs_to_fetch = ['givenName', 'sn', 'mail', 'mailAlias']
new_attr_dict = {} new_attr_dict = {}
# Populate user informations # Populate user informations
result = yldap.search(base='ou=users,dc=yunohost,dc=org', filter='uid=' + args['user'], attrs=attrs_to_fetch) result = yldap.search(base='ou=users,dc=yunohost,dc=org', filter='uid=' + args['user'], attrs=attrs_to_fetch)
if not result: if not result:
raise YunoHostError(167, _("No user found")) raise YunoHostError(167, _("No user found"))
user = result[0] user = result[0]
# Get modifications from arguments # Get modifications from arguments
if args['firstname']: if args['firstname']:
new_attr_dict['givenName'] = args['firstname'] # TODO: Validate new_attr_dict['givenName'] = args['firstname'] # TODO: Validate
new_attr_dict['cn'] = new_attr_dict['displayName'] = args['firstname'] + ' ' + user['sn'][0] new_attr_dict['cn'] = new_attr_dict['displayName'] = args['firstname'] + ' ' + user['sn'][0]
if args['lastname']: if args['lastname']:
new_attr_dict['sn'] = args['lastname'] # TODO: Validate new_attr_dict['sn'] = args['lastname'] # TODO: Validate
new_attr_dict['cn'] = new_attr_dict['displayName'] = user['givenName'][0] + ' ' + args['lastname'] new_attr_dict['cn'] = new_attr_dict['displayName'] = user['givenName'][0] + ' ' + args['lastname']
if args['lastname'] and args['firstname']: if args['lastname'] and args['firstname']:
new_attr_dict['cn'] = new_attr_dict['displayName'] = args['firstname'] + ' ' + args['lastname'] new_attr_dict['cn'] = new_attr_dict['displayName'] = args['firstname'] + ' ' + args['lastname']
if args['change_password']: if args['change_password']:
char_set = string.ascii_uppercase + string.digits char_set = string.ascii_uppercase + string.digits
salt = ''.join(random.sample(char_set,8)) salt = ''.join(random.sample(char_set,8))
salt = '$1$' + salt + '$' salt = '$1$' + salt + '$'
new_attr_dict['userPassword'] = '{CRYPT}' + crypt.crypt(str(args['change_password']), salt) new_attr_dict['userPassword'] = '{CRYPT}' + crypt.crypt(str(args['change_password']), salt)
if args['mail']: if args['mail']:
validate({ args['mail'] : r'^[\w.-]+@[\w.-]+\.[a-zA-Z]{2,6}$' }) validate({ args['mail'] : r'^[\w.-]+@[\w.-]+\.[a-zA-Z]{2,6}$' })
yldap.validate_uniqueness({
'mail' : args['mail'],
'mailalias' : args['mail']
})
del user['mail'][0]
new_attr_dict['mail'] = [args['mail']] + user['mail']
if args['add_mailforward']:
if not isinstance(args['add_mailforward'], list):
args['add_mailforward'] = [ args['add_mailforward'] ]
for mail in args['add_mailforward']:
validate({ mail : r'^[\w.-]+@[\w.-]+\.[a-zA-Z]{2,6}$' })
yldap.validate_uniqueness({ yldap.validate_uniqueness({
'mail' : mail, 'mail' : args['mail'],
'mailalias' : mail 'mailalias' : args['mail']
}) })
user['mail'].append(mail) del user['mail'][0]
new_attr_dict['mail'] = user['mail'] new_attr_dict['mail'] = [args['mail']] + user['mail']
if args['remove_mailforward']: if args['add_mailforward']:
if not isinstance(args['remove_mailforward'], list): if not isinstance(args['add_mailforward'], list):
args['remove_mailforward'] = [ args['remove_mailforward'] ] args['add_mailforward'] = [ args['add_mailforward'] ]
for mail in args['remove_mailforward']: for mail in args['add_mailforward']:
if len(user['mail']) > 1 and mail in user['mail'][1:]: validate({ mail : r'^[\w.-]+@[\w.-]+\.[a-zA-Z]{2,6}$' })
user['mail'].remove(mail) yldap.validate_uniqueness({
else: 'mail' : mail,
raise YunoHostError(22, _("Invalid mail forward : ") + mail) 'mailalias' : mail
new_attr_dict['mail'] = user['mail'] })
user['mail'].append(mail)
new_attr_dict['mail'] = user['mail']
if args['add_mailalias']: if args['remove_mailforward']:
if not isinstance(args['add_mailalias'], list): if not isinstance(args['remove_mailforward'], list):
args['add_mailalias'] = [ args['add_mailalias'] ] args['remove_mailforward'] = [ args['remove_mailforward'] ]
for mail in args['add_mailalias']: for mail in args['remove_mailforward']:
validate({ mail : r'^[\w.-]+@[\w.-]+\.[a-zA-Z]{2,6}$' }) if len(user['mail']) > 1 and mail in user['mail'][1:]:
yldap.validate_uniqueness({ user['mail'].remove(mail)
'mail' : mail, else:
'mailalias' : mail raise YunoHostError(22, _("Invalid mail forward : ") + mail)
}) new_attr_dict['mail'] = user['mail']
if 'mailalias' in user:
user['mailalias'].append(mail)
else:
user['mailalias'] = [ mail ]
new_attr_dict['mailalias'] = user['mailalias']
if args['remove_mailalias']: if args['add_mailalias']:
if not isinstance(args['remove_mailalias'], list): if not isinstance(args['add_mailalias'], list):
args['remove_mailalias'] = [ args['remove_mailalias'] ] args['add_mailalias'] = [ args['add_mailalias'] ]
for mail in args['remove_mailalias']: for mail in args['add_mailalias']:
if 'mailalias' in user and mail in user['mailalias']: validate({ mail : r'^[\w.-]+@[\w.-]+\.[a-zA-Z]{2,6}$' })
user['mailalias'].remove(mail) yldap.validate_uniqueness({
else: 'mail' : mail,
raise YunoHostError(22, _("Invalid mail alias : ") + mail) 'mailalias' : mail
new_attr_dict['mailalias'] = user['mailalias'] })
if 'mailalias' in user:
user['mailalias'].append(mail)
else:
user['mailalias'] = [ mail ]
new_attr_dict['mailalias'] = user['mailalias']
if yldap.update('uid=' + args['user'] + ',ou=users', new_attr_dict): if args['remove_mailalias']:
win_msg(_("User successfully updated")) if not isinstance(args['remove_mailalias'], list):
return user_info({ 'user' : args['user'], 'mail' : None }, connections) args['remove_mailalias'] = [ args['remove_mailalias'] ]
else: for mail in args['remove_mailalias']:
raise YunoHostError(169, _("An error occured during user update")) if 'mailalias' in user and mail in user['mailalias']:
user['mailalias'].remove(mail)
else:
raise YunoHostError(22, _("Invalid mail alias : ") + mail)
new_attr_dict['mailalias'] = user['mailalias']
if yldap.update('uid=' + args['user'] + ',ou=users', new_attr_dict):
win_msg(_("User successfully updated"))
return user_info({ 'user' : args['user'], 'mail' : None }, connections)
else:
raise YunoHostError(169, _("An error occured during user update"))
def user_info(args, connections): def user_info(args):
""" """
Fetch user informations from LDAP Fetch user informations from LDAP
Keyword argument: Keyword argument:
args -- Dictionnary of values (can be empty) args -- Dictionnary of values (can be empty)
connections -- LDAP connection
Returns: Returns:
Dict Dict
""" """
yldap = connections['ldap'] with YunoHostLDAP() as yldap:
user_attrs = ['cn', 'mail', 'uid', 'mailAlias'] user_attrs = ['cn', 'mail', 'uid', 'mailAlias']
if args['mail']: if args['mail']:
validate({ args['mail'] : r'^[\w.-]+@[\w.-]+\.[a-zA-Z]{2,6}$' }) validate({ args['mail'] : r'^[\w.-]+@[\w.-]+\.[a-zA-Z]{2,6}$' })
filter = 'mail=' + args['mail'] filter = 'mail=' + args['mail']
else: else:
args = get_required_args(args, { 'user' : _("Username") }) args = get_required_args(args, { 'user' : _("Username") })
validate({ args['user'] : r'^[a-z0-9_]+$' }) validate({ args['user'] : r'^[a-z0-9_]+$' })
filter = 'uid=' + args['user'] filter = 'uid=' + args['user']
result = yldap.search('ou=users,dc=yunohost,dc=org', filter, user_attrs) result = yldap.search('ou=users,dc=yunohost,dc=org', filter, user_attrs)
user = result[0] user = result[0]
result_dict = { result_dict = {
'Username': user['uid'], 'Username': user['uid'],
'Fullname': user['cn'], 'Fullname': user['cn'],
'Mail': user['mail'][0] 'Mail': user['mail'][0]
} }
if len(user['mail']) > 1: if len(user['mail']) > 1:
result_dict['Mail Forward'] = user['mail'][1:] result_dict['Mail Forward'] = user['mail'][1:]
if 'mailalias' in user: if 'mailalias' in user:
result_dict['Mail Aliases'] = user['mailalias'] result_dict['Mail Aliases'] = user['mailalias']
if result: if result:
return result_dict return result_dict
else: else:
raise YunoHostError(167, _("No user found")) raise YunoHostError(167, _("No user found"))