├── .gitignore ├── LICENSE ├── README.md ├── ciscospark ├── ciscospark.go ├── licenses.go ├── memberships.go ├── messages.go ├── organizations.go ├── people.go ├── roles.go ├── rooms.go ├── strings.go ├── team-memberships.go ├── teams.go ├── timestamp.go └── webhooks.go └── examples ├── licenses └── main.go ├── memberships └── main.go ├── messages └── main.go ├── organizations └── main.go ├── people └── main.go ├── roles └── main.go ├── rooms └── main.go ├── team-memberships └── main.go ├── teams └── main.go └── webhooks └── main.go /.gitignore: -------------------------------------------------------------------------------- 1 | # Compiled Object files, Static and Dynamic libs (Shared Objects) 2 | *.o 3 | *.a 4 | *.so 5 | 6 | # Folders 7 | _obj 8 | _test 9 | 10 | # Architecture specific extensions/prefixes 11 | *.[568vq] 12 | [568vq].out 13 | 14 | *.cgo1.go 15 | *.cgo2.c 16 | _cgo_defun.c 17 | _cgo_gotypes.go 18 | _cgo_export.* 19 | 20 | _testmain.go 21 | 22 | *.exe 23 | *.test 24 | *.prof 25 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | The MIT License (MIT) 2 | Copyright (c) 2016 go-cisco-spark AUTHORs. 3 | 4 | Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: 5 | 6 | The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. 7 | 8 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 9 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # go-cisco-spark # 2 | This repo is outdated and no longer mantained. You should go to [go-cisco-webex-teams](https://github.com/jbogarin/go-cisco-webex-teams) 3 | -------------------------------------------------------------------------------- /ciscospark/ciscospark.go: -------------------------------------------------------------------------------- 1 | package ciscospark 2 | 3 | import ( 4 | "bytes" 5 | "encoding/json" 6 | "fmt" 7 | "io" 8 | "io/ioutil" 9 | "net/http" 10 | "net/url" 11 | "reflect" 12 | 13 | "github.com/google/go-querystring/query" 14 | ) 15 | 16 | const ( 17 | libraryVersion = "0.1.0" 18 | userAgent = "ciscospark/" + libraryVersion 19 | mediaType = "application/json" 20 | ) 21 | 22 | var ( 23 | defaultBaseURL = "https://api.ciscospark.com/" 24 | authorizationToken = "" 25 | ) 26 | 27 | // Client manages communication with Cisco Spark V1 API. 28 | type Client struct { 29 | // HTTP client used to communicate with the Cisco Spark API. 30 | client *http.Client 31 | 32 | // Base URL for API requests. 33 | BaseURL *url.URL 34 | 35 | // User agent for client 36 | UserAgent string 37 | 38 | // Authorization is the authentication token 39 | Authorization string 40 | 41 | common service // Reuse a single struct instead of allocating one for each service on the heap 42 | 43 | // Services used for communicating with the APIC-EM API 44 | Memberships *MembershipsService 45 | Messages *MessagesService 46 | People *PeopleService 47 | Rooms *RoomsService 48 | TeamMemberships *TeamMembershipsService 49 | Teams *TeamsService 50 | Webhooks *WebhooksService 51 | Organizations *OrganizationsService 52 | Licenses *LicensesService 53 | Roles *RolesService 54 | 55 | // Optional function called after every successful request made to the Cisco Spark APIs 56 | onRequestCompleted RequestCompletionCallback 57 | } 58 | 59 | type service struct { 60 | client *Client 61 | } 62 | 63 | // RequestCompletionCallback defines the type of the request callback function 64 | type RequestCompletionCallback func(*http.Request, *http.Response) 65 | 66 | // ListOptions specifies the optional parameters to various List methods that 67 | // support pagination. 68 | type ListOptions struct { 69 | // For paginated result sets, page of results to retrieve. 70 | Page int `url:"page,omitempty"` 71 | 72 | // For paginated result sets, the number of results to include per page. 73 | PerPage int `url:"per_page,omitempty"` 74 | } 75 | 76 | // Response is a Cisco Spark response. This wraps the standard http.Response returned from Cisco Spark. 77 | type Response struct { 78 | *http.Response 79 | 80 | // Monitoring URI 81 | Monitor string 82 | } 83 | 84 | // An ErrorResponse reports the error caused by an API request 85 | type ErrorResponse struct { 86 | // HTTP response that caused this error 87 | HTTPResponse *http.Response 88 | 89 | Message string 90 | Errors []struct { 91 | Description string 92 | } 93 | TrackingID string 94 | } 95 | 96 | func addOptions(s string, opt interface{}) (string, error) { 97 | v := reflect.ValueOf(opt) 98 | 99 | if v.Kind() == reflect.Ptr && v.IsNil() { 100 | return s, nil 101 | } 102 | 103 | origURL, err := url.Parse(s) 104 | if err != nil { 105 | return s, err 106 | } 107 | 108 | origValues := origURL.Query() 109 | 110 | newValues, err := query.Values(opt) 111 | if err != nil { 112 | return s, err 113 | } 114 | 115 | for k, v := range newValues { 116 | origValues[k] = v 117 | } 118 | 119 | origURL.RawQuery = origValues.Encode() 120 | return origURL.String(), nil 121 | } 122 | 123 | // NewClient returns a new Cisco Spark API client. 124 | func NewClient(httpClient *http.Client) *Client { 125 | if httpClient == nil { 126 | httpClient = http.DefaultClient 127 | } 128 | 129 | baseURL, _ := url.Parse(defaultBaseURL) 130 | 131 | c := &Client{client: httpClient, BaseURL: baseURL, UserAgent: userAgent, Authorization: authorizationToken} 132 | c.common.client = c 133 | c.Memberships = (*MembershipsService)(&c.common) 134 | c.Messages = (*MessagesService)(&c.common) 135 | c.People = (*PeopleService)(&c.common) 136 | c.Rooms = (*RoomsService)(&c.common) 137 | c.TeamMemberships = (*TeamMembershipsService)(&c.common) 138 | c.Teams = (*TeamsService)(&c.common) 139 | c.Webhooks = (*WebhooksService)(&c.common) 140 | c.Organizations = (*OrganizationsService)(&c.common) 141 | c.Licenses = (*LicensesService)(&c.common) 142 | c.Roles = (*RolesService)(&c.common) 143 | 144 | return c 145 | } 146 | 147 | // ClientOpt are options for New. 148 | type ClientOpt func(*Client) error 149 | 150 | // New returns a new Cisco Spark API client instance. 151 | func New(httpClient *http.Client, opts ...ClientOpt) (*Client, error) { 152 | c := NewClient(httpClient) 153 | for _, opt := range opts { 154 | if err := opt(c); err != nil { 155 | return nil, err 156 | } 157 | } 158 | 159 | return c, nil 160 | } 161 | 162 | // SetBaseURL is a client option for setting the base URL. 163 | func SetBaseURL(bu string) ClientOpt { 164 | return func(c *Client) error { 165 | u, err := url.Parse(bu) 166 | if err != nil { 167 | return err 168 | } 169 | 170 | c.BaseURL = u 171 | return nil 172 | } 173 | } 174 | 175 | // SetUserAgent is a client option for setting the user agent. 176 | func SetUserAgent(ua string) ClientOpt { 177 | return func(c *Client) error { 178 | c.UserAgent = fmt.Sprintf("%s+%s", ua, c.UserAgent) 179 | return nil 180 | } 181 | } 182 | 183 | // NewRequest creates an API request. A relative URL can be provided in urlStr, which will be resolved to the 184 | // BaseURL of the Client. Relative URLS should always be specified without a preceding slash. If specified, the 185 | // value pointed to by body is JSON encoded and included in as the request body. 186 | func (c *Client) NewRequest(method, urlStr string, body interface{}) (*http.Request, error) { 187 | rel, err := url.Parse(urlStr) 188 | if err != nil { 189 | return nil, err 190 | } 191 | 192 | u := c.BaseURL.ResolveReference(rel) 193 | 194 | buf := new(bytes.Buffer) 195 | if body != nil { 196 | err := json.NewEncoder(buf).Encode(body) 197 | if err != nil { 198 | return nil, err 199 | } 200 | } 201 | 202 | req, err := http.NewRequest(method, u.String(), buf) 203 | if err != nil { 204 | return nil, err 205 | } 206 | 207 | req.Header.Add("Content-Type", mediaType) 208 | req.Header.Add("Accept", mediaType) 209 | req.Header.Add("User-Agent", c.UserAgent) 210 | if c.Authorization != "" { 211 | req.Header.Add("Authorization", c.Authorization) 212 | } 213 | return req, nil 214 | } 215 | 216 | // OnRequestCompleted sets the Cisco Spark API request completion callback 217 | func (c *Client) OnRequestCompleted(rc RequestCompletionCallback) { 218 | c.onRequestCompleted = rc 219 | } 220 | 221 | // newResponse creates a new Response for the provided http.Response 222 | func newResponse(r *http.Response) *Response { 223 | response := Response{Response: r} 224 | 225 | return &response 226 | } 227 | 228 | // Do sends an API request and returns the API response. The API response is JSON decoded and stored in the value 229 | // pointed to by v, or returned as an error if an API error has occurred. If v implements the io.Writer interface, 230 | // the raw response will be written to v, without attempting to decode it. 231 | func (c *Client) Do(req *http.Request, v interface{}) (*Response, error) { 232 | resp, err := c.client.Do(req) 233 | if err != nil { 234 | return nil, err 235 | } 236 | if c.onRequestCompleted != nil { 237 | c.onRequestCompleted(req, resp) 238 | } 239 | 240 | defer func() { 241 | if rerr := resp.Body.Close(); err == nil { 242 | err = rerr 243 | } 244 | }() 245 | 246 | defer func() { 247 | // Drain up to 512 bytes and close the body to let the Transport reuse the connection 248 | io.CopyN(ioutil.Discard, resp.Body, 512) 249 | resp.Body.Close() 250 | }() 251 | 252 | response := newResponse(resp) 253 | 254 | err = CheckResponse(resp) 255 | if err != nil { 256 | return response, err 257 | } 258 | 259 | if v != nil { 260 | if w, ok := v.(io.Writer); ok { 261 | _, err := io.Copy(w, resp.Body) 262 | if err != nil { 263 | return nil, err 264 | } 265 | } else { 266 | err := json.NewDecoder(resp.Body).Decode(v) 267 | if err != nil { 268 | return nil, err 269 | } 270 | } 271 | } 272 | 273 | return response, err 274 | } 275 | 276 | func (r *ErrorResponse) Error() string { 277 | return fmt.Sprintf("%v %v: %d %v - %v", 278 | r.HTTPResponse.Request.Method, r.HTTPResponse.Request.URL, r.HTTPResponse.StatusCode, r.Message, r.TrackingID) 279 | } 280 | 281 | // CheckResponse checks the API response for errors, and returns them if present. A response is considered an 282 | // error if it has a status code outside the 200 range. API error responses are expected to have either no response 283 | // body, or a JSON response body that maps to ErrorResponse. Any other response body will be silently ignored. 284 | func CheckResponse(r *http.Response) error { 285 | if c := r.StatusCode; c >= 200 && c <= 299 { 286 | return nil 287 | } 288 | 289 | errorResponse := &ErrorResponse{HTTPResponse: r} 290 | data, err := ioutil.ReadAll(r.Body) 291 | if err == nil && data != nil { 292 | json.Unmarshal(data, errorResponse) 293 | } 294 | if err == nil && len(data) > 0 { 295 | err := json.Unmarshal(data, errorResponse) 296 | if err != nil { 297 | return err 298 | } 299 | } 300 | 301 | return errorResponse 302 | } 303 | 304 | // String is a helper routine that allocates a new string value 305 | // to store v and returns a pointer to it. 306 | func String(v string) *string { 307 | p := new(string) 308 | *p = v 309 | return p 310 | } 311 | 312 | // Int is a helper routine that allocates a new int32 value 313 | // to store v and returns a pointer to it, but unlike Int32 314 | // its argument value is an int. 315 | func Int(v int) *int { 316 | p := new(int) 317 | *p = v 318 | return p 319 | } 320 | 321 | // Bool is a helper routine that allocates a new bool value 322 | // to store v and returns a pointer to it. 323 | func Bool(v bool) *bool { 324 | p := new(bool) 325 | *p = v 326 | return p 327 | } 328 | 329 | // StreamToString converts a reader to a string 330 | func StreamToString(stream io.Reader) string { 331 | buf := new(bytes.Buffer) 332 | _, _ = buf.ReadFrom(stream) 333 | return buf.String() 334 | } 335 | -------------------------------------------------------------------------------- /ciscospark/licenses.go: -------------------------------------------------------------------------------- 1 | package ciscospark 2 | 3 | const licensesBasePath = "v1/licenses" 4 | 5 | // LicensesService is an interface for interfacing with the Licenses 6 | // endpoints of the Cisco Spark API 7 | type LicensesService service 8 | 9 | // GetLicensesQueryParams ... 10 | type GetLicensesQueryParams struct { 11 | Max int `url:"max,omitempty"` 12 | OrgID string `url:"orgId,omitempty"` 13 | } 14 | 15 | // License represents the Spark Licenses 16 | type License struct { 17 | ID string `json:"id,omitempty"` 18 | Name string `json:"name,omitempty"` 19 | TotalUnits int `json:"totalUnits,omitempty"` 20 | ConsumedUnits int `json:"consumedUnits,omitempty"` 21 | } 22 | 23 | type LicensesRoot struct { 24 | Licenses []*License `json:"items"` 25 | } 26 | 27 | func (r License) String() string { 28 | return Stringify(r) 29 | } 30 | 31 | // Get .... 32 | func (s *LicensesService) Get(queryParams *GetLicensesQueryParams) ([]*License, *Response, error) { 33 | path := licensesBasePath 34 | path, err := addOptions(path, queryParams) 35 | if err != nil { 36 | return nil, nil, err 37 | } 38 | 39 | req, err := s.client.NewRequest("GET", path, nil) 40 | if err != nil { 41 | return nil, nil, err 42 | } 43 | 44 | root := new(LicensesRoot) 45 | resp, err := s.client.Do(req, root) 46 | if err != nil { 47 | return nil, resp, err 48 | } 49 | 50 | return root.Licenses, resp, err 51 | } 52 | 53 | // GetLicense .... 54 | func (s *LicensesService) GetLicense(LicenseID string) (*License, *Response, error) { 55 | path := licensesBasePath + "/" + LicenseID 56 | 57 | req, err := s.client.NewRequest("GET", path, nil) 58 | if err != nil { 59 | return nil, nil, err 60 | } 61 | 62 | License := new(License) 63 | resp, err := s.client.Do(req, License) 64 | if err != nil { 65 | return nil, resp, err 66 | } 67 | 68 | return License, resp, err 69 | } 70 | -------------------------------------------------------------------------------- /ciscospark/memberships.go: -------------------------------------------------------------------------------- 1 | package ciscospark 2 | 3 | const membershipsBasePath = "v1/memberships" 4 | 5 | // MembershipsService handles communication with the Memberships related methods of 6 | // the Cisco Spark API. 7 | type MembershipsService service 8 | 9 | // MembershipQueryParams ... 10 | type MembershipQueryParams struct { 11 | RoomID string `url:"roomId,omitempty"` 12 | PersonID string `url:"personId,omitempty"` 13 | PersonEmail string `url:"personEmail,omitempty"` 14 | Max int `url:"max,omitempty"` 15 | } 16 | 17 | // MembershipRequest represents the Spark memberships 18 | type MembershipRequest struct { 19 | RoomID string `json:"roomId,omitempty"` 20 | PersonID string `json:"personId,omitempty"` 21 | PersonEmail string `json:"personEmail,omitempty"` 22 | IsModerator bool `json:"isModerator,omitempty"` 23 | } 24 | 25 | // UpdateMembershipRequest represents the Spark memberships 26 | type UpdateMembershipRequest struct { 27 | IsModerator bool `json:"isModerator,omitempty"` 28 | } 29 | 30 | // Membership ... 31 | type Membership struct { 32 | ID string `json:"id,omitempty"` 33 | RoomID string `json:"roomId,omitempty"` 34 | PersonID string `json:"personId,omitempty"` 35 | PersonEmail string `json:"personEmail,omitempty"` 36 | Created string `json:"created,omitempty"` 37 | IsModerator bool `json:"isModerator,omitempty"` 38 | IsMonitor bool `json:"isMonitor,omitempty"` 39 | } 40 | 41 | type membershipsRoot struct { 42 | Memberships []*Membership `json:"items"` 43 | } 44 | 45 | func (r Membership) String() string { 46 | return Stringify(r) 47 | } 48 | 49 | func (r MembershipRequest) String() string { 50 | return Stringify(r) 51 | } 52 | 53 | // Get .... 54 | func (s *MembershipsService) Get(queryParams *MembershipQueryParams) ([]*Membership, *Response, error) { 55 | path := membershipsBasePath 56 | path, err := addOptions(path, queryParams) 57 | if err != nil { 58 | return nil, nil, err 59 | } 60 | 61 | req, err := s.client.NewRequest("GET", path, nil) 62 | if err != nil { 63 | return nil, nil, err 64 | } 65 | 66 | root := new(membershipsRoot) 67 | resp, err := s.client.Do(req, root) 68 | if err != nil { 69 | return nil, resp, err 70 | } 71 | 72 | return root.Memberships, resp, err 73 | 74 | } 75 | 76 | // Post .... 77 | func (s *MembershipsService) Post(membershipRequest *MembershipRequest) (*Membership, *Response, error) { 78 | path := membershipsBasePath 79 | 80 | req, err := s.client.NewRequest("POST", path, membershipRequest) 81 | if err != nil { 82 | return nil, nil, err 83 | } 84 | 85 | response := new(Membership) 86 | resp, err := s.client.Do(req, response) 87 | if err != nil { 88 | return nil, resp, err 89 | } 90 | 91 | return response, resp, err 92 | } 93 | 94 | // GetMembership .... 95 | func (s *MembershipsService) GetMembership(membershipID string) (*Membership, *Response, error) { 96 | path := membershipsBasePath + "/" + membershipID 97 | 98 | req, err := s.client.NewRequest("GET", path, nil) 99 | if err != nil { 100 | return nil, nil, err 101 | } 102 | 103 | membership := new(Membership) 104 | resp, err := s.client.Do(req, membership) 105 | if err != nil { 106 | return nil, resp, err 107 | } 108 | 109 | return membership, resp, err 110 | } 111 | 112 | // UpdateMembership .... 113 | func (s *MembershipsService) UpdateMembership(membershipID string, updateMembershipRequest *UpdateMembershipRequest) (*Membership, *Response, error) { 114 | path := membershipsBasePath + "/" + membershipID 115 | 116 | req, err := s.client.NewRequest("PUT", path, updateMembershipRequest) 117 | if err != nil { 118 | return nil, nil, err 119 | } 120 | 121 | membership := new(Membership) 122 | resp, err := s.client.Do(req, membership) 123 | if err != nil { 124 | return nil, resp, err 125 | } 126 | 127 | return membership, resp, err 128 | } 129 | 130 | // DeleteMembership .... 131 | func (s *MembershipsService) DeleteMembership(membershipID string) (*Response, error) { 132 | path := membershipsBasePath + "/" + membershipID 133 | 134 | req, err := s.client.NewRequest("DELETE", path, nil) 135 | if err != nil { 136 | return nil, err 137 | } 138 | 139 | resp, err := s.client.Do(req, nil) 140 | if err != nil { 141 | return resp, err 142 | } 143 | 144 | return resp, err 145 | } 146 | -------------------------------------------------------------------------------- /ciscospark/messages.go: -------------------------------------------------------------------------------- 1 | package ciscospark 2 | 3 | const messagesBasePath = "v1/messages" 4 | 5 | // MessagesService handles communication with the Messages related methods of 6 | // the Cisco Spark API. 7 | type MessagesService service 8 | 9 | // MessageQueryParams ... 10 | type MessageQueryParams struct { 11 | RoomID string `url:"roomId,omitempty"` 12 | Before string `url:"before,omitempty"` 13 | BeforeMessage string `url:"beforeMessage,omitempty"` 14 | Max int `url:"max,omitempty"` 15 | MentionedPeople string `url:"mentionedPeople,omitempty"` 16 | } 17 | 18 | // MessageRequest represents the Spark messages 19 | type MessageRequest struct { 20 | RoomID string `json:"roomId,omitempty"` 21 | Text string `json:"text,omitempty"` 22 | Files []string `json:"files,omitempty"` 23 | ToPersonID string `json:"toPersonId,omitempty"` 24 | ToPersonEmail string `json:"toPersonEmail,omitempty"` 25 | MarkDown string `json:"markdown,omitempty"` 26 | } 27 | 28 | // Message ... 29 | type Message struct { 30 | ID string `json:"id,omitempty"` 31 | RoomID string `json:"roomId,omitempty"` 32 | ToPersonEmail string `json:"toPersonEmail,omitempty"` 33 | ToPersonID string `json:"toPersonId,omitempty"` 34 | Text string `json:"text,omitempty"` 35 | PersonID string `json:"personId,omitempty"` 36 | PersonEmail string `json:"personEmail,omitempty"` 37 | Created string `json:"created,omitempty"` 38 | MarkDown string `json:"markdown,omitempty"` 39 | Files []string `json:"files,omitempty"` 40 | RoomType string `json:"roomType,omitempty"` 41 | MentionedPeople []string `json:"mentionedPeople,omitempty"` 42 | } 43 | 44 | type messagesRoot struct { 45 | Messages []*Message `json:"items"` 46 | } 47 | 48 | func (r Message) String() string { 49 | return Stringify(r) 50 | } 51 | 52 | func (r MessageRequest) String() string { 53 | return Stringify(r) 54 | } 55 | 56 | // Get .... 57 | func (s *MessagesService) Get(queryParams *MessageQueryParams) ([]*Message, *Response, error) { 58 | path := messagesBasePath 59 | path, err := addOptions(path, queryParams) 60 | if err != nil { 61 | return nil, nil, err 62 | } 63 | 64 | req, err := s.client.NewRequest("GET", path, nil) 65 | if err != nil { 66 | return nil, nil, err 67 | } 68 | 69 | root := new(messagesRoot) 70 | resp, err := s.client.Do(req, root) 71 | if err != nil { 72 | return nil, resp, err 73 | } 74 | 75 | return root.Messages, resp, err 76 | 77 | } 78 | 79 | // Post .... 80 | func (s *MessagesService) Post(messageRequest *MessageRequest) (*Message, *Response, error) { 81 | path := messagesBasePath 82 | 83 | req, err := s.client.NewRequest("POST", path, messageRequest) 84 | if err != nil { 85 | return nil, nil, err 86 | } 87 | 88 | response := new(Message) 89 | resp, err := s.client.Do(req, response) 90 | if err != nil { 91 | return nil, resp, err 92 | } 93 | 94 | return response, resp, err 95 | } 96 | 97 | // GetMessage .... 98 | func (s *MessagesService) GetMessage(messageID string) (*Message, *Response, error) { 99 | path := messagesBasePath + "/" + messageID 100 | 101 | req, err := s.client.NewRequest("GET", path, nil) 102 | if err != nil { 103 | return nil, nil, err 104 | } 105 | 106 | message := new(Message) 107 | resp, err := s.client.Do(req, message) 108 | if err != nil { 109 | return nil, resp, err 110 | } 111 | 112 | return message, resp, err 113 | } 114 | 115 | // DeleteMessage .... 116 | func (s *MessagesService) DeleteMessage(messageID string) (*Response, error) { 117 | path := messagesBasePath + "/" + messageID 118 | 119 | req, err := s.client.NewRequest("DELETE", path, nil) 120 | if err != nil { 121 | return nil, err 122 | } 123 | 124 | resp, err := s.client.Do(req, nil) 125 | if err != nil { 126 | return resp, err 127 | } 128 | 129 | return resp, err 130 | } 131 | -------------------------------------------------------------------------------- /ciscospark/organizations.go: -------------------------------------------------------------------------------- 1 | package ciscospark 2 | 3 | const organizationsBasePath = "v1/organizations" 4 | 5 | // organizationsService is an interface for interfacing with the organizations 6 | // endpoints of the Cisco Spark API 7 | type OrganizationsService service 8 | 9 | // GetOrganizationsQueryParams ... 10 | type GetOrganizationsQueryParams struct { 11 | Max int `url:"max,omitempty"` 12 | } 13 | 14 | // Organization represents the Spark organizations 15 | type Organization struct { 16 | ID string `json:"id,omitempty"` 17 | DisplayName string `json:"displayName,omitempty"` 18 | Created string `json:"created,omitempty"` 19 | } 20 | 21 | type organizationsRoot struct { 22 | Organizations []*Organization `json:"items"` 23 | } 24 | 25 | func (r Organization) String() string { 26 | return Stringify(r) 27 | } 28 | 29 | // Get .... 30 | func (s *OrganizationsService) Get(queryParams *GetOrganizationsQueryParams) ([]*Organization, *Response, error) { 31 | path := organizationsBasePath 32 | path, err := addOptions(path, queryParams) 33 | if err != nil { 34 | return nil, nil, err 35 | } 36 | 37 | req, err := s.client.NewRequest("GET", path, nil) 38 | if err != nil { 39 | return nil, nil, err 40 | } 41 | 42 | root := new(organizationsRoot) 43 | resp, err := s.client.Do(req, root) 44 | if err != nil { 45 | return nil, resp, err 46 | } 47 | 48 | return root.Organizations, resp, err 49 | } 50 | 51 | // GetOrganization .... 52 | func (s *OrganizationsService) GetOrganization(OrganizationID string) (*Organization, *Response, error) { 53 | path := organizationsBasePath + "/" + OrganizationID 54 | 55 | req, err := s.client.NewRequest("GET", path, nil) 56 | if err != nil { 57 | return nil, nil, err 58 | } 59 | 60 | Organization := new(Organization) 61 | resp, err := s.client.Do(req, Organization) 62 | if err != nil { 63 | return nil, resp, err 64 | } 65 | 66 | return Organization, resp, err 67 | } 68 | -------------------------------------------------------------------------------- /ciscospark/people.go: -------------------------------------------------------------------------------- 1 | package ciscospark 2 | 3 | const peopleBasePath = "v1/people" 4 | 5 | // PeopleService is an interface for interfacing with the People 6 | // endpoints of the Cisco Spark API 7 | type PeopleService service 8 | 9 | // GetPeopleQueryParams ... 10 | type GetPeopleQueryParams struct { 11 | Email string `url:"email,omitempty"` 12 | DisplayName string `url:"displayName,omitempty"` 13 | Max int `url:"max,omitempty"` 14 | } 15 | 16 | // Person represents the Spark people 17 | type Person struct { 18 | ID string `json:"id,omitempty"` 19 | Emails []string `json:"emails,omitempty"` 20 | DisplayName string `json:"displayName,omitempty"` 21 | FirstName string `json:"firstName,omitempty"` 22 | LastName string `json:"lastName,omitempty"` 23 | Avatar string `json:"avatar,omitempty"` 24 | Created string `json:"created,omitempty"` 25 | OrgID string `json:"orgId,omitempty"` 26 | Roles []string `json:"roles,omitempty"` 27 | Licenses []string `json:"licenses,omitempty"` 28 | TimeZone string `json:"timezone,omitempty"` 29 | Status string `json:"status,omitempty"` 30 | NickName string `json:"nickName,omitempty"` 31 | Type string `json:"type,omitempty"` 32 | } 33 | 34 | type peopleRoot struct { 35 | People []*Person `json:"items"` 36 | } 37 | 38 | func (r Person) String() string { 39 | return Stringify(r) 40 | } 41 | 42 | // Get .... 43 | func (s *PeopleService) Get(queryParams *GetPeopleQueryParams) ([]*Person, *Response, error) { 44 | path := peopleBasePath 45 | path, err := addOptions(path, queryParams) 46 | if err != nil { 47 | return nil, nil, err 48 | } 49 | 50 | req, err := s.client.NewRequest("GET", path, nil) 51 | if err != nil { 52 | return nil, nil, err 53 | } 54 | 55 | root := new(peopleRoot) 56 | resp, err := s.client.Do(req, root) 57 | if err != nil { 58 | return nil, resp, err 59 | } 60 | 61 | return root.People, resp, err 62 | } 63 | 64 | // GetPerson .... 65 | func (s *PeopleService) GetPerson(personID string) (*Person, *Response, error) { 66 | path := peopleBasePath + "/" + personID 67 | 68 | req, err := s.client.NewRequest("GET", path, nil) 69 | if err != nil { 70 | return nil, nil, err 71 | } 72 | 73 | person := new(Person) 74 | resp, err := s.client.Do(req, person) 75 | if err != nil { 76 | return nil, resp, err 77 | } 78 | 79 | return person, resp, err 80 | } 81 | 82 | // GetMe .... 83 | func (s *PeopleService) GetMe() (*Person, *Response, error) { 84 | path := peopleBasePath + "/me" 85 | 86 | req, err := s.client.NewRequest("GET", path, nil) 87 | if err != nil { 88 | return nil, nil, err 89 | } 90 | 91 | person := new(Person) 92 | resp, err := s.client.Do(req, person) 93 | if err != nil { 94 | return nil, resp, err 95 | } 96 | 97 | return person, resp, err 98 | } 99 | -------------------------------------------------------------------------------- /ciscospark/roles.go: -------------------------------------------------------------------------------- 1 | package ciscospark 2 | 3 | const rolesBasePath = "v1/roles" 4 | 5 | // rolesService is an interface for interfacing with the roles 6 | // endpoints of the Cisco Spark API 7 | type RolesService service 8 | 9 | // GetRolesQueryParams ... 10 | type GetRolesQueryParams struct { 11 | Max int `url:"max,omitempty"` 12 | } 13 | 14 | // Role represents the Spark roles 15 | type Role struct { 16 | ID string `json:"id,omitempty"` 17 | Name string `json:"name,omitempty"` 18 | } 19 | 20 | type rolesRoot struct { 21 | Roles []*Role `json:"items"` 22 | } 23 | 24 | func (r Role) String() string { 25 | return Stringify(r) 26 | } 27 | 28 | // Get .... 29 | func (s *RolesService) Get(queryParams *GetRolesQueryParams) ([]*Role, *Response, error) { 30 | path := rolesBasePath 31 | path, err := addOptions(path, queryParams) 32 | if err != nil { 33 | return nil, nil, err 34 | } 35 | 36 | req, err := s.client.NewRequest("GET", path, nil) 37 | if err != nil { 38 | return nil, nil, err 39 | } 40 | 41 | root := new(rolesRoot) 42 | resp, err := s.client.Do(req, root) 43 | if err != nil { 44 | return nil, resp, err 45 | } 46 | 47 | return root.Roles, resp, err 48 | } 49 | 50 | // GetRole .... 51 | func (s *RolesService) GetRole(RoleID string) (*Role, *Response, error) { 52 | path := rolesBasePath + "/" + RoleID 53 | 54 | req, err := s.client.NewRequest("GET", path, nil) 55 | if err != nil { 56 | return nil, nil, err 57 | } 58 | 59 | Role := new(Role) 60 | resp, err := s.client.Do(req, Role) 61 | if err != nil { 62 | return nil, resp, err 63 | } 64 | 65 | return Role, resp, err 66 | } 67 | -------------------------------------------------------------------------------- /ciscospark/rooms.go: -------------------------------------------------------------------------------- 1 | package ciscospark 2 | 3 | const roomsBasePath = "v1/rooms" 4 | 5 | // RoomsService is an interface for interfacing with the Rooms 6 | // endpoints of the Cisco Spark API 7 | type RoomsService service 8 | 9 | // RoomQueryParams ... 10 | type RoomQueryParams struct { 11 | Max int `url:"max,omitempty"` 12 | TeamID string `url:"teamId,omitempty"` 13 | Type string `url:"type,omitempty"` 14 | } 15 | 16 | // RoomRequest represents the Spark rooms 17 | type RoomRequest struct { 18 | TeamID string `json:"teamId,omitempty"` 19 | Title string `json:"title,omitempty"` 20 | } 21 | 22 | // UpdateRoomRequest represents the Spark rooms 23 | type UpdateRoomRequest struct { 24 | Title string `json:"title,omitempty"` 25 | } 26 | 27 | // Room ... 28 | type Room struct { 29 | ID string `json:"id,omitempty"` 30 | Title string `json:"title,omitempty"` 31 | Type string `json:"type,omitempty"` 32 | IsLocked bool `json:"isLocked,omitempty"` 33 | TeamID string `json:"teamId,omitempty"` 34 | LastActivity string `json:"lastActivity,omitempty"` 35 | Created string `json:"created,omitempty"` 36 | } 37 | 38 | type roomsRoot struct { 39 | Rooms []*Room `json:"items"` 40 | } 41 | 42 | func (r Room) String() string { 43 | return Stringify(r) 44 | } 45 | 46 | func (r RoomRequest) String() string { 47 | return Stringify(r) 48 | } 49 | 50 | // Get .... 51 | func (s *RoomsService) Get(queryParams *RoomQueryParams) ([]*Room, *Response, error) { 52 | path := roomsBasePath 53 | path, err := addOptions(path, queryParams) 54 | if err != nil { 55 | return nil, nil, err 56 | } 57 | 58 | req, err := s.client.NewRequest("GET", path, nil) 59 | if err != nil { 60 | return nil, nil, err 61 | } 62 | 63 | root := new(roomsRoot) 64 | resp, err := s.client.Do(req, root) 65 | if err != nil { 66 | return nil, resp, err 67 | } 68 | 69 | return root.Rooms, resp, err 70 | 71 | } 72 | 73 | // Post .... 74 | func (s *RoomsService) Post(roomRequest *RoomRequest) (*Room, *Response, error) { 75 | path := roomsBasePath 76 | 77 | req, err := s.client.NewRequest("POST", path, roomRequest) 78 | if err != nil { 79 | return nil, nil, err 80 | } 81 | 82 | response := new(Room) 83 | resp, err := s.client.Do(req, response) 84 | if err != nil { 85 | return nil, resp, err 86 | } 87 | 88 | return response, resp, err 89 | } 90 | 91 | // GetRoom .... 92 | func (s *RoomsService) GetRoom(roomID string) (*Room, *Response, error) { 93 | path := roomsBasePath + "/" + roomID 94 | 95 | req, err := s.client.NewRequest("GET", path, nil) 96 | if err != nil { 97 | return nil, nil, err 98 | } 99 | 100 | room := new(Room) 101 | resp, err := s.client.Do(req, room) 102 | if err != nil { 103 | return nil, resp, err 104 | } 105 | 106 | return room, resp, err 107 | } 108 | 109 | // UpdateRoom .... 110 | func (s *RoomsService) UpdateRoom(roomID string, updateRoomRequest *UpdateRoomRequest) (*Room, *Response, error) { 111 | path := roomsBasePath + "/" + roomID 112 | 113 | req, err := s.client.NewRequest("PUT", path, updateRoomRequest) 114 | if err != nil { 115 | return nil, nil, err 116 | } 117 | 118 | room := new(Room) 119 | resp, err := s.client.Do(req, room) 120 | if err != nil { 121 | return nil, resp, err 122 | } 123 | 124 | return room, resp, err 125 | } 126 | 127 | // DeleteRoom .... 128 | func (s *RoomsService) DeleteRoom(roomID string) (*Response, error) { 129 | path := roomsBasePath + "/" + roomID 130 | 131 | req, err := s.client.NewRequest("DELETE", path, nil) 132 | if err != nil { 133 | return nil, err 134 | } 135 | 136 | resp, err := s.client.Do(req, nil) 137 | if err != nil { 138 | return resp, err 139 | } 140 | 141 | return resp, err 142 | } 143 | -------------------------------------------------------------------------------- /ciscospark/strings.go: -------------------------------------------------------------------------------- 1 | package ciscospark 2 | 3 | import ( 4 | "bytes" 5 | "fmt" 6 | "reflect" 7 | ) 8 | 9 | var timestampType = reflect.TypeOf(Timestamp{}) 10 | 11 | // Stringify attempts to create a string representation of Cisco APIC-EM types 12 | func Stringify(message interface{}) string { 13 | var buf bytes.Buffer 14 | v := reflect.ValueOf(message) 15 | stringifyValue(&buf, v) 16 | return buf.String() 17 | } 18 | 19 | // stringifyValue was graciously cargoculted from the goprotubuf library 20 | func stringifyValue(w *bytes.Buffer, val reflect.Value) { 21 | if val.Kind() == reflect.Ptr && val.IsNil() { 22 | _, _ = w.Write([]byte("")) 23 | return 24 | } 25 | 26 | v := reflect.Indirect(val) 27 | 28 | switch v.Kind() { 29 | case reflect.String: 30 | fmt.Fprintf(w, `"%s"`, v) 31 | case reflect.Slice: 32 | _, _ = w.Write([]byte{'['}) 33 | for i := 0; i < v.Len(); i++ { 34 | if i > 0 { 35 | _, _ = w.Write([]byte{' '}) 36 | } 37 | 38 | stringifyValue(w, v.Index(i)) 39 | } 40 | 41 | _, _ = w.Write([]byte{']'}) 42 | return 43 | case reflect.Struct: 44 | if v.Type().Name() != "" { 45 | _, _ = w.Write([]byte(v.Type().String())) 46 | } 47 | 48 | // special handling of Timestamp values 49 | if v.Type() == timestampType { 50 | fmt.Fprintf(w, "{%s}", v.Interface()) 51 | return 52 | } 53 | 54 | _, _ = w.Write([]byte{'{'}) 55 | 56 | var sep bool 57 | for i := 0; i < v.NumField(); i++ { 58 | fv := v.Field(i) 59 | if fv.Kind() == reflect.Ptr && fv.IsNil() { 60 | continue 61 | } 62 | if fv.Kind() == reflect.Slice && fv.IsNil() { 63 | continue 64 | } 65 | 66 | if sep { 67 | _, _ = w.Write([]byte(", ")) 68 | } else { 69 | sep = true 70 | } 71 | 72 | _, _ = w.Write([]byte(v.Type().Field(i).Name)) 73 | _, _ = w.Write([]byte{':'}) 74 | stringifyValue(w, fv) 75 | } 76 | 77 | _, _ = w.Write([]byte{'}'}) 78 | default: 79 | if v.CanInterface() { 80 | fmt.Fprint(w, v.Interface()) 81 | } 82 | } 83 | } 84 | -------------------------------------------------------------------------------- /ciscospark/team-memberships.go: -------------------------------------------------------------------------------- 1 | package ciscospark 2 | 3 | const teamMembershipsBasePath = "v1/team/memberships" 4 | 5 | // TeamMembershipsService is an interface for interfacing with the TeamMemberships 6 | // endpoints of the Cisco Spark API 7 | type TeamMembershipsService service 8 | 9 | // TeamMembershipQueryParams ... 10 | type TeamMembershipQueryParams struct { 11 | Max int `url:"max,omitempty"` 12 | TeamID string `url:"teamId,omitempty"` 13 | } 14 | 15 | // TeamMembershipRequest represents the Spark teamMemberships 16 | type TeamMembershipRequest struct { 17 | TeamID string `json:"teamId,omitempty"` 18 | PersonID string `json:"personId,omitempty"` 19 | PersonEmail string `json:"personEmail,omitempty"` 20 | IsModerator bool `json:"isModerator,omitempty"` 21 | } 22 | 23 | // UpdateTeamMembershipRequest represents the Spark teamMemberships 24 | type UpdateTeamMembershipRequest struct { 25 | IsModerator bool `json:"isModerator,omitempty"` 26 | } 27 | 28 | // TeamMembership ... 29 | type TeamMembership struct { 30 | ID string `json:"id,omitempty"` 31 | TeamID string `json:"teamId,omitempty"` 32 | PersonID string `json:"personId,omitempty"` 33 | PersonEmail string `json:"personEmail,omitempty"` 34 | IsModerator bool `json:"isModerator,omitempty"` 35 | Created string `json:"created,omitempty"` 36 | } 37 | 38 | type teamMembershipsRoot struct { 39 | TeamMemberships []*TeamMembership `json:"items"` 40 | } 41 | 42 | func (r TeamMembership) String() string { 43 | return Stringify(r) 44 | } 45 | 46 | func (r TeamMembershipRequest) String() string { 47 | return Stringify(r) 48 | } 49 | 50 | // Get .... 51 | func (s *TeamMembershipsService) Get(queryParams *TeamMembershipQueryParams) ([]*TeamMembership, *Response, error) { 52 | path := teamMembershipsBasePath 53 | path, err := addOptions(path, queryParams) 54 | if err != nil { 55 | return nil, nil, err 56 | } 57 | 58 | req, err := s.client.NewRequest("GET", path, nil) 59 | if err != nil { 60 | return nil, nil, err 61 | } 62 | 63 | root := new(teamMembershipsRoot) 64 | resp, err := s.client.Do(req, root) 65 | if err != nil { 66 | return nil, resp, err 67 | } 68 | 69 | return root.TeamMemberships, resp, err 70 | 71 | } 72 | 73 | // Post .... 74 | func (s *TeamMembershipsService) Post(teamRequest *TeamMembershipRequest) (*TeamMembership, *Response, error) { 75 | path := teamMembershipsBasePath 76 | 77 | req, err := s.client.NewRequest("POST", path, teamRequest) 78 | if err != nil { 79 | return nil, nil, err 80 | } 81 | 82 | response := new(TeamMembership) 83 | resp, err := s.client.Do(req, response) 84 | if err != nil { 85 | return nil, resp, err 86 | } 87 | 88 | return response, resp, err 89 | } 90 | 91 | // GetTeamMembership .... 92 | func (s *TeamMembershipsService) GetTeamMembership(teamID string) (*TeamMembership, *Response, error) { 93 | path := teamMembershipsBasePath + "/" + teamID 94 | 95 | req, err := s.client.NewRequest("GET", path, nil) 96 | if err != nil { 97 | return nil, nil, err 98 | } 99 | 100 | team := new(TeamMembership) 101 | resp, err := s.client.Do(req, team) 102 | if err != nil { 103 | return nil, resp, err 104 | } 105 | 106 | return team, resp, err 107 | } 108 | 109 | // UpdateTeamMembership .... 110 | func (s *TeamMembershipsService) UpdateTeamMembership(teamID string, updateTeamMembershipRequest *UpdateTeamMembershipRequest) (*TeamMembership, *Response, error) { 111 | path := teamMembershipsBasePath + "/" + teamID 112 | 113 | req, err := s.client.NewRequest("PUT", path, updateTeamMembershipRequest) 114 | if err != nil { 115 | return nil, nil, err 116 | } 117 | 118 | team := new(TeamMembership) 119 | resp, err := s.client.Do(req, team) 120 | if err != nil { 121 | return nil, resp, err 122 | } 123 | 124 | return team, resp, err 125 | } 126 | 127 | // DeleteTeamMembership .... 128 | func (s *TeamMembershipsService) DeleteTeamMembership(teamID string) (*Response, error) { 129 | path := teamMembershipsBasePath + "/" + teamID 130 | 131 | req, err := s.client.NewRequest("DELETE", path, nil) 132 | if err != nil { 133 | return nil, err 134 | } 135 | 136 | resp, err := s.client.Do(req, nil) 137 | if err != nil { 138 | return resp, err 139 | } 140 | 141 | return resp, err 142 | } 143 | -------------------------------------------------------------------------------- /ciscospark/teams.go: -------------------------------------------------------------------------------- 1 | package ciscospark 2 | 3 | const teamsBasePath = "v1/teams" 4 | 5 | // TeamsService is an interface for interfacing with the Teams 6 | // endpoints of the Cisco Spark API 7 | type TeamsService service 8 | 9 | // TeamQueryParams ... 10 | type TeamQueryParams struct { 11 | Max int `url:"max,omitempty"` 12 | } 13 | 14 | // TeamRequest represents the Spark teams 15 | type TeamRequest struct { 16 | Name string `json:"name,omitempty"` 17 | } 18 | 19 | // UpdateTeamRequest represents the Spark teams 20 | type UpdateTeamRequest struct { 21 | Name string `json:"name,omitempty"` 22 | } 23 | 24 | // Team ... 25 | type Team struct { 26 | ID string `json:"id,omitempty"` 27 | Name string `json:"name,omitempty"` 28 | Created string `json:"created,omitempty"` 29 | } 30 | 31 | type teamsRoot struct { 32 | Teams []*Team `json:"items"` 33 | } 34 | 35 | func (r Team) String() string { 36 | return Stringify(r) 37 | } 38 | 39 | func (r TeamRequest) String() string { 40 | return Stringify(r) 41 | } 42 | 43 | // Get .... 44 | func (s *TeamsService) Get(queryParams *TeamQueryParams) ([]*Team, *Response, error) { 45 | path := teamsBasePath 46 | path, err := addOptions(path, queryParams) 47 | if err != nil { 48 | return nil, nil, err 49 | } 50 | 51 | req, err := s.client.NewRequest("GET", path, nil) 52 | if err != nil { 53 | return nil, nil, err 54 | } 55 | 56 | root := new(teamsRoot) 57 | resp, err := s.client.Do(req, root) 58 | if err != nil { 59 | return nil, resp, err 60 | } 61 | 62 | return root.Teams, resp, err 63 | 64 | } 65 | 66 | // Post .... 67 | func (s *TeamsService) Post(teamRequest *TeamRequest) (*Team, *Response, error) { 68 | path := teamsBasePath 69 | 70 | req, err := s.client.NewRequest("POST", path, teamRequest) 71 | if err != nil { 72 | return nil, nil, err 73 | } 74 | 75 | response := new(Team) 76 | resp, err := s.client.Do(req, response) 77 | if err != nil { 78 | return nil, resp, err 79 | } 80 | 81 | return response, resp, err 82 | } 83 | 84 | // GetTeam .... 85 | func (s *TeamsService) GetTeam(teamID string) (*Team, *Response, error) { 86 | path := teamsBasePath + "/" + teamID 87 | 88 | req, err := s.client.NewRequest("GET", path, nil) 89 | if err != nil { 90 | return nil, nil, err 91 | } 92 | 93 | team := new(Team) 94 | resp, err := s.client.Do(req, team) 95 | if err != nil { 96 | return nil, resp, err 97 | } 98 | 99 | return team, resp, err 100 | } 101 | 102 | // UpdateTeam .... 103 | func (s *TeamsService) UpdateTeam(teamID string, updateTeamRequest *UpdateTeamRequest) (*Team, *Response, error) { 104 | path := teamsBasePath + "/" + teamID 105 | 106 | req, err := s.client.NewRequest("PUT", path, updateTeamRequest) 107 | if err != nil { 108 | return nil, nil, err 109 | } 110 | 111 | team := new(Team) 112 | resp, err := s.client.Do(req, team) 113 | if err != nil { 114 | return nil, resp, err 115 | } 116 | 117 | return team, resp, err 118 | } 119 | 120 | // DeleteTeam .... 121 | func (s *TeamsService) DeleteTeam(teamID string) (*Response, error) { 122 | path := teamsBasePath + "/" + teamID 123 | 124 | req, err := s.client.NewRequest("DELETE", path, nil) 125 | if err != nil { 126 | return nil, err 127 | } 128 | 129 | resp, err := s.client.Do(req, nil) 130 | if err != nil { 131 | return resp, err 132 | } 133 | 134 | return resp, err 135 | } 136 | -------------------------------------------------------------------------------- /ciscospark/timestamp.go: -------------------------------------------------------------------------------- 1 | package ciscospark 2 | 3 | import ( 4 | "strconv" 5 | "time" 6 | ) 7 | 8 | // Timestamp represents a time that can be unmarshalled from a JSON string 9 | // formatted as either an RFC3339 or Unix timestamp. All 10 | // exported methods of time.Time can be called on Timestamp. 11 | type Timestamp struct { 12 | time.Time 13 | } 14 | 15 | func (t Timestamp) String() string { 16 | return t.Time.String() 17 | } 18 | 19 | // UnmarshalJSON implements the json.Unmarshaler interface. 20 | // Time is expected in RFC3339 or Unix format. 21 | func (t *Timestamp) UnmarshalJSON(data []byte) error { 22 | str := string(data) 23 | i, err := strconv.ParseInt(str, 10, 64) 24 | if err == nil { 25 | t.Time = time.Unix(i, 0) 26 | } else { 27 | t.Time, err = time.Parse(`"`+time.RFC3339+`"`, str) 28 | } 29 | return err 30 | } 31 | 32 | // Equal reports whether t and u are equal based on time.Equal 33 | func (t Timestamp) Equal(u Timestamp) bool { 34 | return t.Time.Equal(u.Time) 35 | } 36 | -------------------------------------------------------------------------------- /ciscospark/webhooks.go: -------------------------------------------------------------------------------- 1 | package ciscospark 2 | 3 | const webhooksBasePath = "v1/webhooks" 4 | 5 | // WebhooksService is an interface for interfacing with the Webhooks 6 | // endpoints of the Cisco Spark API 7 | type WebhooksService service 8 | 9 | // WebhookQueryParams ... 10 | type WebhookQueryParams struct { 11 | Max int `url:"max,omitempty"` 12 | } 13 | 14 | // WebhookRequest represents the Spark webhooks 15 | type WebhookRequest struct { 16 | Name string `json:"name,omitempty"` 17 | TargetURL string `json:"targetUrl,omitempty"` 18 | Resource string `json:"resource,omitempty"` 19 | Event string `json:"event,omitempty"` 20 | Filter string `json:"filter,omitempty"` 21 | } 22 | 23 | // UpdateWebhookRequest represents the Spark webhooks 24 | type UpdateWebhookRequest struct { 25 | Name string `json:"name,omitempty"` 26 | TargetURL string `json:"targetUrl,omitempty"` 27 | } 28 | 29 | // Webhook ... 30 | type Webhook struct { 31 | ID string `json:"id,omitempty"` 32 | Name string `json:"name,omitempty"` 33 | TargetURL string `json:"targetUrl,omitempty"` 34 | Resource string `json:"resource,omitempty"` 35 | Event string `json:"event,omitempty"` 36 | Filter string `json:"filter,omitempty"` 37 | Created string `json:"created,omitempty"` 38 | } 39 | 40 | type webhooksRoot struct { 41 | Webhooks []*Webhook `json:"items"` 42 | } 43 | 44 | func (r Webhook) String() string { 45 | return Stringify(r) 46 | } 47 | 48 | func (r WebhookRequest) String() string { 49 | return Stringify(r) 50 | } 51 | 52 | // Get .... 53 | func (s *WebhooksService) Get(queryParams *WebhookQueryParams) ([]*Webhook, *Response, error) { 54 | path := webhooksBasePath 55 | path, err := addOptions(path, queryParams) 56 | if err != nil { 57 | return nil, nil, err 58 | } 59 | 60 | req, err := s.client.NewRequest("GET", path, nil) 61 | if err != nil { 62 | return nil, nil, err 63 | } 64 | 65 | root := new(webhooksRoot) 66 | resp, err := s.client.Do(req, root) 67 | if err != nil { 68 | return nil, resp, err 69 | } 70 | 71 | return root.Webhooks, resp, err 72 | 73 | } 74 | 75 | // Post .... 76 | func (s *WebhooksService) Post(webhookRequest *WebhookRequest) (*Webhook, *Response, error) { 77 | path := webhooksBasePath 78 | 79 | req, err := s.client.NewRequest("POST", path, webhookRequest) 80 | if err != nil { 81 | return nil, nil, err 82 | } 83 | 84 | response := new(Webhook) 85 | resp, err := s.client.Do(req, response) 86 | if err != nil { 87 | return nil, resp, err 88 | } 89 | 90 | return response, resp, err 91 | } 92 | 93 | // GetWebhook .... 94 | func (s *WebhooksService) GetWebhook(webhookID string) (*Webhook, *Response, error) { 95 | path := webhooksBasePath + "/" + webhookID 96 | 97 | req, err := s.client.NewRequest("GET", path, nil) 98 | if err != nil { 99 | return nil, nil, err 100 | } 101 | 102 | webhook := new(Webhook) 103 | resp, err := s.client.Do(req, webhook) 104 | if err != nil { 105 | return nil, resp, err 106 | } 107 | 108 | return webhook, resp, err 109 | } 110 | 111 | // UpdateWebhook .... 112 | func (s *WebhooksService) UpdateWebhook(webhookID string, updateWebhookRequest *UpdateWebhookRequest) (*Webhook, *Response, error) { 113 | path := webhooksBasePath + "/" + webhookID 114 | 115 | req, err := s.client.NewRequest("PUT", path, updateWebhookRequest) 116 | if err != nil { 117 | return nil, nil, err 118 | } 119 | 120 | webhook := new(Webhook) 121 | resp, err := s.client.Do(req, webhook) 122 | if err != nil { 123 | return nil, resp, err 124 | } 125 | 126 | return webhook, resp, err 127 | } 128 | 129 | // DeleteWebhook .... 130 | func (s *WebhooksService) DeleteWebhook(webhookID string) (*Response, error) { 131 | path := webhooksBasePath + "/" + webhookID 132 | 133 | req, err := s.client.NewRequest("DELETE", path, nil) 134 | if err != nil { 135 | return nil, err 136 | } 137 | 138 | resp, err := s.client.Do(req, nil) 139 | if err != nil { 140 | return resp, err 141 | } 142 | 143 | return resp, err 144 | } 145 | -------------------------------------------------------------------------------- /examples/licenses/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "crypto/tls" 5 | "fmt" 6 | "log" 7 | "net/http" 8 | 9 | "github.com/jbogarin/go-cisco-spark/ciscospark" 10 | ) 11 | 12 | func main() { 13 | tr := &http.Transport{ 14 | TLSClientConfig: &tls.Config{InsecureSkipVerify: true}, 15 | } 16 | client := &http.Client{Transport: tr} 17 | sparkClient := ciscospark.NewClient(client) 18 | token := "" // Change to your token 19 | sparkClient.Authorization = "Bearer " + token 20 | 21 | /* 22 | 23 | Licenses 24 | 25 | */ 26 | 27 | // GET Licenses 28 | queryParams := &ciscospark.GetLicensesQueryParams{ 29 | Max: 2, 30 | } 31 | 32 | Licenses, _, err := sparkClient.Licenses.Get(queryParams) 33 | if err != nil { 34 | log.Fatal(err) 35 | } 36 | 37 | LicenseID := "" 38 | for id, License := range Licenses { 39 | fmt.Println("GET:", id, License.ID, License.Name, License.TotalUnits, License.ConsumedUnits) 40 | LicenseID = License.ID 41 | } 42 | 43 | // GET Licenses/ 44 | License, _, err := sparkClient.Licenses.GetLicense(LicenseID) 45 | if err != nil { 46 | log.Fatal(err) 47 | } 48 | fmt.Println("GET :", License.ID, License.Name, License.TotalUnits, License.ConsumedUnits) 49 | 50 | } 51 | -------------------------------------------------------------------------------- /examples/memberships/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "crypto/tls" 5 | "fmt" 6 | "log" 7 | "net/http" 8 | 9 | "github.com/jbogarin/go-cisco-spark/ciscospark" 10 | ) 11 | 12 | func main() { 13 | tr := &http.Transport{ 14 | TLSClientConfig: &tls.Config{InsecureSkipVerify: true}, 15 | } 16 | client := &http.Client{Transport: tr} 17 | sparkClient := ciscospark.NewClient(client) 18 | token := "" // Change to your token 19 | sparkClient.Authorization = "Bearer " + token 20 | 21 | /* 22 | 23 | MEMBERSHIPS 24 | 25 | */ 26 | 27 | // This works if you create a room where you are a moderator (paid feature). I tested with a room that it is part of a team. 28 | 29 | myRoomID := "" // Change to your testing room 30 | myTestingEmail := "" // Change to your email 31 | 32 | // GET memberships 33 | 34 | membershipQueryParams := &ciscospark.MembershipQueryParams{ 35 | Max: 2, 36 | PersonEmail: myTestingEmail, 37 | } 38 | 39 | memberships, _, err := sparkClient.Memberships.Get(membershipQueryParams) 40 | if err != nil { 41 | log.Fatal(err) 42 | } 43 | for _, membership := range memberships { 44 | fmt.Println("GET:", membership.ID, membership.PersonEmail, membership.IsModerator, membership.Created) 45 | } 46 | 47 | // POST memberships 48 | 49 | membershipRequest := &ciscospark.MembershipRequest{ 50 | RoomID: myRoomID, 51 | PersonEmail: myTestingEmail, 52 | IsModerator: true, 53 | } 54 | 55 | testMembership, _, err := sparkClient.Memberships.Post(membershipRequest) 56 | if err != nil { 57 | log.Fatal(err) 58 | } 59 | 60 | fmt.Println("POST:", testMembership.ID, testMembership.PersonEmail, testMembership.IsModerator, testMembership.Created) 61 | 62 | // GET memberships/ 63 | 64 | membership, _, err := sparkClient.Memberships.GetMembership(testMembership.ID) 65 | if err != nil { 66 | log.Fatal(err) 67 | } 68 | 69 | fmt.Println("GET :", membership.ID, membership.PersonEmail, membership.IsModerator, membership.Created) 70 | 71 | // PUT memberships/ 72 | 73 | updateMembershipRequest := &ciscospark.UpdateMembershipRequest{ 74 | IsModerator: false, 75 | } 76 | 77 | updatedMembership, _, err := sparkClient.Memberships.UpdateMembership(testMembership.ID, updateMembershipRequest) 78 | if err != nil { 79 | log.Fatal(err) 80 | } 81 | 82 | fmt.Println("PUT:", updatedMembership.ID, updatedMembership.PersonEmail, updatedMembership.IsModerator, updatedMembership.Created) 83 | 84 | // DELETE memberships 85 | 86 | resp, err := sparkClient.Memberships.DeleteMembership(testMembership.ID) 87 | if err != nil { 88 | log.Fatal(err) 89 | } 90 | 91 | fmt.Println("DELETE:", resp.StatusCode) 92 | 93 | } 94 | -------------------------------------------------------------------------------- /examples/messages/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "crypto/tls" 5 | "fmt" 6 | "log" 7 | "net/http" 8 | 9 | "github.com/jbogarin/go-cisco-spark/ciscospark" 10 | ) 11 | 12 | func main() { 13 | tr := &http.Transport{ 14 | TLSClientConfig: &tls.Config{InsecureSkipVerify: true}, 15 | } 16 | client := &http.Client{Transport: tr} 17 | sparkClient := ciscospark.NewClient(client) 18 | token := "" // Change to your token 19 | sparkClient.Authorization = "Bearer " + token 20 | 21 | /* 22 | 23 | MESSAGES 24 | 25 | */ 26 | 27 | myRoomID := "" // Change to your testing room 28 | 29 | // POST messages - Text Message 30 | 31 | message := &ciscospark.MessageRequest{ 32 | Text: "This is a text message", 33 | RoomID: myRoomID, 34 | } 35 | newTextMessage, _, err := sparkClient.Messages.Post(message) 36 | if err != nil { 37 | log.Fatal(err) 38 | } 39 | fmt.Println("POST:", newTextMessage.ID, newTextMessage.Text, newTextMessage.Created) 40 | 41 | // POST messages - Markdown Message 42 | 43 | markDownMessage := &ciscospark.MessageRequest{ 44 | MarkDown: "This is a markdown message. *Italic*, **bold** and ***italic/bold***.", 45 | RoomID: myRoomID, 46 | } 47 | newMarkDownMessage, _, err := sparkClient.Messages.Post(markDownMessage) 48 | if err != nil { 49 | log.Fatal(err) 50 | } 51 | fmt.Println("POST:", newMarkDownMessage.ID, newMarkDownMessage.MarkDown, newMarkDownMessage.Created) 52 | 53 | // POST messages - Markdown Message 54 | 55 | htmlMessage := &ciscospark.MessageRequest{ 56 | MarkDown: "This is a html message with strong", 57 | RoomID: myRoomID, 58 | } 59 | newHTMLMessage, _, err := sparkClient.Messages.Post(htmlMessage) 60 | if err != nil { 61 | log.Fatal(err) 62 | } 63 | fmt.Println("POST:", newHTMLMessage.ID, newHTMLMessage.MarkDown, newHTMLMessage.Created) 64 | 65 | // GET messages 66 | messageQueryParams := &ciscospark.MessageQueryParams{ 67 | Max: 5, 68 | RoomID: myRoomID, 69 | } 70 | 71 | messages, _, err := sparkClient.Messages.Get(messageQueryParams) 72 | if err != nil { 73 | log.Fatal(err) 74 | } 75 | for id, message := range messages { 76 | fmt.Println("GET:", id, message.ID, message.Text, message.Created) 77 | } 78 | 79 | // GET messages/ 80 | 81 | htmlMessageGet, _, err := sparkClient.Messages.GetMessage(newHTMLMessage.ID) 82 | if err != nil { 83 | log.Fatal(err) 84 | } 85 | fmt.Println("GET :", htmlMessageGet.ID, htmlMessageGet.Text, htmlMessageGet.Created) 86 | 87 | // DELETE messages 88 | 89 | resp, err := sparkClient.Messages.DeleteMessage(newTextMessage.ID) 90 | if err != nil { 91 | log.Fatal(err) 92 | } 93 | fmt.Println("DELETE:", resp.StatusCode) 94 | 95 | } 96 | -------------------------------------------------------------------------------- /examples/organizations/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "crypto/tls" 5 | "fmt" 6 | "log" 7 | "net/http" 8 | 9 | "github.com/jbogarin/go-cisco-spark/ciscospark" 10 | ) 11 | 12 | func main() { 13 | tr := &http.Transport{ 14 | TLSClientConfig: &tls.Config{InsecureSkipVerify: true}, 15 | } 16 | client := &http.Client{Transport: tr} 17 | sparkClient := ciscospark.NewClient(client) 18 | token := "" // Change to your token 19 | sparkClient.Authorization = "Bearer " + token 20 | 21 | /* 22 | 23 | Organizations 24 | 25 | */ 26 | 27 | // GET Organizations 28 | queryParams := &ciscospark.GetOrganizationsQueryParams{ 29 | Max: 2, 30 | } 31 | 32 | Organizations, _, err := sparkClient.Organizations.Get(queryParams) 33 | if err != nil { 34 | log.Fatal(err) 35 | } 36 | 37 | OrganizationID := "" 38 | for id, Organization := range Organizations { 39 | fmt.Println("GET:", id, Organization.ID, Organization.DisplayName, Organization.Created) 40 | OrganizationID = Organization.ID 41 | } 42 | 43 | // GET Organizations/ 44 | Organization, _, err := sparkClient.Organizations.GetOrganization(OrganizationID) 45 | if err != nil { 46 | log.Fatal(err) 47 | } 48 | fmt.Println("GET :", Organization.ID, Organization.DisplayName, Organization.Created) 49 | 50 | } 51 | -------------------------------------------------------------------------------- /examples/people/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "crypto/tls" 5 | "fmt" 6 | "log" 7 | "net/http" 8 | 9 | "github.com/jbogarin/go-cisco-spark/ciscospark" 10 | ) 11 | 12 | func main() { 13 | tr := &http.Transport{ 14 | TLSClientConfig: &tls.Config{InsecureSkipVerify: true}, 15 | } 16 | client := &http.Client{Transport: tr} 17 | sparkClient := ciscospark.NewClient(client) 18 | token := "" // Change to your token 19 | sparkClient.Authorization = "Bearer " + token 20 | 21 | /* 22 | 23 | PEOPLE 24 | 25 | */ 26 | 27 | // GET people 28 | queryParams := &ciscospark.GetPeopleQueryParams{ 29 | DisplayName: "", // Change to the person you want to look for 30 | Max: 2, 31 | } 32 | 33 | people, _, err := sparkClient.People.Get(queryParams) 34 | if err != nil { 35 | log.Fatal(err) 36 | } 37 | 38 | personID := "" 39 | for id, person := range people { 40 | fmt.Println("GET:", id, person.ID, person.DisplayName, person.Created) 41 | personID = person.ID 42 | } 43 | 44 | // GET people/ 45 | person, _, err := sparkClient.People.GetPerson(personID) 46 | if err != nil { 47 | log.Fatal(err) 48 | } 49 | fmt.Println("GET :", person.ID, person.DisplayName, person.Created) 50 | 51 | // GET people/me 52 | me, _, err := sparkClient.People.GetMe() 53 | if err != nil { 54 | log.Fatal(err) 55 | } 56 | fmt.Println("GET ME:", me.ID, me.DisplayName, me.Created) 57 | 58 | } 59 | -------------------------------------------------------------------------------- /examples/roles/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "crypto/tls" 5 | "fmt" 6 | "log" 7 | "net/http" 8 | 9 | "github.com/jbogarin/go-cisco-spark/ciscospark" 10 | ) 11 | 12 | func main() { 13 | tr := &http.Transport{ 14 | TLSClientConfig: &tls.Config{InsecureSkipVerify: true}, 15 | } 16 | client := &http.Client{Transport: tr} 17 | sparkClient := ciscospark.NewClient(client) 18 | token := "" // Change to your token 19 | sparkClient.Authorization = "Bearer " + token 20 | 21 | /* 22 | 23 | Roles 24 | 25 | */ 26 | 27 | // GET Roles 28 | queryParams := &ciscospark.GetRolesQueryParams{ 29 | Max: 2, 30 | } 31 | 32 | Roles, _, err := sparkClient.Roles.Get(queryParams) 33 | if err != nil { 34 | log.Fatal(err) 35 | } 36 | 37 | RoleID := "" 38 | for id, Role := range Roles { 39 | fmt.Println("GET:", id, Role.ID, Role.Name) 40 | RoleID = Role.ID 41 | } 42 | 43 | // GET Roles/ 44 | Role, _, err := sparkClient.Roles.GetRole(RoleID) 45 | if err != nil { 46 | log.Fatal(err) 47 | } 48 | fmt.Println("GET :", Role.ID, Role.Name) 49 | 50 | } 51 | -------------------------------------------------------------------------------- /examples/rooms/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "crypto/tls" 5 | "fmt" 6 | "log" 7 | "net/http" 8 | 9 | "github.com/jbogarin/go-cisco-spark/ciscospark" 10 | ) 11 | 12 | func main() { 13 | tr := &http.Transport{ 14 | TLSClientConfig: &tls.Config{InsecureSkipVerify: true}, 15 | } 16 | client := &http.Client{Transport: tr} 17 | sparkClient := ciscospark.NewClient(client) 18 | token := "" // Change to your token 19 | sparkClient.Authorization = "Bearer " + token 20 | 21 | /* 22 | 23 | ROOMS 24 | 25 | */ 26 | 27 | // POST rooms 28 | roomRequest := &ciscospark.RoomRequest{ 29 | Title: "Go Test Room", 30 | } 31 | 32 | newRoom, _, err := sparkClient.Rooms.Post(roomRequest) 33 | if err != nil { 34 | log.Fatal(err) 35 | } 36 | 37 | fmt.Println("POST:", newRoom.ID, newRoom.Title, newRoom.IsLocked, newRoom.Created) 38 | 39 | // GET rooms 40 | roomsQueryParams := &ciscospark.RoomQueryParams{ 41 | Max: 2, 42 | Type: "group", 43 | } 44 | 45 | rooms, _, err := sparkClient.Rooms.Get(roomsQueryParams) 46 | if err != nil { 47 | log.Fatal(err) 48 | } 49 | for id, room := range rooms { 50 | fmt.Println("GET:", id, room.ID, room.IsLocked, room.Title) 51 | } 52 | 53 | // GET rooms/ 54 | room, _, err := sparkClient.Rooms.GetRoom(newRoom.ID) 55 | if err != nil { 56 | log.Fatal(err) 57 | } 58 | 59 | fmt.Println("GET :", room.ID, room.Title, room.IsLocked, room.Created) 60 | 61 | updateRoomRequest := &ciscospark.UpdateRoomRequest{ 62 | Title: "Go Test Room 2", 63 | } 64 | 65 | updatedRoom, _, err := sparkClient.Rooms.UpdateRoom(newRoom.ID, updateRoomRequest) 66 | if err != nil { 67 | log.Fatal(err) 68 | } 69 | 70 | fmt.Println("PUT:", updatedRoom.ID, updatedRoom.Title, updatedRoom.IsLocked, updatedRoom.Created) 71 | 72 | // DELETE 73 | resp, err := sparkClient.Rooms.DeleteRoom(newRoom.ID) 74 | if err != nil { 75 | log.Fatal(err) 76 | } 77 | 78 | fmt.Println("DELETE:", resp.StatusCode) 79 | } 80 | -------------------------------------------------------------------------------- /examples/team-memberships/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "crypto/tls" 5 | "fmt" 6 | "log" 7 | "net/http" 8 | 9 | "github.com/jbogarin/go-cisco-spark/ciscospark" 10 | ) 11 | 12 | func main() { 13 | tr := &http.Transport{ 14 | TLSClientConfig: &tls.Config{InsecureSkipVerify: true}, 15 | } 16 | client := &http.Client{Transport: tr} 17 | sparkClient := ciscospark.NewClient(client) 18 | token := "" // Change to your token 19 | sparkClient.Authorization = "Bearer " + token 20 | 21 | /* 22 | 23 | TEAM MEMBERSHIPS 24 | 25 | */ 26 | 27 | myTeamID := "" // Change to your test team 28 | newTeamMember := "" // Change to the person email you want to add to the team 29 | 30 | // POST team-memberships 31 | teamMembershipRequest := &ciscospark.TeamMembershipRequest{ 32 | TeamID: myTeamID, 33 | PersonEmail: newTeamMember, 34 | IsModerator: true, 35 | } 36 | 37 | newTeamMembership, _, err := sparkClient.TeamMemberships.Post(teamMembershipRequest) 38 | if err != nil { 39 | log.Fatal(err) 40 | } 41 | 42 | fmt.Println("POST:", newTeamMembership.ID, newTeamMembership.PersonEmail, newTeamMembership.IsModerator, newTeamMembership.Created) 43 | 44 | // GET team-memberships 45 | teamMembershipsQueryParams := &ciscospark.TeamMembershipQueryParams{ 46 | Max: 2, 47 | TeamID: myTeamID, 48 | } 49 | 50 | teamMemberships, _, err := sparkClient.TeamMemberships.Get(teamMembershipsQueryParams) 51 | if err != nil { 52 | log.Fatal(err) 53 | } 54 | for id, teamMembership := range teamMemberships { 55 | fmt.Println("GET:", id, teamMembership.ID, teamMembership.PersonEmail, teamMembership.IsModerator, teamMembership.Created) 56 | } 57 | 58 | // GET team-memberships/ 59 | teamMembership, _, err := sparkClient.TeamMemberships.GetTeamMembership(newTeamMembership.ID) 60 | if err != nil { 61 | log.Fatal(err) 62 | } 63 | 64 | fmt.Println("GET :", teamMembership.ID, teamMembership.PersonEmail, teamMembership.IsModerator, teamMembership.Created) 65 | 66 | // PUT team-memberships/ 67 | updateTeamMembershipRequest := &ciscospark.UpdateTeamMembershipRequest{ 68 | IsModerator: false, 69 | } 70 | 71 | updatedTeamMembership, _, err := sparkClient.TeamMemberships.UpdateTeamMembership(newTeamMembership.ID, updateTeamMembershipRequest) 72 | if err != nil { 73 | log.Fatal(err) 74 | } 75 | 76 | fmt.Println(updatedTeamMembership.ID, updatedTeamMembership.PersonEmail, updatedTeamMembership.IsModerator, updatedTeamMembership.Created) 77 | 78 | // DELETE team-memberships/ 79 | resp, err := sparkClient.TeamMemberships.DeleteTeamMembership(newTeamMembership.ID) 80 | if err != nil { 81 | log.Fatal(err) 82 | } 83 | 84 | fmt.Println("DELETE:", resp.StatusCode) 85 | 86 | } 87 | -------------------------------------------------------------------------------- /examples/teams/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "crypto/tls" 5 | "fmt" 6 | "log" 7 | "net/http" 8 | 9 | "github.com/jbogarin/go-cisco-spark/ciscospark" 10 | ) 11 | 12 | func main() { 13 | tr := &http.Transport{ 14 | TLSClientConfig: &tls.Config{InsecureSkipVerify: true}, 15 | } 16 | client := &http.Client{Transport: tr} 17 | sparkClient := ciscospark.NewClient(client) 18 | token := "" // Change to your token 19 | sparkClient.Authorization = "Bearer " + token 20 | 21 | /* 22 | 23 | TEAMS 24 | 25 | */ 26 | 27 | // POST teams 28 | teamRequest := &ciscospark.TeamRequest{ 29 | Name: "Go Test Team", 30 | } 31 | 32 | newTeam, _, err := sparkClient.Teams.Post(teamRequest) 33 | if err != nil { 34 | log.Fatal(err) 35 | } 36 | 37 | fmt.Println("POST:", newTeam.ID, newTeam.Name, newTeam.Created) 38 | 39 | // GET teams 40 | 41 | teamQueryParams := &ciscospark.TeamQueryParams{ 42 | Max: 2, 43 | } 44 | 45 | teams, _, err := sparkClient.Teams.Get(teamQueryParams) 46 | if err != nil { 47 | log.Fatal(err) 48 | } 49 | for id, team := range teams { 50 | fmt.Println("GET:", id, team.ID, team.Name, team.Created) 51 | } 52 | 53 | // GET teams/ 54 | team, _, err := sparkClient.Teams.GetTeam(newTeam.ID) 55 | if err != nil { 56 | log.Fatal(err) 57 | } 58 | 59 | fmt.Println("GET :", team.ID, team.Created, team.Name) 60 | 61 | // PUT teams/ 62 | updateTeamRequest := &ciscospark.UpdateTeamRequest{ 63 | Name: "Go Test Team 2", 64 | } 65 | 66 | updatedTeam, _, err := sparkClient.Teams.UpdateTeam(newTeam.ID, updateTeamRequest) 67 | if err != nil { 68 | log.Fatal(err) 69 | } 70 | 71 | fmt.Println("PUT:", updatedTeam.ID, updatedTeam.Name, updatedTeam.Created) 72 | 73 | // DELETE teams/ 74 | resp, err := sparkClient.Teams.DeleteTeam(newTeam.ID) 75 | if err != nil { 76 | log.Fatal(err) 77 | } 78 | 79 | fmt.Println("DELETE:", resp.StatusCode) 80 | 81 | } 82 | -------------------------------------------------------------------------------- /examples/webhooks/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "crypto/tls" 5 | "fmt" 6 | "log" 7 | "net/http" 8 | 9 | "github.com/jbogarin/go-cisco-spark/ciscospark" 10 | ) 11 | 12 | func main() { 13 | tr := &http.Transport{ 14 | TLSClientConfig: &tls.Config{InsecureSkipVerify: true}, 15 | } 16 | client := &http.Client{Transport: tr} 17 | sparkClient := ciscospark.NewClient(client) 18 | token := "" // Change to your token 19 | sparkClient.Authorization = "Bearer " + token 20 | 21 | myRoomID := "" // Change to your testing room 22 | webHookURL := "" // Change this to your test URL 23 | 24 | // POST webhooks 25 | 26 | webhookRequest := &ciscospark.WebhookRequest{ 27 | Name: "Webhook - Test", 28 | TargetURL: webHookURL, 29 | Resource: "messages", 30 | Event: "created", 31 | Filter: "roomId=" + myRoomID, 32 | } 33 | 34 | testWebhook, _, err := sparkClient.Webhooks.Post(webhookRequest) 35 | if err != nil { 36 | log.Fatal(err) 37 | } 38 | 39 | fmt.Println("POST:", testWebhook.ID, testWebhook.Name, testWebhook.TargetURL, testWebhook.Created) 40 | 41 | // GET webhooks 42 | 43 | webhooksQueryParams := &ciscospark.WebhookQueryParams{ 44 | Max: 10, 45 | } 46 | 47 | webhooks, _, err := sparkClient.Webhooks.Get(webhooksQueryParams) 48 | if err != nil { 49 | log.Fatal(err) 50 | } 51 | for id, webhook := range webhooks { 52 | fmt.Println("GET:", id, webhook.ID, webhook.Name, webhook.TargetURL, webhook.Created) 53 | } 54 | 55 | // GET webhooks/ 56 | webhook, _, err := sparkClient.Webhooks.GetWebhook(testWebhook.ID) 57 | if err != nil { 58 | log.Fatal(err) 59 | } 60 | 61 | fmt.Println("GET :", webhook.ID, webhook.Name, webhook.TargetURL, webhook.Created) 62 | 63 | updateWebhookRequest := &ciscospark.UpdateWebhookRequest{ 64 | Name: "Webhook Update - Test", 65 | TargetURL: webHookURL, 66 | } 67 | 68 | // PUT webhooks/ 69 | updatedWebhook, _, err := sparkClient.Webhooks.UpdateWebhook(testWebhook.ID, updateWebhookRequest) 70 | if err != nil { 71 | log.Fatal(err) 72 | } 73 | 74 | fmt.Println("PUT:", updatedWebhook.ID, updatedWebhook.Name, updatedWebhook.TargetURL, updatedWebhook.Created) 75 | 76 | // DELETE webhooks/ 77 | resp, err := sparkClient.Webhooks.DeleteWebhook(testWebhook.ID) 78 | if err != nil { 79 | log.Fatal(err) 80 | } 81 | 82 | fmt.Println("DELETE:", resp.StatusCode) 83 | 84 | } 85 | --------------------------------------------------------------------------------