mirror of
https://github.com/hanzo-go/sdk.git
synced 2026-11-20 20:13:42 +00:00
3485 lines
118 KiB
Go
3485 lines
118 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"
|
|
)
|
|
|
|
// FormAPIService FormAPI service
|
|
type FormAPIService service
|
|
|
|
type FormAPICreateFormRequest struct {
|
|
ctx context.Context
|
|
ApiService *FormAPIService
|
|
formForm *FormForm
|
|
}
|
|
|
|
func (r FormAPICreateFormRequest) FormForm(formForm FormForm) FormAPICreateFormRequest {
|
|
r.formForm = &formForm
|
|
return r
|
|
}
|
|
|
|
func (r FormAPICreateFormRequest) Execute() (*FormForm, *http.Response, error) {
|
|
return r.ApiService.CreateFormExecute(r)
|
|
}
|
|
|
|
/*
|
|
CreateForm Makes a form in the caller's org and answers it as stored, its fields' ids assigned and its defaults filled: kind form, visibility public, language en, one question at a time, and the platform's default sinks when it names none.
|
|
|
|
Makes a form in the caller's org and answers it as stored, its fields' ids
|
|
assigned and its defaults filled: kind form, visibility public, language en,
|
|
one question at a time, and the platform's default sinks when it names none.
|
|
|
|
A slug, when given, is the form's id for good: a second form with the same
|
|
slug is refused (409). Every problem with the form is named at once (400). An
|
|
org admin only.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@return FormAPICreateFormRequest
|
|
*/
|
|
func (a *FormAPIService) CreateForm(ctx context.Context) FormAPICreateFormRequest {
|
|
return FormAPICreateFormRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return FormForm
|
|
func (a *FormAPIService) CreateFormExecute(r FormAPICreateFormRequest) (*FormForm, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodPost
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *FormForm
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "FormAPIService.CreateForm")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/form/forms"
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
if r.formForm == nil {
|
|
return localVarReturnValue, nil, reportError("formForm 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.formForm
|
|
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 FormAPICreateFormThemeRequest struct {
|
|
ctx context.Context
|
|
ApiService *FormAPIService
|
|
formTheme *FormTheme
|
|
}
|
|
|
|
func (r FormAPICreateFormThemeRequest) FormTheme(formTheme FormTheme) FormAPICreateFormThemeRequest {
|
|
r.formTheme = &formTheme
|
|
return r
|
|
}
|
|
|
|
func (r FormAPICreateFormThemeRequest) Execute() (*FormTheme, *http.Response, error) {
|
|
return r.ApiService.CreateFormThemeExecute(r)
|
|
}
|
|
|
|
/*
|
|
CreateFormTheme Makes a theme in the caller's org: a name, four colours (#rrggbb), a font family and an https background image, each optional but the name.
|
|
|
|
Makes a theme in the caller's org: a name, four colours (#rrggbb), a font
|
|
family and an https background image, each optional but the name. An org
|
|
admin only.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@return FormAPICreateFormThemeRequest
|
|
*/
|
|
func (a *FormAPIService) CreateFormTheme(ctx context.Context) FormAPICreateFormThemeRequest {
|
|
return FormAPICreateFormThemeRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return FormTheme
|
|
func (a *FormAPIService) CreateFormThemeExecute(r FormAPICreateFormThemeRequest) (*FormTheme, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodPost
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *FormTheme
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "FormAPIService.CreateFormTheme")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/form/themes"
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
if r.formTheme == nil {
|
|
return localVarReturnValue, nil, reportError("formTheme 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.formTheme
|
|
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 FormAPICreateFormWebhookRequest struct {
|
|
ctx context.Context
|
|
ApiService *FormAPIService
|
|
id string
|
|
formWebhookIn *FormWebhookIn
|
|
}
|
|
|
|
func (r FormAPICreateFormWebhookRequest) FormWebhookIn(formWebhookIn FormWebhookIn) FormAPICreateFormWebhookRequest {
|
|
r.formWebhookIn = &formWebhookIn
|
|
return r
|
|
}
|
|
|
|
func (r FormAPICreateFormWebhookRequest) Execute() (*FormWebhook, *http.Response, error) {
|
|
return r.ApiService.CreateFormWebhookExecute(r)
|
|
}
|
|
|
|
/*
|
|
CreateFormWebhook Adds a webhook to a form: every completed response is posted to its https address as JSON, signed with Hanzo-Signature: t=<unix seconds>,sha256=<base64 of HMAC-SHA256(secret, \"<seconds>.\" + body)>; a receiver refuses a timestamp older than five minutes and an event_id it has seen.
|
|
|
|
Adds a webhook to a form: every completed response is posted to its https
|
|
address as JSON, signed with Hanzo-Signature: t=<unix seconds>,sha256=<base64
|
|
of HMAC-SHA256(secret, "<seconds>." + body)>; a receiver refuses a timestamp
|
|
older than five minutes and an event_id it has seen. The secret is the one
|
|
given (16 to 256 characters) or one minted, kept in KMS and answered here
|
|
once. A form has at
|
|
most the platform's number of webhooks. An org admin only.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@param id ID is the form's id or slug, from the path.
|
|
@return FormAPICreateFormWebhookRequest
|
|
*/
|
|
func (a *FormAPIService) CreateFormWebhook(ctx context.Context, id string) FormAPICreateFormWebhookRequest {
|
|
return FormAPICreateFormWebhookRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
id: id,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return FormWebhook
|
|
func (a *FormAPIService) CreateFormWebhookExecute(r FormAPICreateFormWebhookRequest) (*FormWebhook, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodPost
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *FormWebhook
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "FormAPIService.CreateFormWebhook")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/form/forms/{id}/webhooks"
|
|
localVarPath = strings.Replace(localVarPath, "{"+"id"+"}", url.PathEscape(parameterValueToString(r.id, "id")), -1)
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
if r.formWebhookIn == nil {
|
|
return localVarReturnValue, nil, reportError("formWebhookIn 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.formWebhookIn
|
|
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 FormAPIDeleteFormRequest struct {
|
|
ctx context.Context
|
|
ApiService *FormAPIService
|
|
id string
|
|
}
|
|
|
|
func (r FormAPIDeleteFormRequest) Execute() (*http.Response, error) {
|
|
return r.ApiService.DeleteFormExecute(r)
|
|
}
|
|
|
|
/*
|
|
DeleteForm Deletes a form with every response, webhook and delivery it has, and the webhooks' signing secrets.
|
|
|
|
Deletes a form with every response, webhook and delivery it has, and the
|
|
webhooks' signing secrets. An org admin only.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@param id ID is the form's id or its slug, from the path.
|
|
@return FormAPIDeleteFormRequest
|
|
*/
|
|
func (a *FormAPIService) DeleteForm(ctx context.Context, id string) FormAPIDeleteFormRequest {
|
|
return FormAPIDeleteFormRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
id: id,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
func (a *FormAPIService) DeleteFormExecute(r FormAPIDeleteFormRequest) (*http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodDelete
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "FormAPIService.DeleteForm")
|
|
if err != nil {
|
|
return nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/form/forms/{id}"
|
|
localVarPath = strings.Replace(localVarPath, "{"+"id"+"}", url.PathEscape(parameterValueToString(r.id, "id")), -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 FormAPIDeleteFormResponseRequest struct {
|
|
ctx context.Context
|
|
ApiService *FormAPIService
|
|
id string
|
|
response string
|
|
}
|
|
|
|
func (r FormAPIDeleteFormResponseRequest) Execute() (*http.Response, error) {
|
|
return r.ApiService.DeleteFormResponseExecute(r)
|
|
}
|
|
|
|
/*
|
|
DeleteFormResponse Deletes one response of a form, and its webhook deliveries.
|
|
|
|
Deletes one response of a form, and its webhook deliveries. What the sinks
|
|
already hold (the CRM's timeline, a webhook's receiver) is theirs. An org admin
|
|
only.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@param id ID is the form's id or slug, from the path.
|
|
@param response Response is the response's id, from the path.
|
|
@return FormAPIDeleteFormResponseRequest
|
|
*/
|
|
func (a *FormAPIService) DeleteFormResponse(ctx context.Context, id string, response string) FormAPIDeleteFormResponseRequest {
|
|
return FormAPIDeleteFormResponseRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
id: id,
|
|
response: response,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
func (a *FormAPIService) DeleteFormResponseExecute(r FormAPIDeleteFormResponseRequest) (*http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodDelete
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "FormAPIService.DeleteFormResponse")
|
|
if err != nil {
|
|
return nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/form/forms/{id}/responses/{response}"
|
|
localVarPath = strings.Replace(localVarPath, "{"+"id"+"}", url.PathEscape(parameterValueToString(r.id, "id")), -1)
|
|
localVarPath = strings.Replace(localVarPath, "{"+"response"+"}", url.PathEscape(parameterValueToString(r.response, "response")), -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 FormAPIDeleteFormThemeRequest struct {
|
|
ctx context.Context
|
|
ApiService *FormAPIService
|
|
id string
|
|
}
|
|
|
|
func (r FormAPIDeleteFormThemeRequest) Execute() (*http.Response, error) {
|
|
return r.ApiService.DeleteFormThemeExecute(r)
|
|
}
|
|
|
|
/*
|
|
DeleteFormTheme Deletes a theme.
|
|
|
|
Deletes a theme. A form drawn in it is refused (409) until it names another,
|
|
so no form is left naming a theme that is gone. An org admin only.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@param id ID is the theme's id, from the path.
|
|
@return FormAPIDeleteFormThemeRequest
|
|
*/
|
|
func (a *FormAPIService) DeleteFormTheme(ctx context.Context, id string) FormAPIDeleteFormThemeRequest {
|
|
return FormAPIDeleteFormThemeRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
id: id,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
func (a *FormAPIService) DeleteFormThemeExecute(r FormAPIDeleteFormThemeRequest) (*http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodDelete
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "FormAPIService.DeleteFormTheme")
|
|
if err != nil {
|
|
return nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/form/themes/{id}"
|
|
localVarPath = strings.Replace(localVarPath, "{"+"id"+"}", url.PathEscape(parameterValueToString(r.id, "id")), -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 FormAPIDeleteFormWebhookRequest struct {
|
|
ctx context.Context
|
|
ApiService *FormAPIService
|
|
id string
|
|
webhook string
|
|
}
|
|
|
|
func (r FormAPIDeleteFormWebhookRequest) Execute() (*http.Response, error) {
|
|
return r.ApiService.DeleteFormWebhookExecute(r)
|
|
}
|
|
|
|
/*
|
|
DeleteFormWebhook Deletes a webhook, its deliveries and its secret.
|
|
|
|
Deletes a webhook, its deliveries and its secret. An org admin only.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@param id ID is the form's id or slug, from the path.
|
|
@param webhook Webhook is the webhook's id, from the path.
|
|
@return FormAPIDeleteFormWebhookRequest
|
|
*/
|
|
func (a *FormAPIService) DeleteFormWebhook(ctx context.Context, id string, webhook string) FormAPIDeleteFormWebhookRequest {
|
|
return FormAPIDeleteFormWebhookRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
id: id,
|
|
webhook: webhook,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
func (a *FormAPIService) DeleteFormWebhookExecute(r FormAPIDeleteFormWebhookRequest) (*http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodDelete
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "FormAPIService.DeleteFormWebhook")
|
|
if err != nil {
|
|
return nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/form/forms/{id}/webhooks/{webhook}"
|
|
localVarPath = strings.Replace(localVarPath, "{"+"id"+"}", url.PathEscape(parameterValueToString(r.id, "id")), -1)
|
|
localVarPath = strings.Replace(localVarPath, "{"+"webhook"+"}", url.PathEscape(parameterValueToString(r.webhook, "webhook")), -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 FormAPIExportFormResponsesRequest struct {
|
|
ctx context.Context
|
|
ApiService *FormAPIService
|
|
id string
|
|
page *int64
|
|
pageSize *int64
|
|
since *string
|
|
until *string
|
|
completed *bool
|
|
query *string
|
|
filed *bool
|
|
sort *string
|
|
includedResponseIds *string
|
|
excludedResponseIds *string
|
|
format *string
|
|
}
|
|
|
|
// Page is the page, from 1. Default 1.
|
|
func (r FormAPIExportFormResponsesRequest) Page(page int64) FormAPIExportFormResponsesRequest {
|
|
r.page = &page
|
|
return r
|
|
}
|
|
|
|
// PageSize is how many a page holds: at most 1000, default 25.
|
|
func (r FormAPIExportFormResponsesRequest) PageSize(pageSize int64) FormAPIExportFormResponsesRequest {
|
|
r.pageSize = &pageSize
|
|
return r
|
|
}
|
|
|
|
// Since keeps the responses made at or after it, RFC 3339.
|
|
func (r FormAPIExportFormResponsesRequest) Since(since string) FormAPIExportFormResponsesRequest {
|
|
r.since = &since
|
|
return r
|
|
}
|
|
|
|
// Until keeps the responses made before it, RFC 3339.
|
|
func (r FormAPIExportFormResponsesRequest) Until(until string) FormAPIExportFormResponsesRequest {
|
|
r.until = &until
|
|
return r
|
|
}
|
|
|
|
// Completed keeps the completed responses (true) or the open ones (false); absent keeps both.
|
|
func (r FormAPIExportFormResponsesRequest) Completed(completed bool) FormAPIExportFormResponsesRequest {
|
|
r.completed = &completed
|
|
return r
|
|
}
|
|
|
|
// Query keeps the responses whose answers hold it.
|
|
func (r FormAPIExportFormResponsesRequest) Query(query string) FormAPIExportFormResponsesRequest {
|
|
r.query = &query
|
|
return r
|
|
}
|
|
|
|
// Filed keeps the responses on the CRM's timeline (true) or not yet on it (false); absent keeps both.
|
|
func (r FormAPIExportFormResponsesRequest) Filed(filed bool) FormAPIExportFormResponsesRequest {
|
|
r.filed = &filed
|
|
return r
|
|
}
|
|
|
|
// Sort is submitted_at,desc (the default) or submitted_at,asc.
|
|
func (r FormAPIExportFormResponsesRequest) Sort(sort string) FormAPIExportFormResponsesRequest {
|
|
r.sort = &sort
|
|
return r
|
|
}
|
|
|
|
// IncludedResponseIDs keeps only these responses, comma separated, at most 90.
|
|
func (r FormAPIExportFormResponsesRequest) IncludedResponseIds(includedResponseIds string) FormAPIExportFormResponsesRequest {
|
|
r.includedResponseIds = &includedResponseIds
|
|
return r
|
|
}
|
|
|
|
// ExcludedResponseIDs drops these responses, comma separated, at most 90.
|
|
func (r FormAPIExportFormResponsesRequest) ExcludedResponseIds(excludedResponseIds string) FormAPIExportFormResponsesRequest {
|
|
r.excludedResponseIds = &excludedResponseIds
|
|
return r
|
|
}
|
|
|
|
// Format is json (the default) or csv.
|
|
func (r FormAPIExportFormResponsesRequest) Format(format string) FormAPIExportFormResponsesRequest {
|
|
r.format = &format
|
|
return r
|
|
}
|
|
|
|
func (r FormAPIExportFormResponsesRequest) Execute() (*FormExport, *http.Response, error) {
|
|
return r.ApiService.ExportFormResponsesExecute(r)
|
|
}
|
|
|
|
/*
|
|
ExportFormResponses Exports a form's responses as JSON or CSV, a page of up to 5000 at a time under the same filter a listing takes; next is the page to ask for after it, 0 at the end.
|
|
|
|
Exports a form's responses as JSON or CSV, a page of up to 5000 at a time
|
|
under the same filter a listing takes; next is the page to ask for after it,
|
|
0 at the end. The CSV has one column per field (its title), then each hidden
|
|
value, the respondent's address and kind, and when the response was landed on
|
|
and submitted. An org admin only.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@param id ID is the form's id or slug, from the path.
|
|
@return FormAPIExportFormResponsesRequest
|
|
*/
|
|
func (a *FormAPIService) ExportFormResponses(ctx context.Context, id string) FormAPIExportFormResponsesRequest {
|
|
return FormAPIExportFormResponsesRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
id: id,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return FormExport
|
|
func (a *FormAPIService) ExportFormResponsesExecute(r FormAPIExportFormResponsesRequest) (*FormExport, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodGet
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *FormExport
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "FormAPIService.ExportFormResponses")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/form/forms/{id}/export"
|
|
localVarPath = strings.Replace(localVarPath, "{"+"id"+"}", url.PathEscape(parameterValueToString(r.id, "id")), -1)
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
|
|
if r.page != nil {
|
|
parameterAddToHeaderOrQuery(localVarQueryParams, "page", r.page, "form", "")
|
|
}
|
|
if r.pageSize != nil {
|
|
parameterAddToHeaderOrQuery(localVarQueryParams, "page_size", r.pageSize, "form", "")
|
|
}
|
|
if r.since != nil {
|
|
parameterAddToHeaderOrQuery(localVarQueryParams, "since", r.since, "form", "")
|
|
}
|
|
if r.until != nil {
|
|
parameterAddToHeaderOrQuery(localVarQueryParams, "until", r.until, "form", "")
|
|
}
|
|
if r.completed != nil {
|
|
parameterAddToHeaderOrQuery(localVarQueryParams, "completed", r.completed, "form", "")
|
|
}
|
|
if r.query != nil {
|
|
parameterAddToHeaderOrQuery(localVarQueryParams, "query", r.query, "form", "")
|
|
}
|
|
if r.filed != nil {
|
|
parameterAddToHeaderOrQuery(localVarQueryParams, "filed", r.filed, "form", "")
|
|
}
|
|
if r.sort != nil {
|
|
parameterAddToHeaderOrQuery(localVarQueryParams, "sort", r.sort, "form", "")
|
|
}
|
|
if r.includedResponseIds != nil {
|
|
parameterAddToHeaderOrQuery(localVarQueryParams, "included_response_ids", r.includedResponseIds, "form", "")
|
|
}
|
|
if r.excludedResponseIds != nil {
|
|
parameterAddToHeaderOrQuery(localVarQueryParams, "excluded_response_ids", r.excludedResponseIds, "form", "")
|
|
}
|
|
if r.format != nil {
|
|
parameterAddToHeaderOrQuery(localVarQueryParams, "format", r.format, "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 FormAPIFileFormResponseRequest struct {
|
|
ctx context.Context
|
|
ApiService *FormAPIService
|
|
id string
|
|
response string
|
|
}
|
|
|
|
func (r FormAPIFileFormResponseRequest) Execute() (*FormResponse, *http.Response, error) {
|
|
return r.ApiService.FileFormResponseExecute(r)
|
|
}
|
|
|
|
/*
|
|
FileFormResponse Files a completed response on the CRM's timeline now, and answers the response with whether it is filed and, when it is not, why.
|
|
|
|
Files a completed response on the CRM's timeline now, and answers the response
|
|
with whether it is filed and, when it is not, why. A filing that failed after
|
|
its submission is retried on a schedule; one a restart abandoned waits here.
|
|
Filing twice is one timeline entry. 409 for an open response, or a form that
|
|
files nowhere. An org admin only.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@param id ID is the form's id or slug, from the path.
|
|
@param response Response is the response's id, from the path.
|
|
@return FormAPIFileFormResponseRequest
|
|
*/
|
|
func (a *FormAPIService) FileFormResponse(ctx context.Context, id string, response string) FormAPIFileFormResponseRequest {
|
|
return FormAPIFileFormResponseRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
id: id,
|
|
response: response,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return FormResponse
|
|
func (a *FormAPIService) FileFormResponseExecute(r FormAPIFileFormResponseRequest) (*FormResponse, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodPost
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *FormResponse
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "FormAPIService.FileFormResponse")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/form/forms/{id}/responses/{response}/file"
|
|
localVarPath = strings.Replace(localVarPath, "{"+"id"+"}", url.PathEscape(parameterValueToString(r.id, "id")), -1)
|
|
localVarPath = strings.Replace(localVarPath, "{"+"response"+"}", url.PathEscape(parameterValueToString(r.response, "response")), -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 FormAPIGetFormRequest struct {
|
|
ctx context.Context
|
|
ApiService *FormAPIService
|
|
id string
|
|
}
|
|
|
|
func (r FormAPIGetFormRequest) Execute() (*FormForm, *http.Response, error) {
|
|
return r.ApiService.GetFormExecute(r)
|
|
}
|
|
|
|
/*
|
|
GetForm Reads one form of the caller's org, by its id or its slug.
|
|
|
|
Reads one form of the caller's org, by its id or its slug. An org admin only.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@param id ID is the form's id or its slug, from the path.
|
|
@return FormAPIGetFormRequest
|
|
*/
|
|
func (a *FormAPIService) GetForm(ctx context.Context, id string) FormAPIGetFormRequest {
|
|
return FormAPIGetFormRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
id: id,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return FormForm
|
|
func (a *FormAPIService) GetFormExecute(r FormAPIGetFormRequest) (*FormForm, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodGet
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *FormForm
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "FormAPIService.GetForm")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/form/forms/{id}"
|
|
localVarPath = strings.Replace(localVarPath, "{"+"id"+"}", url.PathEscape(parameterValueToString(r.id, "id")), -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 FormAPIGetFormResponseRequest struct {
|
|
ctx context.Context
|
|
ApiService *FormAPIService
|
|
id string
|
|
response string
|
|
}
|
|
|
|
func (r FormAPIGetFormResponseRequest) Execute() (*FormResponse, *http.Response, error) {
|
|
return r.ApiService.GetFormResponseExecute(r)
|
|
}
|
|
|
|
/*
|
|
GetFormResponse Reads one response of a form.
|
|
|
|
Reads one response of a form. An org admin only.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@param id ID is the form's id or slug, from the path.
|
|
@param response Response is the response's id, from the path.
|
|
@return FormAPIGetFormResponseRequest
|
|
*/
|
|
func (a *FormAPIService) GetFormResponse(ctx context.Context, id string, response string) FormAPIGetFormResponseRequest {
|
|
return FormAPIGetFormResponseRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
id: id,
|
|
response: response,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return FormResponse
|
|
func (a *FormAPIService) GetFormResponseExecute(r FormAPIGetFormResponseRequest) (*FormResponse, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodGet
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *FormResponse
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "FormAPIService.GetFormResponse")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/form/forms/{id}/responses/{response}"
|
|
localVarPath = strings.Replace(localVarPath, "{"+"id"+"}", url.PathEscape(parameterValueToString(r.id, "id")), -1)
|
|
localVarPath = strings.Replace(localVarPath, "{"+"response"+"}", url.PathEscape(parameterValueToString(r.response, "response")), -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 FormAPIGetFormThemeRequest struct {
|
|
ctx context.Context
|
|
ApiService *FormAPIService
|
|
id string
|
|
}
|
|
|
|
func (r FormAPIGetFormThemeRequest) Execute() (*FormTheme, *http.Response, error) {
|
|
return r.ApiService.GetFormThemeExecute(r)
|
|
}
|
|
|
|
/*
|
|
GetFormTheme Reads one theme of the caller's org.
|
|
|
|
Reads one theme of the caller's org. An org admin only.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@param id ID is the theme's id, from the path.
|
|
@return FormAPIGetFormThemeRequest
|
|
*/
|
|
func (a *FormAPIService) GetFormTheme(ctx context.Context, id string) FormAPIGetFormThemeRequest {
|
|
return FormAPIGetFormThemeRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
id: id,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return FormTheme
|
|
func (a *FormAPIService) GetFormThemeExecute(r FormAPIGetFormThemeRequest) (*FormTheme, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodGet
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *FormTheme
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "FormAPIService.GetFormTheme")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/form/themes/{id}"
|
|
localVarPath = strings.Replace(localVarPath, "{"+"id"+"}", url.PathEscape(parameterValueToString(r.id, "id")), -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 FormAPIGetFormWebhookRequest struct {
|
|
ctx context.Context
|
|
ApiService *FormAPIService
|
|
id string
|
|
webhook string
|
|
}
|
|
|
|
func (r FormAPIGetFormWebhookRequest) Execute() (*FormWebhook, *http.Response, error) {
|
|
return r.ApiService.GetFormWebhookExecute(r)
|
|
}
|
|
|
|
/*
|
|
GetFormWebhook Reads one webhook of a form.
|
|
|
|
Reads one webhook of a form. Its secret is never read back. An org admin only.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@param id ID is the form's id or slug, from the path.
|
|
@param webhook Webhook is the webhook's id, from the path.
|
|
@return FormAPIGetFormWebhookRequest
|
|
*/
|
|
func (a *FormAPIService) GetFormWebhook(ctx context.Context, id string, webhook string) FormAPIGetFormWebhookRequest {
|
|
return FormAPIGetFormWebhookRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
id: id,
|
|
webhook: webhook,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return FormWebhook
|
|
func (a *FormAPIService) GetFormWebhookExecute(r FormAPIGetFormWebhookRequest) (*FormWebhook, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodGet
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *FormWebhook
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "FormAPIService.GetFormWebhook")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/form/forms/{id}/webhooks/{webhook}"
|
|
localVarPath = strings.Replace(localVarPath, "{"+"id"+"}", url.PathEscape(parameterValueToString(r.id, "id")), -1)
|
|
localVarPath = strings.Replace(localVarPath, "{"+"webhook"+"}", url.PathEscape(parameterValueToString(r.webhook, "webhook")), -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 FormAPIGetPublicFormRequest struct {
|
|
ctx context.Context
|
|
ApiService *FormAPIService
|
|
id string
|
|
}
|
|
|
|
func (r FormAPIGetPublicFormRequest) Execute() (*FormPublicForm, *http.Response, error) {
|
|
return r.ApiService.GetPublicFormExecute(r)
|
|
}
|
|
|
|
/*
|
|
GetPublicForm Reads a published form as its page draws it: the questions, the screens, the hidden values it takes, how it is answered and its theme.
|
|
|
|
Reads a published form as its page draws it: the questions, the screens, the
|
|
hidden values it takes, how it is answered and its theme. Nothing about where
|
|
its responses go. No credential is needed; a form that is private, deleted or
|
|
never was is a 404.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@param id ID is the form's public id, \"<org>.<slug or id>\", from the path.
|
|
@return FormAPIGetPublicFormRequest
|
|
*/
|
|
func (a *FormAPIService) GetPublicForm(ctx context.Context, id string) FormAPIGetPublicFormRequest {
|
|
return FormAPIGetPublicFormRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
id: id,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return FormPublicForm
|
|
func (a *FormAPIService) GetPublicFormExecute(r FormAPIGetPublicFormRequest) (*FormPublicForm, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodGet
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *FormPublicForm
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "FormAPIService.GetPublicForm")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/form/public/{id}"
|
|
localVarPath = strings.Replace(localVarPath, "{"+"id"+"}", url.PathEscape(parameterValueToString(r.id, "id")), -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 FormAPIImportFormResponsesRequest struct {
|
|
ctx context.Context
|
|
ApiService *FormAPIService
|
|
id string
|
|
formImportIn *FormImportIn
|
|
}
|
|
|
|
func (r FormAPIImportFormResponsesRequest) FormImportIn(formImportIn FormImportIn) FormAPIImportFormResponsesRequest {
|
|
r.formImportIn = &formImportIn
|
|
return r
|
|
}
|
|
|
|
func (r FormAPIImportFormResponsesRequest) Execute() (*FormImports, *http.Response, error) {
|
|
return r.ApiService.ImportFormResponsesExecute(r)
|
|
}
|
|
|
|
/*
|
|
ImportFormResponses Brings responses made elsewhere into a form, keeping when each was made, a batch of at most 500 at a time.
|
|
|
|
Brings responses made elsewhere into a form, keeping when each was made, a
|
|
batch of at most 500 at a time. Each is keyed by its external id (on a
|
|
subscribe form, by its address), so a batch sent again, or an import resumed
|
|
from any point, makes nothing twice. Each answer is read against its field as
|
|
a submission's is; a required field may be unanswered. With file, each new
|
|
response is also filed in the CRM at the time it was made; nothing is mailed
|
|
and no webhook is told. An org admin only.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@param id ID is the form's id or slug, from the path.
|
|
@return FormAPIImportFormResponsesRequest
|
|
*/
|
|
func (a *FormAPIService) ImportFormResponses(ctx context.Context, id string) FormAPIImportFormResponsesRequest {
|
|
return FormAPIImportFormResponsesRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
id: id,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return FormImports
|
|
func (a *FormAPIService) ImportFormResponsesExecute(r FormAPIImportFormResponsesRequest) (*FormImports, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodPost
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *FormImports
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "FormAPIService.ImportFormResponses")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/form/forms/{id}/import"
|
|
localVarPath = strings.Replace(localVarPath, "{"+"id"+"}", url.PathEscape(parameterValueToString(r.id, "id")), -1)
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
if r.formImportIn == nil {
|
|
return localVarReturnValue, nil, reportError("formImportIn 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.formImportIn
|
|
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 FormAPIListFormDeliveriesRequest struct {
|
|
ctx context.Context
|
|
ApiService *FormAPIService
|
|
id string
|
|
webhook string
|
|
page *int64
|
|
pageSize *int64
|
|
}
|
|
|
|
// Page is the page, from 1; PageSize at most 200, default 50.
|
|
func (r FormAPIListFormDeliveriesRequest) Page(page int64) FormAPIListFormDeliveriesRequest {
|
|
r.page = &page
|
|
return r
|
|
}
|
|
|
|
func (r FormAPIListFormDeliveriesRequest) PageSize(pageSize int64) FormAPIListFormDeliveriesRequest {
|
|
r.pageSize = &pageSize
|
|
return r
|
|
}
|
|
|
|
func (r FormAPIListFormDeliveriesRequest) Execute() (*FormDeliveryList, *http.Response, error) {
|
|
return r.ApiService.ListFormDeliveriesExecute(r)
|
|
}
|
|
|
|
/*
|
|
ListFormDeliveries Lists a webhook's deliveries, newest first: each response posted, how many attempts it took, the last status the address answered and why it failed.
|
|
|
|
Lists a webhook's deliveries, newest first: each response posted, how many
|
|
attempts it took, the last status the address answered and why it failed. An
|
|
org admin only.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@param id ID is the form's id or slug, from the path.
|
|
@param webhook Webhook is the webhook's id, from the path.
|
|
@return FormAPIListFormDeliveriesRequest
|
|
*/
|
|
func (a *FormAPIService) ListFormDeliveries(ctx context.Context, id string, webhook string) FormAPIListFormDeliveriesRequest {
|
|
return FormAPIListFormDeliveriesRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
id: id,
|
|
webhook: webhook,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return FormDeliveryList
|
|
func (a *FormAPIService) ListFormDeliveriesExecute(r FormAPIListFormDeliveriesRequest) (*FormDeliveryList, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodGet
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *FormDeliveryList
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "FormAPIService.ListFormDeliveries")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/form/forms/{id}/webhooks/{webhook}/deliveries"
|
|
localVarPath = strings.Replace(localVarPath, "{"+"id"+"}", url.PathEscape(parameterValueToString(r.id, "id")), -1)
|
|
localVarPath = strings.Replace(localVarPath, "{"+"webhook"+"}", url.PathEscape(parameterValueToString(r.webhook, "webhook")), -1)
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
|
|
if r.page != nil {
|
|
parameterAddToHeaderOrQuery(localVarQueryParams, "page", r.page, "form", "")
|
|
}
|
|
if r.pageSize != nil {
|
|
parameterAddToHeaderOrQuery(localVarQueryParams, "page_size", r.pageSize, "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 FormAPIListFormResponsesRequest struct {
|
|
ctx context.Context
|
|
ApiService *FormAPIService
|
|
id string
|
|
page *int64
|
|
pageSize *int64
|
|
since *string
|
|
until *string
|
|
completed *bool
|
|
query *string
|
|
filed *bool
|
|
sort *string
|
|
includedResponseIds *string
|
|
excludedResponseIds *string
|
|
}
|
|
|
|
// Page is the page, from 1. Default 1.
|
|
func (r FormAPIListFormResponsesRequest) Page(page int64) FormAPIListFormResponsesRequest {
|
|
r.page = &page
|
|
return r
|
|
}
|
|
|
|
// PageSize is how many a page holds: at most 1000, default 25.
|
|
func (r FormAPIListFormResponsesRequest) PageSize(pageSize int64) FormAPIListFormResponsesRequest {
|
|
r.pageSize = &pageSize
|
|
return r
|
|
}
|
|
|
|
// Since keeps the responses made at or after it, RFC 3339.
|
|
func (r FormAPIListFormResponsesRequest) Since(since string) FormAPIListFormResponsesRequest {
|
|
r.since = &since
|
|
return r
|
|
}
|
|
|
|
// Until keeps the responses made before it, RFC 3339.
|
|
func (r FormAPIListFormResponsesRequest) Until(until string) FormAPIListFormResponsesRequest {
|
|
r.until = &until
|
|
return r
|
|
}
|
|
|
|
// Completed keeps the completed responses (true) or the open ones (false); absent keeps both.
|
|
func (r FormAPIListFormResponsesRequest) Completed(completed bool) FormAPIListFormResponsesRequest {
|
|
r.completed = &completed
|
|
return r
|
|
}
|
|
|
|
// Query keeps the responses whose answers hold it.
|
|
func (r FormAPIListFormResponsesRequest) Query(query string) FormAPIListFormResponsesRequest {
|
|
r.query = &query
|
|
return r
|
|
}
|
|
|
|
// Filed keeps the responses on the CRM's timeline (true) or not yet on it (false); absent keeps both.
|
|
func (r FormAPIListFormResponsesRequest) Filed(filed bool) FormAPIListFormResponsesRequest {
|
|
r.filed = &filed
|
|
return r
|
|
}
|
|
|
|
// Sort is submitted_at,desc (the default) or submitted_at,asc.
|
|
func (r FormAPIListFormResponsesRequest) Sort(sort string) FormAPIListFormResponsesRequest {
|
|
r.sort = &sort
|
|
return r
|
|
}
|
|
|
|
// IncludedResponseIDs keeps only these responses, comma separated, at most 90.
|
|
func (r FormAPIListFormResponsesRequest) IncludedResponseIds(includedResponseIds string) FormAPIListFormResponsesRequest {
|
|
r.includedResponseIds = &includedResponseIds
|
|
return r
|
|
}
|
|
|
|
// ExcludedResponseIDs drops these responses, comma separated, at most 90.
|
|
func (r FormAPIListFormResponsesRequest) ExcludedResponseIds(excludedResponseIds string) FormAPIListFormResponsesRequest {
|
|
r.excludedResponseIds = &excludedResponseIds
|
|
return r
|
|
}
|
|
|
|
func (r FormAPIListFormResponsesRequest) Execute() (*FormResponseList, *http.Response, error) {
|
|
return r.ApiService.ListFormResponsesExecute(r)
|
|
}
|
|
|
|
/*
|
|
ListFormResponses Lists a form's responses, newest first, a page at a time: since and until bound when they were made, completed keeps the finished or the open ones, query keeps the ones whose answers hold it, and included_response_ids and excluded_response_ids keep or drop named ones.
|
|
|
|
Lists a form's responses, newest first, a page at a time: since and until
|
|
bound when they were made, completed keeps the finished or the open ones, query
|
|
keeps the ones whose answers hold it, and included_response_ids and
|
|
excluded_response_ids keep or drop named ones. An org admin only.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@param id ID is the form's id or slug, from the path.
|
|
@return FormAPIListFormResponsesRequest
|
|
*/
|
|
func (a *FormAPIService) ListFormResponses(ctx context.Context, id string) FormAPIListFormResponsesRequest {
|
|
return FormAPIListFormResponsesRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
id: id,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return FormResponseList
|
|
func (a *FormAPIService) ListFormResponsesExecute(r FormAPIListFormResponsesRequest) (*FormResponseList, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodGet
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *FormResponseList
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "FormAPIService.ListFormResponses")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/form/forms/{id}/responses"
|
|
localVarPath = strings.Replace(localVarPath, "{"+"id"+"}", url.PathEscape(parameterValueToString(r.id, "id")), -1)
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
|
|
if r.page != nil {
|
|
parameterAddToHeaderOrQuery(localVarQueryParams, "page", r.page, "form", "")
|
|
}
|
|
if r.pageSize != nil {
|
|
parameterAddToHeaderOrQuery(localVarQueryParams, "page_size", r.pageSize, "form", "")
|
|
}
|
|
if r.since != nil {
|
|
parameterAddToHeaderOrQuery(localVarQueryParams, "since", r.since, "form", "")
|
|
}
|
|
if r.until != nil {
|
|
parameterAddToHeaderOrQuery(localVarQueryParams, "until", r.until, "form", "")
|
|
}
|
|
if r.completed != nil {
|
|
parameterAddToHeaderOrQuery(localVarQueryParams, "completed", r.completed, "form", "")
|
|
}
|
|
if r.query != nil {
|
|
parameterAddToHeaderOrQuery(localVarQueryParams, "query", r.query, "form", "")
|
|
}
|
|
if r.filed != nil {
|
|
parameterAddToHeaderOrQuery(localVarQueryParams, "filed", r.filed, "form", "")
|
|
}
|
|
if r.sort != nil {
|
|
parameterAddToHeaderOrQuery(localVarQueryParams, "sort", r.sort, "form", "")
|
|
}
|
|
if r.includedResponseIds != nil {
|
|
parameterAddToHeaderOrQuery(localVarQueryParams, "included_response_ids", r.includedResponseIds, "form", "")
|
|
}
|
|
if r.excludedResponseIds != nil {
|
|
parameterAddToHeaderOrQuery(localVarQueryParams, "excluded_response_ids", r.excludedResponseIds, "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 FormAPIListFormThemesRequest struct {
|
|
ctx context.Context
|
|
ApiService *FormAPIService
|
|
}
|
|
|
|
func (r FormAPIListFormThemesRequest) Execute() (*FormThemeList, *http.Response, error) {
|
|
return r.ApiService.ListFormThemesExecute(r)
|
|
}
|
|
|
|
/*
|
|
ListFormThemes Lists the caller org's themes by name.
|
|
|
|
Lists the caller org's themes by name. An org admin only.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@return FormAPIListFormThemesRequest
|
|
*/
|
|
func (a *FormAPIService) ListFormThemes(ctx context.Context) FormAPIListFormThemesRequest {
|
|
return FormAPIListFormThemesRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return FormThemeList
|
|
func (a *FormAPIService) ListFormThemesExecute(r FormAPIListFormThemesRequest) (*FormThemeList, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodGet
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *FormThemeList
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "FormAPIService.ListFormThemes")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/form/themes"
|
|
|
|
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 FormAPIListFormWebhooksRequest struct {
|
|
ctx context.Context
|
|
ApiService *FormAPIService
|
|
id string
|
|
}
|
|
|
|
func (r FormAPIListFormWebhooksRequest) Execute() (*FormWebhookList, *http.Response, error) {
|
|
return r.ApiService.ListFormWebhooksExecute(r)
|
|
}
|
|
|
|
/*
|
|
ListFormWebhooks Lists a form's webhooks.
|
|
|
|
Lists a form's webhooks. Secrets are never read back. An org admin only.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@param id ID is the form's id or its slug, from the path.
|
|
@return FormAPIListFormWebhooksRequest
|
|
*/
|
|
func (a *FormAPIService) ListFormWebhooks(ctx context.Context, id string) FormAPIListFormWebhooksRequest {
|
|
return FormAPIListFormWebhooksRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
id: id,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return FormWebhookList
|
|
func (a *FormAPIService) ListFormWebhooksExecute(r FormAPIListFormWebhooksRequest) (*FormWebhookList, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodGet
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *FormWebhookList
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "FormAPIService.ListFormWebhooks")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/form/forms/{id}/webhooks"
|
|
localVarPath = strings.Replace(localVarPath, "{"+"id"+"}", url.PathEscape(parameterValueToString(r.id, "id")), -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 FormAPIListFormsRequest struct {
|
|
ctx context.Context
|
|
ApiService *FormAPIService
|
|
page *int64
|
|
pageSize *int64
|
|
search *string
|
|
tag *string
|
|
}
|
|
|
|
// Page is the page, from 1. Default 1.
|
|
func (r FormAPIListFormsRequest) Page(page int64) FormAPIListFormsRequest {
|
|
r.page = &page
|
|
return r
|
|
}
|
|
|
|
// PageSize is how many a page holds: at most 200, default 50.
|
|
func (r FormAPIListFormsRequest) PageSize(pageSize int64) FormAPIListFormsRequest {
|
|
r.pageSize = &pageSize
|
|
return r
|
|
}
|
|
|
|
// Search keeps the forms whose title holds it.
|
|
func (r FormAPIListFormsRequest) Search(search string) FormAPIListFormsRequest {
|
|
r.search = &search
|
|
return r
|
|
}
|
|
|
|
// Tag keeps the forms tagged with it.
|
|
func (r FormAPIListFormsRequest) Tag(tag string) FormAPIListFormsRequest {
|
|
r.tag = &tag
|
|
return r
|
|
}
|
|
|
|
func (r FormAPIListFormsRequest) Execute() (*FormFormList, *http.Response, error) {
|
|
return r.ApiService.ListFormsExecute(r)
|
|
}
|
|
|
|
/*
|
|
ListForms Lists the caller org's forms, newest first, a page at a time; search keeps the forms whose title holds it and tag the ones carrying it.
|
|
|
|
Lists the caller org's forms, newest first, a page at a time; search keeps
|
|
the forms whose title holds it and tag the ones carrying it. An org admin only.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@return FormAPIListFormsRequest
|
|
*/
|
|
func (a *FormAPIService) ListForms(ctx context.Context) FormAPIListFormsRequest {
|
|
return FormAPIListFormsRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return FormFormList
|
|
func (a *FormAPIService) ListFormsExecute(r FormAPIListFormsRequest) (*FormFormList, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodGet
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *FormFormList
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "FormAPIService.ListForms")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/form/forms"
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
|
|
if r.page != nil {
|
|
parameterAddToHeaderOrQuery(localVarQueryParams, "page", r.page, "form", "")
|
|
}
|
|
if r.pageSize != nil {
|
|
parameterAddToHeaderOrQuery(localVarQueryParams, "page_size", r.pageSize, "form", "")
|
|
}
|
|
if r.search != nil {
|
|
parameterAddToHeaderOrQuery(localVarQueryParams, "search", r.search, "form", "")
|
|
}
|
|
if r.tag != nil {
|
|
parameterAddToHeaderOrQuery(localVarQueryParams, "tag", r.tag, "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 FormAPIRedeliverFormWebhookRequest struct {
|
|
ctx context.Context
|
|
ApiService *FormAPIService
|
|
id string
|
|
webhook string
|
|
delivery string
|
|
}
|
|
|
|
func (r FormAPIRedeliverFormWebhookRequest) Execute() (*FormDelivery, *http.Response, error) {
|
|
return r.ApiService.RedeliverFormWebhookExecute(r)
|
|
}
|
|
|
|
/*
|
|
RedeliverFormWebhook Posts a delivery's response to its webhook again, now, and answers how it went.
|
|
|
|
Posts a delivery's response to its webhook again, now, and answers how it
|
|
went. A delivery that failed, or was waiting on a retry when the service
|
|
restarted, is sent this way. An org admin only.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@param id ID is the form's id or slug, from the path.
|
|
@param webhook Webhook is the webhook's id, from the path.
|
|
@param delivery Delivery is the delivery's id, from the path.
|
|
@return FormAPIRedeliverFormWebhookRequest
|
|
*/
|
|
func (a *FormAPIService) RedeliverFormWebhook(ctx context.Context, id string, webhook string, delivery string) FormAPIRedeliverFormWebhookRequest {
|
|
return FormAPIRedeliverFormWebhookRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
id: id,
|
|
webhook: webhook,
|
|
delivery: delivery,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return FormDelivery
|
|
func (a *FormAPIService) RedeliverFormWebhookExecute(r FormAPIRedeliverFormWebhookRequest) (*FormDelivery, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodPost
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *FormDelivery
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "FormAPIService.RedeliverFormWebhook")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/form/forms/{id}/webhooks/{webhook}/deliveries/{delivery}/retry"
|
|
localVarPath = strings.Replace(localVarPath, "{"+"id"+"}", url.PathEscape(parameterValueToString(r.id, "id")), -1)
|
|
localVarPath = strings.Replace(localVarPath, "{"+"webhook"+"}", url.PathEscape(parameterValueToString(r.webhook, "webhook")), -1)
|
|
localVarPath = strings.Replace(localVarPath, "{"+"delivery"+"}", url.PathEscape(parameterValueToString(r.delivery, "delivery")), -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 FormAPIReplaceFormRequest struct {
|
|
ctx context.Context
|
|
ApiService *FormAPIService
|
|
id string
|
|
formForm *FormForm
|
|
}
|
|
|
|
func (r FormAPIReplaceFormRequest) FormForm(formForm FormForm) FormAPIReplaceFormRequest {
|
|
r.formForm = &formForm
|
|
return r
|
|
}
|
|
|
|
func (r FormAPIReplaceFormRequest) Execute() (*FormForm, *http.Response, error) {
|
|
return r.ApiService.ReplaceFormExecute(r)
|
|
}
|
|
|
|
/*
|
|
ReplaceForm Replaces a form whole and answers it as stored.
|
|
|
|
Replaces a form whole and answers it as stored. Named by a slug no form has
|
|
yet, it makes the form under that slug, so a definition written twice is one
|
|
form: the way a seed states a form. A field sent with its id keeps it; a type
|
|
the platform no longer offers stays answerable where the form already asks
|
|
it, and is refused where it is new. An org admin only.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@param id ID is the form's id: 15 lowercase hex characters, derived from the slug when the form has one, so a slug names one form for good.
|
|
@return FormAPIReplaceFormRequest
|
|
*/
|
|
func (a *FormAPIService) ReplaceForm(ctx context.Context, id string) FormAPIReplaceFormRequest {
|
|
return FormAPIReplaceFormRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
id: id,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return FormForm
|
|
func (a *FormAPIService) ReplaceFormExecute(r FormAPIReplaceFormRequest) (*FormForm, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodPut
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *FormForm
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "FormAPIService.ReplaceForm")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/form/forms/{id}"
|
|
localVarPath = strings.Replace(localVarPath, "{"+"id"+"}", url.PathEscape(parameterValueToString(r.id, "id")), -1)
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
if r.formForm == nil {
|
|
return localVarReturnValue, nil, reportError("formForm 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.formForm
|
|
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 FormAPIReplaceFormThemeRequest struct {
|
|
ctx context.Context
|
|
ApiService *FormAPIService
|
|
id string
|
|
formTheme *FormTheme
|
|
}
|
|
|
|
func (r FormAPIReplaceFormThemeRequest) FormTheme(formTheme FormTheme) FormAPIReplaceFormThemeRequest {
|
|
r.formTheme = &formTheme
|
|
return r
|
|
}
|
|
|
|
func (r FormAPIReplaceFormThemeRequest) Execute() (*FormTheme, *http.Response, error) {
|
|
return r.ApiService.ReplaceFormThemeExecute(r)
|
|
}
|
|
|
|
/*
|
|
ReplaceFormTheme Replaces a theme whole; every form drawn in it is drawn in the new one.
|
|
|
|
Replaces a theme whole; every form drawn in it is drawn in the new one. An
|
|
org admin only.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@param id ID is the theme's id.
|
|
@return FormAPIReplaceFormThemeRequest
|
|
*/
|
|
func (a *FormAPIService) ReplaceFormTheme(ctx context.Context, id string) FormAPIReplaceFormThemeRequest {
|
|
return FormAPIReplaceFormThemeRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
id: id,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return FormTheme
|
|
func (a *FormAPIService) ReplaceFormThemeExecute(r FormAPIReplaceFormThemeRequest) (*FormTheme, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodPut
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *FormTheme
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "FormAPIService.ReplaceFormTheme")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/form/themes/{id}"
|
|
localVarPath = strings.Replace(localVarPath, "{"+"id"+"}", url.PathEscape(parameterValueToString(r.id, "id")), -1)
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
if r.formTheme == nil {
|
|
return localVarReturnValue, nil, reportError("formTheme 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.formTheme
|
|
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 FormAPIReplaceFormWebhookRequest struct {
|
|
ctx context.Context
|
|
ApiService *FormAPIService
|
|
id string
|
|
webhook string
|
|
formWebhookIn *FormWebhookIn
|
|
}
|
|
|
|
func (r FormAPIReplaceFormWebhookRequest) FormWebhookIn(formWebhookIn FormWebhookIn) FormAPIReplaceFormWebhookRequest {
|
|
r.formWebhookIn = &formWebhookIn
|
|
return r
|
|
}
|
|
|
|
func (r FormAPIReplaceFormWebhookRequest) Execute() (*FormWebhook, *http.Response, error) {
|
|
return r.ApiService.ReplaceFormWebhookExecute(r)
|
|
}
|
|
|
|
/*
|
|
ReplaceFormWebhook Replaces a webhook's tag, address and whether it is enabled.
|
|
|
|
Replaces a webhook's tag, address and whether it is enabled. A secret given is
|
|
kept in place of the one held, rotate mints a new one, and either is answered
|
|
once; otherwise the secret held stays. An org admin only.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@param id ID is the form's id or slug, from the path.
|
|
@param webhook Webhook is the webhook's id, from the path of a replace.
|
|
@return FormAPIReplaceFormWebhookRequest
|
|
*/
|
|
func (a *FormAPIService) ReplaceFormWebhook(ctx context.Context, id string, webhook string) FormAPIReplaceFormWebhookRequest {
|
|
return FormAPIReplaceFormWebhookRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
id: id,
|
|
webhook: webhook,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return FormWebhook
|
|
func (a *FormAPIService) ReplaceFormWebhookExecute(r FormAPIReplaceFormWebhookRequest) (*FormWebhook, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodPut
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *FormWebhook
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "FormAPIService.ReplaceFormWebhook")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/form/forms/{id}/webhooks/{webhook}"
|
|
localVarPath = strings.Replace(localVarPath, "{"+"id"+"}", url.PathEscape(parameterValueToString(r.id, "id")), -1)
|
|
localVarPath = strings.Replace(localVarPath, "{"+"webhook"+"}", url.PathEscape(parameterValueToString(r.webhook, "webhook")), -1)
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
if r.formWebhookIn == nil {
|
|
return localVarReturnValue, nil, reportError("formWebhookIn 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.formWebhookIn
|
|
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 FormAPISubmitFormResponseRequest struct {
|
|
ctx context.Context
|
|
ApiService *FormAPIService
|
|
id string
|
|
formSubmission *FormSubmission
|
|
}
|
|
|
|
func (r FormAPISubmitFormResponseRequest) FormSubmission(formSubmission FormSubmission) FormAPISubmitFormResponseRequest {
|
|
r.formSubmission = &formSubmission
|
|
return r
|
|
}
|
|
|
|
func (r FormAPISubmitFormResponseRequest) Execute() (*FormReceipt, *http.Response, error) {
|
|
return r.ApiService.SubmitFormResponseExecute(r)
|
|
}
|
|
|
|
/*
|
|
SubmitFormResponse Answers a published form.
|
|
|
|
Answers a published form. No credential is needed.
|
|
|
|
The answers are read against the form's own fields: each names a field (by
|
|
ref) once and carries the one value its type takes, inside its bounds; a
|
|
completed submission answers every required field. Hidden values are the
|
|
names the form declares. The response is from the signed-in person when there
|
|
is one (their account, from their token, never from the body), else from the
|
|
email field's answer, else from the page's visitor id.
|
|
|
|
Idempotent by token: the same token is the same response, so a submission
|
|
sent twice files one. With completed false the answers so far are saved and
|
|
the response stays open; a completed response is final and a later submission
|
|
under its token is answered with it unchanged. A subscribe form's response is
|
|
keyed by its address instead: one address is one subscriber.
|
|
|
|
A completed response goes to the form's sinks: the event stream, the CRM, the
|
|
forwarding address, the welcome mail and the webhooks.
|
|
|
|
429 past the platform's rate for one address, 413 past its body bound, 400
|
|
for a body that does not decode, a field no person fills, or any problem with
|
|
the answers (every one named), 404 for a form that is not published.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@param id ID is the form's public id, from the path.
|
|
@return FormAPISubmitFormResponseRequest
|
|
*/
|
|
func (a *FormAPIService) SubmitFormResponse(ctx context.Context, id string) FormAPISubmitFormResponseRequest {
|
|
return FormAPISubmitFormResponseRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
id: id,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return FormReceipt
|
|
func (a *FormAPIService) SubmitFormResponseExecute(r FormAPISubmitFormResponseRequest) (*FormReceipt, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodPost
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *FormReceipt
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "FormAPIService.SubmitFormResponse")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/form/public/{id}/responses"
|
|
localVarPath = strings.Replace(localVarPath, "{"+"id"+"}", url.PathEscape(parameterValueToString(r.id, "id")), -1)
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
if r.formSubmission == nil {
|
|
return localVarReturnValue, nil, reportError("formSubmission 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.formSubmission
|
|
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 FormAPISummarizeFormRequest struct {
|
|
ctx context.Context
|
|
ApiService *FormAPIService
|
|
id string
|
|
since *string
|
|
until *string
|
|
}
|
|
|
|
// Since keeps the responses made at or after it, RFC 3339.
|
|
func (r FormAPISummarizeFormRequest) Since(since string) FormAPISummarizeFormRequest {
|
|
r.since = &since
|
|
return r
|
|
}
|
|
|
|
// Until keeps the responses made before it, RFC 3339.
|
|
func (r FormAPISummarizeFormRequest) Until(until string) FormAPISummarizeFormRequest {
|
|
r.until = &until
|
|
return r
|
|
}
|
|
|
|
func (r FormAPISummarizeFormRequest) Execute() (*FormSummary, *http.Response, error) {
|
|
return r.ApiService.SummarizeFormExecute(r)
|
|
}
|
|
|
|
/*
|
|
SummarizeForm Sums up a form's responses: how many were begun and completed, and for each field how many answered it, the distribution of what was said (choices, points, yes and no), the mean, least and most of a number, and how many open responses stopped in front of it.
|
|
|
|
Sums up a form's responses: how many were begun and completed, and for each
|
|
field how many answered it, the distribution of what was said (choices,
|
|
points, yes and no), the mean, least and most of a number, and how many open
|
|
responses stopped in front of it. since and until narrow it to when the
|
|
responses were made. At most the newest 50000 are read, and truncated says so.
|
|
An org admin only.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@param id ID is the form's id or slug, from the path.
|
|
@return FormAPISummarizeFormRequest
|
|
*/
|
|
func (a *FormAPIService) SummarizeForm(ctx context.Context, id string) FormAPISummarizeFormRequest {
|
|
return FormAPISummarizeFormRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
id: id,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return FormSummary
|
|
func (a *FormAPIService) SummarizeFormExecute(r FormAPISummarizeFormRequest) (*FormSummary, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodGet
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *FormSummary
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "FormAPIService.SummarizeForm")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/form/forms/{id}/summary"
|
|
localVarPath = strings.Replace(localVarPath, "{"+"id"+"}", url.PathEscape(parameterValueToString(r.id, "id")), -1)
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
|
|
if r.since != nil {
|
|
parameterAddToHeaderOrQuery(localVarQueryParams, "since", r.since, "form", "")
|
|
}
|
|
if r.until != nil {
|
|
parameterAddToHeaderOrQuery(localVarQueryParams, "until", r.until, "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 FormAPIUpdateFormRequest struct {
|
|
ctx context.Context
|
|
ApiService *FormAPIService
|
|
id string
|
|
formFormPatch *FormFormPatch
|
|
}
|
|
|
|
func (r FormAPIUpdateFormRequest) FormFormPatch(formFormPatch FormFormPatch) FormAPIUpdateFormRequest {
|
|
r.formFormPatch = &formFormPatch
|
|
return r
|
|
}
|
|
|
|
func (r FormAPIUpdateFormRequest) Execute() (*FormForm, *http.Response, error) {
|
|
return r.ApiService.UpdateFormExecute(r)
|
|
}
|
|
|
|
/*
|
|
UpdateForm Changes the parts of a form the body names and keeps the rest, then answers it as stored.
|
|
|
|
Changes the parts of a form the body names and keeps the rest, then answers it
|
|
as stored. The whole form is checked as it will be, exactly as a replace is.
|
|
An org admin only.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@param id ID is the form's id or its slug, from the path.
|
|
@return FormAPIUpdateFormRequest
|
|
*/
|
|
func (a *FormAPIService) UpdateForm(ctx context.Context, id string) FormAPIUpdateFormRequest {
|
|
return FormAPIUpdateFormRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
id: id,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return FormForm
|
|
func (a *FormAPIService) UpdateFormExecute(r FormAPIUpdateFormRequest) (*FormForm, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodPatch
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *FormForm
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "FormAPIService.UpdateForm")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/form/forms/{id}"
|
|
localVarPath = strings.Replace(localVarPath, "{"+"id"+"}", url.PathEscape(parameterValueToString(r.id, "id")), -1)
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
if r.formFormPatch == nil {
|
|
return localVarReturnValue, nil, reportError("formFormPatch 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.formFormPatch
|
|
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
|
|
}
|