var nodes = enterpriseData.Nodes
.Where(x => string.Equals(x.DisplayName, arguments.Node, StringComparison.InvariantCultureIgnoreCase))
.ToArray();
# List all nodes
PS> Get-KeeperEnterpriseNode
----------------------------------------
# Get specific node
PS> Get-KeeperEnterpriseNode -NodeId 12345 - Not Implemented
node = enterprise_data.nodes.get_entity(node_id) if isintance(node_id, int)
node = [node for node in enterprise_data.nodes.get_all_entities() if node.name.lower() == node_id] if isintance(node_id, str)
My Vault> enterprise-node --command=add "Engineering"
OR
My Vault> en --command=add "Isolated Team" --toggle-isolated
from keepersdk.enterprise import batch_management, enterprise_management
node_names = list['names of nodes to be created']
nodes_to_add = [enterprise_management.NodeEdit(
node_id=enterprise_loader.get_enterprise_id(), name=node_name, parent_id=parent_node_id,
restrict_visibility=is_isolated)
for node_name in node_names]
batch = batch_management.BatchManagement(loader=enterprise_loader, logger=enterprise_manager_logger)
batch.modify_nodes(to_add=nodes_to_add)
batch.apply()
PS> Remove-KeeperEnterpriseNode -Node "test_node_1"
Confirm
Are you sure you want to perform this action?
Performing the operation "Delete Enterprise Node" on target "test_node_1".
[Y] Yes [A] Yes to All [N] No [L] No to All [S] Suspend [?] Help (default is "Y"): a
Node "test_node_1" deleted successfully.
from keepersdk.enterprise import batch_management, enterprise_management
node = enterprise_data.nodes.get_entity(node_id)
node_list = [node]
batch = batch_management.BatchManagement(loader=enterprise_loader, logger=enterprise_manager_logger)
batch.modify_nodes(to_remove=(enterprise_management.NodeEdit(node_id=node.node_id) for node in node_list))
batch.apply()
My Vault> enterprise-node set-logo <node_uid> --logo-file="logo.jpg"
from keepersdk.vault import attachment
upload_task = attachment.FileUploadTask(logo_filepath)
upload_task.prepare()
# Check file MIME-type and size
if upload_task.mime_type not in {'image/jpeg', 'image/png', 'image/gif'}:
raise Exception('File must be a JPEG, PNG, or GIF image')
if upload_task.size > 500000:
raise Exception('Filesize must be less than 500 kB')
rq_logo = {
'command': f'request_{logo_type}_logo_upload',
'node_id': node_id,
}
rs_logo = KeeperAuth_obj.execute_auth_command(rq_logo)
# Construct POST request for upload
upload_id = rs_logo.get('upload_id')
upload_url = rs_logo.get('url')
assert isinstance(upload_url, str)
success_status_code = rs_logo.get('success_status_code')
file_param: Optional[str] = rs_logo.get('file_parameter')
assert file_param is not None
form_data = rs_logo.get('parameters')
assert isinstance(form_data, dict)
form_data['Content-Type'] = upload_task.mime_type
with upload_task.open() as task_stream:
files = {file_param: (None, task_stream, upload_task.mime_type)}
upload_rs = requests.post(upload_url, files=files, data=form_data)
if upload_rs.status_code == success_status_code:
# Verify file upload
check_rq = {
'command': f'check_{logo_type}_logo_upload',
'node_id': node_id,
'upload_id': upload_id
}
while True:
check_rs = KeeperAuth_obj.execute_auth_command(check_rq)
check_status = check_rs.get('status')
if check_status == 'pending':
time.sleep(2)
else:
if check_status != 'active':
if check_status == 'invalid_dimensions':
raise Exception('Image dimensions must be between 10x10 and 320x320')
else:
raise Exception(f'Upload status = {check_status}')
else:
get_logger().info('File "%s" set as %s logo.', logo_fp, logo_type)
break
else:
raise Exception(f'HTTP status code: {upload_rs.status_code}, expected {success_status_code}')
from keepersdk.enterprise import batch_management, enterprise_management
node = enterprise_data.nodes.get_entity(node_id)
if node.node_id == enterprise_data.root_node.node_id:
raise ValueError('Cannot wipe out root node')
subnode_lookup: Dict[int, List[int]] = {}
for n in enterprise_data.nodes.get_all_entities():
parent_id = n.parent_id or 0
if parent_id not in subnode_lookup:
subnode_lookup[parent_id] = []
subnode_lookup[parent_id].append(n.node_id)
sub_nodes = [node.node_id]
pos = 0
while pos < len(sub_nodes):
if sub_nodes[pos] in subnode_lookup:
sub_nodes.extend(subnode_lookup[sub_nodes[pos]])
pos += 1
nodes = set(sub_nodes)
batch = batch_management.BatchManagement(loader=enterprise_loader, logger=enterprise_manager_logger)
roles = {x.role_id for x in enterprise_data.roles.get_all_entities() if x.node_id in nodes}
users = {x.enterprise_user_id for x in enterprise_data.users.get_all_entities() if x.node_id in nodes}
role_users = [enterprise_management.RoleUserEdit(role_id=x.role_id, enterprise_user_id=x.enterprise_user_id)
for x in enterprise_data.role_users.get_all_links() if
x.role_id in roles or x.enterprise_user_id in users]
if len(role_users) > 0:
batch.modify_role_users(to_remove=role_users)
managed_nodes = [enterprise_management.ManagedNodeEdit(role_id=x.role_id, managed_node_id=x.managed_node_id)
for x in enterprise_data.managed_nodes.get_all_links() if
x.managed_node_id in nodes or x.role_id in roles]
if len(managed_nodes) > 0:
batch.modify_managed_nodes(to_remove=managed_nodes)
roles_to_remove = [enterprise_management.RoleEdit(role_id=x) for x in roles]
if len(roles) > 0:
batch.modify_roles(to_remove=roles_to_remove)
users_to_remove = [enterprise_management.UserEdit(enterprise_user_id=x) for x in users]
if len(users_to_remove) > 0:
batch.modify_users(to_remove=users_to_remove)
queued_teams = [enterprise_management.TeamEdit(team_uid=x.team_uid)
for x in enterprise_data.queued_teams.get_all_entities() if x.node_id in nodes]
if len(queued_teams) > 0:
batch.modify_teams(to_remove=queued_teams)
teams = [enterprise_management.TeamEdit(team_uid=x.team_uid)
for x in enterprise_data.teams.get_all_entities() if x.node_id in nodes]
if len(teams) > 0:
batch.modify_teams(to_remove=teams)
sub_nodes.pop(0)
sub_nodes.reverse()
nodes_to_remove = [enterprise_management.NodeEdit(node_id=x) for x in sub_nodes]
if len(nodes_to_remove) > 0:
batch.modify_nodes(to_remove=nodes_to_remove)
batch.apply()
