Enterprise Team Commands

Manage an enterprise team(s).

Usage

enterprise-team command [--options] OR et command [--option]

Alias: et

Commands

Command	Description	Alias
view	View enterprise team	v
add	Create enterprise team(s)	a
edit	Edit enterprise team(s)	e
delete	Delete enterprise team(s)	d
membership	Manage enterprise team membership	m

Enterprise Team View

This command is for viewing teams and their permissions.

DotNet CLI

Command: enterprise-team view <team_name> OR et view <team_name>

Parameter:

team_name team name (required)

Options:

• -q, --queued - Include queued team/user information (for list/view)

Example:

My Vault> enterprise-team view "POD Team"           
      Team Name:  POD Team                       
       Team UID:  qS9qkAme2vl6o5UJggaagA         
  Restrict Edit:  No                             
 Restrict Share:  No                             
  Restrict View:  No                             
          Users:  [email protected]
                  [email protected]  
   Queued Users:                                 
           Node:  Metron Security 

DotNet SDK

Function: EnterpriseData.Teams

Usage: Enterprise users list can be obtained from EnterpriseData as a dictionary

Example:

var enterpriseTeam = EnterpriseData.Teams.FirstOrDefault(x =>
                    string.Compare(x.Name, identifier, StringComparison.CurrentCultureIgnoreCase) == 0);

PowerCommander

Command:Get-KeeperEnterpriseTeam

Syntax:

Get-KeeperEnterpriseTeam

Aliases: ket

Example:

# List all teams
PS> Get-KeeperEnterpriseTeam
PS> ket

Python CLI

Command: enterprise-team view

Flag:

• -v, --verbose - Print verbose information

• --format - Output format: json

• --output - Output filename

• team - Team Name or UID (required)

Python SDK

Function:

team_id = 'team name or UID'
team = enterprise_data.teams.get_entity(team_id)
if not team:
    ts = [x for x in enterprise_data.teams.get_all_entities() if x.name.lower() == team_id.lower(

Enterprise Team Add

Create enterprise team(s).

DotNet CLI

Usage

enterprise-team  add [team] [--options] OR et add [team] [--options]

Parameter:

team team name

Options:

• --node <node> - Node name or ID (for add/update)

• --restrict-edit <ON|OFF> - Disable record editing

• --restrict-share <ON|OFF> - Disable record re-sharing

• --restrict-view <ON|OFF> - Disable password viewing/copying

Example:

# Add team
enterprise-team add "Frontend Team" --node "Engineering"
OR 
et add "Backend Team" --node 12345 --restrict-edit OFF --restrict-share ON

DotNet SDK

Function: CreateTeam

public async Task<EnterpriseTeam> CreateTeam(EnterpriseTeam team)

Example:

team = await enterprise.CreateTeam(new EnterpriseTeam
                            {
                                Name = "Google",
                                RestrictEdit = false,
                                RestrictSharing = true,
                                RestrictView = false,
                            });

PowerCommander

Command: New-KeeperEnterpriseTeam

Syntax:

New-KeeperEnterpriseTeam [-TeamName] <string> [[-ParentNode] <long>] [[-RestrictEdit] <bool>] 
    [[-RestrictShare] <bool>] [[-RestrictView] <bool>] [<CommonParameters>]

Parameters:

• -TeamName - Team name (required)

• -ParentNode - Parent name or node ID

• -RestrictEdit - Restrict editing

• -RestrictShare - Restrict sharing

• -RestrictView - Restrict viewing passwords

Examples:

New-KeeperEnterpriseTeam -TeamName "Backend Team"
New-KeeperEnterpriseTeam -TeamName "Support" -ParentNode 12345 -RestrictView $true

Python CLI

Command: enterprise-team add

Parameter:

team - Team Name or Queued Team UID. Can be repeated. (required)

Flag:

• -f, --force - Do not prompt for confirmation

• --parent - Parent node name or ID

• --restrict-edit - Disable record edits: on or off

• --restrict-share - Disable record re-shares: on or off

• --restrict-view - Disable view/copy passwords: on or off

Python SDK

Function:

from keepersdk.enterprise import batch_management,  enterprise_management

team_names = ['teams to be added']
batch = batch_management.BatchManagement(loader=enterprise_loader, logger=enterprise_manager_logger)
teams_to_add = [enterprise_management.TeamEdit(
    team_uid=utils.generate_uid(), name=x, node_id=parent_id,
    restrict_edit=restrict_edit, restrict_share=restrict_share, restrict_view=restrict_view)
    for x in team_names]
batch.modify_teams(to_add=teams_to_add)
batch.apply()

Enterprise Team Edit

Edit enterprise team(s).

DotNet CLI

Command:

enterprise-team update [team] [--options] OR et update [team] [--options]

Parameter:

team team name

Options:

• --node <node> - Node name or ID (for add/update)

• --restrict-edit <ON|OFF> - Disable/Enable record editing

• --restrict-share <ON|OFF> - Disable/Enable record re-sharing

• --restrict-view <ON|OFF> - Disable/Enable password viewing/copying

Example:

# Update team
enterprise-team update "Developers" --restrict-edit ON
et update TeamUID123 --restrict-share OFF --restrict-view ON

DotNet SDK

Function: UpdateTeam

public async Task<EnterpriseTeam> UpdateTeam(EnterpriseTeam team)

Example:

await context.EnterpriseData.UpdateTeam(team);

PowerCommander

Not Implemented

Python CLI

Command: enterprise-team edit

Parameter:

team - Team Name or UID. Can be repeated. (required)

Flag:

• -f, --force - Do not prompt for confirmation

• --name, --displayname - Set team display name

• --parent - Parent node name or ID

• --restrict-edit - Disable record edits: on or off

• --restrict-share - Disable record re-shares: on or off

• --restrict-view - Disable view/copy passwords: on or off

Python SDK

Function:

from keepersdk.enterprise import batch_management,  enterprise_management

team_names = ['teams to be added']
batch = batch_management.BatchManagement(loader=enterprise_loader, logger=enterprise_manager_logger)

team_names_to_edit = {}
team_lookup: Dict[str, Union[enterprise_types.Team, List[enterprise_types.Team]]] = {}
for team in enterprise_data.teams.get_all_entities():
    team_lookup[team.team_uid] = team
    team_name = team.name.lower()
    t = team_lookup.get(team_name)
    if t is None:
        team_lookup[team_name] = team
    elif isinstance(t, list):
        t.append(team)
    elif isinstance(t, enterprise_types.Team):
        team_lookup[team_name] = [t, team]

found_teams: Dict[str, enterprise_types.Team] = {}
t: Optional[enterprise_types.Team]
for team_name in team_names_to_edit:
    t = None
    if isinstance(team_name, str):
        t = enterprise_data.teams.get_entity(team_name)
        if t is None:
            tt = team_lookup.get(team_name.lower())
            if isinstance(tt, list):
                if len(tt) == 1:
                    t = tt[0]
                elif len(tt) >= 2:
                    continue
            elif isinstance(tt, enterprise_types.Team):
                t = tt
    if t is None:
        continue
    found_teams[t.team_uid] = t
team_list = list(found_teams.values())

teams_to_edit = [enterprise_management.TeamEdit(
    team_uid=x.team_uid, name=team_name, node_id=parent_id,
    restrict_edit=restrict_edit, restrict_share=restrict_share, restrict_view=restrict_view)
    for x in team_list]
batch.modify_teams(to_update=teams_to_edit)
batch.apply()

Enterprise Team Delete

Delete enterprise team(s).

DotNet CLI

Command: enterpise-team delete teamID

enterprise-team delete [team] OR et delete [team]

Parameter:

team team name or team ID

Example:

# Delete team
enterprise-team delete "Old Team"
et delete TeamUID123

DotNet SDK

Function: DeleteTeam

 public async Task DeleteTeam(string teamUid)

Example:

await context.EnterpriseData.DeleteTeam(team.Uid);

PowerCommander

Not Implemented

Python CLI

Command: enterprise-team delete

Parameter:

• team - Team Name or UID. Can be repeated. (required)

Python SDK

Function:

from keepersdk.enterprise import batch_management,  enterprise_management

team_names = ['teams to be added']
batch = batch_management.BatchManagement(loader=enterprise_loader, logger=enterprise_manager_logger)

team_names_to_remove = {}
team_lookup: Dict[str, Union[enterprise_types.Team, List[enterprise_types.Team]]] = {}
for team in enterprise_data.teams.get_all_entities():
    team_lookup[team.team_uid] = team
    team_name = team.name.lower()
    t = team_lookup.get(team_name)
    if t is None:
        team_lookup[team_name] = team
    elif isinstance(t, list):
        t.append(team)
    elif isinstance(t, enterprise_types.Team):
        team_lookup[team_name] = [t, team]

found_teams: Dict[str, enterprise_types.Team] = {}
t: Optional[enterprise_types.Team]
for team_name in team_names_to_remove:
    t = None
    if isinstance(team_name, str):
        t = enterprise_data.teams.get_entity(team_name)
        if t is None:
            tt = team_lookup.get(team_name.lower())
            if isinstance(tt, list):
                if len(tt) == 1:
                    t = tt[0]
                elif len(tt) >= 2:
                    continue
            elif isinstance(tt, enterprise_types.Team):
                t = tt
    if t is None:
        continue
    found_teams[t.team_uid] = t
team_list = list(found_teams.values())
batch.modify_teams(to_remove=(enterprise_management.TeamEdit(team_uid=x.team_uid) for x in team_list))
batch.apply()

Enterprise Team Membership

Manage enterprise team membership.

DotNet CLI

Not Implemented

DotNet SDK

Functions:

AddUsersToTeams - This function is for adding user to given team.

RemoveUsersFromTeams - This function is for removing users from team.

Example:

public async Task AddUsersToTeams(string[] emails, string[] teams, Action<string> warnings = null)
public async Task RemoveUsersFromTeams(string[] emails, string[] teamUids, Action<string> warnings = null)

await enterprise.AddUsersToTeams(
                            new[] { "[email protected]", "[email protected]" },
                            new[] { team.Uid }
                            );
 

PowerCommander

Commands:

Add-KeeperEnterpriseTeamMember - This command is for adding user to given team.

Remove-KeeperEnterpriseTeamMember - This command is for removing users from team.

Syntax:

PS> Add-KeeperEnterpriseTeamMember [-Team] <string> [-Emails] <string[]> [<CommonParameters>]
PS> Remove-KeeperEnterpriseTeamMember [-Team] <string> [-Emails] <string[]> [<CommonParameters>]

Aliases: keta, ketu

Parameters:

• -Team - Team UID or name

• -Emails- User email

Examples:

# Add users to team
PS> Add-KeeperEnterpriseTeamMember -Team "Developers" -Emails"[email protected]", "[email protected]"
PS> keta "TeamUID" "[email protected]"

# Remove users from team
PS> Remove-KeeperEnterpriseTeamMember -Team "Developers" -Emails"[email protected]"
PS> ketu "TeamUID" "[email protected]", "[email protected]"

Python CLI

Command: enterprise-team membership

Parameter:

team - Team Name or UID. Can be repeated. (required)

Flag:

• -au, --add-user - Add user to team. Can be repeated.

• -ru, --remove-user - Remove user from team. @all. Can be repeated.

• -ar, --add-role - Add role to team. Can be repeated.

• -rr, --remove-role - Remove role from team, @all. Can be repeated.

Python SDK

Function:

from keepersdk.enterprise import batch_management,  enterprise_management

team_names = ['team uids or names']
batch = batch_management.BatchManagement(loader=enterprise_loader, logger=enterprise_manager_logger)

team_names_to_remove = {}
team_lookup: Dict[str, Union[enterprise_types.Team, List[enterprise_types.Team]]] = {}
for team in enterprise_data.teams.get_all_entities():
    team_lookup[team.team_uid] = team
    team_name = team.name.lower()
    t = team_lookup.get(team_name)
    if t is None:
        team_lookup[team_name] = team
    elif isinstance(t, list):
        t.append(team)
    elif isinstance(t, enterprise_types.Team):
        team_lookup[team_name] = [t, team]

found_teams: Dict[str, enterprise_types.Team] = {}
t: Optional[enterprise_types.Team]
for team_name in team_names_to_remove:
    t = None
    if isinstance(team_name, str):
        t = enterprise_data.teams.get_entity(team_name)
        if t is None:
            tt = team_lookup.get(team_name.lower())
            if isinstance(tt, list):
                if len(tt) == 1:
                    t = tt[0]
                elif len(tt) >= 2:
                    continue
            elif isinstance(tt, enterprise_types.Team):
                t = tt
    if t is None:
        continue
    found_teams[t.team_uid] = t
team_list = list(found_teams.values())

users_to_add: Optional[List[enterprise_types.User]] = None
roles_to_add: Optional[List[enterprise_types.Role]] = None
users_to_remove: Optional[List[enterprise_types.User]] = None
roles_to_remove: Optional[List[enterprise_types.Role]] = None
has_remove_all_users: bool = False
has_remove_all_roles: bool = False

add_users = ['list of usernames to add']
if isinstance(add_users, list):
    for add_user in add_users:
        user = [user for user in enterprise_data.users.get_all_entities() if user.username.lower() == add_user.lower()]
        users_to_add.append(user)

add_roles = ['list of roles to add']
if isinstance(add_roles, list):
    for role_name in add_roles:
        if isinstance(role_name, int):
            role = enterprise_data.roles.get_entity(role_name)
        elif isinstance(role_name, str):
            if role_name.isnumeric():
                role = enterprise_data.roles.get_entity(int(role_name))
            if not role:
                role = [x for x in enterprise_data.roles.get_all_entities() if x.name.lower() == role_name.lower()]
    roles_to_add.append(role)

remove_users = ['list of usernames to remove']
if isinstance(remove_users, list):
    has_remove_all_users = any((True for x in remove_users if x == '@all'))
    if not has_remove_all_users:
        for remove_user in remove_users:
            user = [user for user in enterprise_data.users.get_all_entities() if user.username.lower() == remove_user.lower()]
            users_to_remove.append(user)

remove_roles = ['list of roles to remove']
if isinstance(remove_roles, list):
    has_remove_all_roles = any((True for x in remove_roles if x == '@all'))
    if not has_remove_all_roles:
        for role_name in remove_roles:
            if isinstance(role_name, int):
                role = enterprise_data.roles.get_entity(role_name)
            elif isinstance(role_name, str):
                if role_name.isnumeric():
                    role = enterprise_data.roles.get_entity(int(role_name))
                if not role:
                    role = [x for x in enterprise_data.roles.get_all_entities() if x.name.lower() == role_name.lower()]
        roles_to_remove.append(role)

for team in team_list:
    existing_users = {x.enterprise_user_id for x in enterprise_data.team_users.get_links_by_subject(team.team_uid)}
    existing_roles = {x.role_id for x in enterprise_data.role_teams.get_links_by_object(team.team_uid)}
    if users_to_add:
        users_to_add = [x for x in users_to_add if x.enterprise_user_id not in existing_users]
        if users_to_add:
            batch.modify_team_users(to_add=[enterprise_management.TeamUserEdit(
                team_uid=team.team_uid, enterprise_user_id=x.enterprise_user_id) for x in users_to_add])
    if roles_to_add:
        roles_to_add = [x for x in roles_to_add if x.role_id not in existing_roles]
        if roles_to_add:
            batch.modify_role_teams(to_add=[enterprise_management.RoleTeamEdit(
                role_id=x.role_id, team_uid=team.team_uid) for x in roles_to_add])
    if has_remove_all_users:
        batch.modify_team_users(to_remove=[enterprise_management.TeamUserEdit(
            team_uid=team.team_uid, enterprise_user_id=x) for x in existing_users])
    elif users_to_remove:
        batch.modify_team_users(to_remove=[enterprise_management.TeamUserEdit(
            team_uid=team.team_uid, enterprise_user_id=x.enterprise_user_id) for x in users_to_remove])
    if has_remove_all_roles:
        batch.modify_role_teams(to_remove=[enterprise_management.RoleTeamEdit(
            role_id=x, team_uid=team.team_uid) for x in existing_roles])
    elif roles_to_remove:
        batch.modify_role_teams(to_remove=[enterprise_management.RoleTeamEdit(
            role_id=x.role_id, team_uid=team.team_uid) for x in roles_to_remove])

batch.apply()