mirror of
https://github.com/hanzo-go/sdk.git
synced 2026-11-20 20:13:42 +00:00
1270 lines
46 KiB
Go
1270 lines
46 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"
|
|
)
|
|
|
|
// LeaderboardAPIService LeaderboardAPI service
|
|
type LeaderboardAPIService service
|
|
|
|
type LeaderboardAPIGetLeaderboardRequest struct {
|
|
ctx context.Context
|
|
ApiService *LeaderboardAPIService
|
|
scope *string
|
|
metric *string
|
|
period *string
|
|
limit *int64
|
|
}
|
|
|
|
// Scope picks the board: \"personal\" (default) ranks the caller among their own org's users, \"org\" is that same org board named for an admin, \"global\" ranks organizations against each other.
|
|
func (r LeaderboardAPIGetLeaderboardRequest) Scope(scope string) LeaderboardAPIGetLeaderboardRequest {
|
|
r.scope = &scope
|
|
return r
|
|
}
|
|
|
|
// Metric is the value ranked: tokens (default), requests, or cost.
|
|
func (r LeaderboardAPIGetLeaderboardRequest) Metric(metric string) LeaderboardAPIGetLeaderboardRequest {
|
|
r.metric = &metric
|
|
return r
|
|
}
|
|
|
|
// Period is the window ranked: day, week, month (default) or all.
|
|
func (r LeaderboardAPIGetLeaderboardRequest) Period(period string) LeaderboardAPIGetLeaderboardRequest {
|
|
r.period = &period
|
|
return r
|
|
}
|
|
|
|
// Limit caps the rows returned, clamped to 100. Defaults to 10, which is also what a non-positive or unparseable value takes.
|
|
func (r LeaderboardAPIGetLeaderboardRequest) Limit(limit int64) LeaderboardAPIGetLeaderboardRequest {
|
|
r.limit = &limit
|
|
return r
|
|
}
|
|
|
|
func (r LeaderboardAPIGetLeaderboardRequest) Execute() (*LeaderboardLeaderboardView, *http.Response, error) {
|
|
return r.ApiService.GetLeaderboardExecute(r)
|
|
}
|
|
|
|
/*
|
|
GetLeaderboard Ranks AI usage over a window, either the users of the caller's own org or organizations against each other, and always reports the caller's own standing even when it falls outside the returned page.
|
|
|
|
Ranks AI usage over a window, either the users of the caller's own org
|
|
or organizations against each other, and always reports the caller's own standing
|
|
even when it falls outside the returned page. Identities are private by default: a
|
|
caller sees themselves, plus the peers or orgs that opted into public listing, and
|
|
only an admin sees their own org's members named. Cross-org spend is restricted to
|
|
platform admins. When the warehouse is not connected the board answers empty with
|
|
available=false rather than a fabricated rank.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@return LeaderboardAPIGetLeaderboardRequest
|
|
*/
|
|
func (a *LeaderboardAPIService) GetLeaderboard(ctx context.Context) LeaderboardAPIGetLeaderboardRequest {
|
|
return LeaderboardAPIGetLeaderboardRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return LeaderboardLeaderboardView
|
|
func (a *LeaderboardAPIService) GetLeaderboardExecute(r LeaderboardAPIGetLeaderboardRequest) (*LeaderboardLeaderboardView, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodGet
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *LeaderboardLeaderboardView
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "LeaderboardAPIService.GetLeaderboard")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/leaderboard"
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
|
|
if r.scope != nil {
|
|
parameterAddToHeaderOrQuery(localVarQueryParams, "scope", r.scope, "form", "")
|
|
}
|
|
if r.metric != nil {
|
|
parameterAddToHeaderOrQuery(localVarQueryParams, "metric", r.metric, "form", "")
|
|
}
|
|
if r.period != nil {
|
|
parameterAddToHeaderOrQuery(localVarQueryParams, "period", r.period, "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 LeaderboardAPIGetLeaderboardActivityRequest struct {
|
|
ctx context.Context
|
|
ApiService *LeaderboardAPIService
|
|
subject *string
|
|
id *string
|
|
from *string
|
|
to *string
|
|
}
|
|
|
|
// Subject is what the series is about: \"user\" (default), \"org\" or \"project\".
|
|
func (r LeaderboardAPIGetLeaderboardActivityRequest) Subject(subject string) LeaderboardAPIGetLeaderboardActivityRequest {
|
|
r.subject = &subject
|
|
return r
|
|
}
|
|
|
|
// ID names the subject within what the caller is entitled to see. Omitted (or \"me\") it is the caller themselves, or their own org. Another user requires org admin and must belong to the caller's org; another org requires a SuperAdmin.
|
|
func (r LeaderboardAPIGetLeaderboardActivityRequest) Id(id string) LeaderboardAPIGetLeaderboardActivityRequest {
|
|
r.id = &id
|
|
return r
|
|
}
|
|
|
|
// From is the first day of the range, \"2006-01-02\". Defaults to 90 days back.
|
|
func (r LeaderboardAPIGetLeaderboardActivityRequest) From(from string) LeaderboardAPIGetLeaderboardActivityRequest {
|
|
r.from = &from
|
|
return r
|
|
}
|
|
|
|
// To is the last day of the range, \"2006-01-02\". Defaults to today; the span is clamped to 366 days.
|
|
func (r LeaderboardAPIGetLeaderboardActivityRequest) To(to string) LeaderboardAPIGetLeaderboardActivityRequest {
|
|
r.to = &to
|
|
return r
|
|
}
|
|
|
|
func (r LeaderboardAPIGetLeaderboardActivityRequest) Execute() (*LeaderboardActivityView, *http.Response, error) {
|
|
return r.ApiService.GetLeaderboardActivityExecute(r)
|
|
}
|
|
|
|
/*
|
|
GetLeaderboardActivity Returns the per-day usage series for ONE authorized subject — the points a contribution heatmap and a timeline are drawn from, gap-filled so every day in the range is present.
|
|
|
|
Returns the per-day usage series for ONE authorized subject — the points a
|
|
contribution heatmap and a timeline are drawn from, gap-filled so every day in the
|
|
range is present. Authorization is resolved server-side from the validated
|
|
principal, so a caller can never widen the subject past what they are entitled to:
|
|
a non-admin reads only themselves and their own org. subject=project answers empty
|
|
with a note, because the usage ledger records no project column yet. When the
|
|
warehouse is not connected the series answers empty with available=false rather
|
|
than fabricated days.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@return LeaderboardAPIGetLeaderboardActivityRequest
|
|
*/
|
|
func (a *LeaderboardAPIService) GetLeaderboardActivity(ctx context.Context) LeaderboardAPIGetLeaderboardActivityRequest {
|
|
return LeaderboardAPIGetLeaderboardActivityRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return LeaderboardActivityView
|
|
func (a *LeaderboardAPIService) GetLeaderboardActivityExecute(r LeaderboardAPIGetLeaderboardActivityRequest) (*LeaderboardActivityView, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodGet
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *LeaderboardActivityView
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "LeaderboardAPIService.GetLeaderboardActivity")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/leaderboard/activity"
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
|
|
if r.subject != nil {
|
|
parameterAddToHeaderOrQuery(localVarQueryParams, "subject", r.subject, "form", "")
|
|
}
|
|
if r.id != nil {
|
|
parameterAddToHeaderOrQuery(localVarQueryParams, "id", r.id, "form", "")
|
|
}
|
|
if r.from != nil {
|
|
parameterAddToHeaderOrQuery(localVarQueryParams, "from", r.from, "form", "")
|
|
}
|
|
if r.to != nil {
|
|
parameterAddToHeaderOrQuery(localVarQueryParams, "to", r.to, "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 LeaderboardAPIGetLeaderboardBetaRequest struct {
|
|
ctx context.Context
|
|
ApiService *LeaderboardAPIService
|
|
limit *int64
|
|
}
|
|
|
|
// Limit caps the rows, clamped to 1..100. Defaults to 25, which is also what a non-positive value takes.
|
|
func (r LeaderboardAPIGetLeaderboardBetaRequest) Limit(limit int64) LeaderboardAPIGetLeaderboardBetaRequest {
|
|
r.limit = &limit
|
|
return r
|
|
}
|
|
|
|
func (r LeaderboardAPIGetLeaderboardBetaRequest) Execute() (*LeaderboardBetaBoard, *http.Response, error) {
|
|
return r.ApiService.GetLeaderboardBetaExecute(r)
|
|
}
|
|
|
|
/*
|
|
GetLeaderboardBeta Ranks everyone on the hanzo.ai/beta waitlist by one score: 1 per star on GitHub verified for the record and 1 per founder link followed, plus 1 per org that signed up with its referral code, plus 20 per such org that has made metered spend, plus 1 per 100,000 tokens the person used, all time.
|
|
|
|
Ranks everyone on the hanzo.ai/beta waitlist by one score: 1 per star
|
|
on GitHub verified for the record and 1 per founder link followed, plus 1 per org
|
|
that signed up with its referral code, plus 20 per such org that has made metered
|
|
spend, plus 1 per 100,000 tokens the person used, all time. Ties go to the earlier
|
|
application. Share clicks count for nothing.
|
|
|
|
Everyone who ever applied is on it. A form filed before the person had an
|
|
account is a row of its own (no name, score 0, the day it was filed) until their
|
|
account's record claims it, and the record then begins when the form did.
|
|
|
|
A row is named only for a person who opted into the public board (PUT
|
|
/v1/leaderboard/optin); the caller always sees their own row named. Tokens are a
|
|
range on every row and exact on a named row and the caller's. `tokens` and
|
|
`referrals` say whether the warehouse and the referral service answered; a
|
|
term that did not is left out of every score alike.
|
|
|
|
A named handler, not a closure, so zipdoc can lift this prose into the registry.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@return LeaderboardAPIGetLeaderboardBetaRequest
|
|
*/
|
|
func (a *LeaderboardAPIService) GetLeaderboardBeta(ctx context.Context) LeaderboardAPIGetLeaderboardBetaRequest {
|
|
return LeaderboardAPIGetLeaderboardBetaRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return LeaderboardBetaBoard
|
|
func (a *LeaderboardAPIService) GetLeaderboardBetaExecute(r LeaderboardAPIGetLeaderboardBetaRequest) (*LeaderboardBetaBoard, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodGet
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *LeaderboardBetaBoard
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "LeaderboardAPIService.GetLeaderboardBeta")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/leaderboard/beta"
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
|
|
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 LeaderboardAPIGetLeaderboardBountyRequest struct {
|
|
ctx context.Context
|
|
ApiService *LeaderboardAPIService
|
|
limit *int64
|
|
}
|
|
|
|
// Limit caps the hunter and award rows returned, clamped to 1..100. Defaults to 25.
|
|
func (r LeaderboardAPIGetLeaderboardBountyRequest) Limit(limit int64) LeaderboardAPIGetLeaderboardBountyRequest {
|
|
r.limit = &limit
|
|
return r
|
|
}
|
|
|
|
func (r LeaderboardAPIGetLeaderboardBountyRequest) Execute() (*LeaderboardBountyBoard, *http.Response, error) {
|
|
return r.ApiService.GetLeaderboardBountyExecute(r)
|
|
}
|
|
|
|
/*
|
|
GetLeaderboardBounty Returns the gamified bounty & rewards rules, ranked hunters, and recent bug/bounty awards.
|
|
|
|
Returns the gamified bounty & rewards rules, ranked hunters, and recent bug/bounty awards.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@return LeaderboardAPIGetLeaderboardBountyRequest
|
|
*/
|
|
func (a *LeaderboardAPIService) GetLeaderboardBounty(ctx context.Context) LeaderboardAPIGetLeaderboardBountyRequest {
|
|
return LeaderboardAPIGetLeaderboardBountyRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return LeaderboardBountyBoard
|
|
func (a *LeaderboardAPIService) GetLeaderboardBountyExecute(r LeaderboardAPIGetLeaderboardBountyRequest) (*LeaderboardBountyBoard, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodGet
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *LeaderboardBountyBoard
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "LeaderboardAPIService.GetLeaderboardBounty")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/leaderboard/bounty"
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
|
|
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 LeaderboardAPIGetLeaderboardFeedRequest struct {
|
|
ctx context.Context
|
|
ApiService *LeaderboardAPIService
|
|
}
|
|
|
|
func (r LeaderboardAPIGetLeaderboardFeedRequest) Execute() (*os.File, *http.Response, error) {
|
|
return r.ApiService.GetLeaderboardFeedExecute(r)
|
|
}
|
|
|
|
/*
|
|
GetLeaderboardFeed Stream the board's live lines to anyone as Server-Sent Events
|
|
|
|
Holds one text/event-stream open and pushes a `message` frame for each line as it happens, after replaying the last 20. `data` is `{id, kind, at, handle, detail}`, where kind is joined, referred, tried, milestone, hour, bounty, level or expert. `handle` is masked in the middle, whole for an org that listed itself and empty for one that withdrew. At most 30 lines a minute. A `: ping` comment is written every 25 seconds. There is no resume: a reader that reconnects is replayed the last 20. No credential is needed to read it.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@return LeaderboardAPIGetLeaderboardFeedRequest
|
|
*/
|
|
func (a *LeaderboardAPIService) GetLeaderboardFeed(ctx context.Context) LeaderboardAPIGetLeaderboardFeedRequest {
|
|
return LeaderboardAPIGetLeaderboardFeedRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return *os.File
|
|
func (a *LeaderboardAPIService) GetLeaderboardFeedExecute(r LeaderboardAPIGetLeaderboardFeedRequest) (*os.File, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodGet
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *os.File
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "LeaderboardAPIService.GetLeaderboardFeed")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/leaderboard/feed"
|
|
|
|
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 LeaderboardAPIGetLeaderboardOptinRequest struct {
|
|
ctx context.Context
|
|
ApiService *LeaderboardAPIService
|
|
}
|
|
|
|
func (r LeaderboardAPIGetLeaderboardOptinRequest) Execute() (*LeaderboardOptinView, *http.Response, error) {
|
|
return r.ApiService.GetLeaderboardOptinExecute(r)
|
|
}
|
|
|
|
/*
|
|
GetLeaderboardOptin Returns the caller's own public-listing preference and their org's, each with whether the caller may change it.
|
|
|
|
Returns the caller's own public-listing preference and their org's,
|
|
each with whether the caller may change it. Public listing is opt-in and private
|
|
by default, so a fresh caller reads listed=false for both.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@return LeaderboardAPIGetLeaderboardOptinRequest
|
|
*/
|
|
func (a *LeaderboardAPIService) GetLeaderboardOptin(ctx context.Context) LeaderboardAPIGetLeaderboardOptinRequest {
|
|
return LeaderboardAPIGetLeaderboardOptinRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return LeaderboardOptinView
|
|
func (a *LeaderboardAPIService) GetLeaderboardOptinExecute(r LeaderboardAPIGetLeaderboardOptinRequest) (*LeaderboardOptinView, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodGet
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *LeaderboardOptinView
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "LeaderboardAPIService.GetLeaderboardOptin")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/leaderboard/optin"
|
|
|
|
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 LeaderboardAPIGetLeaderboardPulseRequest struct {
|
|
ctx context.Context
|
|
ApiService *LeaderboardAPIService
|
|
}
|
|
|
|
func (r LeaderboardAPIGetLeaderboardPulseRequest) Execute() (*LeaderboardPulseView, *http.Response, error) {
|
|
return r.ApiService.GetLeaderboardPulseExecute(r)
|
|
}
|
|
|
|
/*
|
|
GetLeaderboardPulse Returns how fast the platform is being used and is spreading, as counts by day for thirty days and by hour for the last day: tokens used, orgs active, orgs signed up, orgs that came through a referral link, and orgs using a model for the first time, with the models most tried.
|
|
|
|
Returns how fast the platform is being used and is spreading, as counts by day for
|
|
thirty days and by hour for the last day: tokens used, orgs active, orgs signed up,
|
|
orgs that came through a referral link, and orgs using a model for the first time,
|
|
with the models most tried. Every series is read from where cloud records it; one
|
|
that cannot be read is left out and named in `missing`, and the ones nothing records
|
|
today (orgs trying a product, shares) are always named there. Counts only: no org,
|
|
no name. No credential is needed to read it.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@return LeaderboardAPIGetLeaderboardPulseRequest
|
|
*/
|
|
func (a *LeaderboardAPIService) GetLeaderboardPulse(ctx context.Context) LeaderboardAPIGetLeaderboardPulseRequest {
|
|
return LeaderboardAPIGetLeaderboardPulseRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return LeaderboardPulseView
|
|
func (a *LeaderboardAPIService) GetLeaderboardPulseExecute(r LeaderboardAPIGetLeaderboardPulseRequest) (*LeaderboardPulseView, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodGet
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *LeaderboardPulseView
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "LeaderboardAPIService.GetLeaderboardPulse")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/leaderboard/pulse"
|
|
|
|
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 LeaderboardAPIGetLeaderboardStandingRequest struct {
|
|
ctx context.Context
|
|
ApiService *LeaderboardAPIService
|
|
}
|
|
|
|
func (r LeaderboardAPIGetLeaderboardStandingRequest) Execute() (*LeaderboardStandingView, *http.Response, error) {
|
|
return r.ApiService.GetLeaderboardStandingExecute(r)
|
|
}
|
|
|
|
/*
|
|
GetLeaderboardStanding Returns the public board of who has used and built the most on Hanzo, shown as a window around the reader.
|
|
|
|
Returns the public board of who has used and built the most on Hanzo, shown as a
|
|
window around the reader. Every org IAM holds is ranked, by points: tokens used,
|
|
referrals, verified stars, follows and bounty awards. A signed-in reader sees their own rank, the ranks
|
|
just below it and as many above it as their points have earned; the rest are
|
|
counted in `locked` and never sent. A reader who is not signed in sees the last
|
|
ranks, where a newcomer starts. Names are masked in the middle; the reader's own is
|
|
whole, an org that listed itself is whole, and one that withdrew has none. No
|
|
credential is needed to read it.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@return LeaderboardAPIGetLeaderboardStandingRequest
|
|
*/
|
|
func (a *LeaderboardAPIService) GetLeaderboardStanding(ctx context.Context) LeaderboardAPIGetLeaderboardStandingRequest {
|
|
return LeaderboardAPIGetLeaderboardStandingRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return LeaderboardStandingView
|
|
func (a *LeaderboardAPIService) GetLeaderboardStandingExecute(r LeaderboardAPIGetLeaderboardStandingRequest) (*LeaderboardStandingView, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodGet
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *LeaderboardStandingView
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "LeaderboardAPIService.GetLeaderboardStanding")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/leaderboard/standing"
|
|
|
|
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 LeaderboardAPIPutLeaderboardOptinRequest struct {
|
|
ctx context.Context
|
|
ApiService *LeaderboardAPIService
|
|
leaderboardUserOptinReq *LeaderboardUserOptinReq
|
|
}
|
|
|
|
func (r LeaderboardAPIPutLeaderboardOptinRequest) LeaderboardUserOptinReq(leaderboardUserOptinReq LeaderboardUserOptinReq) LeaderboardAPIPutLeaderboardOptinRequest {
|
|
r.leaderboardUserOptinReq = &leaderboardUserOptinReq
|
|
return r
|
|
}
|
|
|
|
func (r LeaderboardAPIPutLeaderboardOptinRequest) Execute() (*LeaderboardUserOptinView, *http.Response, error) {
|
|
return r.ApiService.PutLeaderboardOptinExecute(r)
|
|
}
|
|
|
|
/*
|
|
PutLeaderboardOptin Sets the CALLER's own public-listing preference on the leaderboard.
|
|
|
|
Sets the CALLER's own public-listing preference on the leaderboard.
|
|
Self only: the row written is keyed by the caller's validated ledger identity, so
|
|
this can never edit another member's visibility whatever the request says. A
|
|
caller opting in with no handle is given their username, so a listed row never
|
|
renders as "Anonymous" to its own owner.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@return LeaderboardAPIPutLeaderboardOptinRequest
|
|
*/
|
|
func (a *LeaderboardAPIService) PutLeaderboardOptin(ctx context.Context) LeaderboardAPIPutLeaderboardOptinRequest {
|
|
return LeaderboardAPIPutLeaderboardOptinRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return LeaderboardUserOptinView
|
|
func (a *LeaderboardAPIService) PutLeaderboardOptinExecute(r LeaderboardAPIPutLeaderboardOptinRequest) (*LeaderboardUserOptinView, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodPut
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *LeaderboardUserOptinView
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "LeaderboardAPIService.PutLeaderboardOptin")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/leaderboard/optin"
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
if r.leaderboardUserOptinReq == nil {
|
|
return localVarReturnValue, nil, reportError("leaderboardUserOptinReq 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.leaderboardUserOptinReq
|
|
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 LeaderboardAPIPutLeaderboardOptinOrgRequest struct {
|
|
ctx context.Context
|
|
ApiService *LeaderboardAPIService
|
|
leaderboardOrgOptinReq *LeaderboardOrgOptinReq
|
|
}
|
|
|
|
func (r LeaderboardAPIPutLeaderboardOptinOrgRequest) LeaderboardOrgOptinReq(leaderboardOrgOptinReq LeaderboardOrgOptinReq) LeaderboardAPIPutLeaderboardOptinOrgRequest {
|
|
r.leaderboardOrgOptinReq = &leaderboardOrgOptinReq
|
|
return r
|
|
}
|
|
|
|
func (r LeaderboardAPIPutLeaderboardOptinOrgRequest) Execute() (*LeaderboardOrgOptinView, *http.Response, error) {
|
|
return r.ApiService.PutLeaderboardOptinOrgExecute(r)
|
|
}
|
|
|
|
/*
|
|
PutLeaderboardOptinOrg Sets the ORG's listing on the cross-org global board.
|
|
|
|
Sets the ORG's listing on the cross-org global board. Only an admin of
|
|
the caller's own org — an org admin or a platform SuperAdmin — may change it, and
|
|
the org written is the caller's validated tenant, never a value from the request.
|
|
Listing consents to publishing the org's usage VOLUME; cross-org spend stays
|
|
restricted to platform admins regardless.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@return LeaderboardAPIPutLeaderboardOptinOrgRequest
|
|
*/
|
|
func (a *LeaderboardAPIService) PutLeaderboardOptinOrg(ctx context.Context) LeaderboardAPIPutLeaderboardOptinOrgRequest {
|
|
return LeaderboardAPIPutLeaderboardOptinOrgRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return LeaderboardOrgOptinView
|
|
func (a *LeaderboardAPIService) PutLeaderboardOptinOrgExecute(r LeaderboardAPIPutLeaderboardOptinOrgRequest) (*LeaderboardOrgOptinView, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodPut
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *LeaderboardOrgOptinView
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "LeaderboardAPIService.PutLeaderboardOptinOrg")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/leaderboard/optin/org"
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
if r.leaderboardOrgOptinReq == nil {
|
|
return localVarReturnValue, nil, reportError("leaderboardOrgOptinReq 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.leaderboardOrgOptinReq
|
|
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
|
|
}
|