def _modify(options, parser):
# Set parser options
parser.add_argument( "group_id"
, action = "store"
, help = "Group id (not group name)."
)
parser.add_argument( "-n", "--group-name"
, action = "store"
, default = None
, help = "Group name. This is UTF-8 encoded string."
)
parser.add_argument( "-d", "--description"
, action = "store"
, default = None
, help = "Specify group description."
)
# Get options
namespace = parser.parse_args(options)
# Get auth token
auth_token = _func.getAuthTokenByLogin(namespace.admin_name, namespace.domain)
# Operation
return _func.operate( GROUP.updateGroup
, namespace.group_id.lower()
, parser.prog
, namespace.result_file
, namespace.domain
, auth_token
, namespace.group_id.lower() # group id
, namespace.group_name # group name
, namespace.description # group description
)
def _create(options, parser):
# Set parser options
parser.add_argument( "user_name"
, action = "store"
, help = "User name."
)
parser.add_argument( "nickname"
, action = "store"
, help = "Nickname."
)
# Get options
namespace = parser.parse_args(options)
# Get auth token
auth_token = _func.getAuthTokenByLogin(namespace.admin_name, namespace.domain)
# Operation
return _func.operate( NICKNAME.createNickname
, namespace.nickname.lower()
, parser.prog
, namespace.result_file
, namespace.domain
, auth_token
, namespace.user_name.lower() # user
, namespace.nickname.lower() # nickname
)
def _demoteowner(options, parser):
# Set parser options
parser.add_argument( "member_name"
, action = "store"
, help = "Member name."
)
parser.add_argument( "group_id"
, action = "store"
, help = "Group id (not group name)."
)
# Get options
namespace = parser.parse_args(options)
# Get auth token
auth_token = _func.getAuthTokenByLogin(namespace.admin_name, namespace.domain)
# Operation
return _func.operate( GROUP_O.deleteOwnerFromGroup
, namespace.group_id.lower()
, "{} \"{}\"".format( parser.prog
, namespace.member_name.lower()
)
, namespace.result_file
, namespace.domain
, auth_token
, namespace.member_name.lower() # member name
, namespace.group_id.lower() # group id
)
def _delete(options, parser):
# Set parser options
parser.add_argument( "ou_path"
, action = "store"
, help = "Organizational unit full path (e.g. /development/sales)."
)
# Get options
namespace = parser.parse_args(options)
# Get auth token
auth_token = _func.getAuthTokenByLogin(namespace.admin_name, namespace.domain)
# Get Customer ID
try:
customer_id = __getCustomerId(auth_token)
except:
return False
# Check ou has full path
if namespace.ou_path[0] != "/":
sys.stderr.write(_messages.OU_HAS_NOT_FULL_PATH)
return False
# Operation
return _func.operate( OU.deleteOu
, namespace.ou_path
, parser.prog
, namespace.result_file
, auth_token
, customer_id
, namespace.ou_path # ou path
)
def _create(options, parser):
# Set parser options
parser.add_argument( "user_name"
, action = "store"
, help = "User name."
)
parser.add_argument( "sn"
, action = "store"
, help = "Family name."
)
parser.add_argument( "given_name"
, action = "store"
, help = "Given name."
)
parser.add_argument( "-m", "--md5"
, action = "store_true"
, default = False
, help = "Use MD5 hash function (default = SHA-1)."
)
parser.add_argument( "-L", "--lock"
, action = "store_true"
, default = False
, help = "Lock a user's account."
)
# Get options
namespace = parser.parse_args(options)
# Check hash function name
if namespace.md5 == True:
hash_function_name = "MD5"
else:
hash_function_name = "SHA-1"
# Check lock/unlock
if namespace.lock == True:
suspended = "true"
else:
suspended = "false"
# Get auth token
auth_token = _func.getAuthTokenByLogin(namespace.admin_name, namespace.domain)
# Get user's password
hash_password = _func.getHashedPassword_interactive(hash_function_name)
# Operation
return _func.operate( USER.createUser
, namespace.user_name.lower()
, parser.prog
, namespace.result_file
, namespace.domain
, auth_token
, namespace.user_name.lower() # user
, hash_password # password
, namespace.sn # sn
, namespace.given_name # given name
, hash_function_name # function name
, suspended # suspended
)
def _modify_f(options, parser):
import csv
# Get options
namespace = parser.parse_args(options)
# Get auth token
auth_token = _func.getAuthTokenByLogin(namespace.admin_name, namespace.domain)
# Get Customer ID
try:
customer_id = __getCustomerId(auth_token)
except:
return False
# Get records from csv file
with open(namespace.csv_file) as f:
reader = csv.DictReader(f)
# Check header
header = f.next().replace("\n", "").split(",")
must_keys = ["ou_path", "description", "block_inheritance"]
if not _func.checkValidHeader(header, *must_keys):
return False
f.seek(0, 0)
# Read csv
for record in reader:
must_values = ["ou_path"]
if not _func.checkRecordHasValue(record, *must_values):
continue
# Check ou has full path
if record["ou_path"][0] != "/":
sys.stderr.write(_messages.OU_HAS_NOT_FULL_PATH)
continue
# Check block/unblock inheritance
block_inheritance = record["block_inheritance"].lower()
if block_inheritance == "true":
block_inheritance = "true"
elif block_inheritance == "false":
block_inheritance = "false"
else:
block_inheritance = None
# Operation
_func.operate( OU.updateOu
, record["ou_path"]
, parser.prog
, namespace.result_file
, auth_token
, customer_id
, record["ou_path"] # ou path
, _func.replaceSpace2None(
record["description"]) # ou description
, block_inheritance # block inheritance
)
return True
def _list(options, parser):
# Get options
namespace = parser.parse_args(options)
# Get auth token
auth_token = _func.getAuthTokenByLogin(namespace.admin_name, namespace.domain)
# Operation
USER2.outputAllUsers(namespace.domain, auth_token)
return True
def _moveuser_f(options, parser):
import csv
# Get options
namespace = parser.parse_args(options)
# Get auth token
auth_token = _func.getAuthTokenByLogin(namespace.admin_name, namespace.domain)
# Get Customer ID
try:
customer_id = __getCustomerId(auth_token)
except:
return False
# Get records from csv file
with open(namespace.csv_file) as f:
reader = csv.DictReader(f)
# Check header
header = f.next().replace("\n", "").split(",")
must_keys = ["user_name", "ou_path"]
if not _func.checkValidHeader(header, *must_keys):
return False
f.seek(0, 0)
# Read csv
for record in reader:
must_values = ["user_name", "ou_path"]
if not _func.checkRecordHasValue(record, *must_values):
continue
# Check ou has full path
if record["ou_path"][0] != "/":
sys.stderr.write(_messages.OU_HAS_NOT_FULL_PATH)
continue
_func.operate( OU_U.moveUserToOu
, record["ou_path"]
, "{} \"{}\"".format( parser.prog
, record["user_name"].lower()
)
, namespace.result_file
, auth_token
, customer_id
, "{}@{}".format( record["user_name"]
, namespace.domain
) # user name
, record["ou_path"] # ou path
)
return True
def _create(options, parser):
# Set parser options
parser.add_argument( "ou_path"
, action = "store"
, help = "Organizational unit full path (e.g. /development/sales)."
)
parser.add_argument( "-d", "--description"
, action = "store"
, default = ""
, help = "Specify organizational unit description."
)
parser.add_argument( "-b", "--block-inheritance"
, action = "store_true"
, default = False
, help = "Block inheritance (default = False)."
)
# Get options
namespace = parser.parse_args(options)
# Get auth token
auth_token = _func.getAuthTokenByLogin(namespace.admin_name, namespace.domain)
# Get Customer ID
try:
customer_id = __getCustomerId(auth_token)
except:
return False
# Check ou has full path
if namespace.ou_path[0] != "/":
sys.stderr.write(_messages.OU_HAS_NOT_FULL_PATH)
return False
# Check block/unblock inheritance
if namespace.block_inheritance == True:
block_inheritance = "true"
else:
block_inheritance = "false"
# Operation
return _func.operate( OU.createOu
, namespace.ou_path
, parser.prog
, namespace.result_file
, auth_token
, customer_id
, namespace.ou_path # ou path
, namespace.description # ou description
, block_inheritance # block inheritance
)
def _assignowner(options, parser):
# Set parser options
parser.add_argument( "member_name"
, action = "store"
, help = "Member name."
)
parser.add_argument( "group_id"
, action = "store"
, help = "Group id (not group name)."
)
# Get options
namespace = parser.parse_args(options)
# Get auth token
auth_token = _func.getAuthTokenByLogin(namespace.admin_name, namespace.domain)
# Operation
group_members_info = GROUP_M.getAllMembersOfGroup(
namespace.domain
, auth_token
, namespace.group_id.lower()
)
if not group_members_info.has_key(namespace.member_name.lower()):
add_result = _func.operate( GROUP_M.addMemberToGroup
, namespace.group_id.lower()
, "{} \"{}\"".format( "addmember"
, namespace.member_name.lower()
)
, namespace.result_file
, namespace.domain
, auth_token
, namespace.member_name.lower() # member name
, namespace.group_id.lower() # group id
)
if not add_result:
sys.stderr.write(_messages.GROUP_ASSIGNED_OWNER)
return False
return _func.operate( GROUP_O.assignOwnerToGroup
, namespace.group_id.lower()
, "{} \"{}\"".format( parser.prog
, namespace.member_name.lower()
)
, namespace.result_file
, namespace.domain
, auth_token
, namespace.member_name.lower() # member name
, namespace.group_id.lower() # group id
)
def _listnicknamesof(options, parser):
# Set parser options
parser.add_argument( "user_name"
, action = "store"
, help = "User name."
)
# Get options
namespace = parser.parse_args(options)
# Get auth token
auth_token = _func.getAuthTokenByLogin(namespace.admin_name, namespace.domain)
# Operation
NICKNAME.outputAllNicknamesOfUser(namespace.domain, auth_token, namespace.user_name.lower())
return True
def _listownersof(options, parser):
# Set parser options
parser.add_argument( "group_id"
, action = "store"
, help = "Group name."
)
# Get options
namespace = parser.parse_args(options)
# Get auth token
auth_token = _func.getAuthTokenByLogin(namespace.admin_name, namespace.domain)
# Operation
GROUP_O.outputAllOwnersOfGroup(namespace.domain, auth_token, namespace.group_id.lower())
return True
def _listgroupsof(options, parser):
# Set parser options
parser.add_argument( "member_name"
, action = "store"
, help = "Member name."
)
# Get options
namespace = parser.parse_args(options)
# Get auth token
auth_token = _func.getAuthTokenByLogin(namespace.admin_name, namespace.domain)
# Operation
GROUP.outputAllGroupsOfMember(namespace.domain, auth_token, namespace.member_name.lower())
return True
def _listuserswithou(options, parser):
# Get options
namespace = parser.parse_args(options)
# Get auth token
auth_token = _func.getAuthTokenByLogin(namespace.admin_name, namespace.domain)
# Get Customer ID
try:
customer_id = __getCustomerId(auth_token)
except:
return False
# Operation
OU_U.outputAllUsersWithOu(auth_token, customer_id)
return True
def _moveuser(options, parser):
# Set parser options
parser.add_argument( "user_name"
, action = "store"
, help = "User name."
)
parser.add_argument( "new_ou_path"
, action = "store"
, help = "Organizational unit full path (e.g. /development/sales)."
)
# Get options
namespace = parser.parse_args(options)
# Get auth token
auth_token = _func.getAuthTokenByLogin(namespace.admin_name, namespace.domain)
# Get Customer ID
try:
customer_id = __getCustomerId(auth_token)
except:
return False
# Check ou has full path
if namespace.new_ou_path[0] != "/":
sys.stderr.write(_messages.OU_HAS_NOT_FULL_PATH)
return False
# Operation
return _func.operate( OU_U.moveUserToOu
, namespace.new_ou_path
, "{} \"{}\"".format( parser.prog
, namespace.user_name.lower()
)
, namespace.result_file
, auth_token
, customer_id
, "{}@{}".format( namespace.user_name.lower()
, namespace.domain
) # user name
, namespace.new_ou_path # ou path
)
def _delete(options, parser):
# Set parser options
parser.add_argument( "nickname_email"
, action = "store"
, help = "Nickname."
)
# Get options
namespace = parser.parse_args(options)
# Get auth token
auth_token = _func.getAuthTokenByLogin(namespace.admin_name, namespace.domain)
# Operation
return _func.operate( NICKNAME2.deleteAlias
, namespace.nickname_email.lower()
, parser.prog
, namespace.result_file
, namespace.domain
, auth_token
, namespace.nickname_email.lower() # nickname_email
)
def _deletemember_f(options, parser):
import csv
# Get options
namespace = parser.parse_args(options)
# Get auth token
auth_token = _func.getAuthTokenByLogin(namespace.admin_name, namespace.domain)
# Get records from csv file
with open(namespace.csv_file) as f:
reader = csv.DictReader(f)
# Check header
header = f.next().replace("\n", "").split(",")
must_keys = ["member_name", "group_id"]
if not _func.checkValidHeader(header, *must_keys):
return False
f.seek(0, 0)
# Read csv
for record in reader:
must_values = ["member_name", "group_id"]
if not _func.checkRecordHasValue(record, *must_values):
continue
# Operation
_func.operate( GROUP_M.deleteMemberFromGroup
, record["group_id"].lower()
, "{} \"{}\"".format( parser.prog
, record["member_name"].lower()
)
, namespace.result_file
, namespace.domain
, auth_token
, record["member_name"].lower() # member name
, record["group_id"].lower() # group id
)
return True
def _delete(options, parser):
# Set parser options
parser.add_argument( "group_id"
, action = "store"
, help = "Group id (not group name)."
)
# Get options
namespace = parser.parse_args(options)
# Get auth token
auth_token = _func.getAuthTokenByLogin(namespace.admin_name, namespace.domain)
# Operation
return _func.operate( GROUP.deleteGroup
, namespace.group_id.lower()
, parser.prog
, namespace.result_file
, namespace.domain
, auth_token
, namespace.group_id.lower() # group id
)
def _delete(options, parser):
# Set parser options
parser.add_argument( "user_email"
, action = "store"
, help = "User's mail address."
)
# Get options
namespace = parser.parse_args(options)
# Get auth token
auth_token = _func.getAuthTokenByLogin(namespace.admin_name, namespace.domain)
# Operation
return _func.operate( USER2.deleteUser
, namespace.user_email.lower()
, parser.prog
, namespace.result_file
, namespace.domain
, auth_token
, namespace.user_email.lower() # user
)
def _enable_f(options, parser):
import csv
# Get options
namespace = parser.parse_args(options)
# Get auth token
auth_token = _func.getAuthTokenByLogin(namespace.admin_name, namespace.domain)
# Get records from csv file
with open(namespace.csv_file) as f:
reader = csv.DictReader(f)
# Check header
header = f.next().replace("\n", "").split(",")
must_keys = ["user_email"]
if not _func.checkValidHeader(header, *must_keys):
return False
f.seek(0, 0)
# Read csv
for record in reader:
must_values = ["user_email"]
if not _func.checkRecordHasValue(*must_values):
continue
# Operation
_func.operate( USER2.updateUser
, record["user_email"].lower()
, parser.prog
, namespace.result_file
, namespace.domain
, auth_token
, record["user_email"].lower() # user
, is_suspended="false" # suspended
)
return True
def _modify_f(options, parser):
import csv
# Get options
namespace = parser.parse_args(options)
# Get auth token
auth_token = _func.getAuthTokenByLogin(namespace.admin_name, namespace.domain)
# Get records from csv file
with open(namespace.csv_file) as f:
reader = csv.DictReader(f)
# Check header
header = f.next().replace("\n", "").split(",")
must_keys = ["group_id", "group_name", "description"]
if not _func.checkValidHeader(header, *must_keys):
return False
f.seek(0, 0)
# Read csv
for record in reader:
must_values = ["group_id"]
if not _func.checkRecordHasValue(record, *must_values):
continue
# Operation
_func.operate( GROUP.updateGroup
, record["group_id"].lower()
, parser.prog
, namespace.result_file
, namespace.domain
, auth_token
, record["group_id"].lower() # group id
, _func.replaceSpace2None(record["group_name"]) # group name
, _func.replaceSpace2None(record["description"]) # description
)
return True
def _passwd(options, parser):
# Set parser options
parser.add_argument( "user_email"
, action = "store"
, help = "User's mail address."
)
parser.add_argument( "-m", "--md5"
, action = "store_true"
, default = False
, help = "Use MD5 hash function (default = SHA-1)."
)
# Get options
namespace = parser.parse_args(options)
# Check option
if namespace.md5 == True:
hash_function_name = "MD5"
else:
hash_function_name = "SHA-1"
# Get auth token
auth_token = _func.getAuthTokenByLogin(namespace.admin_name, namespace.domain)
# Get user's password
hash_password = _func.getHashedPassword_interactive(hash_function_name)
# Operation
return _func.operate( USER2.updateUser
, namespace.user_email.lower()
, parser.prog
, namespace.result_file
, namespace.domain
, auth_token
, namespace.user_email.lower() # user
, password = hash_password # password
, hash_function_name = hash_function_name # function
)
def _enable(options, parser):
# Set parser options
parser.add_argument( "user_name"
, action = "store"
, help = "User name."
)
# Get options
namespace = parser.parse_args(options)
# Get auth token
auth_token = _func.getAuthTokenByLogin(namespace.admin_name, namespace.domain)
# Operation
return _func.operate( USER.updateUser
, namespace.user_name.lower()
, parser.prog
, namespace.result_file
, namespace.domain
, auth_token
, namespace.user_name.lower() # user
, suspended="false" # suspended
)
def _create(options, parser):
# Set parser options
parser.add_argument( "user_email"
, action = "store"
, help = "User's mail address."
)
parser.add_argument( "sn"
, action = "store"
, help = "Family name."
)
parser.add_argument( "given_name"
, action = "store"
, help = "Given name."
)
parser.add_argument( "-m", "--md5"
, action = "store_true"
, default = False
, help = "Use MD5 hash function (default = SHA-1)."
)
parser.add_argument( "-L", "--lock"
, action = "store_true"
, default = False
, help = "Lock a user's account."
)
parser.add_argument( "--assign-administrator"
, action = "store_const"
, const = "true"
, default = "false"
, help = "Assign administrator to user (default = not assign)."
)
parser.add_argument( "--no-change-password-at-next-login"
, action = "store_const"
, const = "false"
, default = "true"
, help = ( "If this flag specified, "
"user do not have to change password "
"at next login (default = True)."
)
)
# Get options
namespace = parser.parse_args(options)
# Check hash function name
if namespace.md5 == True:
hash_function_name = "MD5"
else:
hash_function_name = "SHA-1"
# Check lock/unlock
if namespace.lock == True:
suspended = "true"
else:
suspended = "false"
# Get auth token
auth_token = _func.getAuthTokenByLogin(namespace.admin_name, namespace.domain)
# Get user's password
hash_password = _func.getHashedPassword_interactive(hash_function_name)
# Operation
return _func.operate( USER2.createUser
, namespace.user_email.lower()
, parser.prog
, namespace.result_file
, namespace.domain
, auth_token
, namespace.user_email.lower() # user
, hash_password # password
, namespace.sn # sn
, namespace.given_name # given name
, hash_function_name # function name
, suspended # suspended
, namespace.assign_administrator # assign admin?
, namespace.no_change_password_at_next_login # no change?
)
def _modify_f(options, parser):
import csv
# Set parser options
parser.add_argument( "-m", "--md5"
, action = "store_true"
, default = False
, help = "Use MD5 hash function (default = SHA-1)."
)
# Get options
namespace = parser.parse_args(options)
# Check hash function name
if namespace.md5 == True:
hash_function_name = "MD5"
else:
hash_function_name = "SHA-1"
# Get auth token
auth_token = _func.getAuthTokenByLogin(namespace.admin_name, namespace.domain)
# Get records from csv file
with open(namespace.csv_file) as f:
reader = csv.DictReader(f)
# Check header
header = f.next().replace("\n", "").split(",")
must_keys = ["user_email", "password", "sn", "given_name", "must_change_pw_next", "lock"]
if not _func.checkValidHeader(header, *must_keys):
return False
f.seek(0, 0)
# Read csv
for record in reader:
must_values = ["user_email"]
if not _func.checkRecordHasValue(*must_values):
continue
# Get hashed password
hash_password = _func.getHashedPassword( record["password"]
, hash_function_name
)
# Check suspended
suspended = record["lock"].lower()
if suspended == "true":
suspended = "true"
elif suspended == "false":
suspended = "false"
else:
suspended = None
# Check must change password at next login
is_change_password = record["must_change_pw_next"].lower()
if is_change_password == "false":
is_change_password = "******"
elif is_change_password == "true":
is_change_password = "******"
else:
is_change_password = None
# Operation
_func.operate( USER2.updateUser
, record["user_email"].lower()
, parser.prog
, namespace.result_file
, namespace.domain
, auth_token
, record["user_email"].lower() # user
, hash_password # password
, _func.replaceSpace2None(record["sn"]) # sn
, _func.replaceSpace2None(record["given_name"]) # given name
, hash_function_name # function name
, suspended # suspended
, is_change_password=is_change_password # is change
)
return True
def _modify(options, parser):
# Set parser options
parser.add_argument( "user_email"
, action = "store"
, help = "User's mail address."
)
parser.add_argument( "-p", "--password"
, action = "store"
, help = "Specify password."
)
parser.add_argument( "-m", "--md5"
, action = "store_true"
, default = False
, help = "Use MD5 hash function (default = SHA-1)."
)
parser.add_argument( "-L", "--lock"
, action = "store_true"
, default = False
, help = "Lock a user's account."
)
parser.add_argument( "-U", "--unlock"
, action = "store_true"
, default = False
, help = "Unock a user's account."
)
parser.add_argument( "-s", "--sn"
, action = "store"
, help = "Specify sn."
)
parser.add_argument( "-g", "--given-name"
, action = "store"
, help = "Specify given_name."
)
parser.add_argument( "--assign-administrator"
, action = "store_true"
, default = False
, help = "Assign administrator to user."
)
parser.add_argument( "--demote-administrator"
, action = "store_true"
, default = False
, help = "Demote user from administrator to general user."
)
parser.add_argument( "--change-password-at-next-login"
, action = "store_true"
, default = False
, help = "User must change password at next login."
)
parser.add_argument( "--no-change-password-at-next-login"
, action = "store_true"
, default = False
, help = "User do not have to change password at next login."
)
# Get options
namespace = parser.parse_args(options)
# Check hash function name
if namespace.md5:
hash_function_name = "MD5"
else:
hash_function_name = "SHA-1"
hash_password = _func.getHashedPassword(namespace.password, hash_function_name)
# Check lock/unlock
suspended = _func.getTrueOrFalse(namespace.lock, namespace.unlock)
if suspended == False:
return False
# Check assign admin/non-admin
is_admin = _func.getTrueOrFalse( namespace.assign_administrator
, namespace.demote_administrator
)
if is_admin == False:
return False
# Check must change password or not
is_change_password = _func.getTrueOrFalse( namespace.change_password_at_next_login
, namespace.no_change_password_at_next_login
)
if is_change_password == False:
return False
# Get auth token
auth_token = _func.getAuthTokenByLogin(namespace.admin_name, namespace.domain)
# Operation
return _func.operate( USER2.updateUser
, namespace.user_email.lower()
, parser.prog
, namespace.result_file
, namespace.domain
, auth_token
, namespace.user_email.lower() # user
, hash_password # password
, namespace.sn # sn
, namespace.given_name # given name
, hash_function_name # function name
, suspended # suspended
, is_admin # assign admin?
, is_change_password # no change?
)
def _modify(options, parser):
# Set parser options
parser.add_argument( "user_name"
, action = "store"
, help = "User name."
)
parser.add_argument( "-p", "--password"
, action = "store"
, help = "Specify password."
)
parser.add_argument( "-m", "--md5"
, action = "store_true"
, default = False
, help = "Use MD5 hash function (default = SHA-1)."
)
parser.add_argument( "-L", "--lock"
, action = "store_true"
, default = False
, help = "Lock a user's account."
)
parser.add_argument( "-U", "--unlock"
, action = "store_true"
, default = False
, help = "Unock a user's account."
)
parser.add_argument( "-s", "--sn"
, action = "store"
, help = "Specify sn."
)
parser.add_argument( "-g", "--given-name"
, action = "store"
, help = "Specify given_name."
)
# Get options
namespace = parser.parse_args(options)
# Check hash function name
if namespace.md5:
hash_function_name = "MD5"
else:
hash_function_name = "SHA-1"
hash_password = _func.getHashedPassword(namespace.password, hash_function_name)
# Check lock/unlock
suspended = _func.getTrueOrFalse(namespace.lock, namespace.unlock)
if suspended == False:
return False
# Get auth token
auth_token = _func.getAuthTokenByLogin(namespace.admin_name, namespace.domain)
# Operation
return _func.operate( USER.updateUser
, namespace.user_name.lower()
, parser.prog
, namespace.result_file
, namespace.domain
, auth_token
, namespace.user_name.lower() # user
, hash_password # password
, namespace.sn # sn
, namespace.given_name # given name
, hash_function_name # function name
, suspended # suspended
)
