mirror of
https://github.com/hanzo-go/sdk.git
synced 2026-11-20 20:13:42 +00:00
5478 lines
200 KiB
Go
5478 lines
200 KiB
Go
/*
|
|
Hanzo Cloud API
|
|
|
|
The Hanzo Cloud API as a customer calls it: every operation under /v1/ except the operator's admin product, relay routes, legacy spellings and capabilities still reached by flag. Tagged by product: the first path segment after /v1/.
|
|
|
|
API version: v1
|
|
*/
|
|
|
|
// Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.
|
|
|
|
package hanzoai
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"io"
|
|
"net/http"
|
|
"net/url"
|
|
"os"
|
|
"strings"
|
|
)
|
|
|
|
// TeamAPIService TeamAPI service
|
|
type TeamAPIService service
|
|
|
|
type TeamAPIDeleteTeamAccountCookieRequest struct {
|
|
ctx context.Context
|
|
ApiService *TeamAPIService
|
|
}
|
|
|
|
func (r TeamAPIDeleteTeamAccountCookieRequest) Execute() (*TeamCookieAck, *http.Response, error) {
|
|
return r.ApiService.DeleteTeamAccountCookieExecute(r)
|
|
}
|
|
|
|
/*
|
|
DeleteTeamAccountCookie Signs this browser out of team by expiring the HttpOnly account-token cookie the OAuth callback set.
|
|
|
|
Signs this browser out of team by expiring the HttpOnly
|
|
account-token cookie the OAuth callback set. It is the counterpart of the
|
|
cookie PUT, it takes nothing — the cookie it clears is named by this service,
|
|
never by the caller — and it is unconditional: a caller with no cookie, an
|
|
expired one or a forged one all get the same acknowledgement, because clearing
|
|
something that is not there is the same outcome as clearing something that is.
|
|
|
|
It clears ONLY the team session cookie. The IAM access-token cookie the same
|
|
callback set is a different credential with a different lifetime and is left
|
|
alone, so this is a team sign-out, not a platform one.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@return TeamAPIDeleteTeamAccountCookieRequest
|
|
*/
|
|
func (a *TeamAPIService) DeleteTeamAccountCookie(ctx context.Context) TeamAPIDeleteTeamAccountCookieRequest {
|
|
return TeamAPIDeleteTeamAccountCookieRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return TeamCookieAck
|
|
func (a *TeamAPIService) DeleteTeamAccountCookieExecute(r TeamAPIDeleteTeamAccountCookieRequest) (*TeamCookieAck, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodDelete
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *TeamCookieAck
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "TeamAPIService.DeleteTeamAccountCookie")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/team/account/cookie"
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
|
|
// to determine the Content-Type header
|
|
localVarHTTPContentTypes := []string{}
|
|
|
|
// set Content-Type header
|
|
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
|
if localVarHTTPContentType != "" {
|
|
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
|
}
|
|
|
|
// to determine the Accept header
|
|
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
|
|
|
|
// set Accept header
|
|
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
|
if localVarHTTPHeaderAccept != "" {
|
|
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
|
}
|
|
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
|
if err != nil {
|
|
return localVarReturnValue, nil, err
|
|
}
|
|
|
|
localVarHTTPResponse, err := a.client.callAPI(req)
|
|
if err != nil || localVarHTTPResponse == nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
|
localVarHTTPResponse.Body.Close()
|
|
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
|
if err != nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
if localVarHTTPResponse.StatusCode >= 300 {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: localVarHTTPResponse.Status,
|
|
}
|
|
var v ProblemDetails
|
|
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr.error = err.Error()
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
|
newErr.model = v
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: err.Error(),
|
|
}
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
return localVarReturnValue, localVarHTTPResponse, nil
|
|
}
|
|
|
|
type TeamAPIDeleteTeamChannelsByIdMembersByAccountRequest struct {
|
|
ctx context.Context
|
|
ApiService *TeamAPIService
|
|
id string
|
|
account string
|
|
space *string
|
|
}
|
|
|
|
// Space is the space uuid holding the channel.
|
|
func (r TeamAPIDeleteTeamChannelsByIdMembersByAccountRequest) Space(space string) TeamAPIDeleteTeamChannelsByIdMembersByAccountRequest {
|
|
r.space = &space
|
|
return r
|
|
}
|
|
|
|
func (r TeamAPIDeleteTeamChannelsByIdMembersByAccountRequest) Execute() (*http.Response, error) {
|
|
return r.ApiService.DeleteTeamChannelsByIdMembersByAccountExecute(r)
|
|
}
|
|
|
|
/*
|
|
DeleteTeamChannelsByIdMembersByAccount Takes one person out of a channel — the caller leaving, when the account is their own.
|
|
|
|
Takes one person out of a channel — the caller leaving, when the
|
|
account is their own. Removing somebody else takes owning the channel or
|
|
administering the space. Leaving a channel you are not in, or removing somebody
|
|
who is not there, changes nothing. A direct message cannot be left: its people
|
|
are what it is. Answers 204.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@param id ID is the channel, from the path.
|
|
@param account Account is the account uuid to remove, from the path. Your own is leaving.
|
|
@return TeamAPIDeleteTeamChannelsByIdMembersByAccountRequest
|
|
*/
|
|
func (a *TeamAPIService) DeleteTeamChannelsByIdMembersByAccount(ctx context.Context, id string, account string) TeamAPIDeleteTeamChannelsByIdMembersByAccountRequest {
|
|
return TeamAPIDeleteTeamChannelsByIdMembersByAccountRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
id: id,
|
|
account: account,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
func (a *TeamAPIService) DeleteTeamChannelsByIdMembersByAccountExecute(r TeamAPIDeleteTeamChannelsByIdMembersByAccountRequest) (*http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodDelete
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "TeamAPIService.DeleteTeamChannelsByIdMembersByAccount")
|
|
if err != nil {
|
|
return nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/team/channels/{id}/members/{account}"
|
|
localVarPath = strings.Replace(localVarPath, "{"+"id"+"}", url.PathEscape(parameterValueToString(r.id, "id")), -1)
|
|
localVarPath = strings.Replace(localVarPath, "{"+"account"+"}", url.PathEscape(parameterValueToString(r.account, "account")), -1)
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
|
|
if r.space != nil {
|
|
parameterAddToHeaderOrQuery(localVarQueryParams, "space", r.space, "form", "")
|
|
}
|
|
// to determine the Content-Type header
|
|
localVarHTTPContentTypes := []string{}
|
|
|
|
// set Content-Type header
|
|
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
|
if localVarHTTPContentType != "" {
|
|
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
|
}
|
|
|
|
// to determine the Accept header
|
|
localVarHTTPHeaderAccepts := []string{"application/problem+json"}
|
|
|
|
// set Accept header
|
|
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
|
if localVarHTTPHeaderAccept != "" {
|
|
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
|
}
|
|
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
localVarHTTPResponse, err := a.client.callAPI(req)
|
|
if err != nil || localVarHTTPResponse == nil {
|
|
return localVarHTTPResponse, err
|
|
}
|
|
|
|
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
|
localVarHTTPResponse.Body.Close()
|
|
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
|
if err != nil {
|
|
return localVarHTTPResponse, err
|
|
}
|
|
|
|
if localVarHTTPResponse.StatusCode >= 300 {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: localVarHTTPResponse.Status,
|
|
}
|
|
var v ProblemDetails
|
|
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr.error = err.Error()
|
|
return localVarHTTPResponse, newErr
|
|
}
|
|
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
|
newErr.model = v
|
|
return localVarHTTPResponse, newErr
|
|
}
|
|
|
|
return localVarHTTPResponse, nil
|
|
}
|
|
|
|
type TeamAPIDeleteTeamDocsByIdRequest struct {
|
|
ctx context.Context
|
|
ApiService *TeamAPIService
|
|
id string
|
|
space *string
|
|
}
|
|
|
|
// Space is the space uuid holding it.
|
|
func (r TeamAPIDeleteTeamDocsByIdRequest) Space(space string) TeamAPIDeleteTeamDocsByIdRequest {
|
|
r.space = &space
|
|
return r
|
|
}
|
|
|
|
func (r TeamAPIDeleteTeamDocsByIdRequest) Execute() (*http.Response, error) {
|
|
return r.ApiService.DeleteTeamDocsByIdExecute(r)
|
|
}
|
|
|
|
/*
|
|
DeleteTeamDocsById Removes a document with everything nested under it and every comment on any of them — the Team client's own delete, which takes the subtree with it.
|
|
|
|
Removes a document with everything nested under it and every
|
|
comment on any of them — the Team client's own delete, which takes the
|
|
subtree with it. Its author, an owner of its teamspace or an admin of the
|
|
space may delete it. Answers 204.
|
|
|
|
The document model has no archived state for a page (only a teamspace can be
|
|
archived), so there is nothing softer to offer here than removal.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@param id ID is the document, from the path.
|
|
@return TeamAPIDeleteTeamDocsByIdRequest
|
|
*/
|
|
func (a *TeamAPIService) DeleteTeamDocsById(ctx context.Context, id string) TeamAPIDeleteTeamDocsByIdRequest {
|
|
return TeamAPIDeleteTeamDocsByIdRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
id: id,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
func (a *TeamAPIService) DeleteTeamDocsByIdExecute(r TeamAPIDeleteTeamDocsByIdRequest) (*http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodDelete
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "TeamAPIService.DeleteTeamDocsById")
|
|
if err != nil {
|
|
return nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/team/docs/{id}"
|
|
localVarPath = strings.Replace(localVarPath, "{"+"id"+"}", url.PathEscape(parameterValueToString(r.id, "id")), -1)
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
|
|
if r.space != nil {
|
|
parameterAddToHeaderOrQuery(localVarQueryParams, "space", r.space, "form", "")
|
|
}
|
|
// to determine the Content-Type header
|
|
localVarHTTPContentTypes := []string{}
|
|
|
|
// set Content-Type header
|
|
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
|
if localVarHTTPContentType != "" {
|
|
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
|
}
|
|
|
|
// to determine the Accept header
|
|
localVarHTTPHeaderAccepts := []string{"application/problem+json"}
|
|
|
|
// set Accept header
|
|
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
|
if localVarHTTPHeaderAccept != "" {
|
|
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
|
}
|
|
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
localVarHTTPResponse, err := a.client.callAPI(req)
|
|
if err != nil || localVarHTTPResponse == nil {
|
|
return localVarHTTPResponse, err
|
|
}
|
|
|
|
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
|
localVarHTTPResponse.Body.Close()
|
|
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
|
if err != nil {
|
|
return localVarHTTPResponse, err
|
|
}
|
|
|
|
if localVarHTTPResponse.StatusCode >= 300 {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: localVarHTTPResponse.Status,
|
|
}
|
|
var v ProblemDetails
|
|
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr.error = err.Error()
|
|
return localVarHTTPResponse, newErr
|
|
}
|
|
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
|
newErr.model = v
|
|
return localVarHTTPResponse, newErr
|
|
}
|
|
|
|
return localVarHTTPResponse, nil
|
|
}
|
|
|
|
type TeamAPIDeleteTeamFilesBySpaceByFilenameRequest struct {
|
|
ctx context.Context
|
|
ApiService *TeamAPIService
|
|
space string
|
|
filename string
|
|
file *string
|
|
}
|
|
|
|
// File is the blob id, and wins over the path segment when both are present.
|
|
func (r TeamAPIDeleteTeamFilesBySpaceByFilenameRequest) File(file string) TeamAPIDeleteTeamFilesBySpaceByFilenameRequest {
|
|
r.file = &file
|
|
return r
|
|
}
|
|
|
|
func (r TeamAPIDeleteTeamFilesBySpaceByFilenameRequest) Execute() (*http.Response, error) {
|
|
return r.ApiService.DeleteTeamFilesBySpaceByFilenameExecute(r)
|
|
}
|
|
|
|
/*
|
|
DeleteTeamFilesBySpaceByFilename Removes one blob from a space's file store.
|
|
|
|
Removes one blob from a space's file store. The caller must
|
|
hold a verified session AND be a member of the space; anything else — an
|
|
unknown space, another tenant's space, a space the caller is not
|
|
in — answers the same 404, so a probe learns nothing about what exists.
|
|
|
|
It is IDEMPOTENT: deleting a present or an absent blob both answer 204, so a
|
|
delete never confirms a blob's existence and a foreign blob id (a physical key
|
|
the caller can never name into another tenant's box) is a harmless no-op. A
|
|
storage backend that is unavailable fails closed with 502 rather than lying
|
|
about success.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@param space Space is the space uuid the blob belongs to, from the path.
|
|
@param filename Filename is the last path segment, which the front sets to the blob id when it sends no explicit `file`.
|
|
@return TeamAPIDeleteTeamFilesBySpaceByFilenameRequest
|
|
*/
|
|
func (a *TeamAPIService) DeleteTeamFilesBySpaceByFilename(ctx context.Context, space string, filename string) TeamAPIDeleteTeamFilesBySpaceByFilenameRequest {
|
|
return TeamAPIDeleteTeamFilesBySpaceByFilenameRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
space: space,
|
|
filename: filename,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
func (a *TeamAPIService) DeleteTeamFilesBySpaceByFilenameExecute(r TeamAPIDeleteTeamFilesBySpaceByFilenameRequest) (*http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodDelete
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "TeamAPIService.DeleteTeamFilesBySpaceByFilename")
|
|
if err != nil {
|
|
return nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/team/files/{space}/{filename}"
|
|
localVarPath = strings.Replace(localVarPath, "{"+"space"+"}", url.PathEscape(parameterValueToString(r.space, "space")), -1)
|
|
localVarPath = strings.Replace(localVarPath, "{"+"filename"+"}", url.PathEscape(parameterValueToString(r.filename, "filename")), -1)
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
|
|
if r.file != nil {
|
|
parameterAddToHeaderOrQuery(localVarQueryParams, "file", r.file, "form", "")
|
|
}
|
|
// to determine the Content-Type header
|
|
localVarHTTPContentTypes := []string{}
|
|
|
|
// set Content-Type header
|
|
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
|
if localVarHTTPContentType != "" {
|
|
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
|
}
|
|
|
|
// to determine the Accept header
|
|
localVarHTTPHeaderAccepts := []string{"application/problem+json"}
|
|
|
|
// set Accept header
|
|
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
|
if localVarHTTPHeaderAccept != "" {
|
|
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
|
}
|
|
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
localVarHTTPResponse, err := a.client.callAPI(req)
|
|
if err != nil || localVarHTTPResponse == nil {
|
|
return localVarHTTPResponse, err
|
|
}
|
|
|
|
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
|
localVarHTTPResponse.Body.Close()
|
|
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
|
if err != nil {
|
|
return localVarHTTPResponse, err
|
|
}
|
|
|
|
if localVarHTTPResponse.StatusCode >= 300 {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: localVarHTTPResponse.Status,
|
|
}
|
|
var v ProblemDetails
|
|
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr.error = err.Error()
|
|
return localVarHTTPResponse, newErr
|
|
}
|
|
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
|
newErr.model = v
|
|
return localVarHTTPResponse, newErr
|
|
}
|
|
|
|
return localVarHTTPResponse, nil
|
|
}
|
|
|
|
type TeamAPIDeleteTeamMessagesByIdRequest struct {
|
|
ctx context.Context
|
|
ApiService *TeamAPIService
|
|
id string
|
|
space *string
|
|
}
|
|
|
|
// Space names the space holding it. A message id is unique within a space, not across the org.
|
|
func (r TeamAPIDeleteTeamMessagesByIdRequest) Space(space string) TeamAPIDeleteTeamMessagesByIdRequest {
|
|
r.space = &space
|
|
return r
|
|
}
|
|
|
|
func (r TeamAPIDeleteTeamMessagesByIdRequest) Execute() (*http.Response, error) {
|
|
return r.ApiService.DeleteTeamMessagesByIdExecute(r)
|
|
}
|
|
|
|
/*
|
|
DeleteTeamMessagesById Removes a message, with its replies, reactions, files and the inbox notifications that point at it.
|
|
|
|
Removes a message, with its replies, reactions, files and the
|
|
inbox notifications that point at it. Its author may delete it, and so may an
|
|
owner or admin of the space.
|
|
|
|
Each removal is a platform remove through the Team client's write path, so the
|
|
message disappears from every open client live. Answers 204.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@param id ID is the message, from the path.
|
|
@return TeamAPIDeleteTeamMessagesByIdRequest
|
|
*/
|
|
func (a *TeamAPIService) DeleteTeamMessagesById(ctx context.Context, id string) TeamAPIDeleteTeamMessagesByIdRequest {
|
|
return TeamAPIDeleteTeamMessagesByIdRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
id: id,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
func (a *TeamAPIService) DeleteTeamMessagesByIdExecute(r TeamAPIDeleteTeamMessagesByIdRequest) (*http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodDelete
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "TeamAPIService.DeleteTeamMessagesById")
|
|
if err != nil {
|
|
return nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/team/messages/{id}"
|
|
localVarPath = strings.Replace(localVarPath, "{"+"id"+"}", url.PathEscape(parameterValueToString(r.id, "id")), -1)
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
|
|
if r.space != nil {
|
|
parameterAddToHeaderOrQuery(localVarQueryParams, "space", r.space, "form", "")
|
|
}
|
|
// to determine the Content-Type header
|
|
localVarHTTPContentTypes := []string{}
|
|
|
|
// set Content-Type header
|
|
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
|
if localVarHTTPContentType != "" {
|
|
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
|
}
|
|
|
|
// to determine the Accept header
|
|
localVarHTTPHeaderAccepts := []string{"application/problem+json"}
|
|
|
|
// set Accept header
|
|
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
|
if localVarHTTPHeaderAccept != "" {
|
|
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
|
}
|
|
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
localVarHTTPResponse, err := a.client.callAPI(req)
|
|
if err != nil || localVarHTTPResponse == nil {
|
|
return localVarHTTPResponse, err
|
|
}
|
|
|
|
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
|
localVarHTTPResponse.Body.Close()
|
|
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
|
if err != nil {
|
|
return localVarHTTPResponse, err
|
|
}
|
|
|
|
if localVarHTTPResponse.StatusCode >= 300 {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: localVarHTTPResponse.Status,
|
|
}
|
|
var v ProblemDetails
|
|
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr.error = err.Error()
|
|
return localVarHTTPResponse, newErr
|
|
}
|
|
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
|
newErr.model = v
|
|
return localVarHTTPResponse, newErr
|
|
}
|
|
|
|
return localVarHTTPResponse, nil
|
|
}
|
|
|
|
type TeamAPIDeleteTeamMessagesByIdReactionsByEmojiRequest struct {
|
|
ctx context.Context
|
|
ApiService *TeamAPIService
|
|
id string
|
|
emoji string
|
|
space *string
|
|
}
|
|
|
|
// Space names the space holding the message.
|
|
func (r TeamAPIDeleteTeamMessagesByIdReactionsByEmojiRequest) Space(space string) TeamAPIDeleteTeamMessagesByIdReactionsByEmojiRequest {
|
|
r.space = &space
|
|
return r
|
|
}
|
|
|
|
func (r TeamAPIDeleteTeamMessagesByIdReactionsByEmojiRequest) Execute() (*TeamTeamMessage, *http.Response, error) {
|
|
return r.ApiService.DeleteTeamMessagesByIdReactionsByEmojiExecute(r)
|
|
}
|
|
|
|
/*
|
|
DeleteTeamMessagesByIdReactionsByEmoji Takes back the caller's reaction to a message and answers the message with its reactions as they now stand.
|
|
|
|
Takes back the caller's reaction to a message and answers the message
|
|
with its reactions as they now stand. Taking back a reaction the caller never
|
|
made changes nothing and is not an error.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@param id ID is the message, from the path.
|
|
@param emoji Emoji is the reaction, from the path (percent-encoded on the wire).
|
|
@return TeamAPIDeleteTeamMessagesByIdReactionsByEmojiRequest
|
|
*/
|
|
func (a *TeamAPIService) DeleteTeamMessagesByIdReactionsByEmoji(ctx context.Context, id string, emoji string) TeamAPIDeleteTeamMessagesByIdReactionsByEmojiRequest {
|
|
return TeamAPIDeleteTeamMessagesByIdReactionsByEmojiRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
id: id,
|
|
emoji: emoji,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return TeamTeamMessage
|
|
func (a *TeamAPIService) DeleteTeamMessagesByIdReactionsByEmojiExecute(r TeamAPIDeleteTeamMessagesByIdReactionsByEmojiRequest) (*TeamTeamMessage, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodDelete
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *TeamTeamMessage
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "TeamAPIService.DeleteTeamMessagesByIdReactionsByEmoji")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/team/messages/{id}/reactions/{emoji}"
|
|
localVarPath = strings.Replace(localVarPath, "{"+"id"+"}", url.PathEscape(parameterValueToString(r.id, "id")), -1)
|
|
localVarPath = strings.Replace(localVarPath, "{"+"emoji"+"}", url.PathEscape(parameterValueToString(r.emoji, "emoji")), -1)
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
|
|
if r.space != nil {
|
|
parameterAddToHeaderOrQuery(localVarQueryParams, "space", r.space, "form", "")
|
|
}
|
|
// to determine the Content-Type header
|
|
localVarHTTPContentTypes := []string{}
|
|
|
|
// set Content-Type header
|
|
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
|
if localVarHTTPContentType != "" {
|
|
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
|
}
|
|
|
|
// to determine the Accept header
|
|
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
|
|
|
|
// set Accept header
|
|
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
|
if localVarHTTPHeaderAccept != "" {
|
|
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
|
}
|
|
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
|
if err != nil {
|
|
return localVarReturnValue, nil, err
|
|
}
|
|
|
|
localVarHTTPResponse, err := a.client.callAPI(req)
|
|
if err != nil || localVarHTTPResponse == nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
|
localVarHTTPResponse.Body.Close()
|
|
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
|
if err != nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
if localVarHTTPResponse.StatusCode >= 300 {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: localVarHTTPResponse.Status,
|
|
}
|
|
var v ProblemDetails
|
|
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr.error = err.Error()
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
|
newErr.model = v
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: err.Error(),
|
|
}
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
return localVarReturnValue, localVarHTTPResponse, nil
|
|
}
|
|
|
|
type TeamAPIGetTeamAccountAuthByProviderRequest struct {
|
|
ctx context.Context
|
|
ApiService *TeamAPIService
|
|
provider string
|
|
}
|
|
|
|
func (r TeamAPIGetTeamAccountAuthByProviderRequest) Execute() (*http.Response, error) {
|
|
return r.ApiService.GetTeamAccountAuthByProviderExecute(r)
|
|
}
|
|
|
|
/*
|
|
GetTeamAccountAuthByProvider Start a sign-in at hanzo.id
|
|
|
|
STARTS the OAuth hop: answers 302 to hanzo.id's authorize endpoint and sets the short-lived HttpOnly state cookie that binds the flow to this browser. NO TOKEN COMES BACK FROM THIS CALL — the session is minted by the callback below, and a client that expects JSON here gets a redirect with no body.
|
|
|
|
A browser is the intended caller. Anything else must follow the Location AND keep the Set-Cookie, because the callback refuses a flow whose state it cannot match. That cookie carries the random nonce plus the client's navigateUrl, so the round trip needs no second channel, and it lives ten minutes — the whole budget for the hop.
|
|
|
|
The provider segment only picks a hint: the redirect_uri is ALWAYS the canonical openid callback, the one IAM has registered. Measured end to end, hanzo.id strips that hint today, so /auth/google and /auth/openid land on the same Hanzo sign-in page — the federation shortcut is an upstream fix, not a second endpoint here.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@param provider
|
|
@return TeamAPIGetTeamAccountAuthByProviderRequest
|
|
*/
|
|
func (a *TeamAPIService) GetTeamAccountAuthByProvider(ctx context.Context, provider string) TeamAPIGetTeamAccountAuthByProviderRequest {
|
|
return TeamAPIGetTeamAccountAuthByProviderRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
provider: provider,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
func (a *TeamAPIService) GetTeamAccountAuthByProviderExecute(r TeamAPIGetTeamAccountAuthByProviderRequest) (*http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodGet
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "TeamAPIService.GetTeamAccountAuthByProvider")
|
|
if err != nil {
|
|
return nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/team/account/auth/{provider}"
|
|
localVarPath = strings.Replace(localVarPath, "{"+"provider"+"}", url.PathEscape(parameterValueToString(r.provider, "provider")), -1)
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
|
|
// to determine the Content-Type header
|
|
localVarHTTPContentTypes := []string{}
|
|
|
|
// set Content-Type header
|
|
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
|
if localVarHTTPContentType != "" {
|
|
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
|
}
|
|
|
|
// to determine the Accept header
|
|
localVarHTTPHeaderAccepts := []string{}
|
|
|
|
// set Accept header
|
|
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
|
if localVarHTTPHeaderAccept != "" {
|
|
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
|
}
|
|
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
localVarHTTPResponse, err := a.client.callAPI(req)
|
|
if err != nil || localVarHTTPResponse == nil {
|
|
return localVarHTTPResponse, err
|
|
}
|
|
|
|
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
|
localVarHTTPResponse.Body.Close()
|
|
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
|
if err != nil {
|
|
return localVarHTTPResponse, err
|
|
}
|
|
|
|
if localVarHTTPResponse.StatusCode >= 300 {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: localVarHTTPResponse.Status,
|
|
}
|
|
return localVarHTTPResponse, newErr
|
|
}
|
|
|
|
return localVarHTTPResponse, nil
|
|
}
|
|
|
|
type TeamAPIGetTeamAccountAuthByProviderCallbackRequest struct {
|
|
ctx context.Context
|
|
ApiService *TeamAPIService
|
|
provider string
|
|
}
|
|
|
|
func (r TeamAPIGetTeamAccountAuthByProviderCallbackRequest) Execute() (*http.Response, error) {
|
|
return r.ApiService.GetTeamAccountAuthByProviderCallbackExecute(r)
|
|
}
|
|
|
|
/*
|
|
GetTeamAccountAuthByProviderCallback Complete a sign-in and hand the browser its session
|
|
|
|
COMPLETES the OAuth hop: hanzo.id redirects the browser here with ?code and ?state, and the answer is another 302 — back to the client's login route carrying the freshly minted team session token in the query. Never JSON, and never a token in this response's own body.
|
|
|
|
THE STATE IS CHECKED FIRST, before the code is even looked at: the flow cookie is read and cleared one-shot, and a callback whose ?state does not equal the nonce it held is bounced with error=state_mismatch and NEVER exchanged. That is what makes a forged or replayed callback inert. Only then is the code exchanged server-side — team is a confidential client with a client_secret, so there is no PKCE and the code never passes through the browser's JS.
|
|
|
|
The tenant is derived from the IAM access token VERIFIED RS256 against the JWKS, the same trust anchor the identity boundary uses; a token whose owner claim is empty fails closed with no login at all. Every org that token proves gets a space ensured, so a member of two orgs is a counted seat in both. The IAM access token is also parked in an HttpOnly cookie for the same-origin agents proxy — page JS never reads it.
|
|
|
|
EVERY failure is a redirect, not a status: a denied consent, a missing code, a failed exchange, an unreadable userinfo, an unverifiable org and a token-mint failure each bounce to the login page with an ?error code naming the step.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@param provider
|
|
@return TeamAPIGetTeamAccountAuthByProviderCallbackRequest
|
|
*/
|
|
func (a *TeamAPIService) GetTeamAccountAuthByProviderCallback(ctx context.Context, provider string) TeamAPIGetTeamAccountAuthByProviderCallbackRequest {
|
|
return TeamAPIGetTeamAccountAuthByProviderCallbackRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
provider: provider,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
func (a *TeamAPIService) GetTeamAccountAuthByProviderCallbackExecute(r TeamAPIGetTeamAccountAuthByProviderCallbackRequest) (*http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodGet
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "TeamAPIService.GetTeamAccountAuthByProviderCallback")
|
|
if err != nil {
|
|
return nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/team/account/auth/{provider}/callback"
|
|
localVarPath = strings.Replace(localVarPath, "{"+"provider"+"}", url.PathEscape(parameterValueToString(r.provider, "provider")), -1)
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
|
|
// to determine the Content-Type header
|
|
localVarHTTPContentTypes := []string{}
|
|
|
|
// set Content-Type header
|
|
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
|
if localVarHTTPContentType != "" {
|
|
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
|
}
|
|
|
|
// to determine the Accept header
|
|
localVarHTTPHeaderAccepts := []string{}
|
|
|
|
// set Accept header
|
|
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
|
if localVarHTTPHeaderAccept != "" {
|
|
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
|
}
|
|
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
localVarHTTPResponse, err := a.client.callAPI(req)
|
|
if err != nil || localVarHTTPResponse == nil {
|
|
return localVarHTTPResponse, err
|
|
}
|
|
|
|
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
|
localVarHTTPResponse.Body.Close()
|
|
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
|
if err != nil {
|
|
return localVarHTTPResponse, err
|
|
}
|
|
|
|
if localVarHTTPResponse.StatusCode >= 300 {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: localVarHTTPResponse.Status,
|
|
}
|
|
return localVarHTTPResponse, newErr
|
|
}
|
|
|
|
return localVarHTTPResponse, nil
|
|
}
|
|
|
|
type TeamAPIGetTeamAccountProvidersRequest struct {
|
|
ctx context.Context
|
|
ApiService *TeamAPIService
|
|
}
|
|
|
|
func (r TeamAPIGetTeamAccountProvidersRequest) Execute() ([]TeamProviderInfo, *http.Response, error) {
|
|
return r.ApiService.GetTeamAccountProvidersExecute(r)
|
|
}
|
|
|
|
/*
|
|
GetTeamAccountProviders Returns the identity providers this deployment starts a login with.
|
|
|
|
Returns the identity providers this deployment starts a login
|
|
with. It is always exactly one — hanzo.id. Which identities that provider accepts
|
|
(Google, GitHub, passkey, password) is IAM's question, answered on IAM's own
|
|
page next to the identity check and the training-data consent that must
|
|
precede a first session; listing them here would be a second place holding
|
|
that answer, and the two drift the moment IAM gains or drops one.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@return TeamAPIGetTeamAccountProvidersRequest
|
|
*/
|
|
func (a *TeamAPIService) GetTeamAccountProviders(ctx context.Context) TeamAPIGetTeamAccountProvidersRequest {
|
|
return TeamAPIGetTeamAccountProvidersRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return []TeamProviderInfo
|
|
func (a *TeamAPIService) GetTeamAccountProvidersExecute(r TeamAPIGetTeamAccountProvidersRequest) ([]TeamProviderInfo, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodGet
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue []TeamProviderInfo
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "TeamAPIService.GetTeamAccountProviders")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/team/account/providers"
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
|
|
// to determine the Content-Type header
|
|
localVarHTTPContentTypes := []string{}
|
|
|
|
// set Content-Type header
|
|
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
|
if localVarHTTPContentType != "" {
|
|
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
|
}
|
|
|
|
// to determine the Accept header
|
|
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
|
|
|
|
// set Accept header
|
|
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
|
if localVarHTTPHeaderAccept != "" {
|
|
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
|
}
|
|
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
|
if err != nil {
|
|
return localVarReturnValue, nil, err
|
|
}
|
|
|
|
localVarHTTPResponse, err := a.client.callAPI(req)
|
|
if err != nil || localVarHTTPResponse == nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
|
localVarHTTPResponse.Body.Close()
|
|
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
|
if err != nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
if localVarHTTPResponse.StatusCode >= 300 {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: localVarHTTPResponse.Status,
|
|
}
|
|
var v ProblemDetails
|
|
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr.error = err.Error()
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
|
newErr.model = v
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: err.Error(),
|
|
}
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
return localVarReturnValue, localVarHTTPResponse, nil
|
|
}
|
|
|
|
type TeamAPIGetTeamBillingPlanRequest struct {
|
|
ctx context.Context
|
|
ApiService *TeamAPIService
|
|
}
|
|
|
|
func (r TeamAPIGetTeamBillingPlanRequest) Execute() (*TeamPlanInfo, *http.Response, error) {
|
|
return r.ApiService.GetTeamBillingPlanExecute(r)
|
|
}
|
|
|
|
/*
|
|
GetTeamBillingPlan Returns the plan and seat counts for the caller's OWN org, resolved from the VERIFIED team session token — never a client header.
|
|
|
|
Returns the plan and seat counts for the caller's OWN org, resolved
|
|
from the VERIFIED team session token — never a client header. Seats and guests
|
|
are the org's distinct active human members (a bot member is not a seat); the
|
|
plan comes from the licensing entitlement and is empty when that read is
|
|
unavailable, so the page shows an honest dash rather than a fabricated tier. A
|
|
caller with no verified session gets 401, and a real seat-read failure is a
|
|
502 rather than a false "0 members".
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@return TeamAPIGetTeamBillingPlanRequest
|
|
*/
|
|
func (a *TeamAPIService) GetTeamBillingPlan(ctx context.Context) TeamAPIGetTeamBillingPlanRequest {
|
|
return TeamAPIGetTeamBillingPlanRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return TeamPlanInfo
|
|
func (a *TeamAPIService) GetTeamBillingPlanExecute(r TeamAPIGetTeamBillingPlanRequest) (*TeamPlanInfo, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodGet
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *TeamPlanInfo
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "TeamAPIService.GetTeamBillingPlan")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/team/billing/plan"
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
|
|
// to determine the Content-Type header
|
|
localVarHTTPContentTypes := []string{}
|
|
|
|
// set Content-Type header
|
|
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
|
if localVarHTTPContentType != "" {
|
|
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
|
}
|
|
|
|
// to determine the Accept header
|
|
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
|
|
|
|
// set Accept header
|
|
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
|
if localVarHTTPHeaderAccept != "" {
|
|
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
|
}
|
|
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
|
if err != nil {
|
|
return localVarReturnValue, nil, err
|
|
}
|
|
|
|
localVarHTTPResponse, err := a.client.callAPI(req)
|
|
if err != nil || localVarHTTPResponse == nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
|
localVarHTTPResponse.Body.Close()
|
|
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
|
if err != nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
if localVarHTTPResponse.StatusCode >= 300 {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: localVarHTTPResponse.Status,
|
|
}
|
|
var v ProblemDetails
|
|
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr.error = err.Error()
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
|
newErr.model = v
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: err.Error(),
|
|
}
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
return localVarReturnValue, localVarHTTPResponse, nil
|
|
}
|
|
|
|
type TeamAPIGetTeamBillingUiRequest struct {
|
|
ctx context.Context
|
|
ApiService *TeamAPIService
|
|
}
|
|
|
|
func (r TeamAPIGetTeamBillingUiRequest) Execute() (*os.File, *http.Response, error) {
|
|
return r.ApiService.GetTeamBillingUiExecute(r)
|
|
}
|
|
|
|
/*
|
|
GetTeamBillingUi Open the wallet page
|
|
|
|
Serves the usage-and-wallet page the Team front links to — HTML, not JSON. It is a static React build compiled into this binary, so there is no upstream to be down and no build step at request time.
|
|
|
|
SESSION-GATED: without a verified team session token — bearer, else the HttpOnly account cookie — the caller gets 401 and not one byte of the page, so an anonymous browser meets a refusal rather than a shell that then fails to load anything.
|
|
|
|
The page is markup only. It reads money SAME-ORIGIN from cloud's own balance and usage endpoints, which pin the org from the IAM cookie the team OAuth callback set — nothing under this path proxies a money read, so there is no second auth mechanism here to get wrong. A deployment whose page was never built answers 503 naming the missing bundle, never a blank 200.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@return TeamAPIGetTeamBillingUiRequest
|
|
*/
|
|
func (a *TeamAPIService) GetTeamBillingUi(ctx context.Context) TeamAPIGetTeamBillingUiRequest {
|
|
return TeamAPIGetTeamBillingUiRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return *os.File
|
|
func (a *TeamAPIService) GetTeamBillingUiExecute(r TeamAPIGetTeamBillingUiRequest) (*os.File, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodGet
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *os.File
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "TeamAPIService.GetTeamBillingUi")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/team/billing/ui"
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
|
|
// to determine the Content-Type header
|
|
localVarHTTPContentTypes := []string{}
|
|
|
|
// set Content-Type header
|
|
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
|
if localVarHTTPContentType != "" {
|
|
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
|
}
|
|
|
|
// to determine the Accept header
|
|
localVarHTTPHeaderAccepts := []string{"text/html; charset=utf-8"}
|
|
|
|
// set Accept header
|
|
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
|
if localVarHTTPHeaderAccept != "" {
|
|
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
|
}
|
|
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
|
if err != nil {
|
|
return localVarReturnValue, nil, err
|
|
}
|
|
|
|
localVarHTTPResponse, err := a.client.callAPI(req)
|
|
if err != nil || localVarHTTPResponse == nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
|
localVarHTTPResponse.Body.Close()
|
|
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
|
if err != nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
if localVarHTTPResponse.StatusCode >= 300 {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: localVarHTTPResponse.Status,
|
|
}
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: err.Error(),
|
|
}
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
return localVarReturnValue, localVarHTTPResponse, nil
|
|
}
|
|
|
|
type TeamAPIGetTeamChannelsRequest struct {
|
|
ctx context.Context
|
|
ApiService *TeamAPIService
|
|
}
|
|
|
|
func (r TeamAPIGetTeamChannelsRequest) Execute() (*TeamTeamChannels, *http.Response, error) {
|
|
return r.ApiService.GetTeamChannelsExecute(r)
|
|
}
|
|
|
|
/*
|
|
GetTeamChannels Returns the channels the caller may see, with the kind and work facet each carries.
|
|
|
|
Returns the channels the caller may see, with the kind and work
|
|
facet each carries.
|
|
|
|
A signed-in TEAM MEMBER reads every channel of every space they are in that is
|
|
open to them: public channels, and the private channels and direct messages
|
|
that name them. An APPLICATION of the org (its own machine credential) reads
|
|
the public channels of the org's spaces and nothing that belongs to
|
|
particular people. Anybody else without a team session is 401.
|
|
|
|
It reads the SAME channel documents the transactor serves, so a channel opened
|
|
in the Team client appears here with no sync, and a facet written here is read
|
|
by anything holding the document.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@return TeamAPIGetTeamChannelsRequest
|
|
*/
|
|
func (a *TeamAPIService) GetTeamChannels(ctx context.Context) TeamAPIGetTeamChannelsRequest {
|
|
return TeamAPIGetTeamChannelsRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return TeamTeamChannels
|
|
func (a *TeamAPIService) GetTeamChannelsExecute(r TeamAPIGetTeamChannelsRequest) (*TeamTeamChannels, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodGet
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *TeamTeamChannels
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "TeamAPIService.GetTeamChannels")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/team/channels"
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
|
|
// to determine the Content-Type header
|
|
localVarHTTPContentTypes := []string{}
|
|
|
|
// set Content-Type header
|
|
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
|
if localVarHTTPContentType != "" {
|
|
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
|
}
|
|
|
|
// to determine the Accept header
|
|
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
|
|
|
|
// set Accept header
|
|
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
|
if localVarHTTPHeaderAccept != "" {
|
|
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
|
}
|
|
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
|
if err != nil {
|
|
return localVarReturnValue, nil, err
|
|
}
|
|
|
|
localVarHTTPResponse, err := a.client.callAPI(req)
|
|
if err != nil || localVarHTTPResponse == nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
|
localVarHTTPResponse.Body.Close()
|
|
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
|
if err != nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
if localVarHTTPResponse.StatusCode >= 300 {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: localVarHTTPResponse.Status,
|
|
}
|
|
var v ProblemDetails
|
|
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr.error = err.Error()
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
|
newErr.model = v
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: err.Error(),
|
|
}
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
return localVarReturnValue, localVarHTTPResponse, nil
|
|
}
|
|
|
|
type TeamAPIGetTeamChannelsByIdMembersRequest struct {
|
|
ctx context.Context
|
|
ApiService *TeamAPIService
|
|
id string
|
|
space *string
|
|
}
|
|
|
|
// Space names the space holding the channel, and is required for the reason the bind op requires it: a channel id is unique within a space and not across the org, so searching every space for a match would make the answer depend on iteration order.
|
|
func (r TeamAPIGetTeamChannelsByIdMembersRequest) Space(space string) TeamAPIGetTeamChannelsByIdMembersRequest {
|
|
r.space = &space
|
|
return r
|
|
}
|
|
|
|
func (r TeamAPIGetTeamChannelsByIdMembersRequest) Execute() (*TeamTeamChannelMembers, *http.Response, error) {
|
|
return r.ApiService.GetTeamChannelsByIdMembersExecute(r)
|
|
}
|
|
|
|
/*
|
|
GetTeamChannelsByIdMembers Returns the people and agents in one channel, as the roster describes them.
|
|
|
|
Returns the people and agents in one channel, as the roster
|
|
describes them. The caller must be able to see the channel.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@param id ID is the channel, from the path. The URL is the authority.
|
|
@return TeamAPIGetTeamChannelsByIdMembersRequest
|
|
*/
|
|
func (a *TeamAPIService) GetTeamChannelsByIdMembers(ctx context.Context, id string) TeamAPIGetTeamChannelsByIdMembersRequest {
|
|
return TeamAPIGetTeamChannelsByIdMembersRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
id: id,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return TeamTeamChannelMembers
|
|
func (a *TeamAPIService) GetTeamChannelsByIdMembersExecute(r TeamAPIGetTeamChannelsByIdMembersRequest) (*TeamTeamChannelMembers, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodGet
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *TeamTeamChannelMembers
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "TeamAPIService.GetTeamChannelsByIdMembers")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/team/channels/{id}/members"
|
|
localVarPath = strings.Replace(localVarPath, "{"+"id"+"}", url.PathEscape(parameterValueToString(r.id, "id")), -1)
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
|
|
if r.space != nil {
|
|
parameterAddToHeaderOrQuery(localVarQueryParams, "space", r.space, "form", "")
|
|
}
|
|
// to determine the Content-Type header
|
|
localVarHTTPContentTypes := []string{}
|
|
|
|
// set Content-Type header
|
|
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
|
if localVarHTTPContentType != "" {
|
|
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
|
}
|
|
|
|
// to determine the Accept header
|
|
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
|
|
|
|
// set Accept header
|
|
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
|
if localVarHTTPHeaderAccept != "" {
|
|
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
|
}
|
|
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
|
if err != nil {
|
|
return localVarReturnValue, nil, err
|
|
}
|
|
|
|
localVarHTTPResponse, err := a.client.callAPI(req)
|
|
if err != nil || localVarHTTPResponse == nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
|
localVarHTTPResponse.Body.Close()
|
|
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
|
if err != nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
if localVarHTTPResponse.StatusCode >= 300 {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: localVarHTTPResponse.Status,
|
|
}
|
|
var v ProblemDetails
|
|
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr.error = err.Error()
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
|
newErr.model = v
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: err.Error(),
|
|
}
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
return localVarReturnValue, localVarHTTPResponse, nil
|
|
}
|
|
|
|
type TeamAPIGetTeamChannelsByIdMessagesRequest struct {
|
|
ctx context.Context
|
|
ApiService *TeamAPIService
|
|
id string
|
|
space *string
|
|
}
|
|
|
|
// Space names the space holding the channel, and is required for the reason the bind op requires it: a channel id is unique within a space and not across the org, so searching every space for a match would make the answer depend on iteration order.
|
|
func (r TeamAPIGetTeamChannelsByIdMessagesRequest) Space(space string) TeamAPIGetTeamChannelsByIdMessagesRequest {
|
|
r.space = &space
|
|
return r
|
|
}
|
|
|
|
func (r TeamAPIGetTeamChannelsByIdMessagesRequest) Execute() (*TeamTeamMessages, *http.Response, error) {
|
|
return r.ApiService.GetTeamChannelsByIdMessagesExecute(r)
|
|
}
|
|
|
|
/*
|
|
GetTeamChannelsByIdMessages Returns the tail of one channel's conversation, oldest first, each message with its reactions, files and thread count.
|
|
|
|
Returns the tail of one channel's conversation, oldest first, each
|
|
message with its reactions, files and thread count.
|
|
|
|
It reads the SAME message documents the transactor serves, so a message typed
|
|
in the Team client is here with no sync. A team member reads any channel they
|
|
may see; an application of the org reads public channels only; anybody else
|
|
without a team session is 401. A channel the caller may not read answers 404
|
|
rather than 403, so a probe learns nothing about what exists.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@param id ID is the channel, from the path. The URL is the authority.
|
|
@return TeamAPIGetTeamChannelsByIdMessagesRequest
|
|
*/
|
|
func (a *TeamAPIService) GetTeamChannelsByIdMessages(ctx context.Context, id string) TeamAPIGetTeamChannelsByIdMessagesRequest {
|
|
return TeamAPIGetTeamChannelsByIdMessagesRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
id: id,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return TeamTeamMessages
|
|
func (a *TeamAPIService) GetTeamChannelsByIdMessagesExecute(r TeamAPIGetTeamChannelsByIdMessagesRequest) (*TeamTeamMessages, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodGet
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *TeamTeamMessages
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "TeamAPIService.GetTeamChannelsByIdMessages")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/team/channels/{id}/messages"
|
|
localVarPath = strings.Replace(localVarPath, "{"+"id"+"}", url.PathEscape(parameterValueToString(r.id, "id")), -1)
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
|
|
if r.space != nil {
|
|
parameterAddToHeaderOrQuery(localVarQueryParams, "space", r.space, "form", "")
|
|
}
|
|
// to determine the Content-Type header
|
|
localVarHTTPContentTypes := []string{}
|
|
|
|
// set Content-Type header
|
|
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
|
if localVarHTTPContentType != "" {
|
|
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
|
}
|
|
|
|
// to determine the Accept header
|
|
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
|
|
|
|
// set Accept header
|
|
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
|
if localVarHTTPHeaderAccept != "" {
|
|
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
|
}
|
|
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
|
if err != nil {
|
|
return localVarReturnValue, nil, err
|
|
}
|
|
|
|
localVarHTTPResponse, err := a.client.callAPI(req)
|
|
if err != nil || localVarHTTPResponse == nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
|
localVarHTTPResponse.Body.Close()
|
|
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
|
if err != nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
if localVarHTTPResponse.StatusCode >= 300 {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: localVarHTTPResponse.Status,
|
|
}
|
|
var v ProblemDetails
|
|
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr.error = err.Error()
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
|
newErr.model = v
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: err.Error(),
|
|
}
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
return localVarReturnValue, localVarHTTPResponse, nil
|
|
}
|
|
|
|
type TeamAPIGetTeamCollaboratorRequest struct {
|
|
ctx context.Context
|
|
ApiService *TeamAPIService
|
|
}
|
|
|
|
func (r TeamAPIGetTeamCollaboratorRequest) Execute() (*http.Response, error) {
|
|
return r.ApiService.GetTeamCollaboratorExecute(r)
|
|
}
|
|
|
|
/*
|
|
GetTeamCollaborator Open the live collaborative-editing socket
|
|
|
|
Upgrades to the hocuspocus WebSocket the Team editor syncs its Y.js documents over: binary frames of document name, message type and payload, with ONE socket multiplexing every document a tab has open. The server is a relay and an ordered update log, not a CRDT engine — it replays the log to each joining peer and broadcasts every update to the rest, which converges because Y.js updates are commutative and idempotent. There is no body; the response is a protocol upgrade.
|
|
|
|
BOTH LANES SHARE ONE ROOT. The client derives them from one configured URL — this socket at its root, the markup-snapshot RPC one segment in — so pointing the editor at this service is one value, and the two lanes cannot drift apart.
|
|
|
|
AUTH IS IN-BAND, PER DOCUMENT, NOT ON THE UPGRADE. The handshake gates only on browser Origin (403 outside the team surfaces; no Origin at all is admitted, which is what a non-browser sends), and then the first frame for a document must be an Auth message carrying the same session or space token every other team route verifies — a browser WebSocket cannot set an Authorization header, which is why the token rides inside the protocol. Anything else on an unauthenticated document is answered with one permission denial and nothing further.
|
|
|
|
Every document is authorized on its own: the document's space must be the token's space when the token pins one, and the caller must be a member of it. A mismatch, an unknown space and a non-member deny alike with "document not found". Rooms are keyed by org and space and the persisted log's key embeds both, so a foreign document id can neither join a room nor read a blob.
|
|
|
|
The server pings every twenty seconds and drops a socket silent for sixty, so a backgrounded tab — whose JS timers are throttled but whose network stack still auto-pongs — stays connected instead of dying into a reconnect loop.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@return TeamAPIGetTeamCollaboratorRequest
|
|
*/
|
|
func (a *TeamAPIService) GetTeamCollaborator(ctx context.Context) TeamAPIGetTeamCollaboratorRequest {
|
|
return TeamAPIGetTeamCollaboratorRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
func (a *TeamAPIService) GetTeamCollaboratorExecute(r TeamAPIGetTeamCollaboratorRequest) (*http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodGet
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "TeamAPIService.GetTeamCollaborator")
|
|
if err != nil {
|
|
return nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/team/collaborator"
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
|
|
// to determine the Content-Type header
|
|
localVarHTTPContentTypes := []string{}
|
|
|
|
// set Content-Type header
|
|
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
|
if localVarHTTPContentType != "" {
|
|
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
|
}
|
|
|
|
// to determine the Accept header
|
|
localVarHTTPHeaderAccepts := []string{}
|
|
|
|
// set Accept header
|
|
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
|
if localVarHTTPHeaderAccept != "" {
|
|
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
|
}
|
|
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
localVarHTTPResponse, err := a.client.callAPI(req)
|
|
if err != nil || localVarHTTPResponse == nil {
|
|
return localVarHTTPResponse, err
|
|
}
|
|
|
|
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
|
localVarHTTPResponse.Body.Close()
|
|
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
|
if err != nil {
|
|
return localVarHTTPResponse, err
|
|
}
|
|
|
|
if localVarHTTPResponse.StatusCode >= 300 {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: localVarHTTPResponse.Status,
|
|
}
|
|
return localVarHTTPResponse, newErr
|
|
}
|
|
|
|
return localVarHTTPResponse, nil
|
|
}
|
|
|
|
type TeamAPIGetTeamDocsRequest struct {
|
|
ctx context.Context
|
|
ApiService *TeamAPIService
|
|
space *string
|
|
teamspace *string
|
|
parent *string
|
|
}
|
|
|
|
// Space is the space uuid. Optional for a caller in exactly one space.
|
|
func (r TeamAPIGetTeamDocsRequest) Space(space string) TeamAPIGetTeamDocsRequest {
|
|
r.space = &space
|
|
return r
|
|
}
|
|
|
|
// Teamspace narrows the answer to one teamspace.
|
|
func (r TeamAPIGetTeamDocsRequest) Teamspace(teamspace string) TeamAPIGetTeamDocsRequest {
|
|
r.teamspace = &teamspace
|
|
return r
|
|
}
|
|
|
|
// Parent narrows the answer to one document's children.
|
|
func (r TeamAPIGetTeamDocsRequest) Parent(parent string) TeamAPIGetTeamDocsRequest {
|
|
r.parent = &parent
|
|
return r
|
|
}
|
|
|
|
func (r TeamAPIGetTeamDocsRequest) Execute() (*TeamTeamDocs, *http.Response, error) {
|
|
return r.ApiService.GetTeamDocsExecute(r)
|
|
}
|
|
|
|
/*
|
|
GetTeamDocs Returns the documents of a space the caller may see, with the teamspaces they are grouped in.
|
|
|
|
Returns the documents of a space the caller may see, with the
|
|
teamspaces they are grouped in.
|
|
|
|
These are the Team client's own document rows, so a page created there is
|
|
here with no sync. Each carries the `collaborator` id its body opens with on
|
|
the /v1/team/collaborator socket. A private teamspace's documents are listed
|
|
only for its members.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@return TeamAPIGetTeamDocsRequest
|
|
*/
|
|
func (a *TeamAPIService) GetTeamDocs(ctx context.Context) TeamAPIGetTeamDocsRequest {
|
|
return TeamAPIGetTeamDocsRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return TeamTeamDocs
|
|
func (a *TeamAPIService) GetTeamDocsExecute(r TeamAPIGetTeamDocsRequest) (*TeamTeamDocs, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodGet
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *TeamTeamDocs
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "TeamAPIService.GetTeamDocs")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/team/docs"
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
|
|
if r.space != nil {
|
|
parameterAddToHeaderOrQuery(localVarQueryParams, "space", r.space, "form", "")
|
|
}
|
|
if r.teamspace != nil {
|
|
parameterAddToHeaderOrQuery(localVarQueryParams, "teamspace", r.teamspace, "form", "")
|
|
}
|
|
if r.parent != nil {
|
|
parameterAddToHeaderOrQuery(localVarQueryParams, "parent", r.parent, "form", "")
|
|
}
|
|
// to determine the Content-Type header
|
|
localVarHTTPContentTypes := []string{}
|
|
|
|
// set Content-Type header
|
|
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
|
if localVarHTTPContentType != "" {
|
|
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
|
}
|
|
|
|
// to determine the Accept header
|
|
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
|
|
|
|
// set Accept header
|
|
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
|
if localVarHTTPHeaderAccept != "" {
|
|
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
|
}
|
|
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
|
if err != nil {
|
|
return localVarReturnValue, nil, err
|
|
}
|
|
|
|
localVarHTTPResponse, err := a.client.callAPI(req)
|
|
if err != nil || localVarHTTPResponse == nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
|
localVarHTTPResponse.Body.Close()
|
|
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
|
if err != nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
if localVarHTTPResponse.StatusCode >= 300 {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: localVarHTTPResponse.Status,
|
|
}
|
|
var v ProblemDetails
|
|
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr.error = err.Error()
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
|
newErr.model = v
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: err.Error(),
|
|
}
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
return localVarReturnValue, localVarHTTPResponse, nil
|
|
}
|
|
|
|
type TeamAPIGetTeamDocsByIdRequest struct {
|
|
ctx context.Context
|
|
ApiService *TeamAPIService
|
|
id string
|
|
space *string
|
|
}
|
|
|
|
// Space is the space uuid holding it.
|
|
func (r TeamAPIGetTeamDocsByIdRequest) Space(space string) TeamAPIGetTeamDocsByIdRequest {
|
|
r.space = &space
|
|
return r
|
|
}
|
|
|
|
func (r TeamAPIGetTeamDocsByIdRequest) Execute() (*TeamTeamDoc, *http.Response, error) {
|
|
return r.ApiService.GetTeamDocsByIdExecute(r)
|
|
}
|
|
|
|
/*
|
|
GetTeamDocsById Returns one document the caller may see.
|
|
|
|
Returns one document the caller may see.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@param id ID is the document, from the path.
|
|
@return TeamAPIGetTeamDocsByIdRequest
|
|
*/
|
|
func (a *TeamAPIService) GetTeamDocsById(ctx context.Context, id string) TeamAPIGetTeamDocsByIdRequest {
|
|
return TeamAPIGetTeamDocsByIdRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
id: id,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return TeamTeamDoc
|
|
func (a *TeamAPIService) GetTeamDocsByIdExecute(r TeamAPIGetTeamDocsByIdRequest) (*TeamTeamDoc, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodGet
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *TeamTeamDoc
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "TeamAPIService.GetTeamDocsById")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/team/docs/{id}"
|
|
localVarPath = strings.Replace(localVarPath, "{"+"id"+"}", url.PathEscape(parameterValueToString(r.id, "id")), -1)
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
|
|
if r.space != nil {
|
|
parameterAddToHeaderOrQuery(localVarQueryParams, "space", r.space, "form", "")
|
|
}
|
|
// to determine the Content-Type header
|
|
localVarHTTPContentTypes := []string{}
|
|
|
|
// set Content-Type header
|
|
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
|
if localVarHTTPContentType != "" {
|
|
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
|
}
|
|
|
|
// to determine the Accept header
|
|
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
|
|
|
|
// set Accept header
|
|
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
|
if localVarHTTPHeaderAccept != "" {
|
|
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
|
}
|
|
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
|
if err != nil {
|
|
return localVarReturnValue, nil, err
|
|
}
|
|
|
|
localVarHTTPResponse, err := a.client.callAPI(req)
|
|
if err != nil || localVarHTTPResponse == nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
|
localVarHTTPResponse.Body.Close()
|
|
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
|
if err != nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
if localVarHTTPResponse.StatusCode >= 300 {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: localVarHTTPResponse.Status,
|
|
}
|
|
var v ProblemDetails
|
|
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr.error = err.Error()
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
|
newErr.model = v
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: err.Error(),
|
|
}
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
return localVarReturnValue, localVarHTTPResponse, nil
|
|
}
|
|
|
|
type TeamAPIGetTeamDocsByIdCommentsRequest struct {
|
|
ctx context.Context
|
|
ApiService *TeamAPIService
|
|
id string
|
|
space *string
|
|
}
|
|
|
|
// Space is the space uuid holding it.
|
|
func (r TeamAPIGetTeamDocsByIdCommentsRequest) Space(space string) TeamAPIGetTeamDocsByIdCommentsRequest {
|
|
r.space = &space
|
|
return r
|
|
}
|
|
|
|
func (r TeamAPIGetTeamDocsByIdCommentsRequest) Execute() (*TeamTeamMessages, *http.Response, error) {
|
|
return r.ApiService.GetTeamDocsByIdCommentsExecute(r)
|
|
}
|
|
|
|
/*
|
|
GetTeamDocsByIdComments Returns the comments on a document, oldest first — the same message shape a channel's conversation answers.
|
|
|
|
Returns the comments on a document, oldest first — the same
|
|
message shape a channel's conversation answers.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@param id ID is the document, from the path.
|
|
@return TeamAPIGetTeamDocsByIdCommentsRequest
|
|
*/
|
|
func (a *TeamAPIService) GetTeamDocsByIdComments(ctx context.Context, id string) TeamAPIGetTeamDocsByIdCommentsRequest {
|
|
return TeamAPIGetTeamDocsByIdCommentsRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
id: id,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return TeamTeamMessages
|
|
func (a *TeamAPIService) GetTeamDocsByIdCommentsExecute(r TeamAPIGetTeamDocsByIdCommentsRequest) (*TeamTeamMessages, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodGet
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *TeamTeamMessages
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "TeamAPIService.GetTeamDocsByIdComments")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/team/docs/{id}/comments"
|
|
localVarPath = strings.Replace(localVarPath, "{"+"id"+"}", url.PathEscape(parameterValueToString(r.id, "id")), -1)
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
|
|
if r.space != nil {
|
|
parameterAddToHeaderOrQuery(localVarQueryParams, "space", r.space, "form", "")
|
|
}
|
|
// to determine the Content-Type header
|
|
localVarHTTPContentTypes := []string{}
|
|
|
|
// set Content-Type header
|
|
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
|
if localVarHTTPContentType != "" {
|
|
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
|
}
|
|
|
|
// to determine the Accept header
|
|
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
|
|
|
|
// set Accept header
|
|
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
|
if localVarHTTPHeaderAccept != "" {
|
|
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
|
}
|
|
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
|
if err != nil {
|
|
return localVarReturnValue, nil, err
|
|
}
|
|
|
|
localVarHTTPResponse, err := a.client.callAPI(req)
|
|
if err != nil || localVarHTTPResponse == nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
|
localVarHTTPResponse.Body.Close()
|
|
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
|
if err != nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
if localVarHTTPResponse.StatusCode >= 300 {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: localVarHTTPResponse.Status,
|
|
}
|
|
var v ProblemDetails
|
|
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr.error = err.Error()
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
|
newErr.model = v
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: err.Error(),
|
|
}
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
return localVarReturnValue, localVarHTTPResponse, nil
|
|
}
|
|
|
|
type TeamAPIGetTeamEventsRequest struct {
|
|
ctx context.Context
|
|
ApiService *TeamAPIService
|
|
}
|
|
|
|
func (r TeamAPIGetTeamEventsRequest) Execute() (*os.File, *http.Response, error) {
|
|
return r.ApiService.GetTeamEventsExecute(r)
|
|
}
|
|
|
|
/*
|
|
GetTeamEvents Stream live changes to what the caller may see, as Server-Sent Events
|
|
|
|
Holds one text/event-stream open per caller and pushes each change as it is written — by the Team client, a typed op or an agent — filtered to the channels, documents and inbox the caller may see under the same rule the ops apply. Authenticate with `Authorization: Bearer` (a fetch-based SSE reader; a browser EventSource cannot set it). `?space=` narrows the stream to one space; without it the stream covers every space the caller is a member of at connect.
|
|
|
|
Each frame is `event: <name>` and a JSON `data:` line carrying `space` and one of:
|
|
- `message.created`, `message.updated` — `message`, the message as the message ops answer it (a channel message, a thread reply or a document comment; a count or reaction change is an update);
|
|
- `message.deleted` — `id`, and `channel`/`doc`/`thread` where known;
|
|
- `reaction.changed` — `message`, with its reactions as they now stand;
|
|
- `channel.changed` — `channel`, as the channel listing answers it, sent to those who can see it after the change (somebody removed from a private channel is not told; the channel list is the truth);
|
|
- `doc.changed` — `doc`, as the document ops answer it (`removed: true` and `id` when deleted); body edits happen on the collaborator socket and are not streamed here;
|
|
- `inbox.created`, `inbox.updated` — `item`, one of the caller's own notifications.
|
|
|
|
A `: ping` comment is written every 25 seconds. There is no resume: the server keeps no event sequence, so frames carry no `id` and Last-Event-ID is ignored; on reconnect, re-read the ops. A stream that falls too far behind is closed rather than allowed to slow a writer, and so is one whose caller is no longer a member of the space an event is in. 401 without a verified team credential; 404 for a named space the caller is not in.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@return TeamAPIGetTeamEventsRequest
|
|
*/
|
|
func (a *TeamAPIService) GetTeamEvents(ctx context.Context) TeamAPIGetTeamEventsRequest {
|
|
return TeamAPIGetTeamEventsRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return *os.File
|
|
func (a *TeamAPIService) GetTeamEventsExecute(r TeamAPIGetTeamEventsRequest) (*os.File, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodGet
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *os.File
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "TeamAPIService.GetTeamEvents")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/team/events"
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
|
|
// to determine the Content-Type header
|
|
localVarHTTPContentTypes := []string{}
|
|
|
|
// set Content-Type header
|
|
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
|
if localVarHTTPContentType != "" {
|
|
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
|
}
|
|
|
|
// to determine the Accept header
|
|
localVarHTTPHeaderAccepts := []string{"text/event-stream"}
|
|
|
|
// set Accept header
|
|
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
|
if localVarHTTPHeaderAccept != "" {
|
|
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
|
}
|
|
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
|
if err != nil {
|
|
return localVarReturnValue, nil, err
|
|
}
|
|
|
|
localVarHTTPResponse, err := a.client.callAPI(req)
|
|
if err != nil || localVarHTTPResponse == nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
|
localVarHTTPResponse.Body.Close()
|
|
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
|
if err != nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
if localVarHTTPResponse.StatusCode >= 300 {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: localVarHTTPResponse.Status,
|
|
}
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: err.Error(),
|
|
}
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
return localVarReturnValue, localVarHTTPResponse, nil
|
|
}
|
|
|
|
type TeamAPIGetTeamFilesBySpaceByFilenameRequest struct {
|
|
ctx context.Context
|
|
ApiService *TeamAPIService
|
|
space string
|
|
filename string
|
|
}
|
|
|
|
func (r TeamAPIGetTeamFilesBySpaceByFilenameRequest) Execute() (*os.File, *http.Response, error) {
|
|
return r.ApiService.GetTeamFilesBySpaceByFilenameExecute(r)
|
|
}
|
|
|
|
/*
|
|
GetTeamFilesBySpaceByFilename Download a space file
|
|
|
|
Streams one blob's raw BYTES back — this is the read side of the space file store, not a JSON envelope around it.
|
|
|
|
THE BLOB IS NAMED BY THE `file` QUERY PARAMETER, NOT BY :filename. The path segment is only the name a browser saves the download under; a request without ?file= is a 400 no matter what the path says.
|
|
|
|
The Content-Type is derived from the STORED BYTES, never from the name: only png, jpeg, gif and webp, recognized by their magic bytes, are served inline under their true type, and everything else is served inert as application/octet-stream with an attachment disposition. Every response carries nosniff, so a file uploaded under an .svg or .html name cannot be talked into executing in a viewer's origin. Blobs are immutable, so a hit caches privately for a year.
|
|
|
|
Same gate as the upload: verified token, membership of the space. A genuine miss, another tenant's space, a space the caller is not in, and a blob id belonging to a different space are ONE answer — 404 — because the physical key is org- and space-scoped and a foreign id is simply a key that does not exist. An unavailable backend is a 502, never an empty 200.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@param space
|
|
@param filename
|
|
@return TeamAPIGetTeamFilesBySpaceByFilenameRequest
|
|
*/
|
|
func (a *TeamAPIService) GetTeamFilesBySpaceByFilename(ctx context.Context, space string, filename string) TeamAPIGetTeamFilesBySpaceByFilenameRequest {
|
|
return TeamAPIGetTeamFilesBySpaceByFilenameRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
space: space,
|
|
filename: filename,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return *os.File
|
|
func (a *TeamAPIService) GetTeamFilesBySpaceByFilenameExecute(r TeamAPIGetTeamFilesBySpaceByFilenameRequest) (*os.File, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodGet
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *os.File
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "TeamAPIService.GetTeamFilesBySpaceByFilename")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/team/files/{space}/{filename}"
|
|
localVarPath = strings.Replace(localVarPath, "{"+"space"+"}", url.PathEscape(parameterValueToString(r.space, "space")), -1)
|
|
localVarPath = strings.Replace(localVarPath, "{"+"filename"+"}", url.PathEscape(parameterValueToString(r.filename, "filename")), -1)
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
|
|
// to determine the Content-Type header
|
|
localVarHTTPContentTypes := []string{}
|
|
|
|
// set Content-Type header
|
|
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
|
if localVarHTTPContentType != "" {
|
|
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
|
}
|
|
|
|
// to determine the Accept header
|
|
localVarHTTPHeaderAccepts := []string{"application/octet-stream"}
|
|
|
|
// set Accept header
|
|
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
|
if localVarHTTPHeaderAccept != "" {
|
|
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
|
}
|
|
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
|
if err != nil {
|
|
return localVarReturnValue, nil, err
|
|
}
|
|
|
|
localVarHTTPResponse, err := a.client.callAPI(req)
|
|
if err != nil || localVarHTTPResponse == nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
|
localVarHTTPResponse.Body.Close()
|
|
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
|
if err != nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
if localVarHTTPResponse.StatusCode >= 300 {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: localVarHTTPResponse.Status,
|
|
}
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: err.Error(),
|
|
}
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
return localVarReturnValue, localVarHTTPResponse, nil
|
|
}
|
|
|
|
type TeamAPIGetTeamInboxRequest struct {
|
|
ctx context.Context
|
|
ApiService *TeamAPIService
|
|
space *string
|
|
archived *bool
|
|
}
|
|
|
|
// Space is the space uuid. Optional for a caller in exactly one space.
|
|
func (r TeamAPIGetTeamInboxRequest) Space(space string) TeamAPIGetTeamInboxRequest {
|
|
r.space = &space
|
|
return r
|
|
}
|
|
|
|
// Archived lists the archived notifications instead of the live ones.
|
|
func (r TeamAPIGetTeamInboxRequest) Archived(archived bool) TeamAPIGetTeamInboxRequest {
|
|
r.archived = &archived
|
|
return r
|
|
}
|
|
|
|
func (r TeamAPIGetTeamInboxRequest) Execute() (*TeamTeamInbox, *http.Response, error) {
|
|
return r.ApiService.GetTeamInboxExecute(r)
|
|
}
|
|
|
|
/*
|
|
GetTeamInbox Returns the caller's notifications, newest first, each with the channel or document it is about and the message that caused it.
|
|
|
|
Returns the caller's notifications, newest first, each with the
|
|
channel or document it is about and the message that caused it.
|
|
|
|
These are the rows the Team client's Inbox reads, so a notification cleared
|
|
there is cleared here. Only the caller's own notifications are ever listed.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@return TeamAPIGetTeamInboxRequest
|
|
*/
|
|
func (a *TeamAPIService) GetTeamInbox(ctx context.Context) TeamAPIGetTeamInboxRequest {
|
|
return TeamAPIGetTeamInboxRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return TeamTeamInbox
|
|
func (a *TeamAPIService) GetTeamInboxExecute(r TeamAPIGetTeamInboxRequest) (*TeamTeamInbox, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodGet
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *TeamTeamInbox
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "TeamAPIService.GetTeamInbox")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/team/inbox"
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
|
|
if r.space != nil {
|
|
parameterAddToHeaderOrQuery(localVarQueryParams, "space", r.space, "form", "")
|
|
}
|
|
if r.archived != nil {
|
|
parameterAddToHeaderOrQuery(localVarQueryParams, "archived", r.archived, "form", "")
|
|
}
|
|
// to determine the Content-Type header
|
|
localVarHTTPContentTypes := []string{}
|
|
|
|
// set Content-Type header
|
|
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
|
if localVarHTTPContentType != "" {
|
|
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
|
}
|
|
|
|
// to determine the Accept header
|
|
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
|
|
|
|
// set Accept header
|
|
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
|
if localVarHTTPHeaderAccept != "" {
|
|
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
|
}
|
|
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
|
if err != nil {
|
|
return localVarReturnValue, nil, err
|
|
}
|
|
|
|
localVarHTTPResponse, err := a.client.callAPI(req)
|
|
if err != nil || localVarHTTPResponse == nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
|
localVarHTTPResponse.Body.Close()
|
|
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
|
if err != nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
if localVarHTTPResponse.StatusCode >= 300 {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: localVarHTTPResponse.Status,
|
|
}
|
|
var v ProblemDetails
|
|
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr.error = err.Error()
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
|
newErr.model = v
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: err.Error(),
|
|
}
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
return localVarReturnValue, localVarHTTPResponse, nil
|
|
}
|
|
|
|
type TeamAPIGetTeamMembersRequest struct {
|
|
ctx context.Context
|
|
ApiService *TeamAPIService
|
|
space *string
|
|
}
|
|
|
|
// Space is the space uuid. Optional for a caller in exactly one space.
|
|
func (r TeamAPIGetTeamMembersRequest) Space(space string) TeamAPIGetTeamMembersRequest {
|
|
r.space = &space
|
|
return r
|
|
}
|
|
|
|
func (r TeamAPIGetTeamMembersRequest) Execute() (*TeamTeamMembers, *http.Response, error) {
|
|
return r.ApiService.GetTeamMembersExecute(r)
|
|
}
|
|
|
|
/*
|
|
GetTeamMembers Returns the people and agents in a space, with the name, avatar, role and presence a client draws them with.
|
|
|
|
Returns the people and agents in a space, with the name, avatar,
|
|
role and presence a client draws them with.
|
|
|
|
People come from IAM, the membership authority; agents from the org's agent
|
|
registry; avatars from the Person documents the Team client edits. An IAM that
|
|
does not answer is a 502 rather than an empty roster, and an agent registry
|
|
that does not answer is named in `degraded` beside the people who did load.
|
|
The caller must be a member of the space.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@return TeamAPIGetTeamMembersRequest
|
|
*/
|
|
func (a *TeamAPIService) GetTeamMembers(ctx context.Context) TeamAPIGetTeamMembersRequest {
|
|
return TeamAPIGetTeamMembersRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return TeamTeamMembers
|
|
func (a *TeamAPIService) GetTeamMembersExecute(r TeamAPIGetTeamMembersRequest) (*TeamTeamMembers, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodGet
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *TeamTeamMembers
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "TeamAPIService.GetTeamMembers")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/team/members"
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
|
|
if r.space != nil {
|
|
parameterAddToHeaderOrQuery(localVarQueryParams, "space", r.space, "form", "")
|
|
}
|
|
// to determine the Content-Type header
|
|
localVarHTTPContentTypes := []string{}
|
|
|
|
// set Content-Type header
|
|
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
|
if localVarHTTPContentType != "" {
|
|
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
|
}
|
|
|
|
// to determine the Accept header
|
|
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
|
|
|
|
// set Accept header
|
|
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
|
if localVarHTTPHeaderAccept != "" {
|
|
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
|
}
|
|
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
|
if err != nil {
|
|
return localVarReturnValue, nil, err
|
|
}
|
|
|
|
localVarHTTPResponse, err := a.client.callAPI(req)
|
|
if err != nil || localVarHTTPResponse == nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
|
localVarHTTPResponse.Body.Close()
|
|
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
|
if err != nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
if localVarHTTPResponse.StatusCode >= 300 {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: localVarHTTPResponse.Status,
|
|
}
|
|
var v ProblemDetails
|
|
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr.error = err.Error()
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
|
newErr.model = v
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: err.Error(),
|
|
}
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
return localVarReturnValue, localVarHTTPResponse, nil
|
|
}
|
|
|
|
type TeamAPIGetTeamMessagesByIdRepliesRequest struct {
|
|
ctx context.Context
|
|
ApiService *TeamAPIService
|
|
id string
|
|
space *string
|
|
}
|
|
|
|
// Space names the space holding it. A message id is unique within a space, not across the org.
|
|
func (r TeamAPIGetTeamMessagesByIdRepliesRequest) Space(space string) TeamAPIGetTeamMessagesByIdRepliesRequest {
|
|
r.space = &space
|
|
return r
|
|
}
|
|
|
|
func (r TeamAPIGetTeamMessagesByIdRepliesRequest) Execute() (*TeamTeamMessages, *http.Response, error) {
|
|
return r.ApiService.GetTeamMessagesByIdRepliesExecute(r)
|
|
}
|
|
|
|
/*
|
|
GetTeamMessagesByIdReplies Returns a message's thread, oldest first, each reply with its reactions and files.
|
|
|
|
Returns a message's thread, oldest first, each reply with its
|
|
reactions and files.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@param id ID is the message, from the path.
|
|
@return TeamAPIGetTeamMessagesByIdRepliesRequest
|
|
*/
|
|
func (a *TeamAPIService) GetTeamMessagesByIdReplies(ctx context.Context, id string) TeamAPIGetTeamMessagesByIdRepliesRequest {
|
|
return TeamAPIGetTeamMessagesByIdRepliesRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
id: id,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return TeamTeamMessages
|
|
func (a *TeamAPIService) GetTeamMessagesByIdRepliesExecute(r TeamAPIGetTeamMessagesByIdRepliesRequest) (*TeamTeamMessages, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodGet
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *TeamTeamMessages
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "TeamAPIService.GetTeamMessagesByIdReplies")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/team/messages/{id}/replies"
|
|
localVarPath = strings.Replace(localVarPath, "{"+"id"+"}", url.PathEscape(parameterValueToString(r.id, "id")), -1)
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
|
|
if r.space != nil {
|
|
parameterAddToHeaderOrQuery(localVarQueryParams, "space", r.space, "form", "")
|
|
}
|
|
// to determine the Content-Type header
|
|
localVarHTTPContentTypes := []string{}
|
|
|
|
// set Content-Type header
|
|
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
|
if localVarHTTPContentType != "" {
|
|
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
|
}
|
|
|
|
// to determine the Accept header
|
|
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
|
|
|
|
// set Accept header
|
|
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
|
if localVarHTTPHeaderAccept != "" {
|
|
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
|
}
|
|
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
|
if err != nil {
|
|
return localVarReturnValue, nil, err
|
|
}
|
|
|
|
localVarHTTPResponse, err := a.client.callAPI(req)
|
|
if err != nil || localVarHTTPResponse == nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
|
localVarHTTPResponse.Body.Close()
|
|
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
|
if err != nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
if localVarHTTPResponse.StatusCode >= 300 {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: localVarHTTPResponse.Status,
|
|
}
|
|
var v ProblemDetails
|
|
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr.error = err.Error()
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
|
newErr.model = v
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: err.Error(),
|
|
}
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
return localVarReturnValue, localVarHTTPResponse, nil
|
|
}
|
|
|
|
type TeamAPIGetTeamPublicRequest struct {
|
|
ctx context.Context
|
|
ApiService *TeamAPIService
|
|
q *string
|
|
org *string
|
|
limit *int64
|
|
}
|
|
|
|
// Q matches a channel's name or its topic.
|
|
func (r TeamAPIGetTeamPublicRequest) Q(q string) TeamAPIGetTeamPublicRequest {
|
|
r.q = &q
|
|
return r
|
|
}
|
|
|
|
// Org narrows to one org's published channels.
|
|
func (r TeamAPIGetTeamPublicRequest) Org(org string) TeamAPIGetTeamPublicRequest {
|
|
r.org = &org
|
|
return r
|
|
}
|
|
|
|
// Limit caps the page, 50 when unstated and 200 at most. An unparseable value reads as unstated rather than as zero — zero pages is not an answer anybody asked for.
|
|
func (r TeamAPIGetTeamPublicRequest) Limit(limit int64) TeamAPIGetTeamPublicRequest {
|
|
r.limit = &limit
|
|
return r
|
|
}
|
|
|
|
func (r TeamAPIGetTeamPublicRequest) Execute() (*TeamPublicChannels, *http.Response, error) {
|
|
return r.ApiService.GetTeamPublicExecute(r)
|
|
}
|
|
|
|
/*
|
|
GetTeamPublic Lists the channels orgs have published, across every org.
|
|
|
|
Lists the channels orgs have published, across every org.
|
|
|
|
It is NOT part of GET /channels, and the separation is the point: that address
|
|
answers the CALLER'S channels, so folding these in would put strangers' channels
|
|
in somebody's own sidebar.
|
|
|
|
It reads the directory and never a tenant's store. Every field it can answer
|
|
with is one an org published by making a channel public, so there is nothing here
|
|
to scope by org — a directory only its own org can read is not a directory.
|
|
An authenticated principal is still required, because an anonymous crawler is
|
|
not who this is for.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@return TeamAPIGetTeamPublicRequest
|
|
*/
|
|
func (a *TeamAPIService) GetTeamPublic(ctx context.Context) TeamAPIGetTeamPublicRequest {
|
|
return TeamAPIGetTeamPublicRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return TeamPublicChannels
|
|
func (a *TeamAPIService) GetTeamPublicExecute(r TeamAPIGetTeamPublicRequest) (*TeamPublicChannels, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodGet
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *TeamPublicChannels
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "TeamAPIService.GetTeamPublic")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/team/public"
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
|
|
if r.q != nil {
|
|
parameterAddToHeaderOrQuery(localVarQueryParams, "q", r.q, "form", "")
|
|
}
|
|
if r.org != nil {
|
|
parameterAddToHeaderOrQuery(localVarQueryParams, "org", r.org, "form", "")
|
|
}
|
|
if r.limit != nil {
|
|
parameterAddToHeaderOrQuery(localVarQueryParams, "limit", r.limit, "form", "")
|
|
}
|
|
// to determine the Content-Type header
|
|
localVarHTTPContentTypes := []string{}
|
|
|
|
// set Content-Type header
|
|
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
|
if localVarHTTPContentType != "" {
|
|
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
|
}
|
|
|
|
// to determine the Accept header
|
|
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
|
|
|
|
// set Accept header
|
|
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
|
if localVarHTTPHeaderAccept != "" {
|
|
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
|
}
|
|
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
|
if err != nil {
|
|
return localVarReturnValue, nil, err
|
|
}
|
|
|
|
localVarHTTPResponse, err := a.client.callAPI(req)
|
|
if err != nil || localVarHTTPResponse == nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
|
localVarHTTPResponse.Body.Close()
|
|
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
|
if err != nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
if localVarHTTPResponse.StatusCode >= 300 {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: localVarHTTPResponse.Status,
|
|
}
|
|
var v ProblemDetails
|
|
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr.error = err.Error()
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
|
newErr.model = v
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: err.Error(),
|
|
}
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
return localVarReturnValue, localVarHTTPResponse, nil
|
|
}
|
|
|
|
type TeamAPIGetTeamTransactorByTokenRequest struct {
|
|
ctx context.Context
|
|
ApiService *TeamAPIService
|
|
token string
|
|
}
|
|
|
|
func (r TeamAPIGetTeamTransactorByTokenRequest) Execute() (*http.Response, error) {
|
|
return r.ApiService.GetTeamTransactorByTokenExecute(r)
|
|
}
|
|
|
|
/*
|
|
GetTeamTransactorByToken Open the space data-plane socket
|
|
|
|
Upgrades to the WebSocket the Team client runs an entire space over: every frame is a ZAP envelope wrapping one JSON-RPC message — findAll/findOne reads against the space's documents, tx writes that broadcast to the other live sessions, hello negotiating JSON rather than msgpack. The response is a protocol upgrade, so there is no body to read.
|
|
|
|
THE PATH SEGMENT IS THE CREDENTIAL. It is the space token selectWorkspace minted — bearer-equivalent, and sitting in a URL that proxies and access logs record, which is exactly why it expires in twelve hours and is re-minted on demand rather than being long-lived like the session token. It is decoded and verified (signature and expiry) BEFORE the upgrade, so a bad one is a 401 and never a socket that is accepted and then dropped, and it must carry both an account and a space claim. Nothing ambient authorizes this socket: a WebSocket is exempt from CORS, so a cookie-borne credential would make the Origin check the only access control on the whole data plane.
|
|
|
|
The tenant is the token's SIGNED org claim and it keys every store path, so no header can name another space's data. The upgrade ALSO refuses a browser Origin outside the team surfaces with 403 — otherwise any page could open an authenticated socket with a token it lured out of a logged-in browser — while a request with no Origin at all is admitted, because that is what a non-browser client sends.
|
|
|
|
On connect the space's system spaces are seeded once and the roster is reconciled every time, so the org's human members and its bots are present as space people without a separate sync call.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@param token
|
|
@return TeamAPIGetTeamTransactorByTokenRequest
|
|
*/
|
|
func (a *TeamAPIService) GetTeamTransactorByToken(ctx context.Context, token string) TeamAPIGetTeamTransactorByTokenRequest {
|
|
return TeamAPIGetTeamTransactorByTokenRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
token: token,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
func (a *TeamAPIService) GetTeamTransactorByTokenExecute(r TeamAPIGetTeamTransactorByTokenRequest) (*http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodGet
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "TeamAPIService.GetTeamTransactorByToken")
|
|
if err != nil {
|
|
return nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/team/transactor/{token}"
|
|
localVarPath = strings.Replace(localVarPath, "{"+"token"+"}", url.PathEscape(parameterValueToString(r.token, "token")), -1)
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
|
|
// to determine the Content-Type header
|
|
localVarHTTPContentTypes := []string{}
|
|
|
|
// set Content-Type header
|
|
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
|
if localVarHTTPContentType != "" {
|
|
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
|
}
|
|
|
|
// to determine the Accept header
|
|
localVarHTTPHeaderAccepts := []string{}
|
|
|
|
// set Accept header
|
|
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
|
if localVarHTTPHeaderAccept != "" {
|
|
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
|
}
|
|
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
localVarHTTPResponse, err := a.client.callAPI(req)
|
|
if err != nil || localVarHTTPResponse == nil {
|
|
return localVarHTTPResponse, err
|
|
}
|
|
|
|
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
|
localVarHTTPResponse.Body.Close()
|
|
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
|
if err != nil {
|
|
return localVarHTTPResponse, err
|
|
}
|
|
|
|
if localVarHTTPResponse.StatusCode >= 300 {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: localVarHTTPResponse.Status,
|
|
}
|
|
return localVarHTTPResponse, newErr
|
|
}
|
|
|
|
return localVarHTTPResponse, nil
|
|
}
|
|
|
|
type TeamAPIGetTeamTransactorStatisticsRequest struct {
|
|
ctx context.Context
|
|
ApiService *TeamAPIService
|
|
token *string
|
|
}
|
|
|
|
// Token is the space token minted by selectWorkspace.
|
|
func (r TeamAPIGetTeamTransactorStatisticsRequest) Token(token string) TeamAPIGetTeamTransactorStatisticsRequest {
|
|
r.token = &token
|
|
return r
|
|
}
|
|
|
|
func (r TeamAPIGetTeamTransactorStatisticsRequest) Execute() (*TeamStatsOut, *http.Response, error) {
|
|
return r.ApiService.GetTeamTransactorStatisticsExecute(r)
|
|
}
|
|
|
|
/*
|
|
GetTeamTransactorStatistics Returns the transactor's live sessions for the space the caller's credential names — the endpoint the front's space switcher and server panel poll on the transactor base.
|
|
|
|
Returns the transactor's live sessions for the space the caller's
|
|
credential names — the endpoint the front's space switcher and server panel
|
|
poll on the transactor base. `token` carries the same two lanes the socket's path
|
|
segment does: a space UUID names the space and is authorized against the
|
|
membership rows, an HS256 space token names it in its signed claims.
|
|
activeSessions carries ONLY that one space, never another tenant's sessions.
|
|
An unverifiable credential, or one the caller is no member under, is 401.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@return TeamAPIGetTeamTransactorStatisticsRequest
|
|
*/
|
|
func (a *TeamAPIService) GetTeamTransactorStatistics(ctx context.Context) TeamAPIGetTeamTransactorStatisticsRequest {
|
|
return TeamAPIGetTeamTransactorStatisticsRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return TeamStatsOut
|
|
func (a *TeamAPIService) GetTeamTransactorStatisticsExecute(r TeamAPIGetTeamTransactorStatisticsRequest) (*TeamStatsOut, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodGet
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *TeamStatsOut
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "TeamAPIService.GetTeamTransactorStatistics")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/team/transactor/statistics"
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
|
|
if r.token != nil {
|
|
parameterAddToHeaderOrQuery(localVarQueryParams, "token", r.token, "form", "")
|
|
}
|
|
// to determine the Content-Type header
|
|
localVarHTTPContentTypes := []string{}
|
|
|
|
// set Content-Type header
|
|
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
|
if localVarHTTPContentType != "" {
|
|
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
|
}
|
|
|
|
// to determine the Accept header
|
|
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
|
|
|
|
// set Accept header
|
|
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
|
if localVarHTTPHeaderAccept != "" {
|
|
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
|
}
|
|
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
|
if err != nil {
|
|
return localVarReturnValue, nil, err
|
|
}
|
|
|
|
localVarHTTPResponse, err := a.client.callAPI(req)
|
|
if err != nil || localVarHTTPResponse == nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
|
localVarHTTPResponse.Body.Close()
|
|
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
|
if err != nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
if localVarHTTPResponse.StatusCode >= 300 {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: localVarHTTPResponse.Status,
|
|
}
|
|
var v ProblemDetails
|
|
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr.error = err.Error()
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
|
newErr.model = v
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: err.Error(),
|
|
}
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
return localVarReturnValue, localVarHTTPResponse, nil
|
|
}
|
|
|
|
type TeamAPIPatchTeamChannelsByIdRequest struct {
|
|
ctx context.Context
|
|
ApiService *TeamAPIService
|
|
id string
|
|
teamTeamChannelEdit *TeamTeamChannelEdit
|
|
}
|
|
|
|
func (r TeamAPIPatchTeamChannelsByIdRequest) TeamTeamChannelEdit(teamTeamChannelEdit TeamTeamChannelEdit) TeamAPIPatchTeamChannelsByIdRequest {
|
|
r.teamTeamChannelEdit = &teamTeamChannelEdit
|
|
return r
|
|
}
|
|
|
|
func (r TeamAPIPatchTeamChannelsByIdRequest) Execute() (*TeamTeamChannelOne, *http.Response, error) {
|
|
return r.ApiService.PatchTeamChannelsByIdExecute(r)
|
|
}
|
|
|
|
/*
|
|
PatchTeamChannelsById Renames a channel, sets its topic, or archives or reopens it, and answers the channel as it now stands.
|
|
|
|
Renames a channel, sets its topic, or archives or reopens it, and
|
|
answers the channel as it now stands.
|
|
|
|
Its owners and the space's admins may edit a channel; a channel nobody owns — one
|
|
opened by an integration — may be edited by anyone in it, and a direct
|
|
message by either person in it. Archiving withdraws a public channel from the
|
|
cross-org directory in the same write; reopening lists it again.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@param id ID is the channel, from the path.
|
|
@return TeamAPIPatchTeamChannelsByIdRequest
|
|
*/
|
|
func (a *TeamAPIService) PatchTeamChannelsById(ctx context.Context, id string) TeamAPIPatchTeamChannelsByIdRequest {
|
|
return TeamAPIPatchTeamChannelsByIdRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
id: id,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return TeamTeamChannelOne
|
|
func (a *TeamAPIService) PatchTeamChannelsByIdExecute(r TeamAPIPatchTeamChannelsByIdRequest) (*TeamTeamChannelOne, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodPatch
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *TeamTeamChannelOne
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "TeamAPIService.PatchTeamChannelsById")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/team/channels/{id}"
|
|
localVarPath = strings.Replace(localVarPath, "{"+"id"+"}", url.PathEscape(parameterValueToString(r.id, "id")), -1)
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
if r.teamTeamChannelEdit == nil {
|
|
return localVarReturnValue, nil, reportError("teamTeamChannelEdit is required and must be specified")
|
|
}
|
|
|
|
// to determine the Content-Type header
|
|
localVarHTTPContentTypes := []string{"application/json"}
|
|
|
|
// set Content-Type header
|
|
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
|
if localVarHTTPContentType != "" {
|
|
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
|
}
|
|
|
|
// to determine the Accept header
|
|
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
|
|
|
|
// set Accept header
|
|
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
|
if localVarHTTPHeaderAccept != "" {
|
|
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
|
}
|
|
// body params
|
|
localVarPostBody = r.teamTeamChannelEdit
|
|
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
|
if err != nil {
|
|
return localVarReturnValue, nil, err
|
|
}
|
|
|
|
localVarHTTPResponse, err := a.client.callAPI(req)
|
|
if err != nil || localVarHTTPResponse == nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
|
localVarHTTPResponse.Body.Close()
|
|
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
|
if err != nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
if localVarHTTPResponse.StatusCode >= 300 {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: localVarHTTPResponse.Status,
|
|
}
|
|
var v ProblemDetails
|
|
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr.error = err.Error()
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
|
newErr.model = v
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: err.Error(),
|
|
}
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
return localVarReturnValue, localVarHTTPResponse, nil
|
|
}
|
|
|
|
type TeamAPIPatchTeamDocsByIdRequest struct {
|
|
ctx context.Context
|
|
ApiService *TeamAPIService
|
|
id string
|
|
teamTeamDocEdit *TeamTeamDocEdit
|
|
}
|
|
|
|
func (r TeamAPIPatchTeamDocsByIdRequest) TeamTeamDocEdit(teamTeamDocEdit TeamTeamDocEdit) TeamAPIPatchTeamDocsByIdRequest {
|
|
r.teamTeamDocEdit = &teamTeamDocEdit
|
|
return r
|
|
}
|
|
|
|
func (r TeamAPIPatchTeamDocsByIdRequest) Execute() (*TeamTeamDoc, *http.Response, error) {
|
|
return r.ApiService.PatchTeamDocsByIdExecute(r)
|
|
}
|
|
|
|
/*
|
|
PatchTeamDocsById Renames a document or moves it — under another document, to the top of its teamspace, or to another teamspace with everything nested under it.
|
|
|
|
Renames a document or moves it — under another document, to the top
|
|
of its teamspace, or to another teamspace with everything nested under it.
|
|
|
|
Anyone who can write the teamspace may rename or move a page, as in the Team
|
|
client. A move goes after its new siblings, and a document cannot be moved
|
|
under itself or under one of its own descendants.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@param id ID is the document, from the path.
|
|
@return TeamAPIPatchTeamDocsByIdRequest
|
|
*/
|
|
func (a *TeamAPIService) PatchTeamDocsById(ctx context.Context, id string) TeamAPIPatchTeamDocsByIdRequest {
|
|
return TeamAPIPatchTeamDocsByIdRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
id: id,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return TeamTeamDoc
|
|
func (a *TeamAPIService) PatchTeamDocsByIdExecute(r TeamAPIPatchTeamDocsByIdRequest) (*TeamTeamDoc, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodPatch
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *TeamTeamDoc
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "TeamAPIService.PatchTeamDocsById")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/team/docs/{id}"
|
|
localVarPath = strings.Replace(localVarPath, "{"+"id"+"}", url.PathEscape(parameterValueToString(r.id, "id")), -1)
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
if r.teamTeamDocEdit == nil {
|
|
return localVarReturnValue, nil, reportError("teamTeamDocEdit is required and must be specified")
|
|
}
|
|
|
|
// to determine the Content-Type header
|
|
localVarHTTPContentTypes := []string{"application/json"}
|
|
|
|
// set Content-Type header
|
|
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
|
if localVarHTTPContentType != "" {
|
|
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
|
}
|
|
|
|
// to determine the Accept header
|
|
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
|
|
|
|
// set Accept header
|
|
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
|
if localVarHTTPHeaderAccept != "" {
|
|
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
|
}
|
|
// body params
|
|
localVarPostBody = r.teamTeamDocEdit
|
|
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
|
if err != nil {
|
|
return localVarReturnValue, nil, err
|
|
}
|
|
|
|
localVarHTTPResponse, err := a.client.callAPI(req)
|
|
if err != nil || localVarHTTPResponse == nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
|
localVarHTTPResponse.Body.Close()
|
|
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
|
if err != nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
if localVarHTTPResponse.StatusCode >= 300 {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: localVarHTTPResponse.Status,
|
|
}
|
|
var v ProblemDetails
|
|
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr.error = err.Error()
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
|
newErr.model = v
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: err.Error(),
|
|
}
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
return localVarReturnValue, localVarHTTPResponse, nil
|
|
}
|
|
|
|
type TeamAPIPatchTeamMessagesByIdRequest struct {
|
|
ctx context.Context
|
|
ApiService *TeamAPIService
|
|
id string
|
|
teamTeamMessageEdit *TeamTeamMessageEdit
|
|
}
|
|
|
|
func (r TeamAPIPatchTeamMessagesByIdRequest) TeamTeamMessageEdit(teamTeamMessageEdit TeamTeamMessageEdit) TeamAPIPatchTeamMessagesByIdRequest {
|
|
r.teamTeamMessageEdit = &teamTeamMessageEdit
|
|
return r
|
|
}
|
|
|
|
func (r TeamAPIPatchTeamMessagesByIdRequest) Execute() (*TeamTeamMessage, *http.Response, error) {
|
|
return r.ApiService.PatchTeamMessagesByIdExecute(r)
|
|
}
|
|
|
|
/*
|
|
PatchTeamMessagesById Rewrites what a message says.
|
|
|
|
Rewrites what a message says. Only its author may edit it.
|
|
|
|
The edit is an ordinary update of the message document through the Team
|
|
client's own write path, stamped with editedOn, so an open client shows the
|
|
new text and the "edited" mark live. Somebody the new text mentions for the
|
|
first time is notified.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@param id ID is the message, from the path.
|
|
@return TeamAPIPatchTeamMessagesByIdRequest
|
|
*/
|
|
func (a *TeamAPIService) PatchTeamMessagesById(ctx context.Context, id string) TeamAPIPatchTeamMessagesByIdRequest {
|
|
return TeamAPIPatchTeamMessagesByIdRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
id: id,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return TeamTeamMessage
|
|
func (a *TeamAPIService) PatchTeamMessagesByIdExecute(r TeamAPIPatchTeamMessagesByIdRequest) (*TeamTeamMessage, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodPatch
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *TeamTeamMessage
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "TeamAPIService.PatchTeamMessagesById")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/team/messages/{id}"
|
|
localVarPath = strings.Replace(localVarPath, "{"+"id"+"}", url.PathEscape(parameterValueToString(r.id, "id")), -1)
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
if r.teamTeamMessageEdit == nil {
|
|
return localVarReturnValue, nil, reportError("teamTeamMessageEdit is required and must be specified")
|
|
}
|
|
|
|
// to determine the Content-Type header
|
|
localVarHTTPContentTypes := []string{"application/json"}
|
|
|
|
// set Content-Type header
|
|
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
|
if localVarHTTPContentType != "" {
|
|
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
|
}
|
|
|
|
// to determine the Accept header
|
|
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
|
|
|
|
// set Accept header
|
|
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
|
if localVarHTTPHeaderAccept != "" {
|
|
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
|
}
|
|
// body params
|
|
localVarPostBody = r.teamTeamMessageEdit
|
|
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
|
if err != nil {
|
|
return localVarReturnValue, nil, err
|
|
}
|
|
|
|
localVarHTTPResponse, err := a.client.callAPI(req)
|
|
if err != nil || localVarHTTPResponse == nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
|
localVarHTTPResponse.Body.Close()
|
|
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
|
if err != nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
if localVarHTTPResponse.StatusCode >= 300 {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: localVarHTTPResponse.Status,
|
|
}
|
|
var v ProblemDetails
|
|
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr.error = err.Error()
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
|
newErr.model = v
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: err.Error(),
|
|
}
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
return localVarReturnValue, localVarHTTPResponse, nil
|
|
}
|
|
|
|
type TeamAPIPostTeamAccountRequest struct {
|
|
ctx context.Context
|
|
ApiService *TeamAPIService
|
|
}
|
|
|
|
func (r TeamAPIPostTeamAccountRequest) Execute() (*http.Response, error) {
|
|
return r.ApiService.PostTeamAccountExecute(r)
|
|
}
|
|
|
|
/*
|
|
PostTeamAccount Read the caller's account and switch space
|
|
|
|
The account control plane the Team client speaks: one POST carries a `method` verb and its `params`, and answers {"result": …}. The verbs are the session's own reads and the space switch — getLoginInfoByToken, getUserWorkspaces, selectWorkspace, getWorkspaceInfo, getMemberships, getPerson, getRegionInfo, isReadOnlyGuest — plus sendInvite, which adds a member to a space and is refused for a caller who is not its owner or admin.
|
|
|
|
A REFUSAL IS HTTP 200 carrying {"error": {severity, code, params}} — the platform Status the client translates — not a 4xx. An unreadable body, an unauthorized session and an unknown verb all arrive that way, so a caller that reads only the status code reads every failure here as a success.
|
|
|
|
NO CREDENTIAL IS EVER HANDLED HERE. login, signUp, the OTP verbs, password change and reset, join and the guest-token exchange each answer Unauthorized with "sign in at hanzo.id" — a stated policy, not an unknown method, so the refusal is a fact a test can pin. Sessions come from the OAuth pair under /account/auth.
|
|
|
|
Auth is the team session token: Authorization: Bearer, else the HttpOnly account-token cookie. The tenant is that token's SIGNED org claim, never a header, and selectWorkspace resolves only among the orgs the token proves membership of. It also demands an explicit workspaceUrl — it never falls back to a first space, and a slug that resolves in two of the caller's orgs answers Ambiguous rather than picking one.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@return TeamAPIPostTeamAccountRequest
|
|
*/
|
|
func (a *TeamAPIService) PostTeamAccount(ctx context.Context) TeamAPIPostTeamAccountRequest {
|
|
return TeamAPIPostTeamAccountRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
func (a *TeamAPIService) PostTeamAccountExecute(r TeamAPIPostTeamAccountRequest) (*http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodPost
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "TeamAPIService.PostTeamAccount")
|
|
if err != nil {
|
|
return nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/team/account"
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
|
|
// to determine the Content-Type header
|
|
localVarHTTPContentTypes := []string{}
|
|
|
|
// set Content-Type header
|
|
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
|
if localVarHTTPContentType != "" {
|
|
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
|
}
|
|
|
|
// to determine the Accept header
|
|
localVarHTTPHeaderAccepts := []string{}
|
|
|
|
// set Accept header
|
|
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
|
if localVarHTTPHeaderAccept != "" {
|
|
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
|
}
|
|
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
localVarHTTPResponse, err := a.client.callAPI(req)
|
|
if err != nil || localVarHTTPResponse == nil {
|
|
return localVarHTTPResponse, err
|
|
}
|
|
|
|
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
|
localVarHTTPResponse.Body.Close()
|
|
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
|
if err != nil {
|
|
return localVarHTTPResponse, err
|
|
}
|
|
|
|
if localVarHTTPResponse.StatusCode >= 300 {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: localVarHTTPResponse.Status,
|
|
}
|
|
return localVarHTTPResponse, newErr
|
|
}
|
|
|
|
return localVarHTTPResponse, nil
|
|
}
|
|
|
|
type TeamAPIPostTeamChannelsRequest struct {
|
|
ctx context.Context
|
|
ApiService *TeamAPIService
|
|
teamTeamChannelNew *TeamTeamChannelNew
|
|
}
|
|
|
|
func (r TeamAPIPostTeamChannelsRequest) TeamTeamChannelNew(teamTeamChannelNew TeamTeamChannelNew) TeamAPIPostTeamChannelsRequest {
|
|
r.teamTeamChannelNew = &teamTeamChannelNew
|
|
return r
|
|
}
|
|
|
|
func (r TeamAPIPostTeamChannelsRequest) Execute() (*TeamTeamChannelOne, *http.Response, error) {
|
|
return r.ApiService.PostTeamChannelsExecute(r)
|
|
}
|
|
|
|
/*
|
|
PostTeamChannels Opens a named channel and answers it as the store now holds it.
|
|
|
|
Opens a named channel and answers it as the store now holds it.
|
|
|
|
It writes through the SAME applyTx path the Team client uses, so a channel opened
|
|
here is broadcast to every live client of the space and appears in an open
|
|
sidebar without a reload — the same property listChannels rests on, read from the
|
|
write side.
|
|
|
|
A SIGNED-IN TEAM MEMBER opens it as themselves: they are its first member and
|
|
its owner, every other member named must be somebody the space knows (a person
|
|
in it, or one of the org's agents), and a guest may not open channels at all. An
|
|
application of the org opens it as the org, with exactly the members it names.
|
|
Anybody else without a team session is 401.
|
|
|
|
TWO TRANSACTIONS, NOT ONE, when the request states a facet. The document and
|
|
its work update are separate writes in this model (bindChannel writes only the second),
|
|
and composing them here rather than inventing a combined tx keeps one write
|
|
path for each. A create that lands and a facet that does not is visible as a
|
|
channel with default intent, which is the honest partial state.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@return TeamAPIPostTeamChannelsRequest
|
|
*/
|
|
func (a *TeamAPIService) PostTeamChannels(ctx context.Context) TeamAPIPostTeamChannelsRequest {
|
|
return TeamAPIPostTeamChannelsRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return TeamTeamChannelOne
|
|
func (a *TeamAPIService) PostTeamChannelsExecute(r TeamAPIPostTeamChannelsRequest) (*TeamTeamChannelOne, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodPost
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *TeamTeamChannelOne
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "TeamAPIService.PostTeamChannels")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/team/channels"
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
if r.teamTeamChannelNew == nil {
|
|
return localVarReturnValue, nil, reportError("teamTeamChannelNew is required and must be specified")
|
|
}
|
|
|
|
// to determine the Content-Type header
|
|
localVarHTTPContentTypes := []string{"application/json"}
|
|
|
|
// set Content-Type header
|
|
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
|
if localVarHTTPContentType != "" {
|
|
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
|
}
|
|
|
|
// to determine the Accept header
|
|
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
|
|
|
|
// set Accept header
|
|
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
|
if localVarHTTPHeaderAccept != "" {
|
|
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
|
}
|
|
// body params
|
|
localVarPostBody = r.teamTeamChannelNew
|
|
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
|
if err != nil {
|
|
return localVarReturnValue, nil, err
|
|
}
|
|
|
|
localVarHTTPResponse, err := a.client.callAPI(req)
|
|
if err != nil || localVarHTTPResponse == nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
|
localVarHTTPResponse.Body.Close()
|
|
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
|
if err != nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
if localVarHTTPResponse.StatusCode >= 300 {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: localVarHTTPResponse.Status,
|
|
}
|
|
var v ProblemDetails
|
|
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr.error = err.Error()
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
|
newErr.model = v
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: err.Error(),
|
|
}
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
return localVarReturnValue, localVarHTTPResponse, nil
|
|
}
|
|
|
|
type TeamAPIPostTeamChannelsByIdMembersRequest struct {
|
|
ctx context.Context
|
|
ApiService *TeamAPIService
|
|
id string
|
|
teamTeamChannelJoin *TeamTeamChannelJoin
|
|
}
|
|
|
|
func (r TeamAPIPostTeamChannelsByIdMembersRequest) TeamTeamChannelJoin(teamTeamChannelJoin TeamTeamChannelJoin) TeamAPIPostTeamChannelsByIdMembersRequest {
|
|
r.teamTeamChannelJoin = &teamTeamChannelJoin
|
|
return r
|
|
}
|
|
|
|
func (r TeamAPIPostTeamChannelsByIdMembersRequest) Execute() (*TeamTeamChannelOne, *http.Response, error) {
|
|
return r.ApiService.PostTeamChannelsByIdMembersExecute(r)
|
|
}
|
|
|
|
/*
|
|
PostTeamChannelsByIdMembers Adds people to a channel and answers the channel as it now stands.
|
|
|
|
Adds people to a channel and answers the channel as it now stands.
|
|
|
|
Anyone in the space except a guest may join a public channel by naming
|
|
themselves. Adding somebody else takes being in the channel already (or
|
|
administering the space, for a channel they can see). A direct message's people
|
|
are what it is, so none can be added — open another one. Everyone added must
|
|
be a member of the space or one of the org's agents; an agent added to a channel
|
|
answers when it is @-mentioned there.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@param id ID is the channel, from the path.
|
|
@return TeamAPIPostTeamChannelsByIdMembersRequest
|
|
*/
|
|
func (a *TeamAPIService) PostTeamChannelsByIdMembers(ctx context.Context, id string) TeamAPIPostTeamChannelsByIdMembersRequest {
|
|
return TeamAPIPostTeamChannelsByIdMembersRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
id: id,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return TeamTeamChannelOne
|
|
func (a *TeamAPIService) PostTeamChannelsByIdMembersExecute(r TeamAPIPostTeamChannelsByIdMembersRequest) (*TeamTeamChannelOne, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodPost
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *TeamTeamChannelOne
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "TeamAPIService.PostTeamChannelsByIdMembers")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/team/channels/{id}/members"
|
|
localVarPath = strings.Replace(localVarPath, "{"+"id"+"}", url.PathEscape(parameterValueToString(r.id, "id")), -1)
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
if r.teamTeamChannelJoin == nil {
|
|
return localVarReturnValue, nil, reportError("teamTeamChannelJoin is required and must be specified")
|
|
}
|
|
|
|
// to determine the Content-Type header
|
|
localVarHTTPContentTypes := []string{"application/json"}
|
|
|
|
// set Content-Type header
|
|
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
|
if localVarHTTPContentType != "" {
|
|
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
|
}
|
|
|
|
// to determine the Accept header
|
|
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
|
|
|
|
// set Accept header
|
|
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
|
if localVarHTTPHeaderAccept != "" {
|
|
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
|
}
|
|
// body params
|
|
localVarPostBody = r.teamTeamChannelJoin
|
|
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
|
if err != nil {
|
|
return localVarReturnValue, nil, err
|
|
}
|
|
|
|
localVarHTTPResponse, err := a.client.callAPI(req)
|
|
if err != nil || localVarHTTPResponse == nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
|
localVarHTTPResponse.Body.Close()
|
|
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
|
if err != nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
if localVarHTTPResponse.StatusCode >= 300 {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: localVarHTTPResponse.Status,
|
|
}
|
|
var v ProblemDetails
|
|
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr.error = err.Error()
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
|
newErr.model = v
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: err.Error(),
|
|
}
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
return localVarReturnValue, localVarHTTPResponse, nil
|
|
}
|
|
|
|
type TeamAPIPostTeamChannelsByIdMessagesRequest struct {
|
|
ctx context.Context
|
|
ApiService *TeamAPIService
|
|
id string
|
|
teamTeamMessageWrite *TeamTeamMessageWrite
|
|
}
|
|
|
|
func (r TeamAPIPostTeamChannelsByIdMessagesRequest) TeamTeamMessageWrite(teamTeamMessageWrite TeamTeamMessageWrite) TeamAPIPostTeamChannelsByIdMessagesRequest {
|
|
r.teamTeamMessageWrite = &teamTeamMessageWrite
|
|
return r
|
|
}
|
|
|
|
func (r TeamAPIPostTeamChannelsByIdMessagesRequest) Execute() (*TeamTeamMessage, *http.Response, error) {
|
|
return r.ApiService.PostTeamChannelsByIdMessagesExecute(r)
|
|
}
|
|
|
|
/*
|
|
PostTeamChannelsByIdMessages Says one thing in a channel, as the caller.
|
|
|
|
Says one thing in a channel, as the caller.
|
|
|
|
The write goes through the SAME applyTx path the Team client's own messages
|
|
take and is broadcast to every connected client of the space, so a message
|
|
sent here appears live in an open channel rather than on the next reload. It
|
|
answers the message as the store now HOLDS it.
|
|
|
|
`<@account-uuid>` in the text is stored as the platform's mention, so the
|
|
person is notified in their inbox. Mentioning one of the org's agents — or
|
|
writing in a direct message with one — wakes it: it runs as itself, on behalf
|
|
of the caller, and posts its answer into the same channel. The caller must be
|
|
able to see the channel, and an archived channel refuses new messages (409).
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@param id ID is the channel to say it in, from the path.
|
|
@return TeamAPIPostTeamChannelsByIdMessagesRequest
|
|
*/
|
|
func (a *TeamAPIService) PostTeamChannelsByIdMessages(ctx context.Context, id string) TeamAPIPostTeamChannelsByIdMessagesRequest {
|
|
return TeamAPIPostTeamChannelsByIdMessagesRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
id: id,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return TeamTeamMessage
|
|
func (a *TeamAPIService) PostTeamChannelsByIdMessagesExecute(r TeamAPIPostTeamChannelsByIdMessagesRequest) (*TeamTeamMessage, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodPost
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *TeamTeamMessage
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "TeamAPIService.PostTeamChannelsByIdMessages")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/team/channels/{id}/messages"
|
|
localVarPath = strings.Replace(localVarPath, "{"+"id"+"}", url.PathEscape(parameterValueToString(r.id, "id")), -1)
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
if r.teamTeamMessageWrite == nil {
|
|
return localVarReturnValue, nil, reportError("teamTeamMessageWrite is required and must be specified")
|
|
}
|
|
|
|
// to determine the Content-Type header
|
|
localVarHTTPContentTypes := []string{"application/json"}
|
|
|
|
// set Content-Type header
|
|
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
|
if localVarHTTPContentType != "" {
|
|
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
|
}
|
|
|
|
// to determine the Accept header
|
|
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
|
|
|
|
// set Accept header
|
|
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
|
if localVarHTTPHeaderAccept != "" {
|
|
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
|
}
|
|
// body params
|
|
localVarPostBody = r.teamTeamMessageWrite
|
|
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
|
if err != nil {
|
|
return localVarReturnValue, nil, err
|
|
}
|
|
|
|
localVarHTTPResponse, err := a.client.callAPI(req)
|
|
if err != nil || localVarHTTPResponse == nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
|
localVarHTTPResponse.Body.Close()
|
|
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
|
if err != nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
if localVarHTTPResponse.StatusCode >= 300 {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: localVarHTTPResponse.Status,
|
|
}
|
|
var v ProblemDetails
|
|
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr.error = err.Error()
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
|
newErr.model = v
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: err.Error(),
|
|
}
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
return localVarReturnValue, localVarHTTPResponse, nil
|
|
}
|
|
|
|
type TeamAPIPostTeamCollaboratorRpcByDocumentidRequest struct {
|
|
ctx context.Context
|
|
ApiService *TeamAPIService
|
|
documentId string
|
|
teamCollabRequest *TeamCollabRequest
|
|
}
|
|
|
|
func (r TeamAPIPostTeamCollaboratorRpcByDocumentidRequest) TeamCollabRequest(teamCollabRequest TeamCollabRequest) TeamAPIPostTeamCollaboratorRpcByDocumentidRequest {
|
|
r.teamCollabRequest = &teamCollabRequest
|
|
return r
|
|
}
|
|
|
|
func (r TeamAPIPostTeamCollaboratorRpcByDocumentidRequest) Execute() (*TeamCollabResult, *http.Response, error) {
|
|
return r.ApiService.PostTeamCollaboratorRpcByDocumentidExecute(r)
|
|
}
|
|
|
|
/*
|
|
PostTeamCollaboratorRpcByDocumentid CollabRPC is the collaborative-markup snapshot plane the Team front's editor speaks: createContent stores a document field's markup at a fresh, immutable blob ref and returns it, updateContent stores a new snapshot and answers nothing, and getContent reads back the exact snapshot a ref names.
|
|
|
|
CollabRPC is the collaborative-markup snapshot plane the Team front's editor
|
|
speaks: createContent stores a document field's markup at a fresh, immutable
|
|
blob ref and returns it, updateContent stores a new snapshot and answers
|
|
nothing, and getContent reads back the exact snapshot a ref names.
|
|
|
|
createContent ALSO seeds the live-editing update log from the front-supplied
|
|
Y.js update, so a dialog-authored description is visible in the collaborative
|
|
editor — which replays that log — and not only in snapshot reads.
|
|
updateContent never touches that log: peers may be live-editing the document,
|
|
and their edits are not this call's to overwrite.
|
|
|
|
Every call is scoped to the caller's VERIFIED session or space token: the
|
|
documentId's space must be the token's space when the token names one,
|
|
and the caller must be a member of it. An unknown space, another tenant's
|
|
space and a space the caller is not in all answer the same 404, so a
|
|
probe learns nothing about what exists.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@param documentId DocumentID addresses the document field, as \"<spaceUuid>|<objectClass>|<objectId>|<objectAttr>\" — the collaborator-client encodeDocumentId shape, from the path.
|
|
@return TeamAPIPostTeamCollaboratorRpcByDocumentidRequest
|
|
*/
|
|
func (a *TeamAPIService) PostTeamCollaboratorRpcByDocumentid(ctx context.Context, documentId string) TeamAPIPostTeamCollaboratorRpcByDocumentidRequest {
|
|
return TeamAPIPostTeamCollaboratorRpcByDocumentidRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
documentId: documentId,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return TeamCollabResult
|
|
func (a *TeamAPIService) PostTeamCollaboratorRpcByDocumentidExecute(r TeamAPIPostTeamCollaboratorRpcByDocumentidRequest) (*TeamCollabResult, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodPost
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *TeamCollabResult
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "TeamAPIService.PostTeamCollaboratorRpcByDocumentid")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/team/collaborator/rpc/{documentId}"
|
|
localVarPath = strings.Replace(localVarPath, "{"+"documentId"+"}", url.PathEscape(parameterValueToString(r.documentId, "documentId")), -1)
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
if r.teamCollabRequest == nil {
|
|
return localVarReturnValue, nil, reportError("teamCollabRequest is required and must be specified")
|
|
}
|
|
|
|
// to determine the Content-Type header
|
|
localVarHTTPContentTypes := []string{"application/json"}
|
|
|
|
// set Content-Type header
|
|
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
|
if localVarHTTPContentType != "" {
|
|
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
|
}
|
|
|
|
// to determine the Accept header
|
|
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
|
|
|
|
// set Accept header
|
|
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
|
if localVarHTTPHeaderAccept != "" {
|
|
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
|
}
|
|
// body params
|
|
localVarPostBody = r.teamCollabRequest
|
|
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
|
if err != nil {
|
|
return localVarReturnValue, nil, err
|
|
}
|
|
|
|
localVarHTTPResponse, err := a.client.callAPI(req)
|
|
if err != nil || localVarHTTPResponse == nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
|
localVarHTTPResponse.Body.Close()
|
|
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
|
if err != nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
if localVarHTTPResponse.StatusCode >= 300 {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: localVarHTTPResponse.Status,
|
|
}
|
|
var v ProblemDetails
|
|
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr.error = err.Error()
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
|
newErr.model = v
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: err.Error(),
|
|
}
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
return localVarReturnValue, localVarHTTPResponse, nil
|
|
}
|
|
|
|
type TeamAPIPostTeamDmsRequest struct {
|
|
ctx context.Context
|
|
ApiService *TeamAPIService
|
|
teamTeamDirectOpen *TeamTeamDirectOpen
|
|
}
|
|
|
|
func (r TeamAPIPostTeamDmsRequest) TeamTeamDirectOpen(teamTeamDirectOpen TeamTeamDirectOpen) TeamAPIPostTeamDmsRequest {
|
|
r.teamTeamDirectOpen = &teamTeamDirectOpen
|
|
return r
|
|
}
|
|
|
|
func (r TeamAPIPostTeamDmsRequest) Execute() (*TeamTeamDirect, *http.Response, error) {
|
|
return r.ApiService.PostTeamDmsExecute(r)
|
|
}
|
|
|
|
/*
|
|
PostTeamDms Opens the direct message between the caller and the people named, or answers the one that already exists — there is one conversation per set of people, however many times it is asked for.
|
|
|
|
Opens the direct message between the caller and the people named,
|
|
or answers the one that already exists — there is one conversation per set of
|
|
people, however many times it is asked for.
|
|
|
|
Every person named must be a member of the space or one of the org's agents;
|
|
a direct message with an agent is a conversation it answers every message in,
|
|
and a guest may not open one.
|
|
Answers 201 when this call opened it and 200 when it was already there.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@return TeamAPIPostTeamDmsRequest
|
|
*/
|
|
func (a *TeamAPIService) PostTeamDms(ctx context.Context) TeamAPIPostTeamDmsRequest {
|
|
return TeamAPIPostTeamDmsRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return TeamTeamDirect
|
|
func (a *TeamAPIService) PostTeamDmsExecute(r TeamAPIPostTeamDmsRequest) (*TeamTeamDirect, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodPost
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *TeamTeamDirect
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "TeamAPIService.PostTeamDms")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/team/dms"
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
if r.teamTeamDirectOpen == nil {
|
|
return localVarReturnValue, nil, reportError("teamTeamDirectOpen is required and must be specified")
|
|
}
|
|
|
|
// to determine the Content-Type header
|
|
localVarHTTPContentTypes := []string{"application/json"}
|
|
|
|
// set Content-Type header
|
|
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
|
if localVarHTTPContentType != "" {
|
|
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
|
}
|
|
|
|
// to determine the Accept header
|
|
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
|
|
|
|
// set Accept header
|
|
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
|
if localVarHTTPHeaderAccept != "" {
|
|
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
|
}
|
|
// body params
|
|
localVarPostBody = r.teamTeamDirectOpen
|
|
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
|
if err != nil {
|
|
return localVarReturnValue, nil, err
|
|
}
|
|
|
|
localVarHTTPResponse, err := a.client.callAPI(req)
|
|
if err != nil || localVarHTTPResponse == nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
|
localVarHTTPResponse.Body.Close()
|
|
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
|
if err != nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
if localVarHTTPResponse.StatusCode >= 300 {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: localVarHTTPResponse.Status,
|
|
}
|
|
var v ProblemDetails
|
|
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr.error = err.Error()
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
|
newErr.model = v
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: err.Error(),
|
|
}
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
return localVarReturnValue, localVarHTTPResponse, nil
|
|
}
|
|
|
|
type TeamAPIPostTeamDocsRequest struct {
|
|
ctx context.Context
|
|
ApiService *TeamAPIService
|
|
teamTeamDocNew *TeamTeamDocNew
|
|
}
|
|
|
|
func (r TeamAPIPostTeamDocsRequest) TeamTeamDocNew(teamTeamDocNew TeamTeamDocNew) TeamAPIPostTeamDocsRequest {
|
|
r.teamTeamDocNew = &teamTeamDocNew
|
|
return r
|
|
}
|
|
|
|
func (r TeamAPIPostTeamDocsRequest) Execute() (*TeamTeamDoc, *http.Response, error) {
|
|
return r.ApiService.PostTeamDocsExecute(r)
|
|
}
|
|
|
|
/*
|
|
PostTeamDocs Creates a document, as the caller, after its siblings.
|
|
|
|
Creates a document, as the caller, after its siblings.
|
|
|
|
It is created through the Team client's own write path, so it appears in an
|
|
open Documents sidebar live, and its author is subscribed to it: a comment on
|
|
it lands in their inbox. Its body starts empty — open the returned
|
|
`collaborator` id on the /v1/team/collaborator socket to write it.
|
|
|
|
A space whose caller can write no teamspace at all gets one on its first
|
|
document: a public "General" teamspace every current member of the space is
|
|
in, which is what the Team client would otherwise make somebody create by hand
|
|
before the first page. Guests and agents are not made members of it.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@return TeamAPIPostTeamDocsRequest
|
|
*/
|
|
func (a *TeamAPIService) PostTeamDocs(ctx context.Context) TeamAPIPostTeamDocsRequest {
|
|
return TeamAPIPostTeamDocsRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return TeamTeamDoc
|
|
func (a *TeamAPIService) PostTeamDocsExecute(r TeamAPIPostTeamDocsRequest) (*TeamTeamDoc, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodPost
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *TeamTeamDoc
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "TeamAPIService.PostTeamDocs")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/team/docs"
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
if r.teamTeamDocNew == nil {
|
|
return localVarReturnValue, nil, reportError("teamTeamDocNew is required and must be specified")
|
|
}
|
|
|
|
// to determine the Content-Type header
|
|
localVarHTTPContentTypes := []string{"application/json"}
|
|
|
|
// set Content-Type header
|
|
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
|
if localVarHTTPContentType != "" {
|
|
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
|
}
|
|
|
|
// to determine the Accept header
|
|
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
|
|
|
|
// set Accept header
|
|
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
|
if localVarHTTPHeaderAccept != "" {
|
|
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
|
}
|
|
// body params
|
|
localVarPostBody = r.teamTeamDocNew
|
|
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
|
if err != nil {
|
|
return localVarReturnValue, nil, err
|
|
}
|
|
|
|
localVarHTTPResponse, err := a.client.callAPI(req)
|
|
if err != nil || localVarHTTPResponse == nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
|
localVarHTTPResponse.Body.Close()
|
|
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
|
if err != nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
if localVarHTTPResponse.StatusCode >= 300 {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: localVarHTTPResponse.Status,
|
|
}
|
|
var v ProblemDetails
|
|
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr.error = err.Error()
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
|
newErr.model = v
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: err.Error(),
|
|
}
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
return localVarReturnValue, localVarHTTPResponse, nil
|
|
}
|
|
|
|
type TeamAPIPostTeamDocsByIdCommentsRequest struct {
|
|
ctx context.Context
|
|
ApiService *TeamAPIService
|
|
id string
|
|
teamTeamCommentWrite *TeamTeamCommentWrite
|
|
}
|
|
|
|
func (r TeamAPIPostTeamDocsByIdCommentsRequest) TeamTeamCommentWrite(teamTeamCommentWrite TeamTeamCommentWrite) TeamAPIPostTeamDocsByIdCommentsRequest {
|
|
r.teamTeamCommentWrite = &teamTeamCommentWrite
|
|
return r
|
|
}
|
|
|
|
func (r TeamAPIPostTeamDocsByIdCommentsRequest) Execute() (*TeamTeamMessage, *http.Response, error) {
|
|
return r.ApiService.PostTeamDocsByIdCommentsExecute(r)
|
|
}
|
|
|
|
/*
|
|
PostTeamDocsByIdComments Comments on a document, as the caller.
|
|
|
|
Comments on a document, as the caller.
|
|
|
|
It is a message attached to the document, written through the Team client's
|
|
own path: the people subscribed to the document and anyone mentioned are
|
|
notified, and an agent mentioned answers with a comment of its own. It can be
|
|
replied to, reacted to, edited and deleted with the message ops.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@param id ID is the document, from the path.
|
|
@return TeamAPIPostTeamDocsByIdCommentsRequest
|
|
*/
|
|
func (a *TeamAPIService) PostTeamDocsByIdComments(ctx context.Context, id string) TeamAPIPostTeamDocsByIdCommentsRequest {
|
|
return TeamAPIPostTeamDocsByIdCommentsRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
id: id,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return TeamTeamMessage
|
|
func (a *TeamAPIService) PostTeamDocsByIdCommentsExecute(r TeamAPIPostTeamDocsByIdCommentsRequest) (*TeamTeamMessage, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodPost
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *TeamTeamMessage
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "TeamAPIService.PostTeamDocsByIdComments")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/team/docs/{id}/comments"
|
|
localVarPath = strings.Replace(localVarPath, "{"+"id"+"}", url.PathEscape(parameterValueToString(r.id, "id")), -1)
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
if r.teamTeamCommentWrite == nil {
|
|
return localVarReturnValue, nil, reportError("teamTeamCommentWrite is required and must be specified")
|
|
}
|
|
|
|
// to determine the Content-Type header
|
|
localVarHTTPContentTypes := []string{"application/json"}
|
|
|
|
// set Content-Type header
|
|
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
|
if localVarHTTPContentType != "" {
|
|
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
|
}
|
|
|
|
// to determine the Accept header
|
|
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
|
|
|
|
// set Accept header
|
|
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
|
if localVarHTTPHeaderAccept != "" {
|
|
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
|
}
|
|
// body params
|
|
localVarPostBody = r.teamTeamCommentWrite
|
|
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
|
if err != nil {
|
|
return localVarReturnValue, nil, err
|
|
}
|
|
|
|
localVarHTTPResponse, err := a.client.callAPI(req)
|
|
if err != nil || localVarHTTPResponse == nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
|
localVarHTTPResponse.Body.Close()
|
|
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
|
if err != nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
if localVarHTTPResponse.StatusCode >= 300 {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: localVarHTTPResponse.Status,
|
|
}
|
|
var v ProblemDetails
|
|
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr.error = err.Error()
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
|
newErr.model = v
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: err.Error(),
|
|
}
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
return localVarReturnValue, localVarHTTPResponse, nil
|
|
}
|
|
|
|
type TeamAPIPostTeamFilesBySpaceRequest struct {
|
|
ctx context.Context
|
|
ApiService *TeamAPIService
|
|
space string
|
|
body *os.File
|
|
}
|
|
|
|
func (r TeamAPIPostTeamFilesBySpaceRequest) Body(body *os.File) TeamAPIPostTeamFilesBySpaceRequest {
|
|
r.body = body
|
|
return r
|
|
}
|
|
|
|
func (r TeamAPIPostTeamFilesBySpaceRequest) Execute() (*os.File, *http.Response, error) {
|
|
return r.ApiService.PostTeamFilesBySpaceExecute(r)
|
|
}
|
|
|
|
/*
|
|
PostTeamFilesBySpace Upload a file into a space
|
|
|
|
Stores one file in a space's blob store and answers the blob id it is addressable by, as plain text — the front discards that body, it is there for a caller driving this by hand.
|
|
|
|
The body is a multipart form with a `file` part, and THAT PART'S FILENAME IS THE BLOB ID: the client mints it (a uuid v4) and the server stores under it, so a part whose filename is not a uuid is refused rather than assigned one. A file over 100 MiB is 413 and an empty one is 400.
|
|
|
|
The caller must hold a verified session or space token AND be a member of the space; an unknown space, another tenant's space and a space the caller is not in all answer the same 404, so a probe learns nothing about what exists. The stored key embeds the verified org and the space, so an upload cannot land in another tenant's box whatever id it names. A storage backend that is unavailable fails closed with 502 rather than reporting a write it never made.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@param space
|
|
@return TeamAPIPostTeamFilesBySpaceRequest
|
|
*/
|
|
func (a *TeamAPIService) PostTeamFilesBySpace(ctx context.Context, space string) TeamAPIPostTeamFilesBySpaceRequest {
|
|
return TeamAPIPostTeamFilesBySpaceRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
space: space,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return *os.File
|
|
func (a *TeamAPIService) PostTeamFilesBySpaceExecute(r TeamAPIPostTeamFilesBySpaceRequest) (*os.File, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodPost
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *os.File
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "TeamAPIService.PostTeamFilesBySpace")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/team/files/{space}"
|
|
localVarPath = strings.Replace(localVarPath, "{"+"space"+"}", url.PathEscape(parameterValueToString(r.space, "space")), -1)
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
|
|
// to determine the Content-Type header
|
|
localVarHTTPContentTypes := []string{"application/octet-stream"}
|
|
|
|
// set Content-Type header
|
|
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
|
if localVarHTTPContentType != "" {
|
|
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
|
}
|
|
|
|
// to determine the Accept header
|
|
localVarHTTPHeaderAccepts := []string{"text/plain; charset=utf-8"}
|
|
|
|
// set Accept header
|
|
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
|
if localVarHTTPHeaderAccept != "" {
|
|
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
|
}
|
|
// body params
|
|
localVarPostBody = r.body
|
|
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
|
if err != nil {
|
|
return localVarReturnValue, nil, err
|
|
}
|
|
|
|
localVarHTTPResponse, err := a.client.callAPI(req)
|
|
if err != nil || localVarHTTPResponse == nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
|
localVarHTTPResponse.Body.Close()
|
|
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
|
if err != nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
if localVarHTTPResponse.StatusCode >= 300 {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: localVarHTTPResponse.Status,
|
|
}
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: err.Error(),
|
|
}
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
return localVarReturnValue, localVarHTTPResponse, nil
|
|
}
|
|
|
|
type TeamAPIPostTeamInboxByIdArchiveRequest struct {
|
|
ctx context.Context
|
|
ApiService *TeamAPIService
|
|
id string
|
|
teamTeamInboxAt *TeamTeamInboxAt
|
|
}
|
|
|
|
func (r TeamAPIPostTeamInboxByIdArchiveRequest) TeamTeamInboxAt(teamTeamInboxAt TeamTeamInboxAt) TeamAPIPostTeamInboxByIdArchiveRequest {
|
|
r.teamTeamInboxAt = &teamTeamInboxAt
|
|
return r
|
|
}
|
|
|
|
func (r TeamAPIPostTeamInboxByIdArchiveRequest) Execute() (*TeamTeamInboxItem, *http.Response, error) {
|
|
return r.ApiService.PostTeamInboxByIdArchiveExecute(r)
|
|
}
|
|
|
|
/*
|
|
PostTeamInboxByIdArchive Archives one of the caller's notifications — read, and out of the live inbox — and answers it.
|
|
|
|
Archives one of the caller's notifications — read, and
|
|
out of the live inbox — and answers it. It is listed again with
|
|
`archived=true`.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@param id ID is the notification, from the path.
|
|
@return TeamAPIPostTeamInboxByIdArchiveRequest
|
|
*/
|
|
func (a *TeamAPIService) PostTeamInboxByIdArchive(ctx context.Context, id string) TeamAPIPostTeamInboxByIdArchiveRequest {
|
|
return TeamAPIPostTeamInboxByIdArchiveRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
id: id,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return TeamTeamInboxItem
|
|
func (a *TeamAPIService) PostTeamInboxByIdArchiveExecute(r TeamAPIPostTeamInboxByIdArchiveRequest) (*TeamTeamInboxItem, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodPost
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *TeamTeamInboxItem
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "TeamAPIService.PostTeamInboxByIdArchive")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/team/inbox/{id}/archive"
|
|
localVarPath = strings.Replace(localVarPath, "{"+"id"+"}", url.PathEscape(parameterValueToString(r.id, "id")), -1)
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
if r.teamTeamInboxAt == nil {
|
|
return localVarReturnValue, nil, reportError("teamTeamInboxAt is required and must be specified")
|
|
}
|
|
|
|
// to determine the Content-Type header
|
|
localVarHTTPContentTypes := []string{"application/json"}
|
|
|
|
// set Content-Type header
|
|
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
|
if localVarHTTPContentType != "" {
|
|
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
|
}
|
|
|
|
// to determine the Accept header
|
|
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
|
|
|
|
// set Accept header
|
|
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
|
if localVarHTTPHeaderAccept != "" {
|
|
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
|
}
|
|
// body params
|
|
localVarPostBody = r.teamTeamInboxAt
|
|
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
|
if err != nil {
|
|
return localVarReturnValue, nil, err
|
|
}
|
|
|
|
localVarHTTPResponse, err := a.client.callAPI(req)
|
|
if err != nil || localVarHTTPResponse == nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
|
localVarHTTPResponse.Body.Close()
|
|
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
|
if err != nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
if localVarHTTPResponse.StatusCode >= 300 {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: localVarHTTPResponse.Status,
|
|
}
|
|
var v ProblemDetails
|
|
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr.error = err.Error()
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
|
newErr.model = v
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: err.Error(),
|
|
}
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
return localVarReturnValue, localVarHTTPResponse, nil
|
|
}
|
|
|
|
type TeamAPIPostTeamInboxByIdReadRequest struct {
|
|
ctx context.Context
|
|
ApiService *TeamAPIService
|
|
id string
|
|
teamTeamInboxAt *TeamTeamInboxAt
|
|
}
|
|
|
|
func (r TeamAPIPostTeamInboxByIdReadRequest) TeamTeamInboxAt(teamTeamInboxAt TeamTeamInboxAt) TeamAPIPostTeamInboxByIdReadRequest {
|
|
r.teamTeamInboxAt = &teamTeamInboxAt
|
|
return r
|
|
}
|
|
|
|
func (r TeamAPIPostTeamInboxByIdReadRequest) Execute() (*TeamTeamInboxItem, *http.Response, error) {
|
|
return r.ApiService.PostTeamInboxByIdReadExecute(r)
|
|
}
|
|
|
|
/*
|
|
PostTeamInboxByIdRead Marks one of the caller's notifications read and answers it.
|
|
|
|
Marks one of the caller's notifications read and answers it.
|
|
Another person's notification is a 404, as one that does not exist is.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@param id ID is the notification, from the path.
|
|
@return TeamAPIPostTeamInboxByIdReadRequest
|
|
*/
|
|
func (a *TeamAPIService) PostTeamInboxByIdRead(ctx context.Context, id string) TeamAPIPostTeamInboxByIdReadRequest {
|
|
return TeamAPIPostTeamInboxByIdReadRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
id: id,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return TeamTeamInboxItem
|
|
func (a *TeamAPIService) PostTeamInboxByIdReadExecute(r TeamAPIPostTeamInboxByIdReadRequest) (*TeamTeamInboxItem, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodPost
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *TeamTeamInboxItem
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "TeamAPIService.PostTeamInboxByIdRead")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/team/inbox/{id}/read"
|
|
localVarPath = strings.Replace(localVarPath, "{"+"id"+"}", url.PathEscape(parameterValueToString(r.id, "id")), -1)
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
if r.teamTeamInboxAt == nil {
|
|
return localVarReturnValue, nil, reportError("teamTeamInboxAt is required and must be specified")
|
|
}
|
|
|
|
// to determine the Content-Type header
|
|
localVarHTTPContentTypes := []string{"application/json"}
|
|
|
|
// set Content-Type header
|
|
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
|
if localVarHTTPContentType != "" {
|
|
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
|
}
|
|
|
|
// to determine the Accept header
|
|
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
|
|
|
|
// set Accept header
|
|
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
|
if localVarHTTPHeaderAccept != "" {
|
|
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
|
}
|
|
// body params
|
|
localVarPostBody = r.teamTeamInboxAt
|
|
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
|
if err != nil {
|
|
return localVarReturnValue, nil, err
|
|
}
|
|
|
|
localVarHTTPResponse, err := a.client.callAPI(req)
|
|
if err != nil || localVarHTTPResponse == nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
|
localVarHTTPResponse.Body.Close()
|
|
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
|
if err != nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
if localVarHTTPResponse.StatusCode >= 300 {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: localVarHTTPResponse.Status,
|
|
}
|
|
var v ProblemDetails
|
|
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr.error = err.Error()
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
|
newErr.model = v
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: err.Error(),
|
|
}
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
return localVarReturnValue, localVarHTTPResponse, nil
|
|
}
|
|
|
|
type TeamAPIPostTeamInboxReadRequest struct {
|
|
ctx context.Context
|
|
ApiService *TeamAPIService
|
|
teamTeamInboxAll *TeamTeamInboxAll
|
|
}
|
|
|
|
func (r TeamAPIPostTeamInboxReadRequest) TeamTeamInboxAll(teamTeamInboxAll TeamTeamInboxAll) TeamAPIPostTeamInboxReadRequest {
|
|
r.teamTeamInboxAll = &teamTeamInboxAll
|
|
return r
|
|
}
|
|
|
|
func (r TeamAPIPostTeamInboxReadRequest) Execute() (*TeamTeamInboxCleared, *http.Response, error) {
|
|
return r.ApiService.PostTeamInboxReadExecute(r)
|
|
}
|
|
|
|
/*
|
|
PostTeamInboxRead Marks every live notification of the caller's read, and says how many it changed.
|
|
|
|
Marks every live notification of the caller's read, and
|
|
says how many it changed.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@return TeamAPIPostTeamInboxReadRequest
|
|
*/
|
|
func (a *TeamAPIService) PostTeamInboxRead(ctx context.Context) TeamAPIPostTeamInboxReadRequest {
|
|
return TeamAPIPostTeamInboxReadRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return TeamTeamInboxCleared
|
|
func (a *TeamAPIService) PostTeamInboxReadExecute(r TeamAPIPostTeamInboxReadRequest) (*TeamTeamInboxCleared, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodPost
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *TeamTeamInboxCleared
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "TeamAPIService.PostTeamInboxRead")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/team/inbox/read"
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
if r.teamTeamInboxAll == nil {
|
|
return localVarReturnValue, nil, reportError("teamTeamInboxAll is required and must be specified")
|
|
}
|
|
|
|
// to determine the Content-Type header
|
|
localVarHTTPContentTypes := []string{"application/json"}
|
|
|
|
// set Content-Type header
|
|
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
|
if localVarHTTPContentType != "" {
|
|
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
|
}
|
|
|
|
// to determine the Accept header
|
|
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
|
|
|
|
// set Accept header
|
|
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
|
if localVarHTTPHeaderAccept != "" {
|
|
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
|
}
|
|
// body params
|
|
localVarPostBody = r.teamTeamInboxAll
|
|
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
|
if err != nil {
|
|
return localVarReturnValue, nil, err
|
|
}
|
|
|
|
localVarHTTPResponse, err := a.client.callAPI(req)
|
|
if err != nil || localVarHTTPResponse == nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
|
localVarHTTPResponse.Body.Close()
|
|
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
|
if err != nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
if localVarHTTPResponse.StatusCode >= 300 {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: localVarHTTPResponse.Status,
|
|
}
|
|
var v ProblemDetails
|
|
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr.error = err.Error()
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
|
newErr.model = v
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: err.Error(),
|
|
}
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
return localVarReturnValue, localVarHTTPResponse, nil
|
|
}
|
|
|
|
type TeamAPIPostTeamMessagesByIdRepliesRequest struct {
|
|
ctx context.Context
|
|
ApiService *TeamAPIService
|
|
id string
|
|
teamTeamReplyWrite *TeamTeamReplyWrite
|
|
}
|
|
|
|
func (r TeamAPIPostTeamMessagesByIdRepliesRequest) TeamTeamReplyWrite(teamTeamReplyWrite TeamTeamReplyWrite) TeamAPIPostTeamMessagesByIdRepliesRequest {
|
|
r.teamTeamReplyWrite = &teamTeamReplyWrite
|
|
return r
|
|
}
|
|
|
|
func (r TeamAPIPostTeamMessagesByIdRepliesRequest) Execute() (*TeamTeamMessage, *http.Response, error) {
|
|
return r.ApiService.PostTeamMessagesByIdRepliesExecute(r)
|
|
}
|
|
|
|
/*
|
|
PostTeamMessagesByIdReplies Answers a message in its thread, as the caller.
|
|
|
|
Answers a message in its thread, as the caller.
|
|
|
|
A reply is a thread message attached to the one it answers, written through
|
|
the Team client's own path: the parent's reply count and last-reply time move
|
|
with it, the people already in the thread and anyone mentioned are notified,
|
|
and an agent mentioned in a reply answers in the same thread. A reply cannot
|
|
itself be replied to — threads are one level deep, as in the Team client.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@param id ID is the message being answered, from the path.
|
|
@return TeamAPIPostTeamMessagesByIdRepliesRequest
|
|
*/
|
|
func (a *TeamAPIService) PostTeamMessagesByIdReplies(ctx context.Context, id string) TeamAPIPostTeamMessagesByIdRepliesRequest {
|
|
return TeamAPIPostTeamMessagesByIdRepliesRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
id: id,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return TeamTeamMessage
|
|
func (a *TeamAPIService) PostTeamMessagesByIdRepliesExecute(r TeamAPIPostTeamMessagesByIdRepliesRequest) (*TeamTeamMessage, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodPost
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *TeamTeamMessage
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "TeamAPIService.PostTeamMessagesByIdReplies")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/team/messages/{id}/replies"
|
|
localVarPath = strings.Replace(localVarPath, "{"+"id"+"}", url.PathEscape(parameterValueToString(r.id, "id")), -1)
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
if r.teamTeamReplyWrite == nil {
|
|
return localVarReturnValue, nil, reportError("teamTeamReplyWrite is required and must be specified")
|
|
}
|
|
|
|
// to determine the Content-Type header
|
|
localVarHTTPContentTypes := []string{"application/json"}
|
|
|
|
// set Content-Type header
|
|
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
|
if localVarHTTPContentType != "" {
|
|
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
|
}
|
|
|
|
// to determine the Accept header
|
|
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
|
|
|
|
// set Accept header
|
|
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
|
if localVarHTTPHeaderAccept != "" {
|
|
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
|
}
|
|
// body params
|
|
localVarPostBody = r.teamTeamReplyWrite
|
|
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
|
if err != nil {
|
|
return localVarReturnValue, nil, err
|
|
}
|
|
|
|
localVarHTTPResponse, err := a.client.callAPI(req)
|
|
if err != nil || localVarHTTPResponse == nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
|
localVarHTTPResponse.Body.Close()
|
|
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
|
if err != nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
if localVarHTTPResponse.StatusCode >= 300 {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: localVarHTTPResponse.Status,
|
|
}
|
|
var v ProblemDetails
|
|
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr.error = err.Error()
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
|
newErr.model = v
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: err.Error(),
|
|
}
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
return localVarReturnValue, localVarHTTPResponse, nil
|
|
}
|
|
|
|
type TeamAPIPutTeamAccountCookieRequest struct {
|
|
ctx context.Context
|
|
ApiService *TeamAPIService
|
|
}
|
|
|
|
func (r TeamAPIPutTeamAccountCookieRequest) Execute() (*CookieAck, *http.Response, error) {
|
|
return r.ApiService.PutTeamAccountCookieExecute(r)
|
|
}
|
|
|
|
/*
|
|
PutTeamAccountCookie Store the session token as this browser's cookie
|
|
|
|
Writes the team session token into the HttpOnly `account-token` cookie — Secure, SameSite=Lax, whole-origin scope, thirty days — and answers {"result": true}. This is how the client turns the token it caught off the OAuth bounce into a credential page JS can no longer read, which IS the security property: script that cannot see the cookie cannot exfiltrate it, and every later call on the files, billing and collaborator planes authenticates from it when no bearer is sent.
|
|
|
|
The token is VERIFIED — signature and expiry, against this service's own signing secret — BEFORE it is stored. Anything this service did not sign is 401 and nothing is written; persisting a caller-supplied value unchecked would be a session-fixation hole, where an attacker pins a cookie the victim's browser then presents as its own.
|
|
|
|
The token may arrive as `token` in the JSON body or, when the body is absent or unparseable, from the Authorization bearer — an unreadable body is NOT an error here. The sibling DELETE clears this same cookie and signs the browser out of team only: the IAM cookie set alongside it is a different credential with its own lifetime and is left alone.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@return TeamAPIPutTeamAccountCookieRequest
|
|
*/
|
|
func (a *TeamAPIService) PutTeamAccountCookie(ctx context.Context) TeamAPIPutTeamAccountCookieRequest {
|
|
return TeamAPIPutTeamAccountCookieRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return CookieAck
|
|
func (a *TeamAPIService) PutTeamAccountCookieExecute(r TeamAPIPutTeamAccountCookieRequest) (*CookieAck, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodPut
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *CookieAck
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "TeamAPIService.PutTeamAccountCookie")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/team/account/cookie"
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
|
|
// to determine the Content-Type header
|
|
localVarHTTPContentTypes := []string{}
|
|
|
|
// set Content-Type header
|
|
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
|
if localVarHTTPContentType != "" {
|
|
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
|
}
|
|
|
|
// to determine the Accept header
|
|
localVarHTTPHeaderAccepts := []string{"application/json"}
|
|
|
|
// set Accept header
|
|
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
|
if localVarHTTPHeaderAccept != "" {
|
|
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
|
}
|
|
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
|
if err != nil {
|
|
return localVarReturnValue, nil, err
|
|
}
|
|
|
|
localVarHTTPResponse, err := a.client.callAPI(req)
|
|
if err != nil || localVarHTTPResponse == nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
|
localVarHTTPResponse.Body.Close()
|
|
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
|
if err != nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
if localVarHTTPResponse.StatusCode >= 300 {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: localVarHTTPResponse.Status,
|
|
}
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: err.Error(),
|
|
}
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
return localVarReturnValue, localVarHTTPResponse, nil
|
|
}
|
|
|
|
type TeamAPIPutTeamChannelsByIdRequest struct {
|
|
ctx context.Context
|
|
ApiService *TeamAPIService
|
|
id string
|
|
teamTeamChannelBind *TeamTeamChannelBind
|
|
}
|
|
|
|
func (r TeamAPIPutTeamChannelsByIdRequest) TeamTeamChannelBind(teamTeamChannelBind TeamTeamChannelBind) TeamAPIPutTeamChannelsByIdRequest {
|
|
r.teamTeamChannelBind = &teamTeamChannelBind
|
|
return r
|
|
}
|
|
|
|
func (r TeamAPIPutTeamChannelsByIdRequest) Execute() (*TeamTeamChannelOne, *http.Response, error) {
|
|
return r.ApiService.PutTeamChannelsByIdExecute(r)
|
|
}
|
|
|
|
/*
|
|
PutTeamChannelsById States what a channel is for: its lifecycle intent, and what it is about.
|
|
|
|
States what a channel is for: its lifecycle intent, and what it is
|
|
about. It answers the channel as it now stands.
|
|
|
|
The write updates the work fields on the channel document, applied through the
|
|
SAME applyTx path the Team client's own writes take and broadcast to every
|
|
connected client — so a channel bound here updates live in an open space
|
|
rather than on the next reload. A team member binds a channel they can see; an
|
|
application of the org binds its public channels only; anybody else without
|
|
a team session is 401.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@param id ID is the channel to bind, from the path. The URL is the authority; a body carrying another id cannot redirect the write.
|
|
@return TeamAPIPutTeamChannelsByIdRequest
|
|
*/
|
|
func (a *TeamAPIService) PutTeamChannelsById(ctx context.Context, id string) TeamAPIPutTeamChannelsByIdRequest {
|
|
return TeamAPIPutTeamChannelsByIdRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
id: id,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return TeamTeamChannelOne
|
|
func (a *TeamAPIService) PutTeamChannelsByIdExecute(r TeamAPIPutTeamChannelsByIdRequest) (*TeamTeamChannelOne, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodPut
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *TeamTeamChannelOne
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "TeamAPIService.PutTeamChannelsById")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/team/channels/{id}"
|
|
localVarPath = strings.Replace(localVarPath, "{"+"id"+"}", url.PathEscape(parameterValueToString(r.id, "id")), -1)
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
if r.teamTeamChannelBind == nil {
|
|
return localVarReturnValue, nil, reportError("teamTeamChannelBind is required and must be specified")
|
|
}
|
|
|
|
// to determine the Content-Type header
|
|
localVarHTTPContentTypes := []string{"application/json"}
|
|
|
|
// set Content-Type header
|
|
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
|
if localVarHTTPContentType != "" {
|
|
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
|
}
|
|
|
|
// to determine the Accept header
|
|
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
|
|
|
|
// set Accept header
|
|
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
|
if localVarHTTPHeaderAccept != "" {
|
|
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
|
}
|
|
// body params
|
|
localVarPostBody = r.teamTeamChannelBind
|
|
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
|
if err != nil {
|
|
return localVarReturnValue, nil, err
|
|
}
|
|
|
|
localVarHTTPResponse, err := a.client.callAPI(req)
|
|
if err != nil || localVarHTTPResponse == nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
|
localVarHTTPResponse.Body.Close()
|
|
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
|
if err != nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
if localVarHTTPResponse.StatusCode >= 300 {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: localVarHTTPResponse.Status,
|
|
}
|
|
var v ProblemDetails
|
|
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr.error = err.Error()
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
|
newErr.model = v
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: err.Error(),
|
|
}
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
return localVarReturnValue, localVarHTTPResponse, nil
|
|
}
|
|
|
|
type TeamAPIPutTeamMessagesByIdReactionsByEmojiRequest struct {
|
|
ctx context.Context
|
|
ApiService *TeamAPIService
|
|
id string
|
|
emoji string
|
|
teamTeamReactionWrite *TeamTeamReactionWrite
|
|
}
|
|
|
|
func (r TeamAPIPutTeamMessagesByIdReactionsByEmojiRequest) TeamTeamReactionWrite(teamTeamReactionWrite TeamTeamReactionWrite) TeamAPIPutTeamMessagesByIdReactionsByEmojiRequest {
|
|
r.teamTeamReactionWrite = &teamTeamReactionWrite
|
|
return r
|
|
}
|
|
|
|
func (r TeamAPIPutTeamMessagesByIdReactionsByEmojiRequest) Execute() (*TeamTeamMessage, *http.Response, error) {
|
|
return r.ApiService.PutTeamMessagesByIdReactionsByEmojiExecute(r)
|
|
}
|
|
|
|
/*
|
|
PutTeamMessagesByIdReactionsByEmoji Adds the caller's reaction to a message and answers the message with its reactions as they now stand.
|
|
|
|
Adds the caller's reaction to a message and answers the message with
|
|
its reactions as they now stand. Reacting twice with one emoji is one
|
|
reaction: the second call changes nothing.
|
|
|
|
The emoji is the last path segment, percent-encoded — PUT
|
|
/v1/team/messages/7a1c/reactions/%F0%9F%91%8D for 👍.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@param id ID is the message, from the path.
|
|
@param emoji Emoji is the reaction, from the path (percent-encoded on the wire).
|
|
@return TeamAPIPutTeamMessagesByIdReactionsByEmojiRequest
|
|
*/
|
|
func (a *TeamAPIService) PutTeamMessagesByIdReactionsByEmoji(ctx context.Context, id string, emoji string) TeamAPIPutTeamMessagesByIdReactionsByEmojiRequest {
|
|
return TeamAPIPutTeamMessagesByIdReactionsByEmojiRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
id: id,
|
|
emoji: emoji,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return TeamTeamMessage
|
|
func (a *TeamAPIService) PutTeamMessagesByIdReactionsByEmojiExecute(r TeamAPIPutTeamMessagesByIdReactionsByEmojiRequest) (*TeamTeamMessage, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodPut
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *TeamTeamMessage
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "TeamAPIService.PutTeamMessagesByIdReactionsByEmoji")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/team/messages/{id}/reactions/{emoji}"
|
|
localVarPath = strings.Replace(localVarPath, "{"+"id"+"}", url.PathEscape(parameterValueToString(r.id, "id")), -1)
|
|
localVarPath = strings.Replace(localVarPath, "{"+"emoji"+"}", url.PathEscape(parameterValueToString(r.emoji, "emoji")), -1)
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
if r.teamTeamReactionWrite == nil {
|
|
return localVarReturnValue, nil, reportError("teamTeamReactionWrite is required and must be specified")
|
|
}
|
|
|
|
// to determine the Content-Type header
|
|
localVarHTTPContentTypes := []string{"application/json"}
|
|
|
|
// set Content-Type header
|
|
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
|
if localVarHTTPContentType != "" {
|
|
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
|
}
|
|
|
|
// to determine the Accept header
|
|
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
|
|
|
|
// set Accept header
|
|
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
|
if localVarHTTPHeaderAccept != "" {
|
|
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
|
}
|
|
// body params
|
|
localVarPostBody = r.teamTeamReactionWrite
|
|
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
|
if err != nil {
|
|
return localVarReturnValue, nil, err
|
|
}
|
|
|
|
localVarHTTPResponse, err := a.client.callAPI(req)
|
|
if err != nil || localVarHTTPResponse == nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
|
localVarHTTPResponse.Body.Close()
|
|
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
|
if err != nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
if localVarHTTPResponse.StatusCode >= 300 {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: localVarHTTPResponse.Status,
|
|
}
|
|
var v ProblemDetails
|
|
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr.error = err.Error()
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
|
newErr.model = v
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: err.Error(),
|
|
}
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
return localVarReturnValue, localVarHTTPResponse, nil
|
|
}
|