diff --git a/api/members/members_client/document_parameter_contract_test.go b/api/members/members_client/document_parameter_contract_test.go new file mode 100644 index 0000000..a4c0a8b --- /dev/null +++ b/api/members/members_client/document_parameter_contract_test.go @@ -0,0 +1,236 @@ +package members_client_test + +import ( + "context" + "os" + "path/filepath" + "reflect" + "regexp" + "strings" + "testing" + + "code.tnxs.net/vernonkeenan/lib/api/members/members_client" + "code.tnxs.net/vernonkeenan/lib/api/members/members_client/document_parameters" + "code.tnxs.net/vernonkeenan/lib/api/members/members_models" + openapiruntime "github.com/go-openapi/runtime" + "github.com/go-openapi/strfmt" +) + +var documentParameterTestAuth = openapiruntime.ClientAuthInfoWriterFunc( + func(openapiruntime.ClientRequest, strfmt.Registry) error { return nil }, +) + +type documentParameterCaptureTransport struct { + operation *openapiruntime.ClientOperation +} + +func (transport *documentParameterCaptureTransport) Submit( + operation *openapiruntime.ClientOperation, +) (any, error) { + return transport.SubmitContext(context.Background(), operation) +} + +func (transport *documentParameterCaptureTransport) SubmitContext( + _ context.Context, + operation *openapiruntime.ClientOperation, +) (any, error) { + transport.operation = operation + switch operation.ID { + case "getDocumentParameters": + return document_parameters.NewGetDocumentParametersOK(), nil + case "postDocumentParameters": + return document_parameters.NewPostDocumentParametersOK(), nil + case "putDocumentParameters": + return document_parameters.NewPutDocumentParametersOK(), nil + default: + panic("unexpected generated DocumentParameter operation: " + operation.ID) + } +} + +func TestGeneratedDocumentParameterOperationContract(t *testing.T) { + type operationCall func(openapiruntime.ContextualTransport) error + tests := []struct { + name, wantID, wantMethod string + call operationCall + }{ + { + name: "list or get", wantID: "getDocumentParameters", wantMethod: "GET", + call: func(transport openapiruntime.ContextualTransport) error { + _, err := document_parameters.New(transport, strfmt.Default). + GetDocumentParameters( + document_parameters.NewGetDocumentParametersParams(), + documentParameterTestAuth, + ) + return err + }, + }, + { + name: "create", wantID: "postDocumentParameters", wantMethod: "POST", + call: func(transport openapiruntime.ContextualTransport) error { + _, err := document_parameters.New(transport, strfmt.Default). + PostDocumentParameters( + document_parameters.NewPostDocumentParametersParams(), + documentParameterTestAuth, + ) + return err + }, + }, + { + name: "CAS update", wantID: "putDocumentParameters", wantMethod: "PUT", + call: func(transport openapiruntime.ContextualTransport) error { + _, err := document_parameters.New(transport, strfmt.Default). + PutDocumentParameters( + document_parameters.NewPutDocumentParametersParams(), + documentParameterTestAuth, + ) + return err + }, + }, + } + + for _, test := range tests { + t.Run(test.name, func(t *testing.T) { + transport := &documentParameterCaptureTransport{} + if err := test.call(transport); err != nil { + t.Fatalf("generated client operation failed: %v", err) + } + if transport.operation == nil { + t.Fatal("generated client did not submit an operation") + } + if transport.operation.ID != test.wantID || + transport.operation.Method != test.wantMethod || + transport.operation.PathPattern != "/documentparameters" { + t.Fatalf( + "operation = %s %s %s, want %s %s /documentparameters", + transport.operation.ID, transport.operation.Method, + transport.operation.PathPattern, test.wantID, test.wantMethod, + ) + } + if transport.operation.AuthInfo == nil { + t.Fatal("generated operation discarded its compound auth writer") + } + }) + } +} + +func TestDocumentParameterSpecPreservesScopesPersonasAndCAS(t *testing.T) { + specText := readMembersLearningSpec(t) + pathBlock := learningSpecPathBlock(t, specText, "/documentparameters") + for _, forbidden := range []string{" delete:", " patch:"} { + if strings.Contains(pathBlock, forbidden) { + t.Errorf("/documentparameters exposes unsupported %s", strings.TrimSpace(forbidden)) + } + } + operations := map[string]struct{ id, scope string }{ + "get": {id: "getDocumentParameters", scope: "members:document-parameter:read"}, + "post": {id: "postDocumentParameters", scope: "members:document-parameter:create"}, + "put": {id: "putDocumentParameters", scope: "members:document-parameter:update"}, + } + const compoundSecurity = " security:\n - ApiKeyAuth: []\n kvSessionCookie: []" + for method, expected := range operations { + block := learningSpecOperationBlock(t, specText, "/documentparameters", method) + if !strings.Contains(block, " operationId: "+expected.id+"\n") { + t.Errorf("%s lost operationId %q", strings.ToUpper(method), expected.id) + } + if strings.Count(block, compoundSecurity) != 1 { + t.Errorf("%s does not preserve compound authentication", strings.ToUpper(method)) + } + if !strings.Contains(block, expected.scope) { + t.Errorf("%s lost exact scope %q", strings.ToUpper(method), expected.scope) + } + if method != "get" && + (!strings.Contains(block, "Owner") || !strings.Contains(block, "Manager")) { + t.Errorf("%s lost Owner/Manager mutation boundary", strings.ToUpper(method)) + } + } + if !document_parameters.NewPutDocumentParametersConflict().IsCode(409) { + t.Fatal("DocumentParameter update client lost stale-write conflict") + } +} + +func TestDocumentParameterModelAndRequestAreBounded(t *testing.T) { + assertExactModelFields(t, members_models.DocumentParameter{}, map[string]string{ + "CreatedByID": "*string", "CreatedDate": "*string", "DeletedDate": "*string", + "DocumentID": "*string", "ID": "string", "IsDeleted": "*bool", + "LastModifiedByID": "*string", "LastModifiedDate": "*string", + "Name": "*string", "TenantID": "*string", "UserID": "*string", + "Value": "*string", + }) + request := &members_models.DocumentParameterRequest{} + if err := request.Validate(strfmt.Default); err == nil { + t.Fatal("generated request accepted an empty write batch") + } + request.Data = make([]*members_models.DocumentParameter, 101) + if err := request.Validate(strfmt.Default); err == nil { + t.Fatal("generated request accepted more than 100 records") + } + request.Data = []*members_models.DocumentParameter{{}} + if err := request.Validate(strfmt.Default); err != nil { + t.Fatalf("generated request rejected a bounded record: %v", err) + } +} + +func TestDocumentParameterSurfaceExposesNoDeleteOrFolderBypass(t *testing.T) { + contract := reflect.TypeOf((*document_parameters.ClientService)(nil)).Elem() + for index := 0; index < contract.NumMethod(); index++ { + method := contract.Method(index).Name + for _, forbidden := range []string{"Delete", "Folder", "Salesforce", "Cache"} { + if strings.Contains(method, forbidden) { + t.Errorf("DocumentParameter client exposes forbidden method %s", method) + } + } + } + root := reflect.TypeOf(members_client.Members{}) + if _, exists := root.FieldByName("DocumentParameters"); !exists { + t.Fatal("root Members client does not expose governed DocumentParameters") + } + if _, exists := root.FieldByName("Folders"); exists { + t.Fatal("root Members client published deferred Folder operations") + } +} + +func TestGeneratedDocumentParameterSurfaceHasNoExternalBypassOrSecrets(t *testing.T) { + repoRoot := learningRepoRoot(t) + targets := []string{ + filepath.Join(repoRoot, "api", "members", "members_client", "document_parameters"), + filepath.Join(repoRoot, "api", "members", "members_models", "document_parameter.go"), + filepath.Join(repoRoot, "api", "members", "members_models", "document_parameter_request.go"), + filepath.Join(repoRoot, "api", "members", "members_models", "document_parameter_response.go"), + } + credentialLiteral := regexp.MustCompile( + `(?i)(api[_-]?key|password|secret)\s*[:=]\s*["'][^"']+["']`, + ) + for _, target := range targets { + err := filepath.WalkDir(target, func( + path string, entry os.DirEntry, walkErr error, + ) error { + if walkErr != nil { + return walkErr + } + if entry.IsDir() || !strings.HasSuffix(path, ".go") || + strings.HasSuffix(path, "_test.go") { + return nil + } + content, err := os.ReadFile(path) + if err != nil { + return err + } + lower := strings.ToLower(string(content)) + for _, forbidden := range []string{ + "salesforce", "soql", "apex", "sf-gate", "go-force", + "cache", "processor_token", "private key-----", + } { + if strings.Contains(lower, forbidden) { + t.Errorf("%s contains forbidden boundary %q", path, forbidden) + } + } + if credentialLiteral.Match(content) { + t.Errorf("%s contains a credential-like literal", path) + } + return nil + }) + if err != nil { + t.Fatalf("inspect generated DocumentParameter surface: %v", err) + } + } +} diff --git a/api/members/members_client/document_parameters/document_parameters_client.go b/api/members/members_client/document_parameters/document_parameters_client.go new file mode 100644 index 0000000..a198182 --- /dev/null +++ b/api/members/members_client/document_parameters/document_parameters_client.go @@ -0,0 +1,296 @@ +// Code generated by go-swagger; DO NOT EDIT. + +// (c) 2012-2020 by Taxnexus, Inc. +// All rights reserved worldwide. +// Proprietary product; unlicensed use is not allowed + +package document_parameters + +import ( + "context" + "fmt" + "time" + + "github.com/go-openapi/runtime" + httptransport "github.com/go-openapi/runtime/client" + "github.com/go-openapi/strfmt" +) + +// New creates a new document parameters API client. +func New(transport runtime.ContextualTransport, formats strfmt.Registry) ClientService { + return &Client{transport: transport, formats: formats} +} + +// New creates a new document parameters API client with basic auth credentials. +// +// It takes the following parameters: +// - host: http host (github.com). +// - basePath: any base path for the API client ("/v1", "/v3"). +// - scheme: http scheme ("http", "https"). +// - user: user for basic authentication header. +// - password: password for basic authentication header. +func NewClientWithBasicAuth(host, basePath, scheme, user, password string) ClientService { + transport := httptransport.New(host, basePath, []string{scheme}) + transport.DefaultAuthentication = httptransport.BasicAuth(user, password) + return &Client{transport: transport, formats: strfmt.Default} +} + +// New creates a new document parameters API client with a bearer token for authentication. +// +// It takes the following parameters: +// - host: http host (github.com). +// - basePath: any base path for the API client ("/v1", "/v3"). +// - scheme: http scheme ("http", "https"). +// - bearerToken: bearer token for Bearer authentication header. +func NewClientWithBearerToken(host, basePath, scheme, bearerToken string) ClientService { + transport := httptransport.New(host, basePath, []string{scheme}) + transport.DefaultAuthentication = httptransport.BearerToken(bearerToken) + return &Client{transport: transport, formats: strfmt.Default} +} + +// Client for document parameters API. +type Client struct { + transport runtime.ContextualTransport + formats strfmt.Registry +} + +// ClientOption may be used to customize the behavior of Client methods. +type ClientOption func(*runtime.ClientOperation) + +// ClientService is the interface for Client methods. +type ClientService interface { + + // GetDocumentParameters get document parameters. + GetDocumentParameters(params *GetDocumentParametersParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetDocumentParametersOK, error) + + // GetDocumentParametersContext get document parameters. + GetDocumentParametersContext(ctx context.Context, params *GetDocumentParametersParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetDocumentParametersOK, error) + + // PostDocumentParameters create document parameters. + PostDocumentParameters(params *PostDocumentParametersParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PostDocumentParametersOK, error) + + // PostDocumentParametersContext create document parameters. + PostDocumentParametersContext(ctx context.Context, params *PostDocumentParametersParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PostDocumentParametersOK, error) + + // PutDocumentParameters update document parameters. + PutDocumentParameters(params *PutDocumentParametersParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PutDocumentParametersOK, error) + + // PutDocumentParametersContext update document parameters. + PutDocumentParametersContext(ctx context.Context, params *PutDocumentParametersParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PutDocumentParametersOK, error) + + SetTransport(transport runtime.ContextualTransport) +} + +// GetDocumentParameters gets document parameters. +// +// Tenant- and user-scoped DocumentParameter read. Requires members:document-parameter:read and an active human session. Contributors can read only their own records; Owners and Managers can read the tenant.. +// +// This method does not support injected context. +// However, timeout and opentracing contexts are honored whenever enabled. +// +// If you need to pass a specific context, use [Client.GetDocumentParametersContext] instead. +func (a *Client) GetDocumentParameters(params *GetDocumentParametersParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetDocumentParametersOK, error) { + var ctx context.Context + if params.inner.ctx != nil { + ctx = params.inner.ctx + } else { + ctx = context.Background() + } + + return a.GetDocumentParametersContext(ctx, params, authInfo, opts...) +} + +// GetDocumentParametersContext gets document parameters. +// +// Tenant- and user-scoped DocumentParameter read. Requires members:document-parameter:read and an active human session. Contributors can read only their own records; Owners and Managers can read the tenant.. +// +// Do not use the deprecated [GetDocumentParametersParams.Context] with this method: it would be ignored. +func (a *Client) GetDocumentParametersContext(ctx context.Context, params *GetDocumentParametersParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetDocumentParametersOK, error) { + // NOTE: parameters are not validated before sending + if params == nil { + params = NewGetDocumentParametersParams() + } + + op := &runtime.ClientOperation{ + ID: "getDocumentParameters", + Method: "GET", + PathPattern: "/documentparameters", + ProducesMediaTypes: []string{"application/json"}, + ConsumesMediaTypes: []string{"application/json"}, + Schemes: []string{"http"}, + Params: params, + Reader: &GetDocumentParametersReader{formats: a.formats}, + AuthInfo: authInfo, + Client: params.HTTPClient, + } + + for _, opt := range opts { + opt(op) + } + + result, err := a.transport.SubmitContext(ctx, op) + if err != nil { + return nil, err + } + + // only one success response has to be checked + success, ok := result.(*GetDocumentParametersOK) + if ok { + return success, nil + } + + // unexpected success response. + + // no default response is defined. + // + // safeguard: normally, in the absence of a default response, unknown success responses return an error above: so this is a codegen issue + msg := fmt.Sprintf("unexpected success response for getDocumentParameters: API contract not enforced by server. Client expected to get an error, but got: %T", result) + panic(msg) +} + +// PostDocumentParameters creates document parameters. +// +// Tenant-scoped DocumentParameter create. Requires members:document-parameter:create, an active human session, and Owner or Manager authority.. +// +// This method does not support injected context. +// However, timeout and opentracing contexts are honored whenever enabled. +// +// If you need to pass a specific context, use [Client.PostDocumentParametersContext] instead. +func (a *Client) PostDocumentParameters(params *PostDocumentParametersParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PostDocumentParametersOK, error) { + var ctx context.Context + if params.inner.ctx != nil { + ctx = params.inner.ctx + } else { + ctx = context.Background() + } + + return a.PostDocumentParametersContext(ctx, params, authInfo, opts...) +} + +// PostDocumentParametersContext creates document parameters. +// +// Tenant-scoped DocumentParameter create. Requires members:document-parameter:create, an active human session, and Owner or Manager authority.. +// +// Do not use the deprecated [PostDocumentParametersParams.Context] with this method: it would be ignored. +func (a *Client) PostDocumentParametersContext(ctx context.Context, params *PostDocumentParametersParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PostDocumentParametersOK, error) { + // NOTE: parameters are not validated before sending + if params == nil { + params = NewPostDocumentParametersParams() + } + + op := &runtime.ClientOperation{ + ID: "postDocumentParameters", + Method: "POST", + PathPattern: "/documentparameters", + ProducesMediaTypes: []string{"application/json"}, + ConsumesMediaTypes: []string{"application/json"}, + Schemes: []string{"http"}, + Params: params, + Reader: &PostDocumentParametersReader{formats: a.formats}, + AuthInfo: authInfo, + Client: params.HTTPClient, + } + + for _, opt := range opts { + opt(op) + } + + result, err := a.transport.SubmitContext(ctx, op) + if err != nil { + return nil, err + } + + // only one success response has to be checked + success, ok := result.(*PostDocumentParametersOK) + if ok { + return success, nil + } + + // unexpected success response. + + // no default response is defined. + // + // safeguard: normally, in the absence of a default response, unknown success responses return an error above: so this is a codegen issue + msg := fmt.Sprintf("unexpected success response for postDocumentParameters: API contract not enforced by server. Client expected to get an error, but got: %T", result) + panic(msg) +} + +// PutDocumentParameters updates document parameters. +// +// Tenant-scoped DocumentParameter CAS update. Requires members:document-parameter:update, an active human session, and Owner or Manager authority.. +// +// This method does not support injected context. +// However, timeout and opentracing contexts are honored whenever enabled. +// +// If you need to pass a specific context, use [Client.PutDocumentParametersContext] instead. +func (a *Client) PutDocumentParameters(params *PutDocumentParametersParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PutDocumentParametersOK, error) { + var ctx context.Context + if params.inner.ctx != nil { + ctx = params.inner.ctx + } else { + ctx = context.Background() + } + + return a.PutDocumentParametersContext(ctx, params, authInfo, opts...) +} + +// PutDocumentParametersContext updates document parameters. +// +// Tenant-scoped DocumentParameter CAS update. Requires members:document-parameter:update, an active human session, and Owner or Manager authority.. +// +// Do not use the deprecated [PutDocumentParametersParams.Context] with this method: it would be ignored. +func (a *Client) PutDocumentParametersContext(ctx context.Context, params *PutDocumentParametersParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PutDocumentParametersOK, error) { + // NOTE: parameters are not validated before sending + if params == nil { + params = NewPutDocumentParametersParams() + } + + op := &runtime.ClientOperation{ + ID: "putDocumentParameters", + Method: "PUT", + PathPattern: "/documentparameters", + ProducesMediaTypes: []string{"application/json"}, + ConsumesMediaTypes: []string{"application/json"}, + Schemes: []string{"http"}, + Params: params, + Reader: &PutDocumentParametersReader{formats: a.formats}, + AuthInfo: authInfo, + Client: params.HTTPClient, + } + + for _, opt := range opts { + opt(op) + } + + result, err := a.transport.SubmitContext(ctx, op) + if err != nil { + return nil, err + } + + // only one success response has to be checked + success, ok := result.(*PutDocumentParametersOK) + if ok { + return success, nil + } + + // unexpected success response. + + // no default response is defined. + // + // safeguard: normally, in the absence of a default response, unknown success responses return an error above: so this is a codegen issue + msg := fmt.Sprintf("unexpected success response for putDocumentParameters: API contract not enforced by server. Client expected to get an error, but got: %T", result) + panic(msg) +} + +// SetTransport changes the transport on the client +func (a *Client) SetTransport(transport runtime.ContextualTransport) { + a.transport = transport +} + +// innerParams captures internal fields so they don't conflict with user-supplied parameters. +type innerParams struct { + timeout time.Duration + + // Deprecated: use the operation call with context to pass the context instead of [DocumentParametersParams]. + ctx context.Context +} diff --git a/api/members/members_client/document_parameters/get_document_parameters_parameters.go b/api/members/members_client/document_parameters/get_document_parameters_parameters.go new file mode 100644 index 0000000..7cac860 --- /dev/null +++ b/api/members/members_client/document_parameters/get_document_parameters_parameters.go @@ -0,0 +1,241 @@ +// Code generated by go-swagger; DO NOT EDIT. + +// (c) 2012-2020 by Taxnexus, Inc. +// All rights reserved worldwide. +// Proprietary product; unlicensed use is not allowed + +package document_parameters + +import ( + "context" + "net/http" + "time" + + "github.com/go-openapi/errors" + "github.com/go-openapi/runtime" + cr "github.com/go-openapi/runtime/client" + "github.com/go-openapi/strfmt" + "github.com/go-openapi/swag/conv" +) + +// NewGetDocumentParametersParams creates a new GetDocumentParametersParams object, +// with the default timeout for this client. +// +// Default values are not hydrated, since defaults are normally applied by the API server side. +// +// To enforce default values in parameter, use SetDefaults or WithDefaults. +func NewGetDocumentParametersParams() *GetDocumentParametersParams { + return NewGetDocumentParametersParamsWithTimeout(cr.DefaultTimeout) +} + +// NewGetDocumentParametersParamsWithTimeout creates a new GetDocumentParametersParams object +// with the ability to set a timeout on a request. +func NewGetDocumentParametersParamsWithTimeout(timeout time.Duration) *GetDocumentParametersParams { + return &GetDocumentParametersParams{ + inner: innerParams{ + timeout: timeout, + }, + } +} + +// NewGetDocumentParametersParamsWithContext creates a new GetDocumentParametersParams object +// with the ability to set a context for a request. +// +// Deprecated: use the operation call with context to pass the context instead of [GetDocumentParametersParams]. +func NewGetDocumentParametersParamsWithContext(ctx context.Context) *GetDocumentParametersParams { + return &GetDocumentParametersParams{ + inner: innerParams{ + ctx: ctx, + }, + } +} + +// NewGetDocumentParametersParamsWithHTTPClient creates a new GetDocumentParametersParams object +// with the ability to set a custom HTTPClient for a request. +func NewGetDocumentParametersParamsWithHTTPClient(client *http.Client) *GetDocumentParametersParams { + return &GetDocumentParametersParams{ + HTTPClient: client, + } +} + +/* +GetDocumentParametersParams contains all the parameters to send to the API endpoint + + for the get document parameters operation. + + Typically these are written to a http.Request. +*/ +type GetDocumentParametersParams struct { + + // ID. + // + // Unique Record ID + ID *string + + // Limit. + // + // How many objects to return at one time + // + // Format: int64 + Limit *int64 + + // Offset. + // + // How many objects to skip? + // + // Format: int64 + Offset *int64 + + HTTPClient *http.Client + + inner innerParams +} + +// WithDefaults hydrates default values in the get document parameters params (not the query body). +// +// All values with no default are reset to their zero value. +func (o *GetDocumentParametersParams) WithDefaults() *GetDocumentParametersParams { + o.SetDefaults() + return o +} + +// SetDefaults hydrates default values in the get document parameters params (not the query body). +// +// All values with no default are reset to their zero value. +func (o *GetDocumentParametersParams) SetDefaults() { + // no default values defined for this parameter +} + +// WithTimeout adds the timeout to the get document parameters params. +func (o *GetDocumentParametersParams) WithTimeout(timeout time.Duration) *GetDocumentParametersParams { + o.SetTimeout(timeout) + return o +} + +// SetTimeout adds the timeout to the get document parameters params. +func (o *GetDocumentParametersParams) SetTimeout(timeout time.Duration) { + o.inner.timeout = timeout +} + +// WithContext adds the context to the get document parameters params. +// +// Deprecated: use the operation call with context to pass the context instead of [GetDocumentParametersParams]. +func (o *GetDocumentParametersParams) WithContext(ctx context.Context) *GetDocumentParametersParams { + o.SetContext(ctx) + return o +} + +// SetContext adds the context to the get document parameters params. +// +// Deprecated: use the operation call with context to pass the context instead of [GetDocumentParametersParams]. +func (o *GetDocumentParametersParams) SetContext(ctx context.Context) { + o.inner.ctx = ctx +} + +// WithHTTPClient adds the HTTPClient to the get document parameters params. +func (o *GetDocumentParametersParams) WithHTTPClient(client *http.Client) *GetDocumentParametersParams { + o.SetHTTPClient(client) + return o +} + +// SetHTTPClient adds the HTTPClient to the get document parameters params. +func (o *GetDocumentParametersParams) SetHTTPClient(client *http.Client) { + o.HTTPClient = client +} + +// WithID adds the id to the get document parameters params. +func (o *GetDocumentParametersParams) WithID(id *string) *GetDocumentParametersParams { + o.SetID(id) + return o +} + +// SetID adds the id to the get document parameters params. +func (o *GetDocumentParametersParams) SetID(id *string) { + o.ID = id +} + +// WithLimit adds the limit to the get document parameters params. +func (o *GetDocumentParametersParams) WithLimit(limit *int64) *GetDocumentParametersParams { + o.SetLimit(limit) + return o +} + +// SetLimit adds the limit to the get document parameters params. +func (o *GetDocumentParametersParams) SetLimit(limit *int64) { + o.Limit = limit +} + +// WithOffset adds the offset to the get document parameters params. +func (o *GetDocumentParametersParams) WithOffset(offset *int64) *GetDocumentParametersParams { + o.SetOffset(offset) + return o +} + +// SetOffset adds the offset to the get document parameters params. +func (o *GetDocumentParametersParams) SetOffset(offset *int64) { + o.Offset = offset +} + +// WriteToRequest writes these params to a [runtime.ClientRequest]. +func (o *GetDocumentParametersParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error { + if err := r.SetTimeout(o.inner.timeout); err != nil { + return err + } + var res []error + + if o.ID != nil { + + // query param id + var qrID string + + if o.ID != nil { + qrID = *o.ID + } + qID := qrID + if qID != "" { + + if err := r.SetQueryParam("id", qID); err != nil { + return err + } + } + } + + if o.Limit != nil { + + // query param limit + var qrLimit int64 + + if o.Limit != nil { + qrLimit = *o.Limit + } + qLimit := conv.FormatInteger(qrLimit) + if qLimit != "" { + + if err := r.SetQueryParam("limit", qLimit); err != nil { + return err + } + } + } + + if o.Offset != nil { + + // query param offset + var qrOffset int64 + + if o.Offset != nil { + qrOffset = *o.Offset + } + qOffset := conv.FormatInteger(qrOffset) + if qOffset != "" { + + if err := r.SetQueryParam("offset", qOffset); err != nil { + return err + } + } + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} diff --git a/api/members/members_client/document_parameters/get_document_parameters_responses.go b/api/members/members_client/document_parameters/get_document_parameters_responses.go new file mode 100644 index 0000000..75f5eec --- /dev/null +++ b/api/members/members_client/document_parameters/get_document_parameters_responses.go @@ -0,0 +1,484 @@ +// Code generated by go-swagger; DO NOT EDIT. + +// (c) 2012-2020 by Taxnexus, Inc. +// All rights reserved worldwide. +// Proprietary product; unlicensed use is not allowed + +package document_parameters + +import ( + "encoding/json" + stderrors "errors" + "fmt" + "io" + + "code.tnxs.net/vernonkeenan/lib/api/members/members_models" + "github.com/go-openapi/runtime" + "github.com/go-openapi/strfmt" +) + +// GetDocumentParametersReader is a Reader for the GetDocumentParameters structure. +type GetDocumentParametersReader struct { + formats strfmt.Registry +} + +// ReadResponse reads a server response into the received o. +func (o *GetDocumentParametersReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (any, error) { + switch response.Code() { + case 200: + result := NewGetDocumentParametersOK() + if err := result.readResponse(response, consumer, o.formats); err != nil { + return nil, err + } + return result, nil + case 401: + result := NewGetDocumentParametersUnauthorized() + if err := result.readResponse(response, consumer, o.formats); err != nil { + return nil, err + } + return nil, result + case 403: + result := NewGetDocumentParametersForbidden() + if err := result.readResponse(response, consumer, o.formats); err != nil { + return nil, err + } + return nil, result + case 404: + result := NewGetDocumentParametersNotFound() + if err := result.readResponse(response, consumer, o.formats); err != nil { + return nil, err + } + return nil, result + case 422: + result := NewGetDocumentParametersUnprocessableEntity() + if err := result.readResponse(response, consumer, o.formats); err != nil { + return nil, err + } + return nil, result + case 500: + result := NewGetDocumentParametersInternalServerError() + if err := result.readResponse(response, consumer, o.formats); err != nil { + return nil, err + } + return nil, result + default: + return nil, runtime.NewAPIError("[GET /documentparameters] getDocumentParameters", response, response.Code()) + } +} + +// NewGetDocumentParametersOK creates a GetDocumentParametersOK with default headers values +func NewGetDocumentParametersOK() *GetDocumentParametersOK { + return &GetDocumentParametersOK{} +} + +// GetDocumentParametersOK describes a response with status code 200, with default header values. +// +// DocumentParameter Response Object +type GetDocumentParametersOK struct { + Payload *members_models.DocumentParameterResponse +} + +// IsSuccess returns true when this get document parameters o k response has a 2xx status code +func (o *GetDocumentParametersOK) IsSuccess() bool { + return true +} + +// IsRedirect returns true when this get document parameters o k response has a 3xx status code +func (o *GetDocumentParametersOK) IsRedirect() bool { + return false +} + +// IsClientError returns true when this get document parameters o k response has a 4xx status code +func (o *GetDocumentParametersOK) IsClientError() bool { + return false +} + +// IsServerError returns true when this get document parameters o k response has a 5xx status code +func (o *GetDocumentParametersOK) IsServerError() bool { + return false +} + +// IsCode returns true when this get document parameters o k response a status code equal to that given +func (o *GetDocumentParametersOK) IsCode(code int) bool { + return code == 200 +} + +// Code gets the status code for the get document parameters o k response +func (o *GetDocumentParametersOK) Code() int { + return 200 +} + +func (o *GetDocumentParametersOK) Error() string { + payload, _ := json.Marshal(o.Payload) + return fmt.Sprintf("[GET /documentparameters][%d] getDocumentParametersOK %s", 200, payload) +} + +func (o *GetDocumentParametersOK) String() string { + payload, _ := json.Marshal(o.Payload) + return fmt.Sprintf("[GET /documentparameters][%d] getDocumentParametersOK %s", 200, payload) +} + +func (o *GetDocumentParametersOK) GetPayload() *members_models.DocumentParameterResponse { + return o.Payload +} + +func (o *GetDocumentParametersOK) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error { + + o.Payload = new(members_models.DocumentParameterResponse) + + // response payload + if err := consumer.Consume(response.Body(), o.Payload); err != nil && !stderrors.Is(err, io.EOF) { + return err + } + + return nil +} + +// NewGetDocumentParametersUnauthorized creates a GetDocumentParametersUnauthorized with default headers values +func NewGetDocumentParametersUnauthorized() *GetDocumentParametersUnauthorized { + return &GetDocumentParametersUnauthorized{} +} + +// GetDocumentParametersUnauthorized describes a response with status code 401, with default header values. +// +// Access Unauthorized, invalid API-KEY was used +type GetDocumentParametersUnauthorized struct { + Payload *members_models.Error +} + +// IsSuccess returns true when this get document parameters unauthorized response has a 2xx status code +func (o *GetDocumentParametersUnauthorized) IsSuccess() bool { + return false +} + +// IsRedirect returns true when this get document parameters unauthorized response has a 3xx status code +func (o *GetDocumentParametersUnauthorized) IsRedirect() bool { + return false +} + +// IsClientError returns true when this get document parameters unauthorized response has a 4xx status code +func (o *GetDocumentParametersUnauthorized) IsClientError() bool { + return true +} + +// IsServerError returns true when this get document parameters unauthorized response has a 5xx status code +func (o *GetDocumentParametersUnauthorized) IsServerError() bool { + return false +} + +// IsCode returns true when this get document parameters unauthorized response a status code equal to that given +func (o *GetDocumentParametersUnauthorized) IsCode(code int) bool { + return code == 401 +} + +// Code gets the status code for the get document parameters unauthorized response +func (o *GetDocumentParametersUnauthorized) Code() int { + return 401 +} + +func (o *GetDocumentParametersUnauthorized) Error() string { + payload, _ := json.Marshal(o.Payload) + return fmt.Sprintf("[GET /documentparameters][%d] getDocumentParametersUnauthorized %s", 401, payload) +} + +func (o *GetDocumentParametersUnauthorized) String() string { + payload, _ := json.Marshal(o.Payload) + return fmt.Sprintf("[GET /documentparameters][%d] getDocumentParametersUnauthorized %s", 401, payload) +} + +func (o *GetDocumentParametersUnauthorized) GetPayload() *members_models.Error { + return o.Payload +} + +func (o *GetDocumentParametersUnauthorized) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error { + + o.Payload = new(members_models.Error) + + // response payload + if err := consumer.Consume(response.Body(), o.Payload); err != nil && !stderrors.Is(err, io.EOF) { + return err + } + + return nil +} + +// NewGetDocumentParametersForbidden creates a GetDocumentParametersForbidden with default headers values +func NewGetDocumentParametersForbidden() *GetDocumentParametersForbidden { + return &GetDocumentParametersForbidden{} +} + +// GetDocumentParametersForbidden describes a response with status code 403, with default header values. +// +// Access forbidden, account lacks access +type GetDocumentParametersForbidden struct { + AccessControlAllowOrigin string + + Payload *members_models.Error +} + +// IsSuccess returns true when this get document parameters forbidden response has a 2xx status code +func (o *GetDocumentParametersForbidden) IsSuccess() bool { + return false +} + +// IsRedirect returns true when this get document parameters forbidden response has a 3xx status code +func (o *GetDocumentParametersForbidden) IsRedirect() bool { + return false +} + +// IsClientError returns true when this get document parameters forbidden response has a 4xx status code +func (o *GetDocumentParametersForbidden) IsClientError() bool { + return true +} + +// IsServerError returns true when this get document parameters forbidden response has a 5xx status code +func (o *GetDocumentParametersForbidden) IsServerError() bool { + return false +} + +// IsCode returns true when this get document parameters forbidden response a status code equal to that given +func (o *GetDocumentParametersForbidden) IsCode(code int) bool { + return code == 403 +} + +// Code gets the status code for the get document parameters forbidden response +func (o *GetDocumentParametersForbidden) Code() int { + return 403 +} + +func (o *GetDocumentParametersForbidden) Error() string { + payload, _ := json.Marshal(o.Payload) + return fmt.Sprintf("[GET /documentparameters][%d] getDocumentParametersForbidden %s", 403, payload) +} + +func (o *GetDocumentParametersForbidden) String() string { + payload, _ := json.Marshal(o.Payload) + return fmt.Sprintf("[GET /documentparameters][%d] getDocumentParametersForbidden %s", 403, payload) +} + +func (o *GetDocumentParametersForbidden) GetPayload() *members_models.Error { + return o.Payload +} + +func (o *GetDocumentParametersForbidden) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error { + + // hydrates response header Access-Control-Allow-Origin + hdrAccessControlAllowOrigin := response.GetHeader("Access-Control-Allow-Origin") + + if hdrAccessControlAllowOrigin != "" { + o.AccessControlAllowOrigin = hdrAccessControlAllowOrigin + } + + o.Payload = new(members_models.Error) + + // response payload + if err := consumer.Consume(response.Body(), o.Payload); err != nil && !stderrors.Is(err, io.EOF) { + return err + } + + return nil +} + +// NewGetDocumentParametersNotFound creates a GetDocumentParametersNotFound with default headers values +func NewGetDocumentParametersNotFound() *GetDocumentParametersNotFound { + return &GetDocumentParametersNotFound{} +} + +// GetDocumentParametersNotFound describes a response with status code 404, with default header values. +// +// Resource was not found +type GetDocumentParametersNotFound struct { + Payload *members_models.Error +} + +// IsSuccess returns true when this get document parameters not found response has a 2xx status code +func (o *GetDocumentParametersNotFound) IsSuccess() bool { + return false +} + +// IsRedirect returns true when this get document parameters not found response has a 3xx status code +func (o *GetDocumentParametersNotFound) IsRedirect() bool { + return false +} + +// IsClientError returns true when this get document parameters not found response has a 4xx status code +func (o *GetDocumentParametersNotFound) IsClientError() bool { + return true +} + +// IsServerError returns true when this get document parameters not found response has a 5xx status code +func (o *GetDocumentParametersNotFound) IsServerError() bool { + return false +} + +// IsCode returns true when this get document parameters not found response a status code equal to that given +func (o *GetDocumentParametersNotFound) IsCode(code int) bool { + return code == 404 +} + +// Code gets the status code for the get document parameters not found response +func (o *GetDocumentParametersNotFound) Code() int { + return 404 +} + +func (o *GetDocumentParametersNotFound) Error() string { + payload, _ := json.Marshal(o.Payload) + return fmt.Sprintf("[GET /documentparameters][%d] getDocumentParametersNotFound %s", 404, payload) +} + +func (o *GetDocumentParametersNotFound) String() string { + payload, _ := json.Marshal(o.Payload) + return fmt.Sprintf("[GET /documentparameters][%d] getDocumentParametersNotFound %s", 404, payload) +} + +func (o *GetDocumentParametersNotFound) GetPayload() *members_models.Error { + return o.Payload +} + +func (o *GetDocumentParametersNotFound) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error { + + o.Payload = new(members_models.Error) + + // response payload + if err := consumer.Consume(response.Body(), o.Payload); err != nil && !stderrors.Is(err, io.EOF) { + return err + } + + return nil +} + +// NewGetDocumentParametersUnprocessableEntity creates a GetDocumentParametersUnprocessableEntity with default headers values +func NewGetDocumentParametersUnprocessableEntity() *GetDocumentParametersUnprocessableEntity { + return &GetDocumentParametersUnprocessableEntity{} +} + +// GetDocumentParametersUnprocessableEntity describes a response with status code 422, with default header values. +// +// Unprocessable Entity, likely a bad parameter +type GetDocumentParametersUnprocessableEntity struct { + Payload *members_models.Error +} + +// IsSuccess returns true when this get document parameters unprocessable entity response has a 2xx status code +func (o *GetDocumentParametersUnprocessableEntity) IsSuccess() bool { + return false +} + +// IsRedirect returns true when this get document parameters unprocessable entity response has a 3xx status code +func (o *GetDocumentParametersUnprocessableEntity) IsRedirect() bool { + return false +} + +// IsClientError returns true when this get document parameters unprocessable entity response has a 4xx status code +func (o *GetDocumentParametersUnprocessableEntity) IsClientError() bool { + return true +} + +// IsServerError returns true when this get document parameters unprocessable entity response has a 5xx status code +func (o *GetDocumentParametersUnprocessableEntity) IsServerError() bool { + return false +} + +// IsCode returns true when this get document parameters unprocessable entity response a status code equal to that given +func (o *GetDocumentParametersUnprocessableEntity) IsCode(code int) bool { + return code == 422 +} + +// Code gets the status code for the get document parameters unprocessable entity response +func (o *GetDocumentParametersUnprocessableEntity) Code() int { + return 422 +} + +func (o *GetDocumentParametersUnprocessableEntity) Error() string { + payload, _ := json.Marshal(o.Payload) + return fmt.Sprintf("[GET /documentparameters][%d] getDocumentParametersUnprocessableEntity %s", 422, payload) +} + +func (o *GetDocumentParametersUnprocessableEntity) String() string { + payload, _ := json.Marshal(o.Payload) + return fmt.Sprintf("[GET /documentparameters][%d] getDocumentParametersUnprocessableEntity %s", 422, payload) +} + +func (o *GetDocumentParametersUnprocessableEntity) GetPayload() *members_models.Error { + return o.Payload +} + +func (o *GetDocumentParametersUnprocessableEntity) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error { + + o.Payload = new(members_models.Error) + + // response payload + if err := consumer.Consume(response.Body(), o.Payload); err != nil && !stderrors.Is(err, io.EOF) { + return err + } + + return nil +} + +// NewGetDocumentParametersInternalServerError creates a GetDocumentParametersInternalServerError with default headers values +func NewGetDocumentParametersInternalServerError() *GetDocumentParametersInternalServerError { + return &GetDocumentParametersInternalServerError{} +} + +// GetDocumentParametersInternalServerError describes a response with status code 500, with default header values. +// +// Server Internal Error +type GetDocumentParametersInternalServerError struct { + Payload *members_models.Error +} + +// IsSuccess returns true when this get document parameters internal server error response has a 2xx status code +func (o *GetDocumentParametersInternalServerError) IsSuccess() bool { + return false +} + +// IsRedirect returns true when this get document parameters internal server error response has a 3xx status code +func (o *GetDocumentParametersInternalServerError) IsRedirect() bool { + return false +} + +// IsClientError returns true when this get document parameters internal server error response has a 4xx status code +func (o *GetDocumentParametersInternalServerError) IsClientError() bool { + return false +} + +// IsServerError returns true when this get document parameters internal server error response has a 5xx status code +func (o *GetDocumentParametersInternalServerError) IsServerError() bool { + return true +} + +// IsCode returns true when this get document parameters internal server error response a status code equal to that given +func (o *GetDocumentParametersInternalServerError) IsCode(code int) bool { + return code == 500 +} + +// Code gets the status code for the get document parameters internal server error response +func (o *GetDocumentParametersInternalServerError) Code() int { + return 500 +} + +func (o *GetDocumentParametersInternalServerError) Error() string { + payload, _ := json.Marshal(o.Payload) + return fmt.Sprintf("[GET /documentparameters][%d] getDocumentParametersInternalServerError %s", 500, payload) +} + +func (o *GetDocumentParametersInternalServerError) String() string { + payload, _ := json.Marshal(o.Payload) + return fmt.Sprintf("[GET /documentparameters][%d] getDocumentParametersInternalServerError %s", 500, payload) +} + +func (o *GetDocumentParametersInternalServerError) GetPayload() *members_models.Error { + return o.Payload +} + +func (o *GetDocumentParametersInternalServerError) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error { + + o.Payload = new(members_models.Error) + + // response payload + if err := consumer.Consume(response.Body(), o.Payload); err != nil && !stderrors.Is(err, io.EOF) { + return err + } + + return nil +} diff --git a/api/members/members_client/document_parameters/post_document_parameters_parameters.go b/api/members/members_client/document_parameters/post_document_parameters_parameters.go new file mode 100644 index 0000000..b8ca725 --- /dev/null +++ b/api/members/members_client/document_parameters/post_document_parameters_parameters.go @@ -0,0 +1,159 @@ +// Code generated by go-swagger; DO NOT EDIT. + +// (c) 2012-2020 by Taxnexus, Inc. +// All rights reserved worldwide. +// Proprietary product; unlicensed use is not allowed + +package document_parameters + +import ( + "context" + "net/http" + "time" + + "code.tnxs.net/vernonkeenan/lib/api/members/members_models" + "github.com/go-openapi/errors" + "github.com/go-openapi/runtime" + cr "github.com/go-openapi/runtime/client" + "github.com/go-openapi/strfmt" +) + +// NewPostDocumentParametersParams creates a new PostDocumentParametersParams object, +// with the default timeout for this client. +// +// Default values are not hydrated, since defaults are normally applied by the API server side. +// +// To enforce default values in parameter, use SetDefaults or WithDefaults. +func NewPostDocumentParametersParams() *PostDocumentParametersParams { + return NewPostDocumentParametersParamsWithTimeout(cr.DefaultTimeout) +} + +// NewPostDocumentParametersParamsWithTimeout creates a new PostDocumentParametersParams object +// with the ability to set a timeout on a request. +func NewPostDocumentParametersParamsWithTimeout(timeout time.Duration) *PostDocumentParametersParams { + return &PostDocumentParametersParams{ + inner: innerParams{ + timeout: timeout, + }, + } +} + +// NewPostDocumentParametersParamsWithContext creates a new PostDocumentParametersParams object +// with the ability to set a context for a request. +// +// Deprecated: use the operation call with context to pass the context instead of [PostDocumentParametersParams]. +func NewPostDocumentParametersParamsWithContext(ctx context.Context) *PostDocumentParametersParams { + return &PostDocumentParametersParams{ + inner: innerParams{ + ctx: ctx, + }, + } +} + +// NewPostDocumentParametersParamsWithHTTPClient creates a new PostDocumentParametersParams object +// with the ability to set a custom HTTPClient for a request. +func NewPostDocumentParametersParamsWithHTTPClient(client *http.Client) *PostDocumentParametersParams { + return &PostDocumentParametersParams{ + HTTPClient: client, + } +} + +/* +PostDocumentParametersParams contains all the parameters to send to the API endpoint + + for the post document parameters operation. + + Typically these are written to a http.Request. +*/ +type PostDocumentParametersParams struct { + + // DocumentParameterRequest. + // + // An array of DocumentParameter records + DocumentParameterRequest *members_models.DocumentParameterRequest + + HTTPClient *http.Client + + inner innerParams +} + +// WithDefaults hydrates default values in the post document parameters params (not the query body). +// +// All values with no default are reset to their zero value. +func (o *PostDocumentParametersParams) WithDefaults() *PostDocumentParametersParams { + o.SetDefaults() + return o +} + +// SetDefaults hydrates default values in the post document parameters params (not the query body). +// +// All values with no default are reset to their zero value. +func (o *PostDocumentParametersParams) SetDefaults() { + // no default values defined for this parameter +} + +// WithTimeout adds the timeout to the post document parameters params. +func (o *PostDocumentParametersParams) WithTimeout(timeout time.Duration) *PostDocumentParametersParams { + o.SetTimeout(timeout) + return o +} + +// SetTimeout adds the timeout to the post document parameters params. +func (o *PostDocumentParametersParams) SetTimeout(timeout time.Duration) { + o.inner.timeout = timeout +} + +// WithContext adds the context to the post document parameters params. +// +// Deprecated: use the operation call with context to pass the context instead of [PostDocumentParametersParams]. +func (o *PostDocumentParametersParams) WithContext(ctx context.Context) *PostDocumentParametersParams { + o.SetContext(ctx) + return o +} + +// SetContext adds the context to the post document parameters params. +// +// Deprecated: use the operation call with context to pass the context instead of [PostDocumentParametersParams]. +func (o *PostDocumentParametersParams) SetContext(ctx context.Context) { + o.inner.ctx = ctx +} + +// WithHTTPClient adds the HTTPClient to the post document parameters params. +func (o *PostDocumentParametersParams) WithHTTPClient(client *http.Client) *PostDocumentParametersParams { + o.SetHTTPClient(client) + return o +} + +// SetHTTPClient adds the HTTPClient to the post document parameters params. +func (o *PostDocumentParametersParams) SetHTTPClient(client *http.Client) { + o.HTTPClient = client +} + +// WithDocumentParameterRequest adds the documentParameterRequest to the post document parameters params. +func (o *PostDocumentParametersParams) WithDocumentParameterRequest(documentParameterRequest *members_models.DocumentParameterRequest) *PostDocumentParametersParams { + o.SetDocumentParameterRequest(documentParameterRequest) + return o +} + +// SetDocumentParameterRequest adds the documentParameterRequest to the post document parameters params. +func (o *PostDocumentParametersParams) SetDocumentParameterRequest(documentParameterRequest *members_models.DocumentParameterRequest) { + o.DocumentParameterRequest = documentParameterRequest +} + +// WriteToRequest writes these params to a [runtime.ClientRequest]. +func (o *PostDocumentParametersParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error { + if err := r.SetTimeout(o.inner.timeout); err != nil { + return err + } + var res []error + if o.DocumentParameterRequest != nil { + if err := r.SetBodyParam(o.DocumentParameterRequest); err != nil { + return err + } + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} diff --git a/api/members/members_client/document_parameters/post_document_parameters_responses.go b/api/members/members_client/document_parameters/post_document_parameters_responses.go new file mode 100644 index 0000000..2833264 --- /dev/null +++ b/api/members/members_client/document_parameters/post_document_parameters_responses.go @@ -0,0 +1,484 @@ +// Code generated by go-swagger; DO NOT EDIT. + +// (c) 2012-2020 by Taxnexus, Inc. +// All rights reserved worldwide. +// Proprietary product; unlicensed use is not allowed + +package document_parameters + +import ( + "encoding/json" + stderrors "errors" + "fmt" + "io" + + "code.tnxs.net/vernonkeenan/lib/api/members/members_models" + "github.com/go-openapi/runtime" + "github.com/go-openapi/strfmt" +) + +// PostDocumentParametersReader is a Reader for the PostDocumentParameters structure. +type PostDocumentParametersReader struct { + formats strfmt.Registry +} + +// ReadResponse reads a server response into the received o. +func (o *PostDocumentParametersReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (any, error) { + switch response.Code() { + case 200: + result := NewPostDocumentParametersOK() + if err := result.readResponse(response, consumer, o.formats); err != nil { + return nil, err + } + return result, nil + case 401: + result := NewPostDocumentParametersUnauthorized() + if err := result.readResponse(response, consumer, o.formats); err != nil { + return nil, err + } + return nil, result + case 403: + result := NewPostDocumentParametersForbidden() + if err := result.readResponse(response, consumer, o.formats); err != nil { + return nil, err + } + return nil, result + case 404: + result := NewPostDocumentParametersNotFound() + if err := result.readResponse(response, consumer, o.formats); err != nil { + return nil, err + } + return nil, result + case 422: + result := NewPostDocumentParametersUnprocessableEntity() + if err := result.readResponse(response, consumer, o.formats); err != nil { + return nil, err + } + return nil, result + case 500: + result := NewPostDocumentParametersInternalServerError() + if err := result.readResponse(response, consumer, o.formats); err != nil { + return nil, err + } + return nil, result + default: + return nil, runtime.NewAPIError("[POST /documentparameters] postDocumentParameters", response, response.Code()) + } +} + +// NewPostDocumentParametersOK creates a PostDocumentParametersOK with default headers values +func NewPostDocumentParametersOK() *PostDocumentParametersOK { + return &PostDocumentParametersOK{} +} + +// PostDocumentParametersOK describes a response with status code 200, with default header values. +// +// DocumentParameter Response Object +type PostDocumentParametersOK struct { + Payload *members_models.DocumentParameterResponse +} + +// IsSuccess returns true when this post document parameters o k response has a 2xx status code +func (o *PostDocumentParametersOK) IsSuccess() bool { + return true +} + +// IsRedirect returns true when this post document parameters o k response has a 3xx status code +func (o *PostDocumentParametersOK) IsRedirect() bool { + return false +} + +// IsClientError returns true when this post document parameters o k response has a 4xx status code +func (o *PostDocumentParametersOK) IsClientError() bool { + return false +} + +// IsServerError returns true when this post document parameters o k response has a 5xx status code +func (o *PostDocumentParametersOK) IsServerError() bool { + return false +} + +// IsCode returns true when this post document parameters o k response a status code equal to that given +func (o *PostDocumentParametersOK) IsCode(code int) bool { + return code == 200 +} + +// Code gets the status code for the post document parameters o k response +func (o *PostDocumentParametersOK) Code() int { + return 200 +} + +func (o *PostDocumentParametersOK) Error() string { + payload, _ := json.Marshal(o.Payload) + return fmt.Sprintf("[POST /documentparameters][%d] postDocumentParametersOK %s", 200, payload) +} + +func (o *PostDocumentParametersOK) String() string { + payload, _ := json.Marshal(o.Payload) + return fmt.Sprintf("[POST /documentparameters][%d] postDocumentParametersOK %s", 200, payload) +} + +func (o *PostDocumentParametersOK) GetPayload() *members_models.DocumentParameterResponse { + return o.Payload +} + +func (o *PostDocumentParametersOK) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error { + + o.Payload = new(members_models.DocumentParameterResponse) + + // response payload + if err := consumer.Consume(response.Body(), o.Payload); err != nil && !stderrors.Is(err, io.EOF) { + return err + } + + return nil +} + +// NewPostDocumentParametersUnauthorized creates a PostDocumentParametersUnauthorized with default headers values +func NewPostDocumentParametersUnauthorized() *PostDocumentParametersUnauthorized { + return &PostDocumentParametersUnauthorized{} +} + +// PostDocumentParametersUnauthorized describes a response with status code 401, with default header values. +// +// Access Unauthorized, invalid API-KEY was used +type PostDocumentParametersUnauthorized struct { + Payload *members_models.Error +} + +// IsSuccess returns true when this post document parameters unauthorized response has a 2xx status code +func (o *PostDocumentParametersUnauthorized) IsSuccess() bool { + return false +} + +// IsRedirect returns true when this post document parameters unauthorized response has a 3xx status code +func (o *PostDocumentParametersUnauthorized) IsRedirect() bool { + return false +} + +// IsClientError returns true when this post document parameters unauthorized response has a 4xx status code +func (o *PostDocumentParametersUnauthorized) IsClientError() bool { + return true +} + +// IsServerError returns true when this post document parameters unauthorized response has a 5xx status code +func (o *PostDocumentParametersUnauthorized) IsServerError() bool { + return false +} + +// IsCode returns true when this post document parameters unauthorized response a status code equal to that given +func (o *PostDocumentParametersUnauthorized) IsCode(code int) bool { + return code == 401 +} + +// Code gets the status code for the post document parameters unauthorized response +func (o *PostDocumentParametersUnauthorized) Code() int { + return 401 +} + +func (o *PostDocumentParametersUnauthorized) Error() string { + payload, _ := json.Marshal(o.Payload) + return fmt.Sprintf("[POST /documentparameters][%d] postDocumentParametersUnauthorized %s", 401, payload) +} + +func (o *PostDocumentParametersUnauthorized) String() string { + payload, _ := json.Marshal(o.Payload) + return fmt.Sprintf("[POST /documentparameters][%d] postDocumentParametersUnauthorized %s", 401, payload) +} + +func (o *PostDocumentParametersUnauthorized) GetPayload() *members_models.Error { + return o.Payload +} + +func (o *PostDocumentParametersUnauthorized) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error { + + o.Payload = new(members_models.Error) + + // response payload + if err := consumer.Consume(response.Body(), o.Payload); err != nil && !stderrors.Is(err, io.EOF) { + return err + } + + return nil +} + +// NewPostDocumentParametersForbidden creates a PostDocumentParametersForbidden with default headers values +func NewPostDocumentParametersForbidden() *PostDocumentParametersForbidden { + return &PostDocumentParametersForbidden{} +} + +// PostDocumentParametersForbidden describes a response with status code 403, with default header values. +// +// Access forbidden, account lacks access +type PostDocumentParametersForbidden struct { + AccessControlAllowOrigin string + + Payload *members_models.Error +} + +// IsSuccess returns true when this post document parameters forbidden response has a 2xx status code +func (o *PostDocumentParametersForbidden) IsSuccess() bool { + return false +} + +// IsRedirect returns true when this post document parameters forbidden response has a 3xx status code +func (o *PostDocumentParametersForbidden) IsRedirect() bool { + return false +} + +// IsClientError returns true when this post document parameters forbidden response has a 4xx status code +func (o *PostDocumentParametersForbidden) IsClientError() bool { + return true +} + +// IsServerError returns true when this post document parameters forbidden response has a 5xx status code +func (o *PostDocumentParametersForbidden) IsServerError() bool { + return false +} + +// IsCode returns true when this post document parameters forbidden response a status code equal to that given +func (o *PostDocumentParametersForbidden) IsCode(code int) bool { + return code == 403 +} + +// Code gets the status code for the post document parameters forbidden response +func (o *PostDocumentParametersForbidden) Code() int { + return 403 +} + +func (o *PostDocumentParametersForbidden) Error() string { + payload, _ := json.Marshal(o.Payload) + return fmt.Sprintf("[POST /documentparameters][%d] postDocumentParametersForbidden %s", 403, payload) +} + +func (o *PostDocumentParametersForbidden) String() string { + payload, _ := json.Marshal(o.Payload) + return fmt.Sprintf("[POST /documentparameters][%d] postDocumentParametersForbidden %s", 403, payload) +} + +func (o *PostDocumentParametersForbidden) GetPayload() *members_models.Error { + return o.Payload +} + +func (o *PostDocumentParametersForbidden) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error { + + // hydrates response header Access-Control-Allow-Origin + hdrAccessControlAllowOrigin := response.GetHeader("Access-Control-Allow-Origin") + + if hdrAccessControlAllowOrigin != "" { + o.AccessControlAllowOrigin = hdrAccessControlAllowOrigin + } + + o.Payload = new(members_models.Error) + + // response payload + if err := consumer.Consume(response.Body(), o.Payload); err != nil && !stderrors.Is(err, io.EOF) { + return err + } + + return nil +} + +// NewPostDocumentParametersNotFound creates a PostDocumentParametersNotFound with default headers values +func NewPostDocumentParametersNotFound() *PostDocumentParametersNotFound { + return &PostDocumentParametersNotFound{} +} + +// PostDocumentParametersNotFound describes a response with status code 404, with default header values. +// +// Resource was not found +type PostDocumentParametersNotFound struct { + Payload *members_models.Error +} + +// IsSuccess returns true when this post document parameters not found response has a 2xx status code +func (o *PostDocumentParametersNotFound) IsSuccess() bool { + return false +} + +// IsRedirect returns true when this post document parameters not found response has a 3xx status code +func (o *PostDocumentParametersNotFound) IsRedirect() bool { + return false +} + +// IsClientError returns true when this post document parameters not found response has a 4xx status code +func (o *PostDocumentParametersNotFound) IsClientError() bool { + return true +} + +// IsServerError returns true when this post document parameters not found response has a 5xx status code +func (o *PostDocumentParametersNotFound) IsServerError() bool { + return false +} + +// IsCode returns true when this post document parameters not found response a status code equal to that given +func (o *PostDocumentParametersNotFound) IsCode(code int) bool { + return code == 404 +} + +// Code gets the status code for the post document parameters not found response +func (o *PostDocumentParametersNotFound) Code() int { + return 404 +} + +func (o *PostDocumentParametersNotFound) Error() string { + payload, _ := json.Marshal(o.Payload) + return fmt.Sprintf("[POST /documentparameters][%d] postDocumentParametersNotFound %s", 404, payload) +} + +func (o *PostDocumentParametersNotFound) String() string { + payload, _ := json.Marshal(o.Payload) + return fmt.Sprintf("[POST /documentparameters][%d] postDocumentParametersNotFound %s", 404, payload) +} + +func (o *PostDocumentParametersNotFound) GetPayload() *members_models.Error { + return o.Payload +} + +func (o *PostDocumentParametersNotFound) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error { + + o.Payload = new(members_models.Error) + + // response payload + if err := consumer.Consume(response.Body(), o.Payload); err != nil && !stderrors.Is(err, io.EOF) { + return err + } + + return nil +} + +// NewPostDocumentParametersUnprocessableEntity creates a PostDocumentParametersUnprocessableEntity with default headers values +func NewPostDocumentParametersUnprocessableEntity() *PostDocumentParametersUnprocessableEntity { + return &PostDocumentParametersUnprocessableEntity{} +} + +// PostDocumentParametersUnprocessableEntity describes a response with status code 422, with default header values. +// +// Unprocessable Entity, likely a bad parameter +type PostDocumentParametersUnprocessableEntity struct { + Payload *members_models.Error +} + +// IsSuccess returns true when this post document parameters unprocessable entity response has a 2xx status code +func (o *PostDocumentParametersUnprocessableEntity) IsSuccess() bool { + return false +} + +// IsRedirect returns true when this post document parameters unprocessable entity response has a 3xx status code +func (o *PostDocumentParametersUnprocessableEntity) IsRedirect() bool { + return false +} + +// IsClientError returns true when this post document parameters unprocessable entity response has a 4xx status code +func (o *PostDocumentParametersUnprocessableEntity) IsClientError() bool { + return true +} + +// IsServerError returns true when this post document parameters unprocessable entity response has a 5xx status code +func (o *PostDocumentParametersUnprocessableEntity) IsServerError() bool { + return false +} + +// IsCode returns true when this post document parameters unprocessable entity response a status code equal to that given +func (o *PostDocumentParametersUnprocessableEntity) IsCode(code int) bool { + return code == 422 +} + +// Code gets the status code for the post document parameters unprocessable entity response +func (o *PostDocumentParametersUnprocessableEntity) Code() int { + return 422 +} + +func (o *PostDocumentParametersUnprocessableEntity) Error() string { + payload, _ := json.Marshal(o.Payload) + return fmt.Sprintf("[POST /documentparameters][%d] postDocumentParametersUnprocessableEntity %s", 422, payload) +} + +func (o *PostDocumentParametersUnprocessableEntity) String() string { + payload, _ := json.Marshal(o.Payload) + return fmt.Sprintf("[POST /documentparameters][%d] postDocumentParametersUnprocessableEntity %s", 422, payload) +} + +func (o *PostDocumentParametersUnprocessableEntity) GetPayload() *members_models.Error { + return o.Payload +} + +func (o *PostDocumentParametersUnprocessableEntity) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error { + + o.Payload = new(members_models.Error) + + // response payload + if err := consumer.Consume(response.Body(), o.Payload); err != nil && !stderrors.Is(err, io.EOF) { + return err + } + + return nil +} + +// NewPostDocumentParametersInternalServerError creates a PostDocumentParametersInternalServerError with default headers values +func NewPostDocumentParametersInternalServerError() *PostDocumentParametersInternalServerError { + return &PostDocumentParametersInternalServerError{} +} + +// PostDocumentParametersInternalServerError describes a response with status code 500, with default header values. +// +// Server Internal Error +type PostDocumentParametersInternalServerError struct { + Payload *members_models.Error +} + +// IsSuccess returns true when this post document parameters internal server error response has a 2xx status code +func (o *PostDocumentParametersInternalServerError) IsSuccess() bool { + return false +} + +// IsRedirect returns true when this post document parameters internal server error response has a 3xx status code +func (o *PostDocumentParametersInternalServerError) IsRedirect() bool { + return false +} + +// IsClientError returns true when this post document parameters internal server error response has a 4xx status code +func (o *PostDocumentParametersInternalServerError) IsClientError() bool { + return false +} + +// IsServerError returns true when this post document parameters internal server error response has a 5xx status code +func (o *PostDocumentParametersInternalServerError) IsServerError() bool { + return true +} + +// IsCode returns true when this post document parameters internal server error response a status code equal to that given +func (o *PostDocumentParametersInternalServerError) IsCode(code int) bool { + return code == 500 +} + +// Code gets the status code for the post document parameters internal server error response +func (o *PostDocumentParametersInternalServerError) Code() int { + return 500 +} + +func (o *PostDocumentParametersInternalServerError) Error() string { + payload, _ := json.Marshal(o.Payload) + return fmt.Sprintf("[POST /documentparameters][%d] postDocumentParametersInternalServerError %s", 500, payload) +} + +func (o *PostDocumentParametersInternalServerError) String() string { + payload, _ := json.Marshal(o.Payload) + return fmt.Sprintf("[POST /documentparameters][%d] postDocumentParametersInternalServerError %s", 500, payload) +} + +func (o *PostDocumentParametersInternalServerError) GetPayload() *members_models.Error { + return o.Payload +} + +func (o *PostDocumentParametersInternalServerError) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error { + + o.Payload = new(members_models.Error) + + // response payload + if err := consumer.Consume(response.Body(), o.Payload); err != nil && !stderrors.Is(err, io.EOF) { + return err + } + + return nil +} diff --git a/api/members/members_client/document_parameters/put_document_parameters_parameters.go b/api/members/members_client/document_parameters/put_document_parameters_parameters.go new file mode 100644 index 0000000..2e869d6 --- /dev/null +++ b/api/members/members_client/document_parameters/put_document_parameters_parameters.go @@ -0,0 +1,159 @@ +// Code generated by go-swagger; DO NOT EDIT. + +// (c) 2012-2020 by Taxnexus, Inc. +// All rights reserved worldwide. +// Proprietary product; unlicensed use is not allowed + +package document_parameters + +import ( + "context" + "net/http" + "time" + + "code.tnxs.net/vernonkeenan/lib/api/members/members_models" + "github.com/go-openapi/errors" + "github.com/go-openapi/runtime" + cr "github.com/go-openapi/runtime/client" + "github.com/go-openapi/strfmt" +) + +// NewPutDocumentParametersParams creates a new PutDocumentParametersParams object, +// with the default timeout for this client. +// +// Default values are not hydrated, since defaults are normally applied by the API server side. +// +// To enforce default values in parameter, use SetDefaults or WithDefaults. +func NewPutDocumentParametersParams() *PutDocumentParametersParams { + return NewPutDocumentParametersParamsWithTimeout(cr.DefaultTimeout) +} + +// NewPutDocumentParametersParamsWithTimeout creates a new PutDocumentParametersParams object +// with the ability to set a timeout on a request. +func NewPutDocumentParametersParamsWithTimeout(timeout time.Duration) *PutDocumentParametersParams { + return &PutDocumentParametersParams{ + inner: innerParams{ + timeout: timeout, + }, + } +} + +// NewPutDocumentParametersParamsWithContext creates a new PutDocumentParametersParams object +// with the ability to set a context for a request. +// +// Deprecated: use the operation call with context to pass the context instead of [PutDocumentParametersParams]. +func NewPutDocumentParametersParamsWithContext(ctx context.Context) *PutDocumentParametersParams { + return &PutDocumentParametersParams{ + inner: innerParams{ + ctx: ctx, + }, + } +} + +// NewPutDocumentParametersParamsWithHTTPClient creates a new PutDocumentParametersParams object +// with the ability to set a custom HTTPClient for a request. +func NewPutDocumentParametersParamsWithHTTPClient(client *http.Client) *PutDocumentParametersParams { + return &PutDocumentParametersParams{ + HTTPClient: client, + } +} + +/* +PutDocumentParametersParams contains all the parameters to send to the API endpoint + + for the put document parameters operation. + + Typically these are written to a http.Request. +*/ +type PutDocumentParametersParams struct { + + // DocumentParameterRequest. + // + // An array of DocumentParameter records + DocumentParameterRequest *members_models.DocumentParameterRequest + + HTTPClient *http.Client + + inner innerParams +} + +// WithDefaults hydrates default values in the put document parameters params (not the query body). +// +// All values with no default are reset to their zero value. +func (o *PutDocumentParametersParams) WithDefaults() *PutDocumentParametersParams { + o.SetDefaults() + return o +} + +// SetDefaults hydrates default values in the put document parameters params (not the query body). +// +// All values with no default are reset to their zero value. +func (o *PutDocumentParametersParams) SetDefaults() { + // no default values defined for this parameter +} + +// WithTimeout adds the timeout to the put document parameters params. +func (o *PutDocumentParametersParams) WithTimeout(timeout time.Duration) *PutDocumentParametersParams { + o.SetTimeout(timeout) + return o +} + +// SetTimeout adds the timeout to the put document parameters params. +func (o *PutDocumentParametersParams) SetTimeout(timeout time.Duration) { + o.inner.timeout = timeout +} + +// WithContext adds the context to the put document parameters params. +// +// Deprecated: use the operation call with context to pass the context instead of [PutDocumentParametersParams]. +func (o *PutDocumentParametersParams) WithContext(ctx context.Context) *PutDocumentParametersParams { + o.SetContext(ctx) + return o +} + +// SetContext adds the context to the put document parameters params. +// +// Deprecated: use the operation call with context to pass the context instead of [PutDocumentParametersParams]. +func (o *PutDocumentParametersParams) SetContext(ctx context.Context) { + o.inner.ctx = ctx +} + +// WithHTTPClient adds the HTTPClient to the put document parameters params. +func (o *PutDocumentParametersParams) WithHTTPClient(client *http.Client) *PutDocumentParametersParams { + o.SetHTTPClient(client) + return o +} + +// SetHTTPClient adds the HTTPClient to the put document parameters params. +func (o *PutDocumentParametersParams) SetHTTPClient(client *http.Client) { + o.HTTPClient = client +} + +// WithDocumentParameterRequest adds the documentParameterRequest to the put document parameters params. +func (o *PutDocumentParametersParams) WithDocumentParameterRequest(documentParameterRequest *members_models.DocumentParameterRequest) *PutDocumentParametersParams { + o.SetDocumentParameterRequest(documentParameterRequest) + return o +} + +// SetDocumentParameterRequest adds the documentParameterRequest to the put document parameters params. +func (o *PutDocumentParametersParams) SetDocumentParameterRequest(documentParameterRequest *members_models.DocumentParameterRequest) { + o.DocumentParameterRequest = documentParameterRequest +} + +// WriteToRequest writes these params to a [runtime.ClientRequest]. +func (o *PutDocumentParametersParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error { + if err := r.SetTimeout(o.inner.timeout); err != nil { + return err + } + var res []error + if o.DocumentParameterRequest != nil { + if err := r.SetBodyParam(o.DocumentParameterRequest); err != nil { + return err + } + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} diff --git a/api/members/members_client/document_parameters/put_document_parameters_responses.go b/api/members/members_client/document_parameters/put_document_parameters_responses.go new file mode 100644 index 0000000..c8ae188 --- /dev/null +++ b/api/members/members_client/document_parameters/put_document_parameters_responses.go @@ -0,0 +1,558 @@ +// Code generated by go-swagger; DO NOT EDIT. + +// (c) 2012-2020 by Taxnexus, Inc. +// All rights reserved worldwide. +// Proprietary product; unlicensed use is not allowed + +package document_parameters + +import ( + "encoding/json" + stderrors "errors" + "fmt" + "io" + + "code.tnxs.net/vernonkeenan/lib/api/members/members_models" + "github.com/go-openapi/runtime" + "github.com/go-openapi/strfmt" +) + +// PutDocumentParametersReader is a Reader for the PutDocumentParameters structure. +type PutDocumentParametersReader struct { + formats strfmt.Registry +} + +// ReadResponse reads a server response into the received o. +func (o *PutDocumentParametersReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (any, error) { + switch response.Code() { + case 200: + result := NewPutDocumentParametersOK() + if err := result.readResponse(response, consumer, o.formats); err != nil { + return nil, err + } + return result, nil + case 401: + result := NewPutDocumentParametersUnauthorized() + if err := result.readResponse(response, consumer, o.formats); err != nil { + return nil, err + } + return nil, result + case 403: + result := NewPutDocumentParametersForbidden() + if err := result.readResponse(response, consumer, o.formats); err != nil { + return nil, err + } + return nil, result + case 404: + result := NewPutDocumentParametersNotFound() + if err := result.readResponse(response, consumer, o.formats); err != nil { + return nil, err + } + return nil, result + case 409: + result := NewPutDocumentParametersConflict() + if err := result.readResponse(response, consumer, o.formats); err != nil { + return nil, err + } + return nil, result + case 422: + result := NewPutDocumentParametersUnprocessableEntity() + if err := result.readResponse(response, consumer, o.formats); err != nil { + return nil, err + } + return nil, result + case 500: + result := NewPutDocumentParametersInternalServerError() + if err := result.readResponse(response, consumer, o.formats); err != nil { + return nil, err + } + return nil, result + default: + return nil, runtime.NewAPIError("[PUT /documentparameters] putDocumentParameters", response, response.Code()) + } +} + +// NewPutDocumentParametersOK creates a PutDocumentParametersOK with default headers values +func NewPutDocumentParametersOK() *PutDocumentParametersOK { + return &PutDocumentParametersOK{} +} + +// PutDocumentParametersOK describes a response with status code 200, with default header values. +// +// DocumentParameter Response Object +type PutDocumentParametersOK struct { + Payload *members_models.DocumentParameterResponse +} + +// IsSuccess returns true when this put document parameters o k response has a 2xx status code +func (o *PutDocumentParametersOK) IsSuccess() bool { + return true +} + +// IsRedirect returns true when this put document parameters o k response has a 3xx status code +func (o *PutDocumentParametersOK) IsRedirect() bool { + return false +} + +// IsClientError returns true when this put document parameters o k response has a 4xx status code +func (o *PutDocumentParametersOK) IsClientError() bool { + return false +} + +// IsServerError returns true when this put document parameters o k response has a 5xx status code +func (o *PutDocumentParametersOK) IsServerError() bool { + return false +} + +// IsCode returns true when this put document parameters o k response a status code equal to that given +func (o *PutDocumentParametersOK) IsCode(code int) bool { + return code == 200 +} + +// Code gets the status code for the put document parameters o k response +func (o *PutDocumentParametersOK) Code() int { + return 200 +} + +func (o *PutDocumentParametersOK) Error() string { + payload, _ := json.Marshal(o.Payload) + return fmt.Sprintf("[PUT /documentparameters][%d] putDocumentParametersOK %s", 200, payload) +} + +func (o *PutDocumentParametersOK) String() string { + payload, _ := json.Marshal(o.Payload) + return fmt.Sprintf("[PUT /documentparameters][%d] putDocumentParametersOK %s", 200, payload) +} + +func (o *PutDocumentParametersOK) GetPayload() *members_models.DocumentParameterResponse { + return o.Payload +} + +func (o *PutDocumentParametersOK) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error { + + o.Payload = new(members_models.DocumentParameterResponse) + + // response payload + if err := consumer.Consume(response.Body(), o.Payload); err != nil && !stderrors.Is(err, io.EOF) { + return err + } + + return nil +} + +// NewPutDocumentParametersUnauthorized creates a PutDocumentParametersUnauthorized with default headers values +func NewPutDocumentParametersUnauthorized() *PutDocumentParametersUnauthorized { + return &PutDocumentParametersUnauthorized{} +} + +// PutDocumentParametersUnauthorized describes a response with status code 401, with default header values. +// +// Access Unauthorized, invalid API-KEY was used +type PutDocumentParametersUnauthorized struct { + Payload *members_models.Error +} + +// IsSuccess returns true when this put document parameters unauthorized response has a 2xx status code +func (o *PutDocumentParametersUnauthorized) IsSuccess() bool { + return false +} + +// IsRedirect returns true when this put document parameters unauthorized response has a 3xx status code +func (o *PutDocumentParametersUnauthorized) IsRedirect() bool { + return false +} + +// IsClientError returns true when this put document parameters unauthorized response has a 4xx status code +func (o *PutDocumentParametersUnauthorized) IsClientError() bool { + return true +} + +// IsServerError returns true when this put document parameters unauthorized response has a 5xx status code +func (o *PutDocumentParametersUnauthorized) IsServerError() bool { + return false +} + +// IsCode returns true when this put document parameters unauthorized response a status code equal to that given +func (o *PutDocumentParametersUnauthorized) IsCode(code int) bool { + return code == 401 +} + +// Code gets the status code for the put document parameters unauthorized response +func (o *PutDocumentParametersUnauthorized) Code() int { + return 401 +} + +func (o *PutDocumentParametersUnauthorized) Error() string { + payload, _ := json.Marshal(o.Payload) + return fmt.Sprintf("[PUT /documentparameters][%d] putDocumentParametersUnauthorized %s", 401, payload) +} + +func (o *PutDocumentParametersUnauthorized) String() string { + payload, _ := json.Marshal(o.Payload) + return fmt.Sprintf("[PUT /documentparameters][%d] putDocumentParametersUnauthorized %s", 401, payload) +} + +func (o *PutDocumentParametersUnauthorized) GetPayload() *members_models.Error { + return o.Payload +} + +func (o *PutDocumentParametersUnauthorized) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error { + + o.Payload = new(members_models.Error) + + // response payload + if err := consumer.Consume(response.Body(), o.Payload); err != nil && !stderrors.Is(err, io.EOF) { + return err + } + + return nil +} + +// NewPutDocumentParametersForbidden creates a PutDocumentParametersForbidden with default headers values +func NewPutDocumentParametersForbidden() *PutDocumentParametersForbidden { + return &PutDocumentParametersForbidden{} +} + +// PutDocumentParametersForbidden describes a response with status code 403, with default header values. +// +// Access forbidden, account lacks access +type PutDocumentParametersForbidden struct { + AccessControlAllowOrigin string + + Payload *members_models.Error +} + +// IsSuccess returns true when this put document parameters forbidden response has a 2xx status code +func (o *PutDocumentParametersForbidden) IsSuccess() bool { + return false +} + +// IsRedirect returns true when this put document parameters forbidden response has a 3xx status code +func (o *PutDocumentParametersForbidden) IsRedirect() bool { + return false +} + +// IsClientError returns true when this put document parameters forbidden response has a 4xx status code +func (o *PutDocumentParametersForbidden) IsClientError() bool { + return true +} + +// IsServerError returns true when this put document parameters forbidden response has a 5xx status code +func (o *PutDocumentParametersForbidden) IsServerError() bool { + return false +} + +// IsCode returns true when this put document parameters forbidden response a status code equal to that given +func (o *PutDocumentParametersForbidden) IsCode(code int) bool { + return code == 403 +} + +// Code gets the status code for the put document parameters forbidden response +func (o *PutDocumentParametersForbidden) Code() int { + return 403 +} + +func (o *PutDocumentParametersForbidden) Error() string { + payload, _ := json.Marshal(o.Payload) + return fmt.Sprintf("[PUT /documentparameters][%d] putDocumentParametersForbidden %s", 403, payload) +} + +func (o *PutDocumentParametersForbidden) String() string { + payload, _ := json.Marshal(o.Payload) + return fmt.Sprintf("[PUT /documentparameters][%d] putDocumentParametersForbidden %s", 403, payload) +} + +func (o *PutDocumentParametersForbidden) GetPayload() *members_models.Error { + return o.Payload +} + +func (o *PutDocumentParametersForbidden) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error { + + // hydrates response header Access-Control-Allow-Origin + hdrAccessControlAllowOrigin := response.GetHeader("Access-Control-Allow-Origin") + + if hdrAccessControlAllowOrigin != "" { + o.AccessControlAllowOrigin = hdrAccessControlAllowOrigin + } + + o.Payload = new(members_models.Error) + + // response payload + if err := consumer.Consume(response.Body(), o.Payload); err != nil && !stderrors.Is(err, io.EOF) { + return err + } + + return nil +} + +// NewPutDocumentParametersNotFound creates a PutDocumentParametersNotFound with default headers values +func NewPutDocumentParametersNotFound() *PutDocumentParametersNotFound { + return &PutDocumentParametersNotFound{} +} + +// PutDocumentParametersNotFound describes a response with status code 404, with default header values. +// +// Resource was not found +type PutDocumentParametersNotFound struct { + Payload *members_models.Error +} + +// IsSuccess returns true when this put document parameters not found response has a 2xx status code +func (o *PutDocumentParametersNotFound) IsSuccess() bool { + return false +} + +// IsRedirect returns true when this put document parameters not found response has a 3xx status code +func (o *PutDocumentParametersNotFound) IsRedirect() bool { + return false +} + +// IsClientError returns true when this put document parameters not found response has a 4xx status code +func (o *PutDocumentParametersNotFound) IsClientError() bool { + return true +} + +// IsServerError returns true when this put document parameters not found response has a 5xx status code +func (o *PutDocumentParametersNotFound) IsServerError() bool { + return false +} + +// IsCode returns true when this put document parameters not found response a status code equal to that given +func (o *PutDocumentParametersNotFound) IsCode(code int) bool { + return code == 404 +} + +// Code gets the status code for the put document parameters not found response +func (o *PutDocumentParametersNotFound) Code() int { + return 404 +} + +func (o *PutDocumentParametersNotFound) Error() string { + payload, _ := json.Marshal(o.Payload) + return fmt.Sprintf("[PUT /documentparameters][%d] putDocumentParametersNotFound %s", 404, payload) +} + +func (o *PutDocumentParametersNotFound) String() string { + payload, _ := json.Marshal(o.Payload) + return fmt.Sprintf("[PUT /documentparameters][%d] putDocumentParametersNotFound %s", 404, payload) +} + +func (o *PutDocumentParametersNotFound) GetPayload() *members_models.Error { + return o.Payload +} + +func (o *PutDocumentParametersNotFound) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error { + + o.Payload = new(members_models.Error) + + // response payload + if err := consumer.Consume(response.Body(), o.Payload); err != nil && !stderrors.Is(err, io.EOF) { + return err + } + + return nil +} + +// NewPutDocumentParametersConflict creates a PutDocumentParametersConflict with default headers values +func NewPutDocumentParametersConflict() *PutDocumentParametersConflict { + return &PutDocumentParametersConflict{} +} + +// PutDocumentParametersConflict describes a response with status code 409, with default header values. +// +// The supplied LastModifiedDate is stale; reload the record before retrying. +type PutDocumentParametersConflict struct { + Payload *members_models.Error +} + +// IsSuccess returns true when this put document parameters conflict response has a 2xx status code +func (o *PutDocumentParametersConflict) IsSuccess() bool { + return false +} + +// IsRedirect returns true when this put document parameters conflict response has a 3xx status code +func (o *PutDocumentParametersConflict) IsRedirect() bool { + return false +} + +// IsClientError returns true when this put document parameters conflict response has a 4xx status code +func (o *PutDocumentParametersConflict) IsClientError() bool { + return true +} + +// IsServerError returns true when this put document parameters conflict response has a 5xx status code +func (o *PutDocumentParametersConflict) IsServerError() bool { + return false +} + +// IsCode returns true when this put document parameters conflict response a status code equal to that given +func (o *PutDocumentParametersConflict) IsCode(code int) bool { + return code == 409 +} + +// Code gets the status code for the put document parameters conflict response +func (o *PutDocumentParametersConflict) Code() int { + return 409 +} + +func (o *PutDocumentParametersConflict) Error() string { + payload, _ := json.Marshal(o.Payload) + return fmt.Sprintf("[PUT /documentparameters][%d] putDocumentParametersConflict %s", 409, payload) +} + +func (o *PutDocumentParametersConflict) String() string { + payload, _ := json.Marshal(o.Payload) + return fmt.Sprintf("[PUT /documentparameters][%d] putDocumentParametersConflict %s", 409, payload) +} + +func (o *PutDocumentParametersConflict) GetPayload() *members_models.Error { + return o.Payload +} + +func (o *PutDocumentParametersConflict) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error { + + o.Payload = new(members_models.Error) + + // response payload + if err := consumer.Consume(response.Body(), o.Payload); err != nil && !stderrors.Is(err, io.EOF) { + return err + } + + return nil +} + +// NewPutDocumentParametersUnprocessableEntity creates a PutDocumentParametersUnprocessableEntity with default headers values +func NewPutDocumentParametersUnprocessableEntity() *PutDocumentParametersUnprocessableEntity { + return &PutDocumentParametersUnprocessableEntity{} +} + +// PutDocumentParametersUnprocessableEntity describes a response with status code 422, with default header values. +// +// Unprocessable Entity, likely a bad parameter +type PutDocumentParametersUnprocessableEntity struct { + Payload *members_models.Error +} + +// IsSuccess returns true when this put document parameters unprocessable entity response has a 2xx status code +func (o *PutDocumentParametersUnprocessableEntity) IsSuccess() bool { + return false +} + +// IsRedirect returns true when this put document parameters unprocessable entity response has a 3xx status code +func (o *PutDocumentParametersUnprocessableEntity) IsRedirect() bool { + return false +} + +// IsClientError returns true when this put document parameters unprocessable entity response has a 4xx status code +func (o *PutDocumentParametersUnprocessableEntity) IsClientError() bool { + return true +} + +// IsServerError returns true when this put document parameters unprocessable entity response has a 5xx status code +func (o *PutDocumentParametersUnprocessableEntity) IsServerError() bool { + return false +} + +// IsCode returns true when this put document parameters unprocessable entity response a status code equal to that given +func (o *PutDocumentParametersUnprocessableEntity) IsCode(code int) bool { + return code == 422 +} + +// Code gets the status code for the put document parameters unprocessable entity response +func (o *PutDocumentParametersUnprocessableEntity) Code() int { + return 422 +} + +func (o *PutDocumentParametersUnprocessableEntity) Error() string { + payload, _ := json.Marshal(o.Payload) + return fmt.Sprintf("[PUT /documentparameters][%d] putDocumentParametersUnprocessableEntity %s", 422, payload) +} + +func (o *PutDocumentParametersUnprocessableEntity) String() string { + payload, _ := json.Marshal(o.Payload) + return fmt.Sprintf("[PUT /documentparameters][%d] putDocumentParametersUnprocessableEntity %s", 422, payload) +} + +func (o *PutDocumentParametersUnprocessableEntity) GetPayload() *members_models.Error { + return o.Payload +} + +func (o *PutDocumentParametersUnprocessableEntity) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error { + + o.Payload = new(members_models.Error) + + // response payload + if err := consumer.Consume(response.Body(), o.Payload); err != nil && !stderrors.Is(err, io.EOF) { + return err + } + + return nil +} + +// NewPutDocumentParametersInternalServerError creates a PutDocumentParametersInternalServerError with default headers values +func NewPutDocumentParametersInternalServerError() *PutDocumentParametersInternalServerError { + return &PutDocumentParametersInternalServerError{} +} + +// PutDocumentParametersInternalServerError describes a response with status code 500, with default header values. +// +// Server Internal Error +type PutDocumentParametersInternalServerError struct { + Payload *members_models.Error +} + +// IsSuccess returns true when this put document parameters internal server error response has a 2xx status code +func (o *PutDocumentParametersInternalServerError) IsSuccess() bool { + return false +} + +// IsRedirect returns true when this put document parameters internal server error response has a 3xx status code +func (o *PutDocumentParametersInternalServerError) IsRedirect() bool { + return false +} + +// IsClientError returns true when this put document parameters internal server error response has a 4xx status code +func (o *PutDocumentParametersInternalServerError) IsClientError() bool { + return false +} + +// IsServerError returns true when this put document parameters internal server error response has a 5xx status code +func (o *PutDocumentParametersInternalServerError) IsServerError() bool { + return true +} + +// IsCode returns true when this put document parameters internal server error response a status code equal to that given +func (o *PutDocumentParametersInternalServerError) IsCode(code int) bool { + return code == 500 +} + +// Code gets the status code for the put document parameters internal server error response +func (o *PutDocumentParametersInternalServerError) Code() int { + return 500 +} + +func (o *PutDocumentParametersInternalServerError) Error() string { + payload, _ := json.Marshal(o.Payload) + return fmt.Sprintf("[PUT /documentparameters][%d] putDocumentParametersInternalServerError %s", 500, payload) +} + +func (o *PutDocumentParametersInternalServerError) String() string { + payload, _ := json.Marshal(o.Payload) + return fmt.Sprintf("[PUT /documentparameters][%d] putDocumentParametersInternalServerError %s", 500, payload) +} + +func (o *PutDocumentParametersInternalServerError) GetPayload() *members_models.Error { + return o.Payload +} + +func (o *PutDocumentParametersInternalServerError) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error { + + o.Payload = new(members_models.Error) + + // response payload + if err := consumer.Consume(response.Body(), o.Payload); err != nil && !stderrors.Is(err, io.EOF) { + return err + } + + return nil +} diff --git a/api/members/members_client/learning_contract_test.go b/api/members/members_client/learning_contract_test.go index 1474b52..1c5dda3 100644 --- a/api/members/members_client/learning_contract_test.go +++ b/api/members/members_client/learning_contract_test.go @@ -23,7 +23,7 @@ import ( "github.com/go-openapi/strfmt" ) -const membersProviderSpecSHA256 = "fac8e386cb348993648644ba89c1bc14effbce679b2323ecdc332d1b4401d6ea" +const membersProviderSpecSHA256 = "4a5fd893c6490c18c6fa6fe3ddb234caf7cbfebb04a1c974fbf16854c2089acf" var learningTestAuth = openapiruntime.ClientAuthInfoWriterFunc(func(openapiruntime.ClientRequest, strfmt.Registry) error { return nil diff --git a/api/members/members_client/members_client.go b/api/members/members_client/members_client.go index 1e4af9a..6a92b90 100644 --- a/api/members/members_client/members_client.go +++ b/api/members/members_client/members_client.go @@ -14,6 +14,7 @@ import ( "code.tnxs.net/vernonkeenan/lib/api/members/members_client/courses" "code.tnxs.net/vernonkeenan/lib/api/members/members_client/credentials" "code.tnxs.net/vernonkeenan/lib/api/members/members_client/databases" + "code.tnxs.net/vernonkeenan/lib/api/members/members_client/document_parameters" "code.tnxs.net/vernonkeenan/lib/api/members/members_client/documents" "code.tnxs.net/vernonkeenan/lib/api/members/members_client/emails" "code.tnxs.net/vernonkeenan/lib/api/members/members_client/enrollments" @@ -93,6 +94,7 @@ func New(transport runtime.ContextualTransport, formats strfmt.Registry) *Member cli.Courses = courses.New(transport, formats) cli.Credentials = credentials.New(transport, formats) cli.Databases = databases.New(transport, formats) + cli.DocumentParameters = document_parameters.New(transport, formats) cli.Documents = documents.New(transport, formats) cli.Emails = emails.New(transport, formats) cli.Enrollments = enrollments.New(transport, formats) @@ -188,6 +190,8 @@ type Members struct { Databases databases.ClientService + DocumentParameters document_parameters.ClientService + Documents documents.ClientService Emails emails.ClientService @@ -251,6 +255,7 @@ func (c *Members) SetTransport(transport runtime.ContextualTransport) { c.Courses.SetTransport(transport) c.Credentials.SetTransport(transport) c.Databases.SetTransport(transport) + c.DocumentParameters.SetTransport(transport) c.Documents.SetTransport(transport) c.Emails.SetTransport(transport) c.Enrollments.SetTransport(transport) diff --git a/api/members/members_client/track_contract_test.go b/api/members/members_client/track_contract_test.go index 2223dd7..8d89a7a 100644 --- a/api/members/members_client/track_contract_test.go +++ b/api/members/members_client/track_contract_test.go @@ -19,7 +19,7 @@ import ( "github.com/go-openapi/strfmt" ) -const membersTrackSpecSHA256 = "fac8e386cb348993648644ba89c1bc14effbce679b2323ecdc332d1b4401d6ea" +const membersTrackSpecSHA256 = "4a5fd893c6490c18c6fa6fe3ddb234caf7cbfebb04a1c974fbf16854c2089acf" var trackTestAuth = openapiruntime.ClientAuthInfoWriterFunc( func(openapiruntime.ClientRequest, strfmt.Registry) error { return nil }, diff --git a/api/members/members_models/document_parameter.go b/api/members/members_models/document_parameter.go new file mode 100644 index 0000000..e63745c --- /dev/null +++ b/api/members/members_models/document_parameter.go @@ -0,0 +1,84 @@ +// Code generated by go-swagger; DO NOT EDIT. + +// (c) 2012-2020 by Taxnexus, Inc. +// All rights reserved worldwide. +// Proprietary product; unlicensed use is not allowed + +package members_models + +import ( + "context" + + "github.com/go-openapi/strfmt" + "github.com/go-openapi/swag/jsonutils" +) + +// DocumentParameter Tenant-owned document parameter +// +// swagger:model DocumentParameter +type DocumentParameter struct { + + // created by ID + CreatedByID *string `json:"CreatedByID,omitempty"` + + // created date + CreatedDate *string `json:"CreatedDate,omitempty"` + + // deleted date + DeletedDate *string `json:"DeletedDate,omitempty"` + + // document ID + DocumentID *string `json:"DocumentID,omitempty"` + + // ID + ID string `json:"ID,omitempty"` + + // is deleted + IsDeleted *bool `json:"IsDeleted,omitempty"` + + // last modified by ID + LastModifiedByID *string `json:"LastModifiedByID,omitempty"` + + // last modified date + LastModifiedDate *string `json:"LastModifiedDate,omitempty"` + + // name + Name *string `json:"Name,omitempty"` + + // tenant ID + TenantID *string `json:"TenantID,omitempty"` + + // user ID + UserID *string `json:"UserID,omitempty"` + + // value + Value *string `json:"Value,omitempty"` +} + +// Validate validates this document parameter +func (m *DocumentParameter) Validate(formats strfmt.Registry) error { + return nil +} + +// ContextValidate validates this document parameter based on context it is used +func (m *DocumentParameter) ContextValidate(ctx context.Context, formats strfmt.Registry) error { + return nil +} + +// MarshalBinary interface implementation +func (m *DocumentParameter) MarshalBinary() ([]byte, error) { + if m == nil { + return nil, nil + } + return jsonutils.WriteJSON(m) +} + +// UnmarshalBinary interface implementation +func (m *DocumentParameter) UnmarshalBinary(b []byte) error { + var res DocumentParameter + if err := jsonutils.ReadJSON(b, &res); err != nil { + return err + } + *m = res + return nil +} diff --git a/api/members/members_models/document_parameter_request.go b/api/members/members_models/document_parameter_request.go new file mode 100644 index 0000000..6705afc --- /dev/null +++ b/api/members/members_models/document_parameter_request.go @@ -0,0 +1,147 @@ +// Code generated by go-swagger; DO NOT EDIT. + +// (c) 2012-2020 by Taxnexus, Inc. +// All rights reserved worldwide. +// Proprietary product; unlicensed use is not allowed + +package members_models + +import ( + "context" + stderrors "errors" + "strconv" + + "github.com/go-openapi/errors" + "github.com/go-openapi/strfmt" + "github.com/go-openapi/swag/jsonutils" + "github.com/go-openapi/swag/typeutils" + "github.com/go-openapi/validate" +) + +// DocumentParameterRequest An array of DocumentParameter objects +// +// swagger:model DocumentParameterRequest +type DocumentParameterRequest struct { + + // data + // Required: true + // Max Items: 100 + // Min Items: 1 + Data []*DocumentParameter `json:"Data"` +} + +// Validate validates this document parameter request +func (m *DocumentParameterRequest) Validate(formats strfmt.Registry) error { + var res []error + + if err := m.validateData(formats); err != nil { + res = append(res, err) + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} + +func (m *DocumentParameterRequest) validateData(formats strfmt.Registry) error { + + if err := validate.Required("Data", "body", m.Data); err != nil { + return err + } + + iDataSize := int64(len(m.Data)) + + if err := validate.MinItems("Data", "body", iDataSize, 1); err != nil { + return err + } + + if err := validate.MaxItems("Data", "body", iDataSize, 100); err != nil { + return err + } + + for i := 0; i < len(m.Data); i++ { + if typeutils.IsZero(m.Data[i]) { // not required + continue + } + + if m.Data[i] != nil { + if err := m.Data[i].Validate(formats); err != nil { + ve := new(errors.Validation) + if stderrors.As(err, &ve) { + return ve.ValidateName("Data" + "." + strconv.Itoa(i)) + } + ce := new(errors.CompositeError) + if stderrors.As(err, &ce) { + return ce.ValidateName("Data" + "." + strconv.Itoa(i)) + } + + return err + } + } + + } + + return nil +} + +// ContextValidate validate this document parameter request based on the context it is used +func (m *DocumentParameterRequest) ContextValidate(ctx context.Context, formats strfmt.Registry) error { + var res []error + + if err := m.contextValidateData(ctx, formats); err != nil { + res = append(res, err) + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} + +func (m *DocumentParameterRequest) contextValidateData(ctx context.Context, formats strfmt.Registry) error { + + for i := 0; i < len(m.Data); i++ { + + if m.Data[i] != nil { + + if typeutils.IsZero(m.Data[i]) { // not required + return nil + } + + if err := m.Data[i].ContextValidate(ctx, formats); err != nil { + ve := new(errors.Validation) + if stderrors.As(err, &ve) { + return ve.ValidateName("Data" + "." + strconv.Itoa(i)) + } + ce := new(errors.CompositeError) + if stderrors.As(err, &ce) { + return ce.ValidateName("Data" + "." + strconv.Itoa(i)) + } + + return err + } + } + + } + + return nil +} + +// MarshalBinary interface implementation +func (m *DocumentParameterRequest) MarshalBinary() ([]byte, error) { + if m == nil { + return nil, nil + } + return jsonutils.WriteJSON(m) +} + +// UnmarshalBinary interface implementation +func (m *DocumentParameterRequest) UnmarshalBinary(b []byte) error { + var res DocumentParameterRequest + if err := jsonutils.ReadJSON(b, &res); err != nil { + return err + } + *m = res + return nil +} diff --git a/api/members/members_models/document_parameter_response.go b/api/members/members_models/document_parameter_response.go new file mode 100644 index 0000000..706817c --- /dev/null +++ b/api/members/members_models/document_parameter_response.go @@ -0,0 +1,191 @@ +// Code generated by go-swagger; DO NOT EDIT. + +// (c) 2012-2020 by Taxnexus, Inc. +// All rights reserved worldwide. +// Proprietary product; unlicensed use is not allowed + +package members_models + +import ( + "context" + stderrors "errors" + "strconv" + + "github.com/go-openapi/errors" + "github.com/go-openapi/strfmt" + "github.com/go-openapi/swag/jsonutils" + "github.com/go-openapi/swag/typeutils" +) + +// DocumentParameterResponse An array of DocumentParameter objects +// +// swagger:model DocumentParameterResponse +type DocumentParameterResponse struct { + + // data + Data []*DocumentParameter `json:"Data"` + + // meta + Meta *ResponseMeta `json:"Meta,omitempty"` +} + +// Validate validates this document parameter response +func (m *DocumentParameterResponse) Validate(formats strfmt.Registry) error { + var res []error + + if err := m.validateData(formats); err != nil { + res = append(res, err) + } + + if err := m.validateMeta(formats); err != nil { + res = append(res, err) + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} + +func (m *DocumentParameterResponse) validateData(formats strfmt.Registry) error { + if typeutils.IsZero(m.Data) { // not required + return nil + } + + for i := 0; i < len(m.Data); i++ { + if typeutils.IsZero(m.Data[i]) { // not required + continue + } + + if m.Data[i] != nil { + if err := m.Data[i].Validate(formats); err != nil { + ve := new(errors.Validation) + if stderrors.As(err, &ve) { + return ve.ValidateName("Data" + "." + strconv.Itoa(i)) + } + ce := new(errors.CompositeError) + if stderrors.As(err, &ce) { + return ce.ValidateName("Data" + "." + strconv.Itoa(i)) + } + + return err + } + } + + } + + return nil +} + +func (m *DocumentParameterResponse) validateMeta(formats strfmt.Registry) error { + if typeutils.IsZero(m.Meta) { // not required + return nil + } + + if m.Meta != nil { + if err := m.Meta.Validate(formats); err != nil { + ve := new(errors.Validation) + if stderrors.As(err, &ve) { + return ve.ValidateName("Meta") + } + ce := new(errors.CompositeError) + if stderrors.As(err, &ce) { + return ce.ValidateName("Meta") + } + + return err + } + } + + return nil +} + +// ContextValidate validate this document parameter response based on the context it is used +func (m *DocumentParameterResponse) ContextValidate(ctx context.Context, formats strfmt.Registry) error { + var res []error + + if err := m.contextValidateData(ctx, formats); err != nil { + res = append(res, err) + } + + if err := m.contextValidateMeta(ctx, formats); err != nil { + res = append(res, err) + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} + +func (m *DocumentParameterResponse) contextValidateData(ctx context.Context, formats strfmt.Registry) error { + + for i := 0; i < len(m.Data); i++ { + + if m.Data[i] != nil { + + if typeutils.IsZero(m.Data[i]) { // not required + return nil + } + + if err := m.Data[i].ContextValidate(ctx, formats); err != nil { + ve := new(errors.Validation) + if stderrors.As(err, &ve) { + return ve.ValidateName("Data" + "." + strconv.Itoa(i)) + } + ce := new(errors.CompositeError) + if stderrors.As(err, &ce) { + return ce.ValidateName("Data" + "." + strconv.Itoa(i)) + } + + return err + } + } + + } + + return nil +} + +func (m *DocumentParameterResponse) contextValidateMeta(ctx context.Context, formats strfmt.Registry) error { + + if m.Meta != nil { + + if typeutils.IsZero(m.Meta) { // not required + return nil + } + + if err := m.Meta.ContextValidate(ctx, formats); err != nil { + ve := new(errors.Validation) + if stderrors.As(err, &ve) { + return ve.ValidateName("Meta") + } + ce := new(errors.CompositeError) + if stderrors.As(err, &ce) { + return ce.ValidateName("Meta") + } + + return err + } + } + + return nil +} + +// MarshalBinary interface implementation +func (m *DocumentParameterResponse) MarshalBinary() ([]byte, error) { + if m == nil { + return nil, nil + } + return jsonutils.WriteJSON(m) +} + +// UnmarshalBinary interface implementation +func (m *DocumentParameterResponse) UnmarshalBinary(b []byte) error { + var res DocumentParameterResponse + if err := jsonutils.ReadJSON(b, &res); err != nil { + return err + } + *m = res + return nil +} diff --git a/docs/MEMBERS_DOCUMENT_PARAMETER_CLIENT.md b/docs/MEMBERS_DOCUMENT_PARAMETER_CLIENT.md new file mode 100644 index 0000000..ce41dd3 --- /dev/null +++ b/docs/MEMBERS_DOCUMENT_PARAMETER_CLIENT.md @@ -0,0 +1,23 @@ +# Members DocumentParameter client + +The generated `document_parameters` client exposes the governed +`GET /documentparameters`, `POST /documentparameters`, and +`PUT /documentparameters` operations. + +Every call requires the caller to provide both the server-held API-key +authentication writer and the native `kvSession` cookie through the request +transport. The Members service enforces the exact +`members:document-parameter:read`, `:create`, or `:update` machine scope. +Active Contributors can read only their own records. Creates and +compare-and-swap updates require tenant Owner or Manager authority. + +`DocumentID` is required and validated against the same tenant. +`LastModifiedDate` is the optimistic concurrency token; stale updates return +409. IDs, tenant ownership, and audit fields remain server-owned. +`IsDeleted` and `DeletedDate` are lifecycle-owned, and the client exposes no +generic delete operation. + +Folder client generation is deferred because the authoritative Folder schema +contains `AccountID` and a polymorphic `ObjectID`/`ObjectType` pair without +governed same-tenant reference metadata. Publishing those writes would be less +safe than the unambiguous DocumentParameter-to-Document relationship. diff --git a/swagger/external/members-vernonkeenan.yaml b/swagger/external/members-vernonkeenan.yaml index fe03a6a..5cba1f8 100644 --- a/swagger/external/members-vernonkeenan.yaml +++ b/swagger/external/members-vernonkeenan.yaml @@ -2367,7 +2367,7 @@ paths: - Folders /documentparameters: get: - description: Tenant- and user-scoped DocumentParameter read. Requires members:document-parameter:read and an active human session. + description: Tenant- and user-scoped DocumentParameter read. Requires members:document-parameter:read and an active human session. Contributors can read only their own records; Owners and Managers can read the tenant. operationId: getDocumentParameters parameters: - $ref: "#/parameters/idQuery" @@ -2393,7 +2393,7 @@ paths: tags: - Document Parameters post: - description: Tenant- and user-scoped DocumentParameter create. Requires members:document-parameter:create and an active human session. + description: Tenant-scoped DocumentParameter create. Requires members:document-parameter:create, an active human session, and Owner or Manager authority. operationId: postDocumentParameters parameters: - $ref: "#/parameters/documentParameterRequest" @@ -2417,7 +2417,7 @@ paths: tags: - Document Parameters put: - description: Tenant- and user-scoped DocumentParameter CAS update. Requires members:document-parameter:update and an active human session. + description: Tenant-scoped DocumentParameter CAS update. Requires members:document-parameter:update, an active human session, and Owner or Manager authority. operationId: putDocumentParameters parameters: - $ref: "#/parameters/documentParameterRequest" @@ -5745,10 +5745,14 @@ definitions: type: object DocumentParameterRequest: description: An array of DocumentParameter objects + required: + - Data properties: Data: items: $ref: "#/definitions/DocumentParameter" + minItems: 1 + maxItems: 100 type: array type: object DocumentParameterResponse: diff --git a/swagger/members-vernonkeenan.yaml b/swagger/members-vernonkeenan.yaml index f02c81d..39aed3e 100644 --- a/swagger/members-vernonkeenan.yaml +++ b/swagger/members-vernonkeenan.yaml @@ -2367,7 +2367,7 @@ paths: - Folders /documentparameters: get: - description: Tenant- and user-scoped DocumentParameter read. Requires members:document-parameter:read and an active human session. + description: Tenant- and user-scoped DocumentParameter read. Requires members:document-parameter:read and an active human session. Contributors can read only their own records; Owners and Managers can read the tenant. operationId: getDocumentParameters parameters: - $ref: "#/parameters/idQuery" @@ -2393,7 +2393,7 @@ paths: tags: - Document Parameters post: - description: Tenant- and user-scoped DocumentParameter create. Requires members:document-parameter:create and an active human session. + description: Tenant-scoped DocumentParameter create. Requires members:document-parameter:create, an active human session, and Owner or Manager authority. operationId: postDocumentParameters parameters: - $ref: "#/parameters/documentParameterRequest" @@ -2417,7 +2417,7 @@ paths: tags: - Document Parameters put: - description: Tenant- and user-scoped DocumentParameter CAS update. Requires members:document-parameter:update and an active human session. + description: Tenant-scoped DocumentParameter CAS update. Requires members:document-parameter:update, an active human session, and Owner or Manager authority. operationId: putDocumentParameters parameters: - $ref: "#/parameters/documentParameterRequest" @@ -5745,10 +5745,14 @@ definitions: type: object DocumentParameterRequest: description: An array of DocumentParameter objects + required: + - Data properties: Data: items: $ref: "#/definitions/DocumentParameter" + minItems: 1 + maxItems: 100 type: array type: object DocumentParameterResponse: