open-vault/vendor/go.mongodb.org/atlas/mongodbatlas/teams.go

368 lines
10 KiB
Go
Raw Normal View History

package mongodbatlas
import (
"context"
"fmt"
"net/http"
)
const (
teamsBasePath = "orgs/%s/teams"
)
// TeamsService is an interface for interfacing with the Teams
// endpoints of the MongoDB Atlas API.
//
// See more: https://docs.atlas.mongodb.com/reference/api/teams/
type TeamsService interface {
List(context.Context, string, *ListOptions) ([]Team, *Response, error)
Get(context.Context, string, string) (*Team, *Response, error)
GetOneTeamByName(context.Context, string, string) (*Team, *Response, error)
GetTeamUsersAssigned(context.Context, string, string) ([]AtlasUser, *Response, error)
Create(context.Context, string, *Team) (*Team, *Response, error)
Rename(context.Context, string, string, string) (*Team, *Response, error)
UpdateTeamRoles(context.Context, string, string, *TeamUpdateRoles) ([]TeamRoles, *Response, error)
AddUsersToTeam(context.Context, string, string, []string) ([]AtlasUser, *Response, error)
RemoveUserToTeam(context.Context, string, string, string) (*Response, error)
RemoveTeamFromOrganization(context.Context, string, string) (*Response, error)
RemoveTeamFromProject(context.Context, string, string) (*Response, error)
}
// TeamsServiceOp handles communication with the Teams related methods of the
// MongoDB Atlas API
type TeamsServiceOp service
var _ TeamsService = &TeamsServiceOp{}
// TeamsResponse represents a array of project
type TeamsResponse struct {
Links []*Link `json:"links"`
Results []Team `json:"results"`
TotalCount int `json:"totalCount"`
}
// Team defines an Atlas team structure
type Team struct {
ID string `json:"id,omitempty"`
Name string `json:"name"`
Usernames []string `json:"usernames,omitempty"`
}
// AtlasUserAssigned represents the user assigned to the project.
type AtlasUserAssigned struct {
Links []*Link `json:"links"`
Results []AtlasUser `json:"results"`
TotalCount int `json:"totalCount"`
}
// TeamUpdateRoles update request body
type TeamUpdateRoles struct {
RoleNames []string `json:"roleNames"`
}
// TeamUpdateRolesResponse update roles response
type TeamUpdateRolesResponse struct {
Links []*Link `json:"links"`
Results []TeamRoles `json:"results"`
TotalCount int `json:"totalCount"`
}
// TeamRoles List of roles for a team
type TeamRoles struct {
Links []*Link `json:"links"`
RoleNames []string `json:"roleNames"`
TeamID string `json:"teamId"`
}
// List gets all teams.
//
// See more: https://docs.atlas.mongodb.com/reference/api/project-get-all/
func (s *TeamsServiceOp) List(ctx context.Context, orgID string, listOptions *ListOptions) ([]Team, *Response, error) {
path := fmt.Sprintf(teamsBasePath, orgID)
// Add query params from listOptions
path, err := setListOptions(path, listOptions)
if err != nil {
return nil, nil, err
}
req, err := s.Client.NewRequest(ctx, http.MethodGet, path, nil)
if err != nil {
return nil, nil, err
}
root := new(TeamsResponse)
resp, err := s.Client.Do(ctx, req, root)
if err != nil {
return nil, resp, err
}
if l := root.Links; l != nil {
resp.Links = l
}
return root.Results, resp, nil
}
// Get gets a single team in the organization by team ID.
//
// See more: https://docs.atlas.mongodb.com/reference/api/teams-get-one-by-id/
func (s *TeamsServiceOp) Get(ctx context.Context, orgID, teamID string) (*Team, *Response, error) {
if teamID == "" {
return nil, nil, NewArgError("teamID", "must be set")
}
basePath := fmt.Sprintf(teamsBasePath, orgID)
path := fmt.Sprintf("%s/%s", basePath, teamID)
req, err := s.Client.NewRequest(ctx, http.MethodGet, path, nil)
if err != nil {
return nil, nil, err
}
root := new(Team)
resp, err := s.Client.Do(ctx, req, root)
if err != nil {
return nil, resp, err
}
return root, resp, err
}
// GetOneTeamByName gets a single project by its name.
//
// See more: https://docs.atlas.mongodb.com/reference/api/project-get-one-by-name/
func (s *TeamsServiceOp) GetOneTeamByName(ctx context.Context, orgID, teamName string) (*Team, *Response, error) {
if teamName == "" {
return nil, nil, NewArgError("teamName", "must be set")
}
basePath := fmt.Sprintf(teamsBasePath, orgID)
path := fmt.Sprintf("%s/byName/%s", basePath, teamName)
req, err := s.Client.NewRequest(ctx, http.MethodGet, path, nil)
if err != nil {
return nil, nil, err
}
root := new(Team)
resp, err := s.Client.Do(ctx, req, root)
if err != nil {
return nil, resp, err
}
return root, resp, err
}
// GetTeamUsersAssigned gets all the users assigned to a team.
//
// See more: https://docs.atlas.mongodb.com/reference/api/teams-get-all-users/
func (s *TeamsServiceOp) GetTeamUsersAssigned(ctx context.Context, orgID, teamID string) ([]AtlasUser, *Response, error) {
if orgID == "" {
return nil, nil, NewArgError("orgID", "must be set")
}
basePath := fmt.Sprintf(teamsBasePath, orgID)
path := fmt.Sprintf("%s/%s/users", basePath, teamID)
req, err := s.Client.NewRequest(ctx, http.MethodGet, path, nil)
if err != nil {
return nil, nil, err
}
root := new(AtlasUserAssigned)
resp, err := s.Client.Do(ctx, req, root)
if err != nil {
return nil, resp, err
}
if l := root.Links; l != nil {
resp.Links = l
}
return root.Results, resp, nil
}
// Create creates a team.
//
// See more: https://docs.atlas.mongodb.com/reference/api/teams-create-one/
func (s *TeamsServiceOp) Create(ctx context.Context, orgID string, createRequest *Team) (*Team, *Response, error) {
if createRequest == nil {
return nil, nil, NewArgError("createRequest", "cannot be nil")
}
req, err := s.Client.NewRequest(ctx, http.MethodPost, fmt.Sprintf(teamsBasePath, orgID), createRequest)
if err != nil {
return nil, nil, err
}
root := new(Team)
resp, err := s.Client.Do(ctx, req, root)
if err != nil {
return nil, resp, err
}
return root, resp, err
}
// Rename renames a team.
//
// See more: https://docs.atlas.mongodb.com/reference/api/teams-rename-one/
func (s *TeamsServiceOp) Rename(ctx context.Context, orgID, teamID, teamName string) (*Team, *Response, error) {
if teamName == "" {
return nil, nil, NewArgError("teamName", "cannot be nil")
}
basePath := fmt.Sprintf(teamsBasePath, orgID)
path := fmt.Sprintf("%s/%s", basePath, teamID)
req, err := s.Client.NewRequest(ctx, http.MethodPatch, path, map[string]interface{}{
"name": teamName,
})
if err != nil {
return nil, nil, err
}
root := new(Team)
resp, err := s.Client.Do(ctx, req, root)
if err != nil {
return nil, resp, err
}
return root, resp, err
}
// UpdateTeamRoles Update the roles of a team in an Atlas project.
//
// See more: https://docs.atlas.mongodb.com/reference/api/teams-update-roles/
func (s *TeamsServiceOp) UpdateTeamRoles(ctx context.Context, orgID, teamID string, updateTeamRolesRequest *TeamUpdateRoles) ([]TeamRoles, *Response, error) {
if updateTeamRolesRequest == nil {
return nil, nil, NewArgError("updateTeamRolesRequest", "cannot be nil")
}
path := fmt.Sprintf("groups/%s/teams/%s", orgID, teamID)
req, err := s.Client.NewRequest(ctx, http.MethodPatch, path, updateTeamRolesRequest)
if err != nil {
return nil, nil, err
}
root := new(TeamUpdateRolesResponse)
resp, err := s.Client.Do(ctx, req, root)
if err != nil {
return nil, resp, err
}
if l := root.Links; l != nil {
resp.Links = l
}
return root.Results, resp, nil
}
// AddUsersToTeam adds a users from the organization associated with {ORG-ID} to the team with ID {TEAM-ID}.
//
// See more: https://docs.atlas.mongodb.com/reference/api/teams-add-user/
func (s *TeamsServiceOp) AddUsersToTeam(ctx context.Context, orgID, teamID string, usersID []string) ([]AtlasUser, *Response, error) {
if len(usersID) < 1 {
return nil, nil, NewArgError("usersID", "cannot empty at leas one userID must be set")
}
basePath := fmt.Sprintf(teamsBasePath, orgID)
path := fmt.Sprintf("%s/%s/users", basePath, teamID)
users := make([]map[string]interface{}, len(usersID))
for i, id := range usersID {
users[i] = map[string]interface{}{"id": id}
}
req, err := s.Client.NewRequest(ctx, http.MethodPost, path, users)
if err != nil {
return nil, nil, err
}
root := new(AtlasUserAssigned)
resp, err := s.Client.Do(ctx, req, root)
if err != nil {
return nil, resp, err
}
if l := root.Links; l != nil {
resp.Links = l
}
return root.Results, resp, nil
}
// RemoveUserToTeam removes the specified user from the specified team.
//
// See more: https://docs.atlas.mongodb.com/reference/api/teams-remove-user/
func (s *TeamsServiceOp) RemoveUserToTeam(ctx context.Context, orgID, teamID, userID string) (*Response, error) {
if userID == "" {
return nil, NewArgError("userID", "cannot be nil")
}
basePath := fmt.Sprintf(teamsBasePath, orgID)
path := fmt.Sprintf("%s/%s/users/%s", basePath, teamID, userID)
req, err := s.Client.NewRequest(ctx, http.MethodDelete, path, nil)
if err != nil {
return nil, err
}
resp, err := s.Client.Do(ctx, req, nil)
if err != nil {
return resp, err
}
return resp, nil
}
// RemoveTeamFromOrganization deletes the team with ID {TEAM-ID} from the organization specified to {ORG-ID}.
//
// See more: https://docs.atlas.mongodb.com/reference/api/teams-delete-one/
func (s *TeamsServiceOp) RemoveTeamFromOrganization(ctx context.Context, orgID, teamID string) (*Response, error) {
if teamID == "" {
return nil, NewArgError("teamID", "cannot be nil")
}
basePath := fmt.Sprintf(teamsBasePath, orgID)
path := fmt.Sprintf("%s/%s", basePath, teamID)
req, err := s.Client.NewRequest(ctx, http.MethodDelete, path, nil)
if err != nil {
return nil, err
}
resp, err := s.Client.Do(ctx, req, nil)
if err != nil {
return resp, err
}
return resp, nil
}
// RemoveTeamFromProject removes the specified team from the specified project.
//
// See more: https://docs.atlas.mongodb.com/reference/api/teams-remove-from-project/
func (s *TeamsServiceOp) RemoveTeamFromProject(ctx context.Context, groupID, teamID string) (*Response, error) {
if teamID == "" {
return nil, NewArgError("teamID", "cannot be nil")
}
path := fmt.Sprintf("groups/%s/teams/%s", groupID, teamID)
req, err := s.Client.NewRequest(ctx, http.MethodDelete, path, nil)
if err != nil {
return nil, err
}
resp, err := s.Client.Do(ctx, req, nil)
if err != nil {
return resp, err
}
return resp, nil
}