mirror of
https://github.com/hanzo-go/sdk.git
synced 2026-11-20 20:13:42 +00:00
1863 lines
70 KiB
Go
1863 lines
70 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"
|
|
)
|
|
|
|
// FrameworkAPIService FrameworkAPI service
|
|
type FrameworkAPIService service
|
|
|
|
type FrameworkAPIDeleteFrameworkByDoctypeByNameRequest struct {
|
|
ctx context.Context
|
|
ApiService *FrameworkAPIService
|
|
doctype string
|
|
name string
|
|
}
|
|
|
|
func (r FrameworkAPIDeleteFrameworkByDoctypeByNameRequest) Execute() (*http.Response, error) {
|
|
return r.ApiService.DeleteFrameworkByDoctypeByNameExecute(r)
|
|
}
|
|
|
|
/*
|
|
DeleteFrameworkByDoctypeByName Removes one document, after its on_trash hooks agree.
|
|
|
|
Removes one document, after its on_trash hooks agree. A
|
|
SUBMITTED document cannot be deleted — cancel it first. Answers 204.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@param doctype DocType is the document's DocType, by ADDRESS — \"module.name\", from the path.
|
|
@param name Name is the document's name — its key within the DocType — from the path. A name containing a space arrives percent-encoded and is decoded before it is matched against the stored one.
|
|
@return FrameworkAPIDeleteFrameworkByDoctypeByNameRequest
|
|
*/
|
|
func (a *FrameworkAPIService) DeleteFrameworkByDoctypeByName(ctx context.Context, doctype string, name string) FrameworkAPIDeleteFrameworkByDoctypeByNameRequest {
|
|
return FrameworkAPIDeleteFrameworkByDoctypeByNameRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
doctype: doctype,
|
|
name: name,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
func (a *FrameworkAPIService) DeleteFrameworkByDoctypeByNameExecute(r FrameworkAPIDeleteFrameworkByDoctypeByNameRequest) (*http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodDelete
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "FrameworkAPIService.DeleteFrameworkByDoctypeByName")
|
|
if err != nil {
|
|
return nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/framework/{doctype}/{name}"
|
|
localVarPath = strings.Replace(localVarPath, "{"+"doctype"+"}", url.PathEscape(parameterValueToString(r.doctype, "doctype")), -1)
|
|
localVarPath = strings.Replace(localVarPath, "{"+"name"+"}", url.PathEscape(parameterValueToString(r.name, "name")), -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 FrameworkAPIDeleteFrameworkDoctypesByNameRequest struct {
|
|
ctx context.Context
|
|
ApiService *FrameworkAPIService
|
|
name string
|
|
}
|
|
|
|
func (r FrameworkAPIDeleteFrameworkDoctypesByNameRequest) Execute() (*http.Response, error) {
|
|
return r.ApiService.DeleteFrameworkDoctypesByNameExecute(r)
|
|
}
|
|
|
|
/*
|
|
DeleteFrameworkDoctypesByName Removes a DocType and every document stored under it.
|
|
|
|
Removes a DocType and every document stored under it. The
|
|
definition and its data go together — a document with no schema can be neither
|
|
validated nor read back — so there is no undo. Manager-only. Answers 204.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@param name Name is the DocType's ADDRESS — \"module.name\", e.g. \"kb.page\". A name containing a space (\"erp.Sales Invoice\") arrives percent-encoded and is decoded before it is matched against the stored one.
|
|
@return FrameworkAPIDeleteFrameworkDoctypesByNameRequest
|
|
*/
|
|
func (a *FrameworkAPIService) DeleteFrameworkDoctypesByName(ctx context.Context, name string) FrameworkAPIDeleteFrameworkDoctypesByNameRequest {
|
|
return FrameworkAPIDeleteFrameworkDoctypesByNameRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
name: name,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
func (a *FrameworkAPIService) DeleteFrameworkDoctypesByNameExecute(r FrameworkAPIDeleteFrameworkDoctypesByNameRequest) (*http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodDelete
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "FrameworkAPIService.DeleteFrameworkDoctypesByName")
|
|
if err != nil {
|
|
return nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/framework/doctypes/{name}"
|
|
localVarPath = strings.Replace(localVarPath, "{"+"name"+"}", url.PathEscape(parameterValueToString(r.name, "name")), -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 FrameworkAPIGetFrameworkByDoctypeRequest struct {
|
|
ctx context.Context
|
|
ApiService *FrameworkAPIService
|
|
doctype string
|
|
filters *string
|
|
fields *string
|
|
orderBy *string
|
|
limit *string
|
|
}
|
|
|
|
// Filters is a JSON object of equality matches, e.g. {\"priority\":\"High\"}. Every key must be a field the DocType declares (or the managed name / docstatus); an undeclared one is refused rather than silently ignored.
|
|
func (r FrameworkAPIGetFrameworkByDoctypeRequest) Filters(filters string) FrameworkAPIGetFrameworkByDoctypeRequest {
|
|
r.filters = &filters
|
|
return r
|
|
}
|
|
|
|
// Fields projects the response to a subset — a JSON array [\"a\",\"b\"] or a comma list \"a,b\". The envelope keys are always returned.
|
|
func (r FrameworkAPIGetFrameworkByDoctypeRequest) Fields(fields string) FrameworkAPIGetFrameworkByDoctypeRequest {
|
|
r.fields = &fields
|
|
return r
|
|
}
|
|
|
|
// OrderBy is \"<field> [asc|desc]\". Empty means most-recently-updated first.
|
|
func (r FrameworkAPIGetFrameworkByDoctypeRequest) OrderBy(orderBy string) FrameworkAPIGetFrameworkByDoctypeRequest {
|
|
r.orderBy = &orderBy
|
|
return r
|
|
}
|
|
|
|
// Limit caps the rows returned. Anything that is not a positive integer leaves the engine's default in place.
|
|
func (r FrameworkAPIGetFrameworkByDoctypeRequest) Limit(limit string) FrameworkAPIGetFrameworkByDoctypeRequest {
|
|
r.limit = &limit
|
|
return r
|
|
}
|
|
|
|
func (r FrameworkAPIGetFrameworkByDoctypeRequest) Execute() (*FrameworkDocumentList, *http.Response, error) {
|
|
return r.ApiService.GetFrameworkByDoctypeExecute(r)
|
|
}
|
|
|
|
/*
|
|
GetFrameworkByDoctype Returns the caller org's documents of one DocType, filtered, ordered and projected by the query.
|
|
|
|
Returns the caller org's documents of one DocType, filtered,
|
|
ordered and projected by the query. The DocType is resolved FIRST — through
|
|
the same permission gate the list itself uses — because the query is validated
|
|
against its schema: a filter, sort or field name the DocType does not declare
|
|
is refused rather than reaching the store.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@param doctype DocType is the DocType to list, by ADDRESS — \"module.name\", from the path.
|
|
@return FrameworkAPIGetFrameworkByDoctypeRequest
|
|
*/
|
|
func (a *FrameworkAPIService) GetFrameworkByDoctype(ctx context.Context, doctype string) FrameworkAPIGetFrameworkByDoctypeRequest {
|
|
return FrameworkAPIGetFrameworkByDoctypeRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
doctype: doctype,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return FrameworkDocumentList
|
|
func (a *FrameworkAPIService) GetFrameworkByDoctypeExecute(r FrameworkAPIGetFrameworkByDoctypeRequest) (*FrameworkDocumentList, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodGet
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *FrameworkDocumentList
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "FrameworkAPIService.GetFrameworkByDoctype")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/framework/{doctype}"
|
|
localVarPath = strings.Replace(localVarPath, "{"+"doctype"+"}", url.PathEscape(parameterValueToString(r.doctype, "doctype")), -1)
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
|
|
if r.filters != nil {
|
|
parameterAddToHeaderOrQuery(localVarQueryParams, "filters", r.filters, "form", "")
|
|
}
|
|
if r.fields != nil {
|
|
parameterAddToHeaderOrQuery(localVarQueryParams, "fields", r.fields, "form", "")
|
|
}
|
|
if r.orderBy != nil {
|
|
parameterAddToHeaderOrQuery(localVarQueryParams, "order_by", r.orderBy, "form", "")
|
|
}
|
|
if r.limit != nil {
|
|
parameterAddToHeaderOrQuery(localVarQueryParams, "limit", r.limit, "form", "")
|
|
}
|
|
// to determine the Content-Type header
|
|
localVarHTTPContentTypes := []string{}
|
|
|
|
// set Content-Type header
|
|
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
|
if localVarHTTPContentType != "" {
|
|
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
|
}
|
|
|
|
// to determine the Accept header
|
|
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
|
|
|
|
// set Accept header
|
|
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
|
if localVarHTTPHeaderAccept != "" {
|
|
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
|
}
|
|
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
|
if err != nil {
|
|
return localVarReturnValue, nil, err
|
|
}
|
|
|
|
localVarHTTPResponse, err := a.client.callAPI(req)
|
|
if err != nil || localVarHTTPResponse == nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
|
localVarHTTPResponse.Body.Close()
|
|
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
|
if err != nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
if localVarHTTPResponse.StatusCode >= 300 {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: localVarHTTPResponse.Status,
|
|
}
|
|
var v ProblemDetails
|
|
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr.error = err.Error()
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
|
newErr.model = v
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: err.Error(),
|
|
}
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
return localVarReturnValue, localVarHTTPResponse, nil
|
|
}
|
|
|
|
type FrameworkAPIGetFrameworkByDoctypeByNameRequest struct {
|
|
ctx context.Context
|
|
ApiService *FrameworkAPIService
|
|
doctype string
|
|
name string
|
|
}
|
|
|
|
func (r FrameworkAPIGetFrameworkByDoctypeByNameRequest) Execute() (map[string]interface{}, *http.Response, error) {
|
|
return r.ApiService.GetFrameworkByDoctypeByNameExecute(r)
|
|
}
|
|
|
|
/*
|
|
GetFrameworkByDoctypeByName Returns one document by name, with Password fields redacted.
|
|
|
|
Returns one document by name, with Password fields redacted.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@param doctype DocType is the document's DocType, by ADDRESS — \"module.name\", from the path.
|
|
@param name Name is the document's name — its key within the DocType — from the path. A name containing a space arrives percent-encoded and is decoded before it is matched against the stored one.
|
|
@return FrameworkAPIGetFrameworkByDoctypeByNameRequest
|
|
*/
|
|
func (a *FrameworkAPIService) GetFrameworkByDoctypeByName(ctx context.Context, doctype string, name string) FrameworkAPIGetFrameworkByDoctypeByNameRequest {
|
|
return FrameworkAPIGetFrameworkByDoctypeByNameRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
doctype: doctype,
|
|
name: name,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return map[string]interface{}
|
|
func (a *FrameworkAPIService) GetFrameworkByDoctypeByNameExecute(r FrameworkAPIGetFrameworkByDoctypeByNameRequest) (map[string]interface{}, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodGet
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue map[string]interface{}
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "FrameworkAPIService.GetFrameworkByDoctypeByName")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/framework/{doctype}/{name}"
|
|
localVarPath = strings.Replace(localVarPath, "{"+"doctype"+"}", url.PathEscape(parameterValueToString(r.doctype, "doctype")), -1)
|
|
localVarPath = strings.Replace(localVarPath, "{"+"name"+"}", url.PathEscape(parameterValueToString(r.name, "name")), -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 FrameworkAPIGetFrameworkDoctypesRequest struct {
|
|
ctx context.Context
|
|
ApiService *FrameworkAPIService
|
|
}
|
|
|
|
func (r FrameworkAPIGetFrameworkDoctypesRequest) Execute() (*FrameworkDocTypeList, *http.Response, error) {
|
|
return r.ApiService.GetFrameworkDoctypesExecute(r)
|
|
}
|
|
|
|
/*
|
|
GetFrameworkDoctypes Returns every DocType defined in the caller's org.
|
|
|
|
Returns every DocType defined in the caller's org. Another
|
|
tenant's definitions are never included: the org is part of the store key.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@return FrameworkAPIGetFrameworkDoctypesRequest
|
|
*/
|
|
func (a *FrameworkAPIService) GetFrameworkDoctypes(ctx context.Context) FrameworkAPIGetFrameworkDoctypesRequest {
|
|
return FrameworkAPIGetFrameworkDoctypesRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return FrameworkDocTypeList
|
|
func (a *FrameworkAPIService) GetFrameworkDoctypesExecute(r FrameworkAPIGetFrameworkDoctypesRequest) (*FrameworkDocTypeList, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodGet
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *FrameworkDocTypeList
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "FrameworkAPIService.GetFrameworkDoctypes")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/framework/doctypes"
|
|
|
|
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 FrameworkAPIGetFrameworkDoctypesByNameRequest struct {
|
|
ctx context.Context
|
|
ApiService *FrameworkAPIService
|
|
name string
|
|
}
|
|
|
|
func (r FrameworkAPIGetFrameworkDoctypesByNameRequest) Execute() (*FrameworkDocType, *http.Response, error) {
|
|
return r.ApiService.GetFrameworkDoctypesByNameExecute(r)
|
|
}
|
|
|
|
/*
|
|
GetFrameworkDoctypesByName Returns one DocType definition — its fields, naming rule, permissions and lifecycle flags.
|
|
|
|
Returns one DocType definition — its fields, naming rule,
|
|
permissions and lifecycle flags. Scoped to the caller's org, so another
|
|
tenant's DocType of the same name is simply not found.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@param name Name is the DocType's ADDRESS — \"module.name\", e.g. \"kb.page\". A name containing a space (\"erp.Sales Invoice\") arrives percent-encoded and is decoded before it is matched against the stored one.
|
|
@return FrameworkAPIGetFrameworkDoctypesByNameRequest
|
|
*/
|
|
func (a *FrameworkAPIService) GetFrameworkDoctypesByName(ctx context.Context, name string) FrameworkAPIGetFrameworkDoctypesByNameRequest {
|
|
return FrameworkAPIGetFrameworkDoctypesByNameRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
name: name,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return FrameworkDocType
|
|
func (a *FrameworkAPIService) GetFrameworkDoctypesByNameExecute(r FrameworkAPIGetFrameworkDoctypesByNameRequest) (*FrameworkDocType, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodGet
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *FrameworkDocType
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "FrameworkAPIService.GetFrameworkDoctypesByName")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/framework/doctypes/{name}"
|
|
localVarPath = strings.Replace(localVarPath, "{"+"name"+"}", url.PathEscape(parameterValueToString(r.name, "name")), -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 FrameworkAPIGetFrameworkModulesRequest struct {
|
|
ctx context.Context
|
|
ApiService *FrameworkAPIService
|
|
}
|
|
|
|
func (r FrameworkAPIGetFrameworkModulesRequest) Execute() (*FrameworkModuleList, *http.Response, error) {
|
|
return r.ApiService.GetFrameworkModulesExecute(r)
|
|
}
|
|
|
|
/*
|
|
GetFrameworkModules Returns every app lane compiled into this deployment and the DocTypes each one installs.
|
|
|
|
Returns every app lane compiled into this deployment and the
|
|
DocTypes each one installs. It describes the BINARY, not the org: what a given
|
|
org has actually installed is the per-module state below.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@return FrameworkAPIGetFrameworkModulesRequest
|
|
*/
|
|
func (a *FrameworkAPIService) GetFrameworkModules(ctx context.Context) FrameworkAPIGetFrameworkModulesRequest {
|
|
return FrameworkAPIGetFrameworkModulesRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return FrameworkModuleList
|
|
func (a *FrameworkAPIService) GetFrameworkModulesExecute(r FrameworkAPIGetFrameworkModulesRequest) (*FrameworkModuleList, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodGet
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *FrameworkModuleList
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "FrameworkAPIService.GetFrameworkModules")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/framework/modules"
|
|
|
|
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 FrameworkAPIGetFrameworkModulesByModuleRequest struct {
|
|
ctx context.Context
|
|
ApiService *FrameworkAPIService
|
|
module string
|
|
}
|
|
|
|
func (r FrameworkAPIGetFrameworkModulesByModuleRequest) Execute() (*FrameworkModuleState, *http.Response, error) {
|
|
return r.ApiService.GetFrameworkModulesByModuleExecute(r)
|
|
}
|
|
|
|
/*
|
|
GetFrameworkModulesByModule Returns one app lane's install state for the caller's org: the DocTypes the lane declares, and which of them already exist in the org.
|
|
|
|
Returns one app lane's install state for the caller's org: the
|
|
DocTypes the lane declares, and which of them already exist in the org. That
|
|
is the honest "set up" versus "installed" answer a console renders.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@param module Module is the lane's registered name (\"cms\", \"erp\"), from the path.
|
|
@return FrameworkAPIGetFrameworkModulesByModuleRequest
|
|
*/
|
|
func (a *FrameworkAPIService) GetFrameworkModulesByModule(ctx context.Context, module string) FrameworkAPIGetFrameworkModulesByModuleRequest {
|
|
return FrameworkAPIGetFrameworkModulesByModuleRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
module: module,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return FrameworkModuleState
|
|
func (a *FrameworkAPIService) GetFrameworkModulesByModuleExecute(r FrameworkAPIGetFrameworkModulesByModuleRequest) (*FrameworkModuleState, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodGet
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *FrameworkModuleState
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "FrameworkAPIService.GetFrameworkModulesByModule")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/framework/modules/{module}"
|
|
localVarPath = strings.Replace(localVarPath, "{"+"module"+"}", url.PathEscape(parameterValueToString(r.module, "module")), -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 FrameworkAPIGetFrameworkSummaryRequest struct {
|
|
ctx context.Context
|
|
ApiService *FrameworkAPIService
|
|
}
|
|
|
|
func (r FrameworkAPIGetFrameworkSummaryRequest) Execute() (*FrameworkSummaryView, *http.Response, error) {
|
|
return r.ApiService.GetFrameworkSummaryExecute(r)
|
|
}
|
|
|
|
/*
|
|
GetFrameworkSummary Reports how much of the DocType surface the caller's org uses: how many DocTypes it has defined, and how many documents exist across them.
|
|
|
|
Reports how much of the DocType surface the caller's org uses: how
|
|
many DocTypes it has defined, and how many documents exist across them.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@return FrameworkAPIGetFrameworkSummaryRequest
|
|
*/
|
|
func (a *FrameworkAPIService) GetFrameworkSummary(ctx context.Context) FrameworkAPIGetFrameworkSummaryRequest {
|
|
return FrameworkAPIGetFrameworkSummaryRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return FrameworkSummaryView
|
|
func (a *FrameworkAPIService) GetFrameworkSummaryExecute(r FrameworkAPIGetFrameworkSummaryRequest) (*FrameworkSummaryView, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodGet
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *FrameworkSummaryView
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "FrameworkAPIService.GetFrameworkSummary")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/framework/summary"
|
|
|
|
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 FrameworkAPIPostFrameworkByDoctypeRequest struct {
|
|
ctx context.Context
|
|
ApiService *FrameworkAPIService
|
|
doctype string
|
|
}
|
|
|
|
func (r FrameworkAPIPostFrameworkByDoctypeRequest) Execute() (*http.Response, error) {
|
|
return r.ApiService.PostFrameworkByDoctypeExecute(r)
|
|
}
|
|
|
|
/*
|
|
PostFrameworkByDoctype Create one document of a DocType, from that DocType's own fields.
|
|
|
|
The body is the DOCUMENT'S field data: a flat JSON object whose properties are the fieldnames the DocType declares, not a fixed envelope. That is why this operation publishes no request schema — the shape is metadata the DocType defines at run time, and no Go struct both accepts it verbatim and describes it, so nothing is asserted rather than something false.
|
|
|
|
The engine validates and coerces every field against the DocType, runs the before_insert and before_save hooks (either may reject the write), stores the document, then runs the after hooks. It answers 201 with the stored document: the field data plus the managed envelope — `name`, `doctype`, `docstatus`, `createdAt`, `updatedAt`. A Password field comes back as a fixed redaction marker and is dropped when empty; its stored value is never returned by this or any other read on this surface.
|
|
|
|
`name` in the body is the REQUESTED DOCUMENT NAME, not a data field. A DocType with an autoname rule names the document itself and ignores it; a prompt-named DocType takes it. This collision is also why the two path segments cannot be folded into the body, and so why the route stays untyped.
|
|
|
|
Scoped to the org of the validated principal, and the engine's own permission calculus decides the rest: the caller needs create rights on this DocType through a role it holds, or a platform admin bit. A caller with no validated principal reaches the engine as the zero Caller and is refused before any store is opened — a forged org header alone buys nothing.
|
|
|
|
A DocType declared Single has exactly ONE document per org, so this writes that one instance instead of adding a row. The body is size-bounded by the engine, the same bound on every host.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@param doctype
|
|
@return FrameworkAPIPostFrameworkByDoctypeRequest
|
|
*/
|
|
func (a *FrameworkAPIService) PostFrameworkByDoctype(ctx context.Context, doctype string) FrameworkAPIPostFrameworkByDoctypeRequest {
|
|
return FrameworkAPIPostFrameworkByDoctypeRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
doctype: doctype,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
func (a *FrameworkAPIService) PostFrameworkByDoctypeExecute(r FrameworkAPIPostFrameworkByDoctypeRequest) (*http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodPost
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "FrameworkAPIService.PostFrameworkByDoctype")
|
|
if err != nil {
|
|
return nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/framework/{doctype}"
|
|
localVarPath = strings.Replace(localVarPath, "{"+"doctype"+"}", url.PathEscape(parameterValueToString(r.doctype, "doctype")), -1)
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
|
|
// to determine the Content-Type header
|
|
localVarHTTPContentTypes := []string{}
|
|
|
|
// set Content-Type header
|
|
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
|
if localVarHTTPContentType != "" {
|
|
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
|
}
|
|
|
|
// to determine the Accept header
|
|
localVarHTTPHeaderAccepts := []string{}
|
|
|
|
// set Accept header
|
|
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
|
if localVarHTTPHeaderAccept != "" {
|
|
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
|
}
|
|
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
localVarHTTPResponse, err := a.client.callAPI(req)
|
|
if err != nil || localVarHTTPResponse == nil {
|
|
return localVarHTTPResponse, err
|
|
}
|
|
|
|
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
|
localVarHTTPResponse.Body.Close()
|
|
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
|
if err != nil {
|
|
return localVarHTTPResponse, err
|
|
}
|
|
|
|
if localVarHTTPResponse.StatusCode >= 300 {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: localVarHTTPResponse.Status,
|
|
}
|
|
return localVarHTTPResponse, newErr
|
|
}
|
|
|
|
return localVarHTTPResponse, nil
|
|
}
|
|
|
|
type FrameworkAPIPostFrameworkByDoctypeByNameCancelRequest struct {
|
|
ctx context.Context
|
|
ApiService *FrameworkAPIService
|
|
doctype string
|
|
name string
|
|
}
|
|
|
|
func (r FrameworkAPIPostFrameworkByDoctypeByNameCancelRequest) Execute() (map[string]interface{}, *http.Response, error) {
|
|
return r.ApiService.PostFrameworkByDoctypeByNameCancelExecute(r)
|
|
}
|
|
|
|
/*
|
|
PostFrameworkByDoctypeByNameCancel Moves a submitted document to cancelled (docstatus 1 → 2) after its on_cancel hooks agree.
|
|
|
|
Moves a submitted document to cancelled (docstatus 1 → 2) after
|
|
its on_cancel hooks agree. Cancelling is terminal — a cancelled document
|
|
cannot be re-submitted — but it CAN then be deleted.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@param doctype DocType is the document's DocType, by ADDRESS — \"module.name\", from the path.
|
|
@param name Name is the document's name — its key within the DocType — from the path. A name containing a space arrives percent-encoded and is decoded before it is matched against the stored one.
|
|
@return FrameworkAPIPostFrameworkByDoctypeByNameCancelRequest
|
|
*/
|
|
func (a *FrameworkAPIService) PostFrameworkByDoctypeByNameCancel(ctx context.Context, doctype string, name string) FrameworkAPIPostFrameworkByDoctypeByNameCancelRequest {
|
|
return FrameworkAPIPostFrameworkByDoctypeByNameCancelRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
doctype: doctype,
|
|
name: name,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return map[string]interface{}
|
|
func (a *FrameworkAPIService) PostFrameworkByDoctypeByNameCancelExecute(r FrameworkAPIPostFrameworkByDoctypeByNameCancelRequest) (map[string]interface{}, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodPost
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue map[string]interface{}
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "FrameworkAPIService.PostFrameworkByDoctypeByNameCancel")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/framework/{doctype}/{name}/cancel"
|
|
localVarPath = strings.Replace(localVarPath, "{"+"doctype"+"}", url.PathEscape(parameterValueToString(r.doctype, "doctype")), -1)
|
|
localVarPath = strings.Replace(localVarPath, "{"+"name"+"}", url.PathEscape(parameterValueToString(r.name, "name")), -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 FrameworkAPIPostFrameworkByDoctypeByNameSubmitRequest struct {
|
|
ctx context.Context
|
|
ApiService *FrameworkAPIService
|
|
doctype string
|
|
name string
|
|
}
|
|
|
|
func (r FrameworkAPIPostFrameworkByDoctypeByNameSubmitRequest) Execute() (map[string]interface{}, *http.Response, error) {
|
|
return r.ApiService.PostFrameworkByDoctypeByNameSubmitExecute(r)
|
|
}
|
|
|
|
/*
|
|
PostFrameworkByDoctypeByNameSubmit Moves a draft to submitted (docstatus 0 → 1) after its on_submit hooks agree.
|
|
|
|
Moves a draft to submitted (docstatus 0 → 1) after its
|
|
on_submit hooks agree. A submitted document is IMMUTABLE: further writes and
|
|
deletes are refused until it is cancelled. Only a submittable DocType has this
|
|
lifecycle; any other docstatus is an illegal transition.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@param doctype DocType is the document's DocType, by ADDRESS — \"module.name\", from the path.
|
|
@param name Name is the document's name — its key within the DocType — from the path. A name containing a space arrives percent-encoded and is decoded before it is matched against the stored one.
|
|
@return FrameworkAPIPostFrameworkByDoctypeByNameSubmitRequest
|
|
*/
|
|
func (a *FrameworkAPIService) PostFrameworkByDoctypeByNameSubmit(ctx context.Context, doctype string, name string) FrameworkAPIPostFrameworkByDoctypeByNameSubmitRequest {
|
|
return FrameworkAPIPostFrameworkByDoctypeByNameSubmitRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
doctype: doctype,
|
|
name: name,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return map[string]interface{}
|
|
func (a *FrameworkAPIService) PostFrameworkByDoctypeByNameSubmitExecute(r FrameworkAPIPostFrameworkByDoctypeByNameSubmitRequest) (map[string]interface{}, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodPost
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue map[string]interface{}
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "FrameworkAPIService.PostFrameworkByDoctypeByNameSubmit")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/framework/{doctype}/{name}/submit"
|
|
localVarPath = strings.Replace(localVarPath, "{"+"doctype"+"}", url.PathEscape(parameterValueToString(r.doctype, "doctype")), -1)
|
|
localVarPath = strings.Replace(localVarPath, "{"+"name"+"}", url.PathEscape(parameterValueToString(r.name, "name")), -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 FrameworkAPIPostFrameworkDoctypesRequest struct {
|
|
ctx context.Context
|
|
ApiService *FrameworkAPIService
|
|
frameworkDocType *FrameworkDocType
|
|
}
|
|
|
|
func (r FrameworkAPIPostFrameworkDoctypesRequest) FrameworkDocType(frameworkDocType FrameworkDocType) FrameworkAPIPostFrameworkDoctypesRequest {
|
|
r.frameworkDocType = &frameworkDocType
|
|
return r
|
|
}
|
|
|
|
func (r FrameworkAPIPostFrameworkDoctypesRequest) Execute() (*FrameworkDocType, *http.Response, error) {
|
|
return r.ApiService.PostFrameworkDoctypesExecute(r)
|
|
}
|
|
|
|
/*
|
|
PostFrameworkDoctypes Defines a DocType in the caller's org: the metadata that gives a document surface its fields, its naming rule, whether it has a submit/cancel lifecycle, and which role may do what to it.
|
|
|
|
Defines a DocType in the caller's org: the metadata that gives a
|
|
document surface its fields, its naming rule, whether it has a submit/cancel
|
|
lifecycle, and which role may do what to it. Manager-only — on a fresh org the
|
|
first caller to administer it is seeded as its System Manager, after which
|
|
only a System Manager (or a platform admin) may define. Answers 201.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@return FrameworkAPIPostFrameworkDoctypesRequest
|
|
*/
|
|
func (a *FrameworkAPIService) PostFrameworkDoctypes(ctx context.Context) FrameworkAPIPostFrameworkDoctypesRequest {
|
|
return FrameworkAPIPostFrameworkDoctypesRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return FrameworkDocType
|
|
func (a *FrameworkAPIService) PostFrameworkDoctypesExecute(r FrameworkAPIPostFrameworkDoctypesRequest) (*FrameworkDocType, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodPost
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *FrameworkDocType
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "FrameworkAPIService.PostFrameworkDoctypes")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/framework/doctypes"
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
if r.frameworkDocType == nil {
|
|
return localVarReturnValue, nil, reportError("frameworkDocType 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.frameworkDocType
|
|
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 FrameworkAPIPostFrameworkModulesByModuleInstallRequest struct {
|
|
ctx context.Context
|
|
ApiService *FrameworkAPIService
|
|
module string
|
|
}
|
|
|
|
func (r FrameworkAPIPostFrameworkModulesByModuleInstallRequest) Execute() (*FrameworkInstall, *http.Response, error) {
|
|
return r.ApiService.PostFrameworkModulesByModuleInstallExecute(r)
|
|
}
|
|
|
|
/*
|
|
PostFrameworkModulesByModuleInstall Creates an app lane's DocTypes in the caller's org.
|
|
|
|
Creates an app lane's DocTypes in the caller's org. Idempotent:
|
|
a DocType the org already has is reported as existing and never replaced. It
|
|
only grows, by the fields the lane now declares and the stored definition
|
|
lacks (reported as grown), so re-installing is how a lane's new fields reach an
|
|
org that installed it earlier. Manager-only.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@param module Module is the lane's registered name (\"cms\", \"erp\"), from the path.
|
|
@return FrameworkAPIPostFrameworkModulesByModuleInstallRequest
|
|
*/
|
|
func (a *FrameworkAPIService) PostFrameworkModulesByModuleInstall(ctx context.Context, module string) FrameworkAPIPostFrameworkModulesByModuleInstallRequest {
|
|
return FrameworkAPIPostFrameworkModulesByModuleInstallRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
module: module,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return FrameworkInstall
|
|
func (a *FrameworkAPIService) PostFrameworkModulesByModuleInstallExecute(r FrameworkAPIPostFrameworkModulesByModuleInstallRequest) (*FrameworkInstall, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodPost
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *FrameworkInstall
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "FrameworkAPIService.PostFrameworkModulesByModuleInstall")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/framework/modules/{module}/install"
|
|
localVarPath = strings.Replace(localVarPath, "{"+"module"+"}", url.PathEscape(parameterValueToString(r.module, "module")), -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 FrameworkAPIPutFrameworkByDoctypeByNameRequest struct {
|
|
ctx context.Context
|
|
ApiService *FrameworkAPIService
|
|
doctype string
|
|
name string
|
|
}
|
|
|
|
func (r FrameworkAPIPutFrameworkByDoctypeByNameRequest) Execute() (*http.Response, error) {
|
|
return r.ApiService.PutFrameworkByDoctypeByNameExecute(r)
|
|
}
|
|
|
|
/*
|
|
PutFrameworkByDoctypeByName Replace a draft document's field data wholesale.
|
|
|
|
PUT semantics: the stored field data BECOMES the body, so a field the body omits is not left at its previous value. The body is the document's own field data — the same metadata-defined open object the create takes, and the same reason this operation publishes no request schema.
|
|
|
|
Only a DRAFT can be edited. A document that has been submitted or cancelled is immutable and the write is refused as a conflict, so the submit lifecycle cannot be bypassed by a plain update — cancel it first, and note that a cancelled document can be deleted but never re-submitted or re-edited. The engine validates the new data against the DocType, runs before_save (which may reject), writes, then runs the after hooks, and answers 200 with the stored document plus its managed envelope, Password fields redacted.
|
|
|
|
The document name in the path is percent-decoded before it is matched, so a name containing a space is addressed as it is stored. An unknown DocType or document is not found, and the same answer covers a document that exists in another tenant: the org comes from the validated principal and is part of the store key, so a caller cannot learn that another org's document exists. Write rights on the DocType are required, decided by the engine's permission calculus.
|
|
|
|
For a Single DocType the path name is ignored — there is one instance per org and this writes it.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@param doctype
|
|
@param name
|
|
@return FrameworkAPIPutFrameworkByDoctypeByNameRequest
|
|
*/
|
|
func (a *FrameworkAPIService) PutFrameworkByDoctypeByName(ctx context.Context, doctype string, name string) FrameworkAPIPutFrameworkByDoctypeByNameRequest {
|
|
return FrameworkAPIPutFrameworkByDoctypeByNameRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
doctype: doctype,
|
|
name: name,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
func (a *FrameworkAPIService) PutFrameworkByDoctypeByNameExecute(r FrameworkAPIPutFrameworkByDoctypeByNameRequest) (*http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodPut
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "FrameworkAPIService.PutFrameworkByDoctypeByName")
|
|
if err != nil {
|
|
return nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/framework/{doctype}/{name}"
|
|
localVarPath = strings.Replace(localVarPath, "{"+"doctype"+"}", url.PathEscape(parameterValueToString(r.doctype, "doctype")), -1)
|
|
localVarPath = strings.Replace(localVarPath, "{"+"name"+"}", url.PathEscape(parameterValueToString(r.name, "name")), -1)
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
|
|
// to determine the Content-Type header
|
|
localVarHTTPContentTypes := []string{}
|
|
|
|
// set Content-Type header
|
|
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
|
if localVarHTTPContentType != "" {
|
|
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
|
}
|
|
|
|
// to determine the Accept header
|
|
localVarHTTPHeaderAccepts := []string{}
|
|
|
|
// set Accept header
|
|
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
|
if localVarHTTPHeaderAccept != "" {
|
|
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
|
}
|
|
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
localVarHTTPResponse, err := a.client.callAPI(req)
|
|
if err != nil || localVarHTTPResponse == nil {
|
|
return localVarHTTPResponse, err
|
|
}
|
|
|
|
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
|
localVarHTTPResponse.Body.Close()
|
|
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
|
if err != nil {
|
|
return localVarHTTPResponse, err
|
|
}
|
|
|
|
if localVarHTTPResponse.StatusCode >= 300 {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: localVarHTTPResponse.Status,
|
|
}
|
|
return localVarHTTPResponse, newErr
|
|
}
|
|
|
|
return localVarHTTPResponse, nil
|
|
}
|
|
|
|
type FrameworkAPIPutFrameworkDoctypesByNameRequest struct {
|
|
ctx context.Context
|
|
ApiService *FrameworkAPIService
|
|
name string
|
|
frameworkDocType *FrameworkDocType
|
|
}
|
|
|
|
func (r FrameworkAPIPutFrameworkDoctypesByNameRequest) FrameworkDocType(frameworkDocType FrameworkDocType) FrameworkAPIPutFrameworkDoctypesByNameRequest {
|
|
r.frameworkDocType = &frameworkDocType
|
|
return r
|
|
}
|
|
|
|
func (r FrameworkAPIPutFrameworkDoctypesByNameRequest) Execute() (*FrameworkDocType, *http.Response, error) {
|
|
return r.ApiService.PutFrameworkDoctypesByNameExecute(r)
|
|
}
|
|
|
|
/*
|
|
PutFrameworkDoctypesByName Replaces a DocType definition wholesale (PUT semantics): the stored definition becomes the body.
|
|
|
|
Replaces a DocType definition wholesale (PUT semantics): the
|
|
stored definition becomes the body. The name in the URL is authoritative over
|
|
the body's, and documents already stored under the DocType are left intact.
|
|
Manager-only.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@param name
|
|
@return FrameworkAPIPutFrameworkDoctypesByNameRequest
|
|
*/
|
|
func (a *FrameworkAPIService) PutFrameworkDoctypesByName(ctx context.Context, name string) FrameworkAPIPutFrameworkDoctypesByNameRequest {
|
|
return FrameworkAPIPutFrameworkDoctypesByNameRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
name: name,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return FrameworkDocType
|
|
func (a *FrameworkAPIService) PutFrameworkDoctypesByNameExecute(r FrameworkAPIPutFrameworkDoctypesByNameRequest) (*FrameworkDocType, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodPut
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *FrameworkDocType
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "FrameworkAPIService.PutFrameworkDoctypesByName")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/framework/doctypes/{name}"
|
|
localVarPath = strings.Replace(localVarPath, "{"+"name"+"}", url.PathEscape(parameterValueToString(r.name, "name")), -1)
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
if r.frameworkDocType == nil {
|
|
return localVarReturnValue, nil, reportError("frameworkDocType 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.frameworkDocType
|
|
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
|
|
}
|