/
teams.go
114 lines (95 loc) · 2.85 KB
/
teams.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
package clients
import (
"context"
iClient "github.com/manifoldco/manifold-cli/generated/identity/client"
"github.com/manifoldco/manifold-cli/generated/identity/client/invite"
"github.com/manifoldco/manifold-cli/generated/identity/client/team"
iModels "github.com/manifoldco/manifold-cli/generated/identity/models"
)
// TeamMembersCount groups a team name with the amount of members the team has
type TeamMembersCount struct {
Name string
Title string
Members int
}
// FetchTeams returns the teams for the authenticated user
func FetchTeams(ctx context.Context, c *iClient.Identity) ([]*iModels.Team, error) {
res, err := c.Team.GetTeams(
team.NewGetTeamsParamsWithContext(ctx), nil)
if err != nil {
return nil, err
}
return res.Payload, nil
}
// FetchTeamMembers returns a list of members profile from a team.
func FetchTeamMembers(ctx context.Context, id string, c *iClient.Identity) ([]*iModels.MemberProfile, error) {
params := team.NewGetTeamsIDMembersParamsWithContext(ctx)
params.SetID(id)
res, err := c.Team.GetTeamsIDMembers(params, nil)
if err != nil {
return nil, err
}
return res.Payload, nil
}
// FetchInvites returns a list of invites for a given team
func FetchInvites(ctx context.Context, id string, c *iClient.Identity) ([]*iModels.Invite, error) {
params := invite.NewGetInvitesParams()
params.SetTeamID(id)
res, err := c.Invite.GetInvites(params, nil)
if err != nil {
return nil, err
}
return res.Payload, nil
}
// FetchTeamsMembersCount returns a list of all user teams with their names and
// number of members.
func FetchTeamsMembersCount(ctx context.Context, c *iClient.Identity) ([]TeamMembersCount, error) {
teams, err := FetchTeams(ctx, c)
if err != nil {
return nil, err
}
// team payload doesn't contain a list of members. In order to find the
// number for each team we fetch them in parallel.
res := make(chan TeamMembersCount, len(teams))
fail := make(chan error)
for _, t := range teams {
id := t.ID.String()
name := string(t.Body.Label)
title := string(t.Body.Name)
go func() {
members, err := FetchTeamMembers(ctx, id, c)
if err != nil {
fail <- err
return
}
res <- TeamMembersCount{
Name: name,
Title: title,
Members: len(members),
}
}()
}
var counts []TeamMembersCount
for range teams {
select {
case err := <-fail:
return nil, err
case count := <-res:
counts = append(counts, count)
}
}
return counts, nil
}
// FetchMemberships returns all memberships for the authenticated user
func FetchMemberships(ctx context.Context, c *iClient.Identity) ([]iModels.TeamMembership, error) {
params := team.NewGetMembershipsParamsWithContext(ctx)
res, err := c.Team.GetMemberships(params, nil)
if err != nil {
return nil, err
}
var results []iModels.TeamMembership
for _, m := range res.Payload {
results = append(results, *m)
}
return results, nil
}