mirror of
https://github.com/hanzo-go/sdk.git
synced 2026-11-20 20:13:42 +00:00
1283 lines
47 KiB
Go
1283 lines
47 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"
|
|
"strings"
|
|
)
|
|
|
|
// SpaceAPIService SpaceAPI service
|
|
type SpaceAPIService service
|
|
|
|
type SpaceAPIDeleteSpaceBySpaceDrivesByDriveRequest struct {
|
|
ctx context.Context
|
|
ApiService *SpaceAPIService
|
|
space string
|
|
drive string
|
|
}
|
|
|
|
func (r SpaceAPIDeleteSpaceBySpaceDrivesByDriveRequest) Execute() (*http.Response, error) {
|
|
return r.ApiService.DeleteSpaceBySpaceDrivesByDriveExecute(r)
|
|
}
|
|
|
|
/*
|
|
DeleteSpaceBySpaceDrivesByDrive Removes an EMPTY drive and answers 204.
|
|
|
|
Removes an EMPTY drive and answers 204.
|
|
|
|
A drive holding files is 409 rather than a cascade: deleting an org's files
|
|
behind a single drive call is not a thing this surface will do silently. A
|
|
drive or space the caller's org does not own is the same 404 an unknown name
|
|
gives.
|
|
|
|
Billed per call: the balance is checked BEFORE anything is touched, so an
|
|
unfunded org is refused with nothing deleted, and the debit lands only once the
|
|
drive is gone.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@param space Space is the space's name, from the path.
|
|
@param drive Drive is the drive's name, from the path.
|
|
@return SpaceAPIDeleteSpaceBySpaceDrivesByDriveRequest
|
|
*/
|
|
func (a *SpaceAPIService) DeleteSpaceBySpaceDrivesByDrive(ctx context.Context, space string, drive string) SpaceAPIDeleteSpaceBySpaceDrivesByDriveRequest {
|
|
return SpaceAPIDeleteSpaceBySpaceDrivesByDriveRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
space: space,
|
|
drive: drive,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
func (a *SpaceAPIService) DeleteSpaceBySpaceDrivesByDriveExecute(r SpaceAPIDeleteSpaceBySpaceDrivesByDriveRequest) (*http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodDelete
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "SpaceAPIService.DeleteSpaceBySpaceDrivesByDrive")
|
|
if err != nil {
|
|
return nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/space/{space}/drives/{drive}"
|
|
localVarPath = strings.Replace(localVarPath, "{"+"space"+"}", url.PathEscape(parameterValueToString(r.space, "space")), -1)
|
|
localVarPath = strings.Replace(localVarPath, "{"+"drive"+"}", url.PathEscape(parameterValueToString(r.drive, "drive")), -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/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 SpaceAPIDeleteSpaceBySpaceDrivesByDriveFilesByWildcard1Request struct {
|
|
ctx context.Context
|
|
ApiService *SpaceAPIService
|
|
space string
|
|
drive string
|
|
wildcard1 string
|
|
}
|
|
|
|
func (r SpaceAPIDeleteSpaceBySpaceDrivesByDriveFilesByWildcard1Request) Execute() (*http.Response, error) {
|
|
return r.ApiService.DeleteSpaceBySpaceDrivesByDriveFilesByWildcard1Execute(r)
|
|
}
|
|
|
|
/*
|
|
DeleteSpaceBySpaceDrivesByDriveFilesByWildcard1 Removes one file and answers 204.
|
|
|
|
Removes one file and answers 204.
|
|
|
|
It removes ONE file and never a folder: a name that looks like a folder is
|
|
refused, because a folder is emergent from the names beneath it and deleting
|
|
one would have to mean deleting them. The name is path-cleaned first, so the
|
|
delete cannot reach outside the drive it names, and a space the caller's org
|
|
does not own is the same 404 an unknown name gives.
|
|
|
|
Billed per call: the balance is checked BEFORE anything is touched, so an
|
|
unfunded org is refused with nothing deleted, and the debit lands only once the
|
|
file is gone.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@param space Space is the space's name, from the path.
|
|
@param drive Drive is the drive's name, from the path.
|
|
@param wildcard1 File is the file's name within the drive — everything after that drive's /files/. It MAY contain \"/\", because a folder is emergent from the name and this segment is captured whole: \"2019/summer/a.jpg\" is one file in two folders, not three names. It is path-cleaned before use, so \"../\" reaches nothing outside the drive, and a name that is empty, absolute or a bare folder marker is refused 400.
|
|
@return SpaceAPIDeleteSpaceBySpaceDrivesByDriveFilesByWildcard1Request
|
|
*/
|
|
func (a *SpaceAPIService) DeleteSpaceBySpaceDrivesByDriveFilesByWildcard1(ctx context.Context, space string, drive string, wildcard1 string) SpaceAPIDeleteSpaceBySpaceDrivesByDriveFilesByWildcard1Request {
|
|
return SpaceAPIDeleteSpaceBySpaceDrivesByDriveFilesByWildcard1Request{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
space: space,
|
|
drive: drive,
|
|
wildcard1: wildcard1,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
func (a *SpaceAPIService) DeleteSpaceBySpaceDrivesByDriveFilesByWildcard1Execute(r SpaceAPIDeleteSpaceBySpaceDrivesByDriveFilesByWildcard1Request) (*http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodDelete
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "SpaceAPIService.DeleteSpaceBySpaceDrivesByDriveFilesByWildcard1")
|
|
if err != nil {
|
|
return nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/space/{space}/drives/{drive}/files/{wildcard1}"
|
|
localVarPath = strings.Replace(localVarPath, "{"+"space"+"}", url.PathEscape(parameterValueToString(r.space, "space")), -1)
|
|
localVarPath = strings.Replace(localVarPath, "{"+"drive"+"}", url.PathEscape(parameterValueToString(r.drive, "drive")), -1)
|
|
localVarPath = strings.Replace(localVarPath, "{"+"wildcard1"+"}", url.PathEscape(parameterValueToString(r.wildcard1, "wildcard1")), -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/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 SpaceAPIGetSpaceBySpaceDrivesRequest struct {
|
|
ctx context.Context
|
|
ApiService *SpaceAPIService
|
|
space string
|
|
}
|
|
|
|
func (r SpaceAPIGetSpaceBySpaceDrivesRequest) Execute() (*SpaceDriveList, *http.Response, error) {
|
|
return r.ApiService.GetSpaceBySpaceDrivesExecute(r)
|
|
}
|
|
|
|
/*
|
|
GetSpaceBySpaceDrives Lists a space's drives.
|
|
|
|
Lists a space's drives.
|
|
|
|
Listing the drives IS listing the space's root folder, because a drive is the
|
|
first segment of a key and nothing else — so the two can never disagree the way
|
|
a drives table and the keys under it would. A space the caller's org does not
|
|
own is the same 404 an unknown name gives.
|
|
|
|
Billed per call: the balance is checked BEFORE anything is touched, so an
|
|
unfunded org is refused with nothing read, and the debit lands only once the
|
|
listing has succeeded.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@param space Space is the space's name, from the path.
|
|
@return SpaceAPIGetSpaceBySpaceDrivesRequest
|
|
*/
|
|
func (a *SpaceAPIService) GetSpaceBySpaceDrives(ctx context.Context, space string) SpaceAPIGetSpaceBySpaceDrivesRequest {
|
|
return SpaceAPIGetSpaceBySpaceDrivesRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
space: space,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return SpaceDriveList
|
|
func (a *SpaceAPIService) GetSpaceBySpaceDrivesExecute(r SpaceAPIGetSpaceBySpaceDrivesRequest) (*SpaceDriveList, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodGet
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *SpaceDriveList
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "SpaceAPIService.GetSpaceBySpaceDrives")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/space/{space}/drives"
|
|
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{}
|
|
|
|
// 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 SpaceAPIGetSpaceBySpaceDrivesByDriveFilesRequest struct {
|
|
ctx context.Context
|
|
ApiService *SpaceAPIService
|
|
space string
|
|
drive string
|
|
folder *string
|
|
recursive *string
|
|
}
|
|
|
|
func (r SpaceAPIGetSpaceBySpaceDrivesByDriveFilesRequest) Folder(folder string) SpaceAPIGetSpaceBySpaceDrivesByDriveFilesRequest {
|
|
r.folder = &folder
|
|
return r
|
|
}
|
|
|
|
func (r SpaceAPIGetSpaceBySpaceDrivesByDriveFilesRequest) Recursive(recursive string) SpaceAPIGetSpaceBySpaceDrivesByDriveFilesRequest {
|
|
r.recursive = &recursive
|
|
return r
|
|
}
|
|
|
|
func (r SpaceAPIGetSpaceBySpaceDrivesByDriveFilesRequest) Execute() (*SpaceFileList, *http.Response, error) {
|
|
return r.ApiService.GetSpaceBySpaceDrivesByDriveFilesExecute(r)
|
|
}
|
|
|
|
/*
|
|
GetSpaceBySpaceDrivesByDriveFiles Lists one folder level of a drive.
|
|
|
|
Lists one folder level of a drive.
|
|
|
|
Folder-style by default: sub-folders come back as folder entries, which is the
|
|
file-manager view. `?recursive=true` lists every file flat under the folder
|
|
instead. Names are RELATIVE to `?folder=`, and the listing is bounded so a huge
|
|
drive cannot exhaust memory — Total is what came back, not what the drive holds.
|
|
|
|
Billed per call: the balance is checked BEFORE anything is touched, so an
|
|
unfunded org is refused with nothing read, and the debit lands only once the
|
|
listing has succeeded.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@param space Space is the space to list in, from the path.
|
|
@param drive Drive is the drive to list, from the path.
|
|
@return SpaceAPIGetSpaceBySpaceDrivesByDriveFilesRequest
|
|
*/
|
|
func (a *SpaceAPIService) GetSpaceBySpaceDrivesByDriveFiles(ctx context.Context, space string, drive string) SpaceAPIGetSpaceBySpaceDrivesByDriveFilesRequest {
|
|
return SpaceAPIGetSpaceBySpaceDrivesByDriveFilesRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
space: space,
|
|
drive: drive,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return SpaceFileList
|
|
func (a *SpaceAPIService) GetSpaceBySpaceDrivesByDriveFilesExecute(r SpaceAPIGetSpaceBySpaceDrivesByDriveFilesRequest) (*SpaceFileList, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodGet
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *SpaceFileList
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "SpaceAPIService.GetSpaceBySpaceDrivesByDriveFiles")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/space/{space}/drives/{drive}/files"
|
|
localVarPath = strings.Replace(localVarPath, "{"+"space"+"}", url.PathEscape(parameterValueToString(r.space, "space")), -1)
|
|
localVarPath = strings.Replace(localVarPath, "{"+"drive"+"}", url.PathEscape(parameterValueToString(r.drive, "drive")), -1)
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
|
|
if r.folder != nil {
|
|
parameterAddToHeaderOrQuery(localVarQueryParams, "folder", r.folder, "form", "")
|
|
}
|
|
if r.recursive != nil {
|
|
parameterAddToHeaderOrQuery(localVarQueryParams, "recursive", r.recursive, "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 SpaceAPIGetSpaceBySpaceDrivesByDriveFilesByWildcard1Request struct {
|
|
ctx context.Context
|
|
ApiService *SpaceAPIService
|
|
space string
|
|
drive string
|
|
wildcard1 string
|
|
}
|
|
|
|
func (r SpaceAPIGetSpaceBySpaceDrivesByDriveFilesByWildcard1Request) Execute() (*SpaceFileURL, *http.Response, error) {
|
|
return r.ApiService.GetSpaceBySpaceDrivesByDriveFilesByWildcard1Execute(r)
|
|
}
|
|
|
|
/*
|
|
GetSpaceBySpaceDrivesByDriveFilesByWildcard1 Mints a URL the caller downloads the file from DIRECTLY.
|
|
|
|
Mints a URL the caller downloads the file from DIRECTLY.
|
|
|
|
The bytes never pass through this binary and the store credential never leaves
|
|
the server: the URL is signed against the PUBLIC host, scoped to exactly this
|
|
space, drive and file, and expires. It carries a content disposition of
|
|
attachment naming the file, so a browser following it saves the file rather
|
|
than rendering it in place. A deployment with no public endpoint configured
|
|
cannot mint one and answers 503 rather than a URL that will not work.
|
|
|
|
Billed per call — for MINTING the URL, which is the work this operation does;
|
|
the download that follows comes straight from the store and is not seen here.
|
|
The balance is checked BEFORE anything is touched, so an unfunded org is
|
|
refused with no URL issued.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@param space Space is the space's name, from the path.
|
|
@param drive Drive is the drive's name, from the path.
|
|
@param wildcard1 File is the file's name within the drive — everything after that drive's /files/. It MAY contain \"/\", because a folder is emergent from the name and this segment is captured whole: \"2019/summer/a.jpg\" is one file in two folders, not three names. It is path-cleaned before use, so \"../\" reaches nothing outside the drive, and a name that is empty, absolute or a bare folder marker is refused 400.
|
|
@return SpaceAPIGetSpaceBySpaceDrivesByDriveFilesByWildcard1Request
|
|
*/
|
|
func (a *SpaceAPIService) GetSpaceBySpaceDrivesByDriveFilesByWildcard1(ctx context.Context, space string, drive string, wildcard1 string) SpaceAPIGetSpaceBySpaceDrivesByDriveFilesByWildcard1Request {
|
|
return SpaceAPIGetSpaceBySpaceDrivesByDriveFilesByWildcard1Request{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
space: space,
|
|
drive: drive,
|
|
wildcard1: wildcard1,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return SpaceFileURL
|
|
func (a *SpaceAPIService) GetSpaceBySpaceDrivesByDriveFilesByWildcard1Execute(r SpaceAPIGetSpaceBySpaceDrivesByDriveFilesByWildcard1Request) (*SpaceFileURL, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodGet
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *SpaceFileURL
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "SpaceAPIService.GetSpaceBySpaceDrivesByDriveFilesByWildcard1")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/space/{space}/drives/{drive}/files/{wildcard1}"
|
|
localVarPath = strings.Replace(localVarPath, "{"+"space"+"}", url.PathEscape(parameterValueToString(r.space, "space")), -1)
|
|
localVarPath = strings.Replace(localVarPath, "{"+"drive"+"}", url.PathEscape(parameterValueToString(r.drive, "drive")), -1)
|
|
localVarPath = strings.Replace(localVarPath, "{"+"wildcard1"+"}", url.PathEscape(parameterValueToString(r.wildcard1, "wildcard1")), -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/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 SpaceAPIGetSpaceHealthRequest struct {
|
|
ctx context.Context
|
|
ApiService *SpaceAPIService
|
|
}
|
|
|
|
func (r SpaceAPIGetSpaceHealthRequest) Execute() (*SpaceSpaceHealth, *http.Response, error) {
|
|
return r.ApiService.GetSpaceHealthExecute(r)
|
|
}
|
|
|
|
/*
|
|
GetSpaceHealth Reports whether this deployment can serve spaces, drives and files.
|
|
|
|
Reports whether this deployment can serve spaces, drives and files.
|
|
|
|
It is a REAL probe rather than a constant: 200 when object-store credentials
|
|
are present, so the store is reachable in principle, and 503 with the reason
|
|
when they are not. It is deliberately NOT gated — liveness has to be probe-able
|
|
without a token — so it is the one operation here that names no space and bills
|
|
nothing.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@return SpaceAPIGetSpaceHealthRequest
|
|
*/
|
|
func (a *SpaceAPIService) GetSpaceHealth(ctx context.Context) SpaceAPIGetSpaceHealthRequest {
|
|
return SpaceAPIGetSpaceHealthRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return SpaceSpaceHealth
|
|
func (a *SpaceAPIService) GetSpaceHealthExecute(r SpaceAPIGetSpaceHealthRequest) (*SpaceSpaceHealth, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodGet
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *SpaceSpaceHealth
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "SpaceAPIService.GetSpaceHealth")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/space/health"
|
|
|
|
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,
|
|
}
|
|
if localVarHTTPResponse.StatusCode == 503 {
|
|
var v SpaceSpaceHealth
|
|
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
|
|
}
|
|
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 SpaceAPIGetSpaceSpacesRequest struct {
|
|
ctx context.Context
|
|
ApiService *SpaceAPIService
|
|
}
|
|
|
|
func (r SpaceAPIGetSpaceSpacesRequest) Execute() (*SpaceSpaceList, *http.Response, error) {
|
|
return r.ApiService.GetSpaceSpacesExecute(r)
|
|
}
|
|
|
|
/*
|
|
GetSpaceSpaces Lists the caller org's own spaces.
|
|
|
|
Lists the caller org's own spaces.
|
|
|
|
Only the caller's: every space is physically named under a per-org prefix and
|
|
the listing strips that prefix, so another org's spaces are not in the answer at
|
|
all. Another org's space is not refused but INVISIBLE, so this cannot be used to
|
|
learn that a name is taken elsewhere.
|
|
|
|
Billed per call: the balance is checked BEFORE anything is touched, so an
|
|
unfunded org is refused with nothing done, and the debit lands only once the
|
|
work has succeeded.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@return SpaceAPIGetSpaceSpacesRequest
|
|
*/
|
|
func (a *SpaceAPIService) GetSpaceSpaces(ctx context.Context) SpaceAPIGetSpaceSpacesRequest {
|
|
return SpaceAPIGetSpaceSpacesRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return SpaceSpaceList
|
|
func (a *SpaceAPIService) GetSpaceSpacesExecute(r SpaceAPIGetSpaceSpacesRequest) (*SpaceSpaceList, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodGet
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *SpaceSpaceList
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "SpaceAPIService.GetSpaceSpaces")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/space/spaces"
|
|
|
|
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 SpaceAPIPostSpaceBySpaceDrivesRequest struct {
|
|
ctx context.Context
|
|
ApiService *SpaceAPIService
|
|
space string
|
|
spaceDriveIn *SpaceDriveIn
|
|
}
|
|
|
|
func (r SpaceAPIPostSpaceBySpaceDrivesRequest) SpaceDriveIn(spaceDriveIn SpaceDriveIn) SpaceAPIPostSpaceBySpaceDrivesRequest {
|
|
r.spaceDriveIn = &spaceDriveIn
|
|
return r
|
|
}
|
|
|
|
func (r SpaceAPIPostSpaceBySpaceDrivesRequest) Execute() (*SpaceDriveItem, *http.Response, error) {
|
|
return r.ApiService.PostSpaceBySpaceDrivesExecute(r)
|
|
}
|
|
|
|
/*
|
|
PostSpaceBySpaceDrives Makes a new drive in a space and answers 201 with it.
|
|
|
|
Makes a new drive in a space and answers 201 with it.
|
|
|
|
A drive is a PREFIX and not a bucket, so making one writes a zero-byte marker
|
|
at "<name>/" — which is what makes an empty drive visible to a listing that has
|
|
no other key to find. A name already taken in the space is 409.
|
|
|
|
Billed per call: the balance is checked BEFORE anything is touched, so an
|
|
unfunded org is refused with nothing created, and the debit lands only once the
|
|
drive exists.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@param space Space is the space to create the drive in, from the path. It carries NO `url:\"-\"`, unlike the field below it, and the difference is the whole reason both tags are written out: zip's binder skips a field tagged \"-\" for EVERY URL source, path params included, so a path-borne value that carried it would arrive empty and the create would refuse a perfectly good address.
|
|
@return SpaceAPIPostSpaceBySpaceDrivesRequest
|
|
*/
|
|
func (a *SpaceAPIService) PostSpaceBySpaceDrives(ctx context.Context, space string) SpaceAPIPostSpaceBySpaceDrivesRequest {
|
|
return SpaceAPIPostSpaceBySpaceDrivesRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
space: space,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return SpaceDriveItem
|
|
func (a *SpaceAPIService) PostSpaceBySpaceDrivesExecute(r SpaceAPIPostSpaceBySpaceDrivesRequest) (*SpaceDriveItem, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodPost
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *SpaceDriveItem
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "SpaceAPIService.PostSpaceBySpaceDrives")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/space/{space}/drives"
|
|
localVarPath = strings.Replace(localVarPath, "{"+"space"+"}", url.PathEscape(parameterValueToString(r.space, "space")), -1)
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
if r.spaceDriveIn == nil {
|
|
return localVarReturnValue, nil, reportError("spaceDriveIn 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.spaceDriveIn
|
|
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 SpaceAPIPostSpaceSpacesRequest struct {
|
|
ctx context.Context
|
|
ApiService *SpaceAPIService
|
|
spaceSpaceIn *SpaceSpaceIn
|
|
}
|
|
|
|
func (r SpaceAPIPostSpaceSpacesRequest) SpaceSpaceIn(spaceSpaceIn SpaceSpaceIn) SpaceAPIPostSpaceSpacesRequest {
|
|
r.spaceSpaceIn = &spaceSpaceIn
|
|
return r
|
|
}
|
|
|
|
func (r SpaceAPIPostSpaceSpacesRequest) Execute() (*SpaceSpaceItem, *http.Response, error) {
|
|
return r.ApiService.PostSpaceSpacesExecute(r)
|
|
}
|
|
|
|
/*
|
|
PostSpaceSpaces Makes a new space for the caller's org and answers 201 with it.
|
|
|
|
Makes a new space for the caller's org and answers 201 with it.
|
|
|
|
The one bucket a space's files live in is derived from the caller's VALIDATED
|
|
org, so an org can only ever create inside its own namespace and no request
|
|
field can redirect that. A name already taken in the org is 409.
|
|
|
|
Billed per call: the balance is checked BEFORE anything is touched, so an
|
|
unfunded org is refused with nothing created, and the debit lands only once the
|
|
space exists.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@return SpaceAPIPostSpaceSpacesRequest
|
|
*/
|
|
func (a *SpaceAPIService) PostSpaceSpaces(ctx context.Context) SpaceAPIPostSpaceSpacesRequest {
|
|
return SpaceAPIPostSpaceSpacesRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return SpaceSpaceItem
|
|
func (a *SpaceAPIService) PostSpaceSpacesExecute(r SpaceAPIPostSpaceSpacesRequest) (*SpaceSpaceItem, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodPost
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *SpaceSpaceItem
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "SpaceAPIService.PostSpaceSpaces")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/space/spaces"
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
if r.spaceSpaceIn == nil {
|
|
return localVarReturnValue, nil, reportError("spaceSpaceIn 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.spaceSpaceIn
|
|
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 SpaceAPIPutSpaceBySpaceDrivesByDriveFilesByWildcard1Request struct {
|
|
ctx context.Context
|
|
ApiService *SpaceAPIService
|
|
space string
|
|
drive string
|
|
wildcard1 string
|
|
}
|
|
|
|
func (r SpaceAPIPutSpaceBySpaceDrivesByDriveFilesByWildcard1Request) Execute() (*SpaceFileURL, *http.Response, error) {
|
|
return r.ApiService.PutSpaceBySpaceDrivesByDriveFilesByWildcard1Execute(r)
|
|
}
|
|
|
|
/*
|
|
PutSpaceBySpaceDrivesByDriveFilesByWildcard1 Mints a URL the caller uploads the file to DIRECTLY.
|
|
|
|
Mints a URL the caller uploads the file to DIRECTLY.
|
|
|
|
The bytes never pass through this binary and the store credential never leaves
|
|
the server: the URL is signed against the PUBLIC host, scoped to exactly this
|
|
space, drive and file, and expires. Writing into a folder that does not exist
|
|
is fine and creates nothing — a folder is emergent from "/" in the name. A
|
|
deployment with no public endpoint configured cannot mint a URL and answers 503
|
|
rather than one that will not work.
|
|
|
|
Billed per call — for MINTING the URL, which is the work this operation does;
|
|
the upload that follows goes straight to the store and is not seen here. The
|
|
balance is checked BEFORE anything is touched, so an unfunded org is refused
|
|
with no URL issued.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@param space Space is the space's name, from the path.
|
|
@param drive Drive is the drive's name, from the path.
|
|
@param wildcard1 File is the file's name within the drive — everything after that drive's /files/. It MAY contain \"/\", because a folder is emergent from the name and this segment is captured whole: \"2019/summer/a.jpg\" is one file in two folders, not three names. It is path-cleaned before use, so \"../\" reaches nothing outside the drive, and a name that is empty, absolute or a bare folder marker is refused 400.
|
|
@return SpaceAPIPutSpaceBySpaceDrivesByDriveFilesByWildcard1Request
|
|
*/
|
|
func (a *SpaceAPIService) PutSpaceBySpaceDrivesByDriveFilesByWildcard1(ctx context.Context, space string, drive string, wildcard1 string) SpaceAPIPutSpaceBySpaceDrivesByDriveFilesByWildcard1Request {
|
|
return SpaceAPIPutSpaceBySpaceDrivesByDriveFilesByWildcard1Request{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
space: space,
|
|
drive: drive,
|
|
wildcard1: wildcard1,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return SpaceFileURL
|
|
func (a *SpaceAPIService) PutSpaceBySpaceDrivesByDriveFilesByWildcard1Execute(r SpaceAPIPutSpaceBySpaceDrivesByDriveFilesByWildcard1Request) (*SpaceFileURL, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodPut
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *SpaceFileURL
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "SpaceAPIService.PutSpaceBySpaceDrivesByDriveFilesByWildcard1")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/space/{space}/drives/{drive}/files/{wildcard1}"
|
|
localVarPath = strings.Replace(localVarPath, "{"+"space"+"}", url.PathEscape(parameterValueToString(r.space, "space")), -1)
|
|
localVarPath = strings.Replace(localVarPath, "{"+"drive"+"}", url.PathEscape(parameterValueToString(r.drive, "drive")), -1)
|
|
localVarPath = strings.Replace(localVarPath, "{"+"wildcard1"+"}", url.PathEscape(parameterValueToString(r.wildcard1, "wildcard1")), -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/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
|
|
}
|