github.com/grokify/go-ringcentral-client@v0.3.31/office/v1/util/glipgroups/glipgroups.go (about)

     1  package glipgroups
     2  
     3  import (
     4  	"encoding/json"
     5  	"fmt"
     6  	"io/ioutil"
     7  	"net/http"
     8  	"net/url"
     9  	"sort"
    10  	"strings"
    11  	"time"
    12  
    13  	"github.com/grokify/mogo/net/urlutil"
    14  )
    15  
    16  const (
    17  	GroupTypeTeam         = "Team"
    18  	groupNameIdJoin       = " - "
    19  	ApiPathListUserGroups = "/restapi/v1.0/glip/groups"
    20  )
    21  
    22  type GroupsSet struct {
    23  	GroupsMap map[string]Group // ID to Group Map
    24  }
    25  
    26  func (set *GroupsSet) AddGroups(groups []Group) {
    27  	for _, grp := range groups {
    28  		set.GroupsMap[grp.ID] = grp
    29  	}
    30  }
    31  
    32  func (set *GroupsSet) FindGroupsByName(groupName string) []Group {
    33  	groupName = strings.TrimSpace(groupName)
    34  	groups := []Group{}
    35  	for _, group := range set.GroupsMap {
    36  		if groupName == group.Name {
    37  			groups = append(groups, group)
    38  		}
    39  	}
    40  	return groups
    41  }
    42  
    43  func (set *GroupsSet) FindGroupsByNameLower(groupName string) []Group {
    44  	groupName = strings.ToLower(strings.TrimSpace(groupName))
    45  	groups := []Group{}
    46  	for _, group := range set.GroupsMap {
    47  		if groupName == strings.ToLower(group.Name) {
    48  			groups = append(groups, group)
    49  		}
    50  	}
    51  	return groups
    52  }
    53  
    54  func (set *GroupsSet) FindGroupByName(groupName string) (Group, error) {
    55  	groups := set.FindGroupsByName(groupName)
    56  	if len(groups) != 1 {
    57  		return Group{}, fmt.Errorf("Found [%v] groups for name [%v]", len(groups), groupName)
    58  	}
    59  	return groups[0], nil
    60  }
    61  
    62  func (set *GroupsSet) GroupNamesSorted(withIds bool) []string {
    63  	names := []string{}
    64  	for _, group := range set.GroupsMap {
    65  		name := group.Name
    66  		if withIds {
    67  			name += groupNameIdJoin + group.ID
    68  		}
    69  		names = append(names, name)
    70  	}
    71  	sort.Strings(names)
    72  	return names
    73  }
    74  
    75  func (set *GroupsSet) GroupsSorted() []Group {
    76  	names := set.GroupNamesSorted(true)
    77  	groups := []Group{}
    78  	for _, name := range names {
    79  		parts := strings.Split(name, groupNameIdJoin)
    80  		if len(parts) > 0 {
    81  			id := parts[len(parts)-1]
    82  			if g, ok := set.GroupsMap[id]; ok {
    83  				groups = append(groups, g)
    84  			}
    85  		}
    86  	}
    87  	return groups
    88  }
    89  
    90  type Group struct {
    91  	ID               string    `json:"id,omitempty"`
    92  	Name             string    `json:"name,omitempty"`
    93  	Description      string    `json:"description,omitempty"`
    94  	CreationTime     time.Time `json:"creationTime,omitempty"`
    95  	LastModifiedTime time.Time `json:"lastModifiedTime,omitempty"`
    96  	Members          []string  `json:"members,omitempty"`
    97  }
    98  
    99  func NewGroupsSetApiRequest(client *http.Client, serverUrl string, groupType string) (GroupsSet, error) {
   100  	groupType = strings.TrimSpace(groupType)
   101  	if len(groupType) == 0 {
   102  		groupType = "Team"
   103  	}
   104  
   105  	set := GroupsSet{GroupsMap: map[string]Group{}}
   106  
   107  	query := url.Values{}
   108  	query.Add("recordCount", "250")
   109  
   110  	if len(groupType) > 0 {
   111  		query.Add("type", groupType)
   112  	}
   113  
   114  	for {
   115  		// apiUrlString := urlutil.JoinAbsolute(serverUrl, ApiPathListUserGroups)
   116  		// groupsURL := ro.BuildURL(serverUrl, "/glip/groups", true, query)
   117  		groupsURL, err := urlutil.URLStringAddQuery(
   118  			urlutil.JoinAbsolute(serverUrl, ApiPathListUserGroups),
   119  			query, false)
   120  		if err != nil {
   121  			return set, err
   122  		}
   123  		resp, err := client.Get(groupsURL.String())
   124  		if err != nil {
   125  			return set, err
   126  		}
   127  
   128  		groupsResp, err := GetGroupsResponseFromHTTPResponse(resp)
   129  		if err != nil {
   130  			return set, err
   131  		}
   132  		set.AddGroups(groupsResp.Records)
   133  
   134  		if len(groupsResp.Navigation.PrevPageToken) > 0 {
   135  			query.Add("pageToken", groupsResp.Navigation.PrevPageToken)
   136  		} else {
   137  			break
   138  		}
   139  	}
   140  	return set, nil
   141  }
   142  
   143  type GetGroupsResponse struct {
   144  	Records    []Group    `json:"records,omitempty"`
   145  	Navigation Navigation `json:"navigation,omitempty"`
   146  }
   147  
   148  func GetGroupsResponseFromHTTPResponse(resp *http.Response) (GetGroupsResponse, error) {
   149  	bytes, err := ioutil.ReadAll(resp.Body)
   150  	if err != nil {
   151  		return GetGroupsResponse{}, err
   152  	}
   153  	var apiResp GetGroupsResponse
   154  	err = json.Unmarshal(bytes, &apiResp)
   155  	return apiResp, err
   156  }
   157  
   158  type Navigation struct {
   159  	PrevPageToken string `json:"prevPageToken,omitempty"`
   160  	NextPageToken string `json:"nextPageToken,omitempty"`
   161  }