def cli(env, identifier, keys, permissions, hardware, virtual, logins, events):
"""User details."""
mgr = SoftLayer.UserManager(env.client)
user_id = helpers.resolve_id(mgr.resolve_ids, identifier, 'username')
object_mask = "userStatus[name], parent[id, username], apiAuthenticationKeys[authenticationKey], "\
"unsuccessfulLogins, successfulLogins"
user = mgr.get_user(user_id, object_mask)
env.fout(basic_info(user, keys))
if permissions:
perms = mgr.get_user_permissions(user_id)
env.fout(print_permissions(perms))
if hardware:
mask = "id, hardware, dedicatedHosts"
access = mgr.get_user(user_id, mask)
env.fout(print_dedicated_access(access.get('dedicatedHosts', [])))
env.fout(print_access(access.get('hardware', []), 'Hardware'))
if virtual:
mask = "id, virtualGuests"
access = mgr.get_user(user_id, mask)
env.fout(
print_access(access.get('virtualGuests', []), 'Virtual Guests'))
if logins:
login_log = mgr.get_logins(user_id)
env.fout(print_logins(login_log))
if events:
event_log = mgr.get_events(user_id)
env.fout(print_events(event_log))
def cli(env, enable, notification):
"""Enable or Disable specific notifications for the active user.
Notification names should be enclosed in quotation marks.
Example::
slcli user edit-notifications --enable 'Order Approved' 'Reload Complete'
"""
mgr = SoftLayer.UserManager(env.client)
if enable:
result = mgr.enable_notifications(notification)
else:
result = mgr.disable_notifications(notification)
if result:
click.secho("Notifications updated successfully: %s" %
", ".join(notification),
fg='green')
else:
click.secho("Failed to update notifications: %s" %
", ".join(notification),
fg='red')
def cli(env, user, template):
"""Edit a Users details
JSON strings should be enclosed in '' and each item should be enclosed in ""
Example::
slcli user edit-details testUser -t '{"firstName": "Test", "lastName": "Testerson"}'
"""
mgr = SoftLayer.UserManager(env.client)
user_id = helpers.resolve_id(mgr.resolve_ids, user, 'username')
user_template = {}
if template is not None:
try:
template_object = json.loads(template)
for key in template_object:
user_template[key] = template_object[key]
except ValueError as ex:
raise exceptions.ArgumentError("Unable to parse --template. %s" %
ex)
result = mgr.edit_user(user_id, user_template)
if result:
click.secho("%s updated successfully" % (user), fg='green')
else:
click.secho("Failed to update %s" % (user), fg='red')
def cli(env, username, email, password, from_user, template, api_key):
"""Creates a user Users.
:Example: slcli user create [email protected] -e [email protected] -p generate -a
-t '{"firstName": "Test", "lastName": "Testerson"}'
Remember to set the permissions and access for this new user.
"""
mgr = SoftLayer.UserManager(env.client)
user_mask = (
"mask[id, firstName, lastName, email, companyName, address1, city, country, postalCode, "
"state, userStatusId, timezoneId]")
from_user_id = None
if from_user is None:
user_template = mgr.get_current_user(objectmask=user_mask)
from_user_id = user_template['id']
else:
from_user_id = helpers.resolve_id(mgr.resolve_ids, from_user,
'username')
user_template = mgr.get_user(from_user_id, objectmask=user_mask)
# If we send the ID back to the API, an exception will be thrown
del user_template['id']
if template is not None:
try:
template_object = json.loads(template)
for key in template_object:
user_template[key] = template_object[key]
except ValueError as ex:
raise exceptions.ArgumentError("Unable to parse --template. %s" %
ex)
user_template['username'] = username
if password == 'generate':
password = generate_password()
user_template['email'] = email
if not env.skip_confirmations:
table = formatting.KeyValueTable(['name', 'value'])
for key in user_template:
table.add_row([key, user_template[key]])
table.add_row(['password', password])
click.secho("You are about to create the following user...",
fg='green')
env.fout(table)
if not formatting.confirm("Do you wish to continue?"):
raise exceptions.CLIAbort("Canceling creation!")
result = mgr.create_user(user_template, password)
new_api_key = None
if api_key:
click.secho("Adding API key...", fg='green')
new_api_key = mgr.add_api_authentication_key(result['id'])
table = formatting.Table(['Username', 'Email', 'Password', 'API Key'])
table.add_row([result['username'], result['email'], password, new_api_key])
env.fout(table)
def cli(env):
"""My Notifications."""
mgr = SoftLayer.UserManager(env.client)
all_notifications = mgr.get_all_notifications()
env.fout(notification_table(all_notifications))
def cli(env, date_min, date_max, obj_event, obj_id, obj_type, utc_offset,
metadata, limit):
"""Get Event Logs
Example:
slcli event-log get -d 01/01/2019 -D 02/01/2019 -t User -l 10
"""
columns = ['Event', 'Object', 'Type', 'Date', 'Username']
event_mgr = SoftLayer.EventLogManager(env.client)
user_mgr = SoftLayer.UserManager(env.client)
request_filter = event_mgr.build_filter(date_min, date_max, obj_event,
obj_id, obj_type, utc_offset)
logs = event_mgr.get_event_logs(request_filter)
log_time = "%Y-%m-%dT%H:%M:%S.%f%z"
user_data = {}
if metadata:
columns.append('Metadata')
row_count = 0
click.secho(", ".join(columns))
for log in logs:
if isinstance(log, str) or log is None:
click.secho('No logs available for filter %s.' % request_filter,
fg='red')
return
user = log['userType']
label = log.get('label', '')
if user == "CUSTOMER":
username = user_data.get(log['userId'])
if username is None:
username = user_mgr.get_user(log['userId'],
"mask[username]")['username']
user_data[log['userId']] = username
user = username
if metadata:
metadata_data = log['metaData'].strip("\n\t")
click.secho("'{0}','{1}','{2}','{3}','{4}','{5}'".format(
log['eventName'], label, log['objectName'],
utils.clean_time(log['eventCreateDate'], in_format=log_time),
user, metadata_data))
else:
click.secho("'{0}','{1}','{2}','{3}','{4}'".format(
log['eventName'], label, log['objectName'],
utils.clean_time(log['eventCreateDate'], in_format=log_time),
user))
row_count = row_count + 1
if row_count >= limit and limit != -1:
return
def cli(env, user, enable):
"""Enable or disable user vpn subnets manual config"""
mgr = SoftLayer.UserManager(env.client)
user_id = helpers.resolve_id(mgr.resolve_ids, user, 'username')
result = mgr.vpn_manual(user_id, enable)
message = "{} vpn manual config {}".format(user, 'enable' if enable else 'disable')
if result:
click.secho(message, fg='green')
else:
click.secho("Failed to update {}".format(user), fg='red')
def cli(env, columns):
"""List Users."""
mgr = SoftLayer.UserManager(env.client)
users = mgr.list_users()
table = formatting.Table(columns.columns)
for user in users:
table.add_row(
[value or formatting.blank() for value in columns.row(user)])
env.fout(table)
def cli(env, columns):
"""List Users."""
mgr = SoftLayer.UserManager(env.client)
users = mgr.list_users()
table = formatting.Table(columns.columns)
for user in users:
user = _yes_format(user, [TWO_FACTO_AUTH, CLASSIC_API_KEYS])
table.add_row(
[value or formatting.blank() for value in columns.row(user)])
env.fout(table)
def cli(env, user, add, subnet):
"""Add or remove subnets access for a user."""
mgr = SoftLayer.UserManager(env.client)
user_id = helpers.resolve_id(mgr.resolve_ids, user, 'username')
if add:
result = mgr.vpn_subnet_add(user_id, subnet)
else:
result = mgr.vpn_subnet_remove(user_id, subnet)
if result:
click.secho("%s updated successfully" % (user), fg='green')
else:
click.secho("Failed to update %s" % (user), fg='red')
def cli(env, identifier):
"""User Permissions."""
mgr = SoftLayer.UserManager(env.client)
user_id = helpers.resolve_id(mgr.resolve_ids, identifier, 'username')
object_mask = "mask[id, permissions, isMasterUserFlag, roles]"
user = mgr.get_user(user_id, object_mask)
all_permissions = mgr.get_all_permissions()
user_permissions = perms_to_dict(user['permissions'])
if user['isMasterUserFlag']:
click.secho('This account is the Master User and has all permissions enabled', fg='green')
env.fout(roles_table(user))
env.fout(permission_table(user_permissions, all_permissions))
def cli(env, identifier):
"""Sets a user's status to CANCEL_PENDING, which will immediately disable the account,
and will eventually be fully removed from the account by an automated internal process.
Example: slcli user delete userId
"""
mgr = SoftLayer.UserManager(env.client)
user_id = helpers.resolve_id(mgr.resolve_ids, identifier, 'username')
user_template = {'userStatusId': 1021}
result = mgr.edit_user(user_id, user_template)
if result:
click.secho("%s deleted successfully" % identifier, fg='green')
else:
click.secho("Failed to delete %s" % identifier, fg='red')
def cli(env, identifier, enable, permission, from_user):
"""Enable or Disable specific permissions."""
mgr = SoftLayer.UserManager(env.client)
user_id = helpers.resolve_id(mgr.resolve_ids, identifier, 'username')
result = False
if from_user:
from_user_id = helpers.resolve_id(mgr.resolve_ids, from_user,
'username')
result = mgr.permissions_from_user(user_id, from_user_id)
elif enable:
result = mgr.add_permissions(user_id, permission)
else:
result = mgr.remove_permissions(user_id, permission)
if result:
click.secho("Permissions updated successfully: %s" %
", ".join(permission),
fg='green')
else:
click.secho("Failed to update permissions: %s" % ", ".join(permission),
fg='red')
def cli(env, date_min, date_max, obj_event, obj_id, obj_type, utc_offset, metadata):
"""Get Event Logs"""
mgr = SoftLayer.EventLogManager(env.client)
usrmgr = SoftLayer.UserManager(env.client)
request_filter = mgr.build_filter(date_min, date_max, obj_event, obj_id, obj_type, utc_offset)
logs = mgr.get_event_logs(request_filter)
if logs is None:
env.fout('None available.')
return
if metadata and 'metadata' not in COLUMNS:
COLUMNS.append('metadata')
table = formatting.Table(COLUMNS)
if metadata:
table.align['metadata'] = "l"
for log in logs:
user = log['userType']
if user == "CUSTOMER":
user = usrmgr.get_user(log['userId'], "mask[username]")['username']
if metadata:
try:
metadata_data = json.dumps(json.loads(log['metaData']), indent=4, sort_keys=True)
if env.format == "table":
metadata_data = metadata_data.strip("{}\n\t")
except ValueError:
metadata_data = log['metaData']
table.add_row([log['eventName'], log['label'], log['objectName'],
log['eventCreateDate'], user, metadata_data])
else:
table.add_row([log['eventName'], log['label'], log['objectName'],
log['eventCreateDate'], user])
env.fout(table)
def set_up(self):
self.manager = SoftLayer.UserManager(self.client)
