# Enterprise Team Commands

#### Usage <a href="#usage-5" id="usage-5"></a>

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

**Alias:** `et`

#### Commands <a href="#commands-3" id="commands-3"></a>

| Command                                               | Description                       | Alias |
| ----------------------------------------------------- | --------------------------------- | ----- |
| [`view`](#enterprise-team-view)                       | View enterprise team              | `v`   |
| [`add`](#enterprise-info-tree)                        | Create enterprise team(s)         | `a`   |
| [`edit`](#enterprise-info-tree-1)                     | Edit enterprise team(s)           | `e`   |
| [`delete`](#enterprise-info-tree-2)                   | Delete enterprise team(s)         | `d`   |
| [`membership`](#enterprise-node-invite-email)         | Manage enterprise team membership | `m`   |
| [`user-update`](#enterprise-team-user-update-command) | Update user information in team   |       |

### Enterprise Team View Command

This command is for viewing teams and their permissions.

<details>

<summary>DotNet CLI</summary>

**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:  dhananjay.tayade@metronlabs.com
                  satish.gaddala@metronlabs.com  
   Queued Users:                                 
           Node:  Metron Security 
```

</details>

<details>

<summary>DotNet SDK</summary>

**Function:** `EnterpriseData.Teams`

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

**Example:**

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

</details>

<details>

<summary>PowerCommander</summary>

**Command:**`Get-KeeperEnterpriseTeam`

**Syntax:**

```powershell
Get-KeeperEnterpriseTeam
```

**Aliases:** `ket`

**Parameters:**

* `-Name` - User email.
* `-Filter` - Search filter.
* `-Format` - Output format.
* `-Output` - Output file name.

**Example:**

```powershell
# List all teams
PS> Get-KeeperEnterpriseTeam

# Get specific team
PS> Get-KeeperEnterpriseTeam -Name T1

# Search team
PS> Get-KeeperEnterpriseTeam -Filter T1
```

**Command :** `Get-KeeperEnterpriseTeamUser`

**Parameters:**

`-Team` : Name or Uid to filter users for a team.

**Syntax:**

```powershell
Get-KeeperEnterpriseTeamUser
```

**Example:**

```powershell
# Get all users from a specific team
PS> Get-KeeperEnterpriseTeamUser T

Id             DisplayName  Email                         UserStatus NodeName        
--             -----------  -----                         ---------- --------        
70411693850788 test sso     mimafe5220@docsfy.com         Active     SSO
70411693853106 Test1        mimafe5220@gmail.com          Active     Keeper Security 
```

**Command**: `Get-KeeperAvailableTeam`

**Example**:

```powershell
PS > Get-KeeperAvailableTeam 

TeamUid                Name
-------                ----
eun1B5Cy89qO-sknhz59tg T3
7Xo__xOv62mUmqhXVPSZng Test Role Copy
```

</details>

<details>

<summary>Python CLI</summary>

**Command:** `enterprise-team view`

**Flag:**

* `-v`, `--verbose` - Print verbose information
* `--format` - Output format: `json`
* `--output` - Output filename
* `team` - Team Name or UID (required)

</details>

<details>

<summary>Python SDK</summary>

**Function:**

```python
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(
```

</details>

### Enterprise Team Add Command <a href="#enterprise-info-tree" id="enterprise-info-tree"></a>

Create enterprise team(s).

<details>

<summary>DotNet CLI</summary>

**Usage**

```bash
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:**

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

</details>

<details>

<summary>DotNet SDK</summary>

**Function:** `CreateTeam`

```csharp
public async Task<EnterpriseTeam> CreateTeam(EnterpriseTeam team)
```

**Example:**

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

</details>

<details>

<summary>PowerCommander</summary>

**Command**: `New-KeeperEnterpriseTeam`

**Syntax:**

```powershell
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:**

<pre class="language-powershell"><code class="lang-powershell"><strong>New-KeeperEnterpriseTeam -TeamName "Backend Team"
</strong>New-KeeperEnterpriseTeam -TeamName "Support" -ParentNode 12345 -RestrictView $true
</code></pre>

</details>

<details>

<summary>Python CLI</summary>

**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`

</details>

<details>

<summary>Python SDK</summary>

**Function:**

```python
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()
```

</details>

### Enterprise Team Edit Command <a href="#enterprise-info-tree" id="enterprise-info-tree"></a>

Edit enterprise team(s).

<details>

<summary>DotNet CLI</summary>

**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:**

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

</details>

<details>

<summary>DotNet SDK</summary>

**Function:** `UpdateTeam`

```csharp
public async Task<EnterpriseTeam> UpdateTeam(EnterpriseTeam team)
```

**Example:**

```csharp
await context.EnterpriseData.UpdateTeam(team);
```

</details>

<details>

<summary>PowerCommander</summary>

Not Implemented

</details>

<details>

<summary>Python CLI</summary>

**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`

</details>

<details>

<summary>Python SDK</summary>

**Function:**

```python
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()
```

</details>

### Enterprise Team Delete Command <a href="#enterprise-info-tree" id="enterprise-info-tree"></a>

Delete enterprise team(s).

<details>

<summary>DotNet CLI</summary>

**Command:** `enterpise-team delete teamID`

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

**Parameter:**

`team` team name or team ID

**Example:**

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

</details>

<details>

<summary>DotNet SDK</summary>

**Function**: `DeleteTeam`

```csharp
 public async Task DeleteTeam(string teamUid)
```

**Example:**

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

</details>

<details>

<summary>PowerCommander</summary>

Not Implemented

</details>

<details>

<summary>Python CLI</summary>

**Command:** `enterprise-team delete`

**Parameter:**

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

</details>

<details>

<summary>Python SDK</summary>

**Function:**

```python
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()
```

</details>

### Enterprise Team Membership Command <a href="#enterprise-node-invite-email" id="enterprise-node-invite-email"></a>

Manage enterprise team membership.

<details>

<summary>DotNet CLI</summary>

Not Implemented

</details>

<details>

<summary>DotNet SDK</summary>

**Functions:**

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

`RemoveUsersFromTeams` - This function is for removing users from team.

**Example:**

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

```csharp
await enterprise.AddUsersToTeams(
                            new[] { "username@company.com", "username1@company.com" },
                            new[] { team.Uid }
                            );
 
```

</details>

<details>

<summary>PowerCommander</summary>

**Commands**:

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

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

**Syntax:**

```powershell
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:**

```powershell
# Add users to team
PS> Add-KeeperEnterpriseTeamMember -Team "Developers" -Emails"user1@example.com", "user2@example.com"
PS> keta "TeamUID" "user@example.com"

# Remove users from team
PS> Remove-KeeperEnterpriseTeamMember -Team "Developers" -Emails"user@example.com"
PS> ketu "TeamUID" "user1@example.com", "user2@example.com"
```

</details>

<details>

<summary>Python CLI</summary>

**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.

</details>

<details>

<summary>Python SDK</summary>

**Function:**

```python
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()
```

</details>

### Enterprise Team User Update Command

This command/function is used to update the usertype in a team

<details>

<summary>DotNet CLI</summary>

**Command:** `enterprise-user <action> username --team=<team_name> --user-type=<user_type>`

**Parameter:**

`email` - User email or ID.

`team` - Team name or ID

`user-type` - 0=user, 1=admin, 2=admin\_only (means he wont see the shared folders but can add users to the team)

**Examples:**

```sh
My Vault> eu team-user-update "nelelex252@hudisk.com" --team="T2" --user-type=0
```

**Reference:**

[Commander Reference](https://docs.keeper.io/en/keeperpam/commander-cli/command-reference/enterprise-management-commands#changing-role-enforcements-and-privileges)

</details>

<details>

<summary>DotNet SDK</summary>

**Enterprise Team User Update:**

**Function:** `TeamEnterpriseUserUpdate`

**Usage:**

```csharp
 public async Task TeamEnterpriseUserUpdate(EnterpriseTeam enterpriseTeam, EnterpriseUser enterpriseUser, int userType)
```

**Parameters:**

<table><thead><tr><th width="227.4921875"></th><th>Description</th></tr></thead><tbody><tr><td><code>enterpriseTeam</code></td><td>EnterpriseTeam object representing the team</td></tr><tr><td><code>enterpriseUser</code></td><td>EnterpriseUser object representing the user</td></tr><tr><td><code>userType</code></td><td>0=user, 1=admin, 2=admin_only (means he wont see the shared folders but can add users to the team)</td></tr></tbody></table>

**Example:**

{% code overflow="wrap" %}

```csharp
await EnterpriseManagementExamples.EnterpriseUserExamples.UserExamples.TeamEnterpriseUserUpdateExample("jTiPyIP4NmPiyAVv2oKFpw", "nebilem641@nctime.com", 0);
```

{% endcode %}

**Reference:**

[Commander Reference](https://docs.keeper.io/en/keeperpam/commander-cli/command-reference/enterprise-management-commands#changing-role-enforcements-and-privileges)

</details>

<details>

<summary>PowerCommander</summary>

**Command:** `Update-KeeperEnterpriseTeamUser`

**Flags:**

<table><thead><tr><th width="150.9345703125">Parameter</th><th>Description</th></tr></thead><tbody><tr><td><code>User</code></td><td>Updates enterprise user information.</td></tr><tr><td><code>Team</code></td><td>Team name or UID</td></tr><tr><td><code>UserType</code></td><td>User type: 0, 1, or 2<br>0 - User (Normal User)<br>1 - Administrator<br>2 - Administrator Only</td></tr></tbody></table>

**Example:**

```powershell
PS > Update-KeeperEnterpriseTeamUser -Team PCTTeam -User tofam63308@ixospace.com -UserType 1                     
Team user tofam63308@ixospace.com updated
```

**Reference:**

[Commander Reference](https://docs.keeper.io/en/keeperpam/commander-cli/command-reference/enterprise-management-commands#changing-role-enforcements-and-privileges)

</details>

<details>

<summary>Python CLI</summary>

Comming Soon

**Reference:**

[Commander Reference](https://docs.keeper.io/en/keeperpam/commander-cli/command-reference/enterprise-management-commands#changing-role-enforcements-and-privileges)

</details>

<details>

<summary>Python SDK</summary>

Comming Soon

**Reference:**

[Commander Reference](https://docs.keeper.io/en/keeperpam/commander-cli/command-reference/enterprise-management-commands#changing-role-enforcements-and-privileges)

</details>