def delete_group(ctx, name):
"""
Delete a Jumpcloud group
"""
api2 = JumpcloudApiV2(ctx.obj.get('key'))
api2.delete_group(name)
LOGGER.info(f"Group {name} deleted")
def test_get_groups(self, mock_get_groups):
response = [
ObjectView({
'id': '5aa80b9f232e110d4215e3b7',
'name': 'admin',
'type': 'user_group'
}),
ObjectView({
'id': '5b28760145886d16cbfd736a',
'name': 'guests',
'type': 'user_group'
}),
ObjectView({
'id': '5aa81659232e110d42161565',
'name': 'dev',
'type': 'system_group'
}),
ObjectView({
'id': '5c5357e0232e1164e94b2a11',
'name': 'prod',
'type': 'system_group'
})
]
api2 = JumpcloudApiV2("1234")
mock_get_groups.return_value = response
group_id, group_type = api2.get_group("guests")
assert (group_id == "5b28760145886d16cbfd736a"
and group_type == "user_group"), "Failed to get group info"
def create_group(ctx, name, type):
"""
Create a Jumpcloud group
"""
api2 = JumpcloudApiV2(ctx.obj.get('key'))
response = api2.create_group(name, type)
LOGGER.info(f"{response}")
def delete_group(info, name):
"""
Delete a Jumpcloud group
"""
api2 = JumpcloudApiV2(info.key)
response = api2.delete_group(name)
if response is None:
click.echo("Jumpcloud group deleted")
def delete_group(ctx, name):
"""
Delete a group
"""
# FIXME: Ideally, this would output JSON info of the deleted group (similar to delete-user), but at the moment it's
# unclear exactly how to do that, given the API wrappers that we have.
api2 = JumpcloudApiV2(ctx.obj.get('key'))
api2.delete_group(name)
LOGGER.info(f"Group {name} deleted")
def list_groups(ctx, type):
"""
List groups
"""
api2 = JumpcloudApiV2(ctx.obj.get('key'))
logger: Logger = ctx.obj.get('logger')
response = api2.get_groups(type=type)
serialized_response = json.dumps(response, indent=2)
click.echo(f"{serialized_response}")
def test_get_groups_not_found(self, mock_get_groups):
response = [{
'id': '5c5357e0232e1164e94b2a11',
'name': 'prod',
'type': 'system_group'
}]
api2 = JumpcloudApiV2("1234")
mock_get_groups.return_value = response
group_id, group_type = api2.get_group("foo")
assert (group_id == None
and group_type == None), "Group info should be None"
def create_group(info, name, type):
"""
Create a Jumpcloud group
"""
api2 = JumpcloudApiV2(info.key)
# click.echo("Create jumpcloud {} group {}".format(type, name))
response = api2.create_group(name, type)
click.echo(
click.style(
f"{response}",
fg="green",
)
)
def delete_group(ctx, name, type):
"""
Delete a group
"""
logger = ctx.obj.get('logger')
if type is None:
logger.error('groups must have a type (either "user" or "system")')
sys.exit(1)
api2 = JumpcloudApiV2(ctx.obj.get('key'))
group = api2.get_group(group_name=name, group_type=type)
if group is None:
logger.error(f"no group found of type '{type}', name '{name}'")
sys.exit(1)
api2.delete_group(group['id'], type)
click.echo(f"successfully deleted group {name}")
def get_group(ctx, name, type):
"""
Get detail view of a group
"""
api2 = JumpcloudApiV2(ctx.obj.get('key'))
logger = ctx.obj.get('logger')
if type is None:
logger.error('groups must have a type (either "user" or "system")')
sys.exit(1)
group = api2.get_group(group_name=name, group_type=type)
if group is None:
logger.error(f"no group found of type '{type}', name '{name}'")
sys.exit(1)
serialized_response = json.dumps(group)
click.echo(f"{serialized_response}")
def create_group(ctx, name, type):
"""
Create a group
"""
api2 = JumpcloudApiV2(ctx.obj.get('key'))
logger: Logger = ctx.obj.get('logger')
if type is None:
logger.error('groups must have a type (either "user" or "system")')
sys.exit(1)
try:
api2.create_group(name, type)
except ApiException:
logger.error(f"API error (confirm that no group of type '{type}' and name '{name}' already exists)")
sys.exit(1)
click.echo(f"successfully created group: {name}")
def list_users(ctx, name):
"""
List users in a JumpCloud 'user' group
"""
api1 = JumpcloudApiV1(ctx.obj.get('key'))
api2 = JumpcloudApiV2(ctx.obj.get('key'))
logger = ctx.obj.get('logger')
group = api2.get_group(group_name=name, group_type=GroupType.USER_GROUP)
if group:
group_id = group['id']
else:
logger.error(f"no user group found with name {name}")
sys.exit(1)
user_ids = api2.list_group_users(group_id=group_id)
users = api1.retrieve_users(user_ids=user_ids)
serialized_response = json.dumps(users, indent=2)
click.echo(f"{serialized_response}")
def remove_user(ctx, name, username):
"""
Remove a user from a JumpCloud 'user' group
"""
api1 = JumpcloudApiV1(ctx.obj.get('key'))
api2 = JumpcloudApiV2(ctx.obj.get('key'))
logger = ctx.obj.get('logger')
try:
user_id = api1.get_user_id(username)
except SystemUserNotFoundError:
logger.error(f"user '{username}' not found")
sys.exit(1)
group = api2.get_group(group_name=name, group_type=GroupType.USER_GROUP)
if group is None:
logger.error(f"group '{name}' not found")
sys.exit(1)
try:
api2.unbind_user_from_group(user_id, group['id'])
except ApiException:
logger.error(f"API exception (confirm that '{username}' is a member of group '{name}')")
sys.exit(1)
click.echo(f"Successfully removed user '{username}' from group '{name}'")
def add_user(ctx, name, username):
"""
Add a user to a JumpCloud 'user' group
"""
logger = ctx.obj.get('logger')
api1 = JumpcloudApiV1(ctx.obj.get('key'))
api2 = JumpcloudApiV2(ctx.obj.get('key'))
try:
user_id = api1.get_user_id(username)
except SystemUserNotFoundError:
logger.error(f"user '{username}' not found")
sys.exit(1)
group = api2.get_group(group_name=name, group_type=GroupType.USER_GROUP)
if group is None:
logger.error(f"no user group named '{name}' could be found")
sys.exit(1)
try:
api2.bind_user_to_group(user_id, group['id'])
except ApiException:
logger.error(f"API error (confirm that user {username} has not already been added to group {name}")
sys.exit(1)
click.echo(f"Successfully added user '{username}' to group '{name}'")
def test_create_group_invalid_group(self):
api2 = JumpcloudApiV2("1234")
with pytest.raises(ValueError):
api2.create_group("name", "invalid")
def sync_groups(ctx, groups):
# pylint: disable-msg=too-many-locals
# pylint: disable-msg=too-many-branches
"""
Sync Jumpcloud groups with definition in data file
:param ctx: Click context
:param groups: groups from data file
:return:
"""
key = ctx.obj.get('key')
dry_run = ctx.params.get('dry_run')
local_groups = groups
api2 = JumpcloudApiV2(key)
jc_group_names = []
jc_groups_request = api2.get_groups()
if jc_groups_request:
for jc_group in jc_groups_request:
jc_group_names.append(jc_group['_name'])
LOGGER.debug(f"jumpcloud groups: {jc_group_names}")
# create new groups
added_groups = []
for group in local_groups:
do_create_group = False
try:
group_name = group['name']
group_type = group['type']
if group_name not in jc_group_names:
do_create_group = True
else:
LOGGER.debug(f"{group_name} group already exists")
except KeyError as error:
raise error
if do_create_group:
added_groups.append(group_name)
new_group = {}
new_group['name'] = group_name
new_group['type'] = group_type
LOGGER.info(
f"create {' '.join(group_type.split('_'))}: {group_name}")
if not dry_run:
response = api2.create_group(group_name, group_type)
# remove groups that do not exist in the users file
local_group_names = []
for group in local_groups:
local_group_names.append(group['name'])
removed_groups = []
for jc_group in jc_groups_request:
jc_group_type = jc_group['_type']
jc_group_name = jc_group['_name']
do_remove_group = False
if jc_group_name not in local_group_names:
do_remove_group = True
if do_remove_group:
removed_groups.append(jc_group)
LOGGER.info(
f"remove {' '.join(jc_group_type.split('_'))}: {jc_group_name}"
)
if not dry_run:
response = api2.delete_group(jc_group_name)
def sync_users(ctx, users):
# pylint: disable-msg=too-many-locals
# pylint: disable-msg=too-many-branches
# pylint: disable-msg=too-many-statements
"""
Sync Jumpcloud users with definition in data file
:param ctx: Click context
:param users: users from data file
:return:
"""
local_users = users
key = ctx.obj.get('key')
dry_run = ctx.params.get('dry_run')
api1 = JumpcloudApiV1(key)
jc_usernames = []
jc_emails = []
jc_users = []
jc_users_request = api1.get_users()
if jc_users_request:
for jc_user in jc_users_request:
jc_usernames.append(jc_user['_username'])
jc_emails.append(jc_user['_email'])
jc_users.append({
'username': jc_user['_username'],
'email': jc_user['_email']
})
LOGGER.debug(f"jumpcloud users: {jc_usernames}")
# create new users
api2 = JumpcloudApiV2(key)
added_users = []
for user in local_users:
do_create_user = False
try:
user_name = user['username']
user_email = user['email']
if (user_name not in jc_usernames) and (user_email
not in jc_emails):
do_create_user = True
else:
LOGGER.debug(f"{user_name} user already exists")
except KeyError as error:
raise error
if do_create_user:
added_users.append({'username': user_name, 'email': user_email})
new_user = {}
new_user['username'] = user_name
new_user['email'] = user_email
new_user['firstname'] = user['firstname']
new_user['firstname'] = user['lastname']
LOGGER.info(f"create user: {user_name}")
if not dry_run:
response = api1.create_user(new_user)
group_id, group_type = api2.get_group("staff")
if group_id:
user_id = api1.get_user_id(user_name)
LOGGER.info(f"bind {user_id} to group: {group_id}")
if not dry_run:
api2.bind_user_to_group(user_id, group_id)
# remove users that do not exist in the users file
local_usernames = []
local_emails = []
for user in users:
local_usernames.append(user['username'])
local_emails.append(user['email'])
removed_users = []
for jc_user in jc_users:
do_remove_user = False
user_name = jc_user['username']
user_email = jc_user['email']
if (user_name not in local_usernames) and (user_email
not in local_emails):
do_remove_user = True
if do_remove_user:
removed_users.append(jc_user)
LOGGER.info(f"remove user: {user_name}")
if not dry_run:
response = api1.delete_user(username=user_name)
def sync_users(key, users):
# pylint: disable-msg=too-many-locals
# pylint: disable-msg=too-many-branches
"""
Sync data file with jumpcloud
"""
api1 = JumpcloudApiV1(key)
api2 = JumpcloudApiV2(key)
jc_usernames = []
jc_emails = []
jc_users = []
jc_users_request = api1.get_users(limit='')
if jc_users_request:
for jc_user in jc_users_request:
jc_usernames.append(jc_user['_username'])
jc_emails.append(jc_user['_email'])
jc_users.append({'username':jc_user['_username'], 'email':jc_user['_email']})
click.echo("jumpcloud users: " + ','.join(jc_usernames))
# create new users
added_users = []
for user in users:
do_create_user = False
try:
user_name = user['username']
user_email = user['email']
if (user_name not in jc_usernames) and (user_email not in jc_emails):
do_create_user = True
else:
click.echo(user_name + " user already exists")
except KeyError as e:
raise e
if do_create_user:
click.echo("creating user: "******"staff")
if group_id:
user_id = api1.get_user_id(user_name)
click.echo("binding " + user_id + " to group: " + group_id)
# api2.bind_user_to_group(user_id, group_id)
# remove users that do not exist in the users file
local_usernames = []
local_emails = []
for user in users:
local_usernames.append(user['username'])
local_emails.append(user['email'])
removed_users = []
for jc_user in jc_users:
do_remove_user = False
user_name = jc_user['username']
user_email = jc_user['email']
if (user_name not in local_usernames) and (user_email not in local_emails):
do_remove_user = True
if do_remove_user:
click.echo("removing user: " + user_name)
removed_users.append(jc_user)